TwitchScript.js

//* Constants
const BASE_URL = 'https://www.twitch.tv/'
const GQL_URL = 'https://gql.twitch.tv/gql#origin=twilight'
const PLATFORM = 'Twitch'

// Twitch web client identity. Mimicking these values makes usher.ttvnw.net
// return ad-free manifests that a real-browser visit would get.
// Refresh periodically
const CLIENT_ID = 'ue6666qo983tsx6so1t0vnawi233wa' // old: kimne78kx3ncx6brgo4mv6wki5h1ko
const TWITCH_CLIENT_VERSION = 'e3516258-d65a-44d0-9562-6a0288a94079';
const TWITCH_PLAYER_VERSION = '1.52.0-rc.1';
const ACMB_VALUE = btoa(JSON.stringify({ AppVersion: TWITCH_CLIENT_VERSION, ClientApp: 'web' }));
const PLATFORM_CLAIMTYPE = 14;
const IS_DESKTOP = bridge.buildPlatform === "desktop";
const USER_AGENT_FALLBACK = IS_DESKTOP
	? 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.6778.200 Safari/537.36'
	: 'Mozilla/5.0 (Linux; Android 16) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.7559.133 Mobile Safari/537.36';
const getUserAgent = () => bridge.authUserAgent ?? bridge.captchaUserAgent ?? USER_AGENT_FALLBACK;

const IS_IMPERSONATION_AVAILABLE = typeof httpimp !== 'undefined';
const IMPERSONATION_TARGET = IS_DESKTOP ? 'chrome136' : 'chrome131_android';

const OLD_REGEX_URL_VIDEO_DETAILS = /^https?:\/\/(www\.|m\.)?twitch\.tv\/videos\/(\d+)(\?.*)?$/
const REGEX_URL_VIDEO_DETAILS = /^https?:\/\/(www\.|m\.)?twitch\.tv\/[a-zA-Z0-9-_]+\/video\/(\d+)(\?.*)?$/

const REGEX_URL_CHANNEL = /^https?:\/\/(?:www\.|m\.)?twitch\.tv\/(?!login|signup|directory|p\/|search|settings|subscriptions|inventory|friends|help|jobs|partner|moderation|store|bits|subs|creators|ads|extensions|prime|giftcard|turbo)([a-zA-Z0-9-_]+)(?:[?/].*)?$/;

const REGEX_URL_CHANNEL_CLIPS_FILTER = /^https?:\/\/(www\.|m\.)?twitch\.tv\/[a-zA-Z0-9_-]+\/clips\/?\?.*$/

const REGEX_URL_CLIP_DETAILS_LIST = [
    // Matches embedded clip URLs like https://clips.twitch.tv/embed?clip=clip-id
    /^https?:\/\/(www\.)?clips\.twitch\.tv\/embed\?clip=([a-zA-Z0-9_-]+)(&.*)?$/,

    // Matches URLs like https://clips.twitch.tv/clip-id
    /^https?:\/\/(www\.)?clips\.twitch\.tv\/([a-zA-Z0-9_-]+)(\?.*)?$/,

    // Matches URLs like https://www.twitch.tv/user-id/clip/clip-id or https://m.twitch.tv/user-id/clip/clip-id
    /^https?:\/\/(www\.|m\.)?twitch\.tv\/[a-zA-Z0-9_-]+\/clip\/([a-zA-Z0-9_-]+)(\?.*)?$/,

    // Matches URLs like https://www.twitch.tv/clip/clip-id or https://m.twitch.tv/clip/clip-id
    /^https?:\/\/(www\.|m\.)?twitch\.tv\/clip\/([a-zA-Z0-9_-]+)(\?.*)?$/
];

const MAX_RECOMMENDATION_TAGS = 3;
const RECOMMENDATION_LIMIT = 20;

//* Global Variables
let state = { integrity: '', integrityExpiresAt: 0, deviceId: '', sessionId: '' };

let config = {}
let _settings = {};
let webclient = http;

// Integrity tokens are documented as valid for ~16 hours. Cache a little under that
// so saved state doesn't hand out a token that's about to expire mid-session.
const INTEGRITY_TTL_MS = 15 * 60 * 60 * 1000;

function randomHex32() {
    let s = '';
    for (let i = 0; i < 32; i++) s += Math.floor(Math.random() * 16).toString(16);
    return s;
}

function ensureDeviceIds() {
    if (!state.deviceId) state.deviceId = randomHex32();
    if (!state.sessionId) state.sessionId = randomHex32();
}

//* Source
/**
 * The enable endpoint gets an integrity token. These integrity tokens must be passed into the stream playback access token endpoint. The integrity endpoint always returns a token but it is not always valid. Valid tokens work for 16 hours. Valid tokens are generated through a kasada challenge. The way to tell if a token is invalid is to try an endpoint and see if it fails.
 */
source.enable = function (conf, settings, savedState) {
    config = conf ?? {}
    _settings = settings ?? {};

    if (IS_IMPERSONATION_AVAILABLE && _settings.impersonateApiRequests) {
        const client = httpimp.getDefaultClient(true);
        client?.setDefaultImpersonateTarget?.(IMPERSONATION_TARGET);
        webclient = httpimp;
    } else {
        webclient = http;
    }

    if (savedState) {
        try {
            const restored = JSON.parse(savedState);
            if (restored?.integrity && restored.integrityExpiresAt > Date.now()) {
                state = {
                    integrity: restored.integrity,
                    integrityExpiresAt: restored.integrityExpiresAt,
                    deviceId: restored.deviceId || '',
                    sessionId: restored.sessionId || '',
                };
                ensureDeviceIds();
                trace('Restored valid integrity token from saved state');
                return;
            }
        } catch (e) {
            trace(`Failed to restore saved state: ${e.message}`);
        }
    }

    ensureDeviceIds();

    const resp = webclient.POST('https://gql.twitch.tv/integrity', '', {
           ...buildApiHeaders(),
        'Client-Request-Id': randomHex32(),
    })

    ensureHttpOk(resp, 'Integrity fetch');
    trace('Integrity fetch succeeded');

    const json = JSON.parse(resp.body);
    state.integrity = json.token;
    state.integrityExpiresAt = Date.now() + INTEGRITY_TTL_MS;
}

source.saveState = function () {
    return JSON.stringify(state);
}
source.getHome = function () {
    return getHomePagerPopular({ cursor: null, page_size: 20 })
}
source.searchSuggestions = function (query) {
    const gql = {
        extensions: {
            persistedQuery: {
                sha256Hash: 'b71566f2c593dd906493b0ab2012e5626c7f277d3e435504d4454de2ff15788a',
                version: 1,
            },
        },
        query: 'query SearchTray_SearchSuggestions($queryFragment: String! $requestID: ID $withOfflineChannelContent: Boolean) { searchSuggestions(queryFragment: $queryFragment requestID: $requestID withOfflineChannelContent: $withOfflineChannelContent){ edges { ...searchSuggestionNode } tracking { modelTrackingID responseID } } } fragment searchSuggestionNode on SearchSuggestionEdge { node { content { __typename ... on SearchSuggestionChannel { id isLive isVerified login profileImageURL(width: 50) user { id stream { id game { id } } } } ... on SearchSuggestionCategory { id boxArtURL(width: 30 height: 40) } } matchingCharacters { start end } id text } }',
        operationName: 'SearchTray_SearchSuggestions',
        variables: {
            queryFragment: query,
            requestID: '',
            skipSchedule: false,
        },
    }

    /** @type {import("./types.d.ts").SearchSuggestionsResponse} */
    const json = callGQL(gql)

    return json.data.searchSuggestions.edges.map((edge) => edge.node.text)
}
source.getSearchCapabilities = () => {
    return { types: [Type.Feed.Mixed], sorts: [], filters: [] }
}
source.search = function (query, type, order, filters) {
    return getSearchPagerAll({ q: query })
}
source.searchChannels = function (query) {
    return getSearchPagerChannels({ q: query, page_size: 20, results_returned: 0, cursor: null })
}
source.isChannelUrl = function (url) {
    return isChannelUrl(url);
};
source.getChannel = function (url) {
     
    const login = extractChannelId(url);

    const gql = [
        {
            query: 'query ChannelRoot_AboutPanel($channelLogin: String! $skipSchedule: Boolean!) { currentUser { id login } user(login: $channelLogin) { id description displayName isPartner primaryColorHex profileImageURL(width: 300) followers { totalCount } channel { id socialMedias { ...SocialMedia } schedule @skip(if: $skipSchedule) { id nextSegment { id startAt hasReminder } } } lastBroadcast { id game { id displayName } } primaryTeam { id name displayName } videos(first: 30 sort: TIME type: ARCHIVE) { edges { ...userBioVideo } } } } fragment userBioVideo on VideoEdge { node { id game { id displayName } status } } fragment SocialMedia on SocialMedia { id name title url }',
            operationName: 'ChannelRoot_AboutPanel',
            variables: {
                channelLogin: login,
                skipSchedule: false,
            },
            extensions: {
                persistedQuery: {
                    sha256Hash: '6089531acef6c09ece01b440c41978f4c8dc60cb4fa0124c9a9d3f896709b6c6',
                    version: 1,
                },
            },
        },
        {
            query: '#import "./query-channel-with-home-prefs-fragment.gql" query ChannelShell($login: String!) { userOrError: userResultByLogin(login: $login) { ...coreChannelWithHomePrefsFragment ... on UserDoesNotExist { userDoesNotExist: key reason } ... on UserError { userError: key } } }',
            operationName: 'ChannelShell',
            variables: {
                login: login,
            },
            extensions: {
                persistedQuery: {
                    sha256Hash: '580ab410bcd0c1ad194224957ae2241e5d252b2c5173d8e0cce9d32d5bb14efe',
                    version: 1,
                },
            },
        },
    ]

    // Opt-in: fetch user-authored channel-page panels. Complements socialMedias;
    // some channels (e.g. riotgames) keep most of their links in panels rather
    // than in Twitch's curated socialMedias list. Non-persisted query works.
    const includePanels = !!_settings?.includeChannelPanels;
    if (includePanels) {
        gql.push({
            operationName: 'ChannelPanels',
            query: 'query ChannelPanels($login: String!) { user(login: $login) { id panels { ... on DefaultPanel { id title linkURL } } } }',
            variables: { login: login },
        });
    }

    const json = callGQL(gql)

    /** @type {import("./types.d.ts").ChannelAboutResponse} */
    const user_resp = json[0]
    const user = user_resp.data.user

    if (!user) {
        throw new UnavailableException('Channel not found')
    }

    /** @type {import("./types.d.ts").ChannelShellResponse} */
    const shell_resp = json[1]
    const shell = shell_resp.data.userOrError

    const panels = includePanels ? (json[2]?.data?.user?.panels ?? []) : [];

    // Normalize URL for dedup — lowercase + strip trailing slash. Users often
    // have the same link as both a curated socialMedias entry AND a panel.
    const normUrl = u => (u ?? '').toLowerCase().replace(/\/+$/, '');
    const links = {};
    const seenUrls = new Set();

    const addLink = (rawKey, url) => {
        if (!url) return;
        const n = normUrl(url);
        if (seenUrls.has(n)) return;
        seenUrls.add(n);
        let key = rawKey || (() => {
            try { return new URL(url).hostname.replace('www.', '') || url; }
            catch { return url; }
        })();
        // Resolve title collisions (panels sometimes duplicate labels).
        if (links[key]) {
            let i = 2;
            while (links[`${key} (${i})`]) i++;
            key = `${key} (${i})`;
        }
        links[key] = url;
    };

    // Prefer `title` (user-curated display name, e.g. "Twitter" even when name is "x")
    // over capitalized `name`. Falls through addLink's hostname fallback if both absent.
    for (const s of user?.channel?.socialMedias ?? []) {
        const key = s.title || (s.name ? s.name.charAt(0).toUpperCase() + s.name.slice(1) : null);
        addLink(key, s.url);
    }
    for (const p of panels) {
        addLink(p?.title, p?.linkURL);
    }

    return new PlatformChannel({
        id: new PlatformID(PLATFORM, user.id, config.id, PLATFORM_CLAIMTYPE),
        name: user.displayName,
        thumbnail: user.profileImageURL,
        banner: shell.bannerImageURL,
        subscribers: user.followers.totalCount,
        description: user.description,
        url: BASE_URL + login,
        links,
    })
}
source.getChannelContents = function (url) {
    return getChannelPager({ url, page_size: 20, VideoCursor: null })
}

source.getChannelTemplateByClaimMap = () => {
    return {
        14: {
            0: BASE_URL + "{{CLAIMVALUE}}"
        }
    };
};

source.isContentDetailsUrl = function (url) {
    // https://www.twitch.tv/user (for livestreams) or https://www.twitch.tv/videos/123456789 or clips
    return (isChannelUrl(url) || isVideoUrl(url) || isTwitchClipDetailsUrl(url)) && !REGEX_URL_CHANNEL_CLIPS_FILTER.test(url);
}
source.getContentDetails = function (url) {
    if (url.includes('/video/') || url.includes('/videos/')) {
        return getSavedVideo(url)
    }  else if(isTwitchClipDetailsUrl(url)) {
        return getClippedVideo(url);
    }
    else if(!url.includes('/clips?')) {
        return getLiveVideo(url)
    }
}

source.getContentRecommendations = function (url, obj) {
    // Extract content information for recommendations
    let gameId = null;
    let gameName = null;
    let tags = [];
    let broadcasterId = null;

    // Try to get information from the provided object first
    if (obj) {
        if (obj.game) {
            gameId = obj.game.id;
            gameName = obj.game.name || obj.game.displayName;
        }
        if (obj.freeformTags) {
            tags = obj.freeformTags.map(tag => tag.name);
        }
        if (obj.broadcaster) {
            broadcasterId = obj.broadcaster.id;
        } else if (obj?.author?.id) {
            broadcasterId = obj.author.id.value;
        }
    }

    // Build recommendation query based on available information
    return getRecommendationsPager({
        gameId: gameId,
        gameName: gameName,
        tags: tags,
        broadcasterId: broadcasterId,
        excludeUrl: url
    });
}

source.getUserSubscriptions = function () {
    const gql = {
        "operationName": "ChannelFollows",
        "variables": {
            "limit": 100,
            "order": "DESC"
        },
        "extensions": {
            "persistedQuery": {
                "version": 1,
                "sha256Hash": "eecf815273d3d949e5cf0085cc5084cd8a1b5b7b6f7990cf43cb0beadf546907"
            }
        }
    };

    /** @type {import("./types.d.ts").PersonalSectionsFollowedResponse} */
    const json = callGQL(gql, true)

    const user = json.data.user;
    if (!user) {
        throw new ScriptException('Authentication Failed')
    }

    return user.follows.edges.map((e) => BASE_URL + e.node.login)
}

function getClippedVideo(url) {
    
    const clipSlug = extractTwitchClipSlug(url);

    const gql1 = [
        {
            "operationName": "VideoAccessToken_Clip",
            "variables": {
                "platform": "web",
                "slug": clipSlug
            },
            "query": `query VideoAccessToken_Clip($slug: ID!) {
                clip(slug: $slug) {
                    playbackAccessToken(params: {platform: "web", playerType: "site"}) {
                        signature
                        value
                    }
                    videoQualities {
                        frameRate
                        quality
                        sourceURL
                    }
                }
            }`
        },
        {
            "operationName": "ShareClipRenderStatus",
            "variables": {
                "slug": clipSlug
            },
            "query": `query ShareClipRenderStatus($slug: ID!) {
                clip(slug: $slug) {
                    id
                    title
                    thumbnailURL
                    createdAt
                    durationSeconds
                    viewCount
                    broadcaster {
                        id
                        displayName
                        login
                        profileImageURL(width: 150)
                    }
                    curator {
                        displayName
                    }
                    game {
                        displayName
                    }
                }
            }`
        },
    ];

    const gqlResponses = callGQL(gql1, true);

    const clip = gqlResponses[1]?.data?.clip;

    // Check if clip exists
    if (!clip) {
        throw new UnavailableException('Clip not found or unavailable');
    }

    const clipPlayback = gqlResponses[0]?.data?.clip;
    const qualities = clipPlayback?.videoQualities ?? [];

    const sources = qualities.map(quality => {
        const sourceUrl = `${quality.sourceURL}?sig=${clipPlayback.playbackAccessToken.signature}&token=${encodeURIComponent(clipPlayback.playbackAccessToken.value)}`
        return new VideoUrlSource({ 
            name: `${quality.quality}p`, 
            duration: clip.durationSeconds, 
            url: sourceUrl,
            width: parseInt(quality.quality),
            container: "video/mp4"
        });  
    })

    const description = [
        clip?.game?.displayName ? `${clip.game.displayName} ` : '',
        clip?.curator?.displayName ? `Clipped by ${clip.curator.displayName}` : ''
    ]
    .filter(Boolean)
    .join('\n ');

    const result = new PlatformVideoDetails({
        id: new PlatformID(PLATFORM, clipSlug, config.id),
        name: clip.title,
        thumbnails: new Thumbnails([new Thumbnail(clip.thumbnailURL, 0)]),
        author: new PlatformAuthorLink(
            new PlatformID(PLATFORM, clip.broadcaster.id, config.id, PLATFORM_CLAIMTYPE),
            clip.broadcaster.displayName,
            `${BASE_URL}${clip.broadcaster.login}`,
            clip.broadcaster.profileImageURL
        ),
        uploadDate: parseInt(new Date(clip.createdAt).getTime() / 1000),
        duration: clip.durationSeconds,
        viewCount: clip.viewCount,
        url: url,
        isLive: false,
        description,
        video: new VideoSourceDescriptor(sources),
    });

    const clipMetadata = {
        game: clip.game,
        broadcaster: clip.broadcaster
    };

    if (IS_TESTING) {
        source.getContentRecommendations(url, clipMetadata);
    } else {
        result.getContentRecommendations = function () {
            return source.getContentRecommendations(url, clipMetadata);
        };
    }

    return result;
}

/**
 * Returns a saved video
 * @param {string} url
 * @returns {PlatformVideoDetails}
 */
function getSavedVideo(url) {
    // get whatever is after the last slash in twitch.tv/videos/____/
    const id = extractTwitchVideoId(url)

    const gql1 = [
        {
            extensions: {
                persistedQuery: {
                    sha256Hash: 'ed230aa1e33e07eebb8928504583da78a5173989fadfb1ac94be06a04f3cdbe9',
                    version: 1,
                },
            },
            operationName: 'PlaybackAccessToken',
            variables: {
                isLive: false,
                isVod: true,
                login: '',
                platform: 'web',
                playerType: 'site',
                vodID: id,
            },
            query: 'query PlaybackAccessToken($login: String! $isLive: Boolean! $vodID: ID! $isVod: Boolean! $playerType: String!) { streamPlaybackAccessToken(channelName: $login params: {platform: "web" playerBackend: "mediaplayer" playerType: $playerType}) @include(if: $isLive) { value signature } videoPlaybackAccessToken(id: $vodID params: {platform: "web" playerBackend: "mediaplayer" playerType: $playerType}) @include(if: $isVod) { value signature } }',
        },
        {
            extensions: {
                persistedQuery: {
                    sha256Hash: 'cf1ccf6f5b94c94d662efec5223dfb260c9f8bf053239a76125a58118769e8e2',
                    version: 1,
                },
            },
            operationName: 'ChannelVideoCore',
            variables: {
                videoID: id,
            },
            query: 'query ChannelVideoCore($videoID: ID!) { video(id: $videoID) { id owner { id login profileImageURL(width: 50) } } }',
        },
    ]

    const json1 = callGQL(gql1, true)

    /** @type {import("./types.d.ts").PlaybackAccessTokenResponse} */
    const hls_json = json1[0]

    /** @type {import("./types.d.ts").ChannelVideoCoreResponse} */
    const channel_video_core = json1[1]
    const cvc = channel_video_core.data.video

    const spat = hls_json.data.videoPlaybackAccessToken

    if (!spat) {
        throw new UnavailableException('Video playback access token unavailable. Video may be subscriber-only, deleted, or geo-blocked.')
    }

    if (isRestrictedToSubscriberOnly(spat)) {
        throw new UnavailableException('This video is only available to subscribers.')
    }

    const hls_url = buildVodHlsUrl(id, spat.signature, spat.value);

    const gql2 = [
        {
            operationName: 'VideoMetadata',
            variables: {
                videoID: id,
            },
            query: 'query VideoMetadata($videoID: ID!) { video(id: $videoID) { id title description previewThumbnailURL(height: 240, width: 360) createdAt viewCount publishedAt lengthSeconds broadcastType owner { id login displayName } game { id boxArtURL name displayName } } }',
        },
    ]

    const json2 = callGQL(gql2)

    /** @type {import("./types.d.ts").VideoMetadataResponse}*/
    const video_metadata = json2[0]

    const vm = video_metadata.data

    return buildVodVideoDetails({
        id: id,
        title: vm.video.title,
        thumbnail: vm.video.previewThumbnailURL,
        ownerId: cvc.owner.id,
        ownerDisplayName: cvc.owner.login,
        ownerLogin: cvc.owner.login,
        ownerProfileImageURL: cvc.owner.profileImageURL,
        uploadDate: vm.video.publishedAt,
        duration: vm.video.lengthSeconds,
        viewCount: vm.video.viewCount,
        url: url,
        description: vm.video.description,
        hlsUrl: hls_url,
        game: vm.video.game,
    });
}

/**
 * Returns a live video
 * @param {string} url
 * @param {boolean} video_details
 * @returns {PlatformVideoDetails | PlatformVideo}
 */
function getLiveVideo(url, video_details = true) {
    // get whatever is after the last slash in twitch.tv/_____/
    const login = extractChannelId(url);

    const gql_for_metadata = [
        {
            operationName: 'StreamMetadata',
            query: 'query StreamMetadata($channelLogin: String!) { user(login: $channelLogin) { id primaryColorHex isPartner profileImageURL(width: 70) primaryTeam { id name displayName } squadStream { id members { id } status } channel { id chanlets { id } } lastBroadcast { id title } stream { id type createdAt game { id name } } } }',
            variables: {
                channelLogin: login,
            },
            extensions: {
                persistedQuery: {
                    version: 1,
                    sha256Hash: 'a647c2a13599e5991e175155f798ca7f1ecddde73f7f341f39009c14dbf59962',
                },
            },
        },
        {
            query: 'query UseViewCount($channelLogin: String!) { user(login: $channelLogin) { id stream { id viewersCount } } }',
            operationName: 'UseViewCount',
            variables: {
                channelLogin: login,
            },
            extensions: {
                persistedQuery: {
                    sha256Hash: '00b11c9c428f79ae228f30080a06ffd8226a1f068d6f52fbc057cbde66e994c2',
                    version: 1,
                },
            },
        },
        {
            extensions: {
                persistedQuery: {
                    sha256Hash: '639d5f11bfb8bf3053b424d9ef650d04c4ebb7d94711d644afb08fe9a0fad5d9',
                    version: 1,
                },
            },
            query: 'query UseLive($channelLogin: String!) { user(login: $channelLogin) { id login stream { id createdAt } } }',
            operationName: 'UseLive',
            variables: {
                channelLogin: login,
            },
        },
        {
            extensions: {
                persistedQuery: {
                    sha256Hash: 'ed230aa1e33e07eebb8928504583da78a5173989fadfb1ac94be06a04f3cdbe9',
                    version: 1,
                },
            },
            operationName: 'PlaybackAccessToken',
            variables: {
                isLive: true,
                isVod: false,
                login: login,
                platform: 'web',
                playerType: 'site',
                vodID: '',
            },
            query: 'query PlaybackAccessToken($login: String! $isLive: Boolean! $vodID: ID! $isVod: Boolean! $playerType: String!) { streamPlaybackAccessToken(channelName: $login params: {platform: "web" playerBackend: "mediaplayer" playerType: $playerType}) @include(if: $isLive) { value signature } videoPlaybackAccessToken(id: $vodID params: {platform: "web" playerBackend: "mediaplayer" playerType: $playerType}) @include(if: $isVod) { value signature } }',
        },
    ]
    const json = callGQL(gql_for_metadata, true)

    /** @type {import("./types.d.ts").StreamMetadataResponse}*/
    const stream_metadata = json[0]
    /** @type {import("./types.d.ts").ViewCountResponse}*/
    const view_count = json[1]
    /** @type {import("./types.d.ts").UseLiveResponse}*/
    const use_live = json[2]
    /** @type {import("./types.d.ts").PlaybackAccessTokenResponse} */
    const playback_access_token = json[3]

    const sm = stream_metadata.data.user
    const vc = view_count.data.user
    const ul = use_live.data.user

    // Check if channel exists
    if (!sm || !vc || !ul) {
        throw new UnavailableException('Channel not found')
    }

    if (ul?.stream === null) {
        throw new UnavailableException('Channel is not live')
    }

    const spat = playback_access_token.data.streamPlaybackAccessToken

    // Check if playback access token is available
    if (!spat) {
        throw new UnavailableException('Unable to get playback access token')
    }

    const hls_url = buildLiveHlsUrl(login, spat);

    const hls_source_opts = { name: 'live', duration: 0, url: hls_url, requestModifier: mediaRequestModifier() };

    const hls_source = new HLSSource(hls_source_opts)

	const cacheBust = Math.floor(Date.now() / 300000); // refresh every 5 min

    const pv = new PlatformVideo({
        id: new PlatformID(PLATFORM, sm.id, config.id),
        name: sm.lastBroadcast.title,
        thumbnails: new Thumbnails([
            new Thumbnail(`https://static-cdn.jtvnw.net/previews-ttv/live_user_${login}-1280x720.jpg?t=${cacheBust}`, 720),
            new Thumbnail(`https://static-cdn.jtvnw.net/previews-ttv/live_user_${login}-854x480.jpg?t=${cacheBust}`, 480),
        ]),
        author: new PlatformAuthorLink(new PlatformID(PLATFORM, sm.channel.id, config.id, PLATFORM_CLAIMTYPE), login, url, sm.profileImageURL),
        uploadDate: parseInt(new Date(ul.stream.createdAt).getTime() / 1000),
        duration: 0,
        viewCount: vc.stream.viewersCount,
        url: url,
        shareUrl: url,
        isLive: true,
    })

    if (video_details) {
        const result = new PlatformVideoDetails({
            ...pv,
            description: '',
            video: new VideoSourceDescriptor([]),
            live: hls_source,
        });

        const liveMetadata = {
            game: sm.stream?.game,
            broadcaster: {
                id: sm.channel.id,
                login: login,
                displayName: login
            }
        };

        if (IS_TESTING) {
            source.getContentRecommendations(url, liveMetadata);
        } else {
            result.getContentRecommendations = function () {
                return source.getContentRecommendations(url, liveMetadata);
            };
        }

        return result;
    } else {
        return pv
    }
}
source.getComments = function (url) {
    return getCommentPager({ url: url, page: 1, page_size: 20 })
}
source.getSubComments = function (comment) {
    return new CommentPager([], false, {}) //Not implemented
}
source.getLiveChatWindow = function (url) {
    const login = extractChannelId(url);
    return {
        url: "https://www.twitch.tv/popout/" + login + "/chat",
        removeElements: [".stream-chat-header", ".chat-room__content > div:first-child"],
        removeElementsInterval: [".consent-banner"]
    };
}
source.getVODEvents = function (url) {
    return new TwitchVODEventPager(extractTwitchVideoId(url));
}
source.getLiveEvents = function (url) {

    const login = extractChannelId(url);

    const gql = [
        {
            query: '#import "./query-channel-with-home-prefs-fragment.gql" query ChannelShell($login: String!) { userOrError: userResultByLogin(login: $login) { ...coreChannelWithHomePrefsFragment ... on UserDoesNotExist { userDoesNotExist: key reason } ... on UserError { userError: key } } }',
            operationName: 'ChannelShell',
            variables: {
                login: login,
            },
            extensions: {
                persistedQuery: {
                    sha256Hash: '580ab410bcd0c1ad194224957ae2241e5d252b2c5173d8e0cce9d32d5bb14efe',
                    version: 1,
                },
            },
        },
        {
            query: '#import "twilight/features/badges/models/badge-fragment.gql" #import "twilight/features/squad-stream/models/squad-stream-fragment.gql" query ChatList_Badges($channelLogin: String!) { badges { ...badge } user(login: $channelLogin) { id primaryColorHex broadcastBadges { ...badge } self { selectedBadge { ...badge } displayBadges { ...badge } } squadStream { ...squadStreamData } } }',
            extensions: {
                persistedQuery: {
                    sha256Hash: '86f43113c04606e6476e39dcd432dee47c994d77a83e54b732e11d4935f0cd08',
                    version: 1,
                },
            },
            operationName: 'ChatList_Badges',
            variables: {
                channelLogin: login,
            },
        },
    ]

    const json = callGQL(gql)

    /** @type {import("./types.d.ts").ChannelShellResponse} */
    const ChannelShellResponse = json[0]
    const userOrError = ChannelShellResponse.data.userOrError

    const chats = [];

    /** @type {import("./types.d.ts").BadgeListResponse} */
    const BadgeListResponse = json[1]

    let badge_url_map = {}

    BadgeListResponse.data.badges.forEach((badge) => {
        badge_url_map[badge.setID] = badge.image2x
    })

    return new TwitchLiveEventPager(userOrError.id, login, chats, badge_url_map)
}

class TwitchLiveEventPager extends LiveEventPager {
    /**
     * @param {string} channelId
     * @param {string} channelName
     * @param {LiveEventComment[]} chats
     * @param {{[key: string]: string}} badge_url_map
     */
    constructor(channelId, channelName, chats, badge_url_map) {
        super([], true)
        const me = this

        this.channelId = channelId
        this.channelName = channelName
        this.events = [...chats]
        this.emojis = {}
        this.lastFetch = new Date().getTime()

        let socket_irc = http.socket('wss://irc-ws.chat.twitch.tv', {}, false)
        socket_irc.connect(
            {
                open() {
                    const justin_fan_number = Math.floor(Math.random() * 9999)
                    const jf = `justinfan${justin_fan_number}`
                    socket_irc.send('CAP REQ :twitch.tv/tags')
                    socket_irc.send('PASS SCHMOOPIIE')
                    socket_irc.send(`NICK ${jf}`)
                    socket_irc.send(`USER ${jf} 8 * :${jf}`)
                    socket_irc.send(`JOIN #${me.channelName}`)

                    if (IS_TESTING) console.log(`Sent JOIN #${me.channelName}`)
                },
                message(msg) {
                    if (((new Date()).getTime() - me.lastFetch) / 1000 > 10) socket_irc.close()

                    if (!msg.startsWith('@badge-info')) return

                    if (msg.includes(';msg-id=')) {
                        const msg_id = msg.match(/;msg-id=([^;]+);/)[1]
                        let months_param, display_name_param
                        if (msg_id === 'sub' || msg_id === 'resub') {
                            months_param = 'msg-param-cumulative-months'
                            display_name_param = 'display-name'
                        } else {
                            months_param = 'msg-param-gift-months'
                            display_name_param = 'msg-param-recipient-display-name'
                        }
                        const regex = new RegExp(`;${months_param}=(\\d+);.*;${display_name_param}=([^;]+);.*;system-msg=([^;]+);`)
                        const result = regex.exec(msg)
                        const months = parseInt(result[1])
                        const display_name = result[2]
                        const system_message = result[3].replace(/\\s/g, ' ')
                        me.events.push(new LiveEventDonation(months + ' Months', display_name, system_message, ''))
                        return
                    }

                    //TODO: Make this a separate function
                    const parsedMessage = parseEmojiMessage(me.channelName, msg)
                    let newEmojis = {}
                    for (let key of Object.keys(parsedMessage.emojis)) {
                        if (!me.emojis[key]) {
                            me.emojis[key] = parsedMessage.emojis[key]
                            newEmojis[key] = parsedMessage.emojis[key]
                        }
                    }

                    const nameMatch = msg.match(/;display-name=([^;]+);/);
                    const name = (nameMatch && nameMatch.length >= 2) ? nameMatch[1] : null;
                    const colorMatch = msg.match(/;color=([^;]+);/);
                    const color = (colorMatch && colorMatch.length >= 2) ? colorMatch[1] : null;
                    const badges = msg.match(/;badges=([^;]+);/)
                    const badge_array = (badges && badges.length >= 2) ? badges[1].split(',') : [];
                    badge_array.forEach((badge) => {
                        newEmojis[badge] = badge_url_map[badge]
                    })

                    if (Object.keys(newEmojis).length > 0)
                        me.events.push(new LiveEventEmojis(newEmojis))

                    if (name)
                        me.events.push(new LiveEventComment(name, parsedMessage.msg, '', color, badge_array))
                    else if (IS_TESTING)
                        console.log("Failed name/color: " + msg);
                },
            },
            false
        )
        let socket_pub_sub = http.socket('wss://pubsub-edge.twitch.tv/v1', {}, false)
        socket_pub_sub.connect({
            open() {
                socket_pub_sub.send(JSON.stringify({ type: 'LISTEN', nonce: '', data: { topics: [`video-playback-by-id.${me.channelId}`] } }))
                // socket_pub_sub.send(JSON.stringify({"type":"LISTEN","nonce":"","data":{"topics":[`channel-bits-events-v2.${context.channel_id}`]}}))
                socket_pub_sub.send(JSON.stringify({ type: 'LISTEN', nonce: '', data: { topics: [`raid.${me.channelId}`] } }))
                // socket_pub_sub.send(JSON.stringify({"type":"LISTEN","nonce":"","data":{"topics":[`channel-subscribe-events-v1.${context.channel_id}`]}}))
                if (IS_TESTING) console.log(`Sent LISTEN to ${me.channelId}`)
            },
            message(msg) {
                if (((new Date()).getTime() - me.lastFetch) / 1000 > 10) socket_pub_sub.close()

                const json = JSON.parse(msg)
                if (json.type === 'MESSAGE') {
                    // {"type":"MESSAGE","data":{"topic":"video-playback-by-id.156037856","message":"{\"type\":\"viewcount\",\"server_time\":1686777651.803572,\"viewers\":40549}"}}
                    const data = JSON.parse(json.data.message)
                    const messageType = json.data.topic.split('.')[0]
                    switch (messageType) {
                        case 'video-playback-by-id':
                            me.events.push(new LiveEventViewCount(data.viewers))
                            break
                        case 'channel-bits-events-v2':
                            me.events.push(new LiveEventDonation(parseFloat(data.badge_tier) + ' Bits', data.user_name, data.chat_message, null))
                            break
                        case 'raid':
                            me.events.push(new LiveEventRaid(data.display_name, data.viewer_count))
                            break
                        case 'channel-subscribe-events-v1':
                            me.events.push(
                                new LiveEventDonation(parseFloat(data.cumulative_months) + ' Months', data.display_name, data.sub_message.message, null)
                            )
                            break
                    }
                }
            },
            closed() {
                this.hasMore = false
            },
        })
    }

    nextPage() {
        this.lastFetch = new Date().getTime()
        this.results = [...this.events]
        this.events = []
        return this
    }
}

class TwitchVODEventPager extends LiveEventPager {
    /**
     * @param {string} videoId
     */
    constructor(videoId) {
        super([], true);
        this.videoId = videoId;
        this.nextRequest = 1000;
        this._cached = [];
        this._fetchedAt = -1;
        this._cacheMaxMs = -1;
    }

    nextPage(ms) {
        const msNum = ms ?? 0;
        // Grayjay Android drops events with time >= msNum + 1500 (LiveChatManager.kt drip-feed window).
        // Keep in sync if that filter changes.
        const windowEnd = msNum + 1500;

        // Cache is authoritative for [_fetchedAt, _cacheMaxMs]: if the Android
        // filter window [msNum, windowEnd) falls inside that range, skip the fetch.
        const cacheCovers = this._fetchedAt >= 0
            && msNum >= this._fetchedAt
            && this._cacheMaxMs >= windowEnd;

        if (!cacheCovers) {
            this._fetchPage(msNum);
        }

        this.results = this._cached.filter(e => e.time >= msNum);
        return this;
    }

    _fetchPage(msNum) {
        const offsetSeconds = Math.floor(msNum / 1000);
        const gql = [{
            operationName: 'VideoCommentsByOffsetOrCursor',
            variables: { videoID: this.videoId, contentOffsetSeconds: offsetSeconds },
            extensions: {
                persistedQuery: {
                    version: 1,
                    sha256Hash: 'b70a3591ff0f4e0313d126c6a1502d79a1c02baebb288227c582044aa76adf6a',
                },
            },
        }];
        const resp = callGQL(gql);
        const comments = resp?.[0]?.data?.video?.comments;
        if (!comments) {
            this._cached = [];
            this._fetchedAt = -1;
            this._cacheMaxMs = -1;
            this.hasMore = false;
            return;
        }
        const events = [];
        for (const edge of comments.edges ?? []) {
            const node = edge?.node;
            if (!node) continue;
            const name = node.commenter?.displayName ?? node.commenter?.login ?? '';
            const message = (node.message?.fragments ?? []).map(f => f?.text ?? '').join('');
            if (!message) continue;
            const color = node.message?.userColor ?? null;
            const ev = new LiveEventComment(name, message, '', color, []);
            ev.time = (node.contentOffsetSeconds ?? 0) * 1000;
            events.push(ev);
        }
        this._cached = events;
        this._fetchedAt = msNum;
        // If the page has events, trust it up to the last event time.
        // If the page is empty, assume ~30s of forward coverage to avoid a refetch storm on silent stretches.
        this._cacheMaxMs = events.length ? events[events.length - 1].time : msNum + 30000;
        this.hasMore = comments.pageInfo?.hasNextPage ?? false;
    }
}

// @badge-info=;badges=glitchcon2020/1;client-nonce=4aaf7de413ec6cd4ca3cfd342590c53b;color=#0053D5;display-name=bungerlove;emotes=25:10-14;first-msg=0;flags=;id=dd35695a-20f6-430e-a8fa-6ec284c5a02c;mod=0;returning-chatter=0;room-id=21841789;subscriber=0;tmi-sent-ts=1689265271382;turbo=0;user-id=161748597;user-type= :bungerlove!bungerlove@bungerlove.tmi.twitch.tv PRIVMSG #nmplol :prime sub Kappa
// @badge-info=;badges=moments/1;color=#FF0000;display-name=blob___fish;emotes=33:36-43,45-52,67-74/133468:54-65,76-87,89-100/emotesv2_e02650251d204198923de93a0c62f5f5:102-110;first-msg=0;flags=;id=fdd7aafe-2f3a-4600-b5da-a8441e83f682;mod=0;returning-chatter=0;room-id=71092938;subscriber=0;tmi-sent-ts=1689266506402;turbo=0;user-id=737776278;user-type= :blob___fish!blob___fish@blob___fish.tmi.twitch.tv PRIVMSG #xqc :@xqc WHAT HAPPENS TO YOUR GAMESHOW? DansGame DansGame ItsBoshyTime DansGame ItsBoshyTime ItsBoshyTime PotFriend
function parseEmojiMessage(channelName, msg) {
    //TODO: Remove redundant channelName
    // write a regex to select the message content
    const regex = new RegExp(`PRIVMSG #${channelName} :(.*)`)
    const content = msg.match(regex)[1]
    const newEmojis = {}
    let reconstructed = ''
    if (!msg.includes(';emotes=;')) {
        const regex = /;emotes=([^;]+);/
        const result = msg.match(regex)[1]
        const emote_ranges = result.split('/').map((e) => {
            const split = e.split(':')
            return {
                id: split[0],
                ranges: split[1].split(',').map((r) => {
                    const split = r.split('-')
                    return {
                        start: parseInt(split[0]),
                        end: parseInt(split[1]),
                    }
                }),
            }
        })
        /** @type {{id: string, start: number, end: number}[]} */
        const ranges = emote_ranges.flatMap((emote) => emote.ranges.map((range) => ({ emote: emote.id, ...range }))).sort((a, b) => a.start - b.start)
        for (let i = 0; i < content.length; i++) {
            if (ranges.length > 0 && ranges[0].start === i) {
                newEmojis['emote_' + ranges[0].emote] = `https://static-cdn.jtvnw.net/emoticons/v2/${ranges[0].emote}/default/dark/2.0`
                reconstructed += `__${'emote_' + ranges[0].emote}__`
                i = ranges[0].end
                ranges.shift()
            } else {
                reconstructed += content[i]
            }
        }
    } else {
        reconstructed = content
    }
    return {
        emojis: newEmojis,
        msg: reconstructed.trim(),
    }
}

//* Internals
/**
 * Posts to GQL_URL with the gql query. Includes relevant headers.
 * @param {Object} gql the gql query object to be stringified and sent
 * @param {boolean} use_authenticated if true, will use the authenticated headers
 * @param {boolean} parse if true, will parse the response as json and check for errors
 * @returns {string | Object} the response body as a string or the parsed json object
 * @throws {ScriptException}
 */
function callGQL(gql, use_authenticated = false, parse = true) {
    const resp = webclient.POST(
        GQL_URL,
        JSON.stringify(gql),
        buildApiHeaders({ includeIntegrity: true }),
        use_authenticated
    )

    ensureHttpOk(resp, 'GQL');

    if (!parse) return resp.body

    const json = JSON.parse(resp.body)

    // check for errors in the case of different lengths cause json can be array or single object
    if (!json.length && json.errors) {
        trace(`GQL errors: ${JSON.stringify(json.errors)}`);
        throw new ScriptException(`GQL returned errors: ${JSON.stringify(json.errors)}`);
    }

    if (json.length) {
        for (const obj of json) {
            if (obj.errors) {
                trace(`GQL errors on ${obj.extensions?.operationName ?? 'unknown'}: ${JSON.stringify(obj.errors)}`);
                throw new ScriptException(`GQL returned errors: ${JSON.stringify(obj.errors)}`);
            }
        }
    }

    return json
}

//* Pagers
/**
 * Gets a pager for the home pager
 * @param {import("./types.d.ts").HomeContext} context
 * @param {string} [excludeUrl] - Optional URL to exclude from results
 * @returns {HomePagerPopular}
 */
function getHomePagerPopular(context, excludeUrl = null) {
    let gql = {
        query: `query BrowsePage_Popular($limit: Int, $cursor: Cursor, $platformType: PlatformType, $options: StreamOptions) {
            streams(first: $limit, after: $cursor, platformType: $platformType, options: $options) {
                edges {
                    cursor
                    node {
                        id
                        title
                        previewImageURL(width: 320, height: 180)
                        viewersCount
                        broadcaster {
                            id
                            login
                            profileImageURL(width: 50)
                        }
                    }
                }
                pageInfo {
                    hasNextPage
                }
            }
        }`,
        operationName: 'BrowsePage_Popular',
        variables: {
            limit: context.page_size,
            options: {
                broadcasterLanguages: ['EN'],
                freeformTags: null,
                includeRestricted: ['SUB_ONLY_LIVE'],
                recommendationsContext: {
                    platform: 'web',
                },
                requestID: 'JIRA-VXP-2397',
                sort: 'RELEVANCE',
                tags: [],
            },
            platformType: 'all',
        },
    }
    if (context.cursor) gql.variables.cursor = context.cursor

    /** @type {import("./types.d.ts").BrowsePopularResponse}*/
    const json = callGQL(gql) //! to use authentication, requires valid integrity
    // const json = callGQL(gql, true)

    let streams = json.data.streams.edges
    .filter((s) => s.node.broadcaster)
    .map((s) => {
        let n = s.node
        return new PlatformVideo({
            id: new PlatformID(PLATFORM, n.id, config.id),
            name: n.title,
            thumbnails: new Thumbnails([new Thumbnail(n.previewImageURL, 0)]),
            author: new PlatformAuthorLink(
                new PlatformID(PLATFORM, n.broadcaster.id, config.id, PLATFORM_CLAIMTYPE),
                n.broadcaster.login,
                BASE_URL + n.broadcaster.login,
                n.broadcaster.profileImageURL
            ),
            uploadDate: parseInt(new Date().getTime() / 1000),
            duration: 0,
            viewCount: n.viewersCount,
            url: BASE_URL + n.broadcaster.login,
            shareUrl: BASE_URL + n.broadcaster.login,
            isLive: true,
        })
    })

    // Filter out the excluded URL if provided
    if (excludeUrl) {
        // Normalize URLs for comparison (remove trailing slashes, convert to lowercase)
        const normalizeUrl = (url) => url.toLowerCase().replace(/\/$/, '');
        const normalizedExcludeUrl = normalizeUrl(excludeUrl);
        streams = streams.filter(stream => normalizeUrl(stream.url) !== normalizedExcludeUrl);
    }

    context.cursor = json.data.streams.edges[json.data.streams.edges.length - 1].cursor

    return new HomePagerPopular(streams, json.data.streams.pageInfo.hasNextPage, context)
}

/**
 * Gets a comment pager
 * @param {import("./types").HomeContext & {url: string; id: number|null}} context the comment context
 * @returns {ExtendableCommentPager} returns the comment pager
 * @throws {ScriptException}
 */
function getCommentPager(context) {
    return new ExtendableCommentPager(context, [])
}

/**
 * Gets a channel pager
 * @param {import("./types.d.ts").URLContext} context the channel context
 * @returns {ChannelVideoPager} returns the channel pager
 * @throws {ScriptException}
 */
function getChannelPager(context) {
    // url format https://www.twitch.tv/qtcinderella/videos?filter=all&sort=time (query params may or may not be there)
    /** @type {string} */
    let login = extractChannelId(context.url)
    

    const gqlVideoOperationName = 'FilterableVideoTower_Videos';
    const gqlClipOperationName = 'ClipsCards__User';

    let gql = [{
        operationName: gqlVideoOperationName,
        variables: {
            broadcastType: null,
            channelOwnerLogin: login,
            cursor: context.VideoCursor,
            limit: context.page_size,
            videoSort: 'TIME',
        },
        query: `query FilterableVideoTower_Videos($channelOwnerLogin: String!, $limit: Int, $cursor: Cursor, $broadcastType: BroadcastType, $videoSort: VideoSort, $options: VideoConnectionOptionsInput) {
            user(login: $channelOwnerLogin) {
                id
                videos(first: $limit, after: $cursor, type: $broadcastType, sort: $videoSort, options: $options) {
                    edges {
                        cursor
                        node {
                            __typename
                            id
                            title
                            previewThumbnailURL(width: 320, height: 180)
                            publishedAt
                            lengthSeconds
                            viewCount
                            description
                            game {
                                id
                                displayName
                            }
                            owner {
                                id
                                displayName
                                login
                                profileImageURL(width: 50)
                            }
                        }
                    }
                    pageInfo {
                        hasNextPage
                    }
                }
            }
        }`,
    },
    {
        operationName: gqlClipOperationName,
        variables: {
            login: login,
            limit: 30,
            criteria: {
                filter: "ALL_TIME",
                shouldFilterByDiscoverySetting: true
            },
            cursor: context.ClipCursor
        },
        query: `query ClipsCards__User($login: String!, $limit: Int, $criteria: UserClipsInput, $cursor: Cursor) {
            user(login: $login) {
                clips(first: $limit, criteria: $criteria, after: $cursor) {
                    edges {
                        cursor
                        node {
                            __typename
                            id
                            slug
                            title
                            thumbnailURL
                            createdAt
                            durationSeconds
                            viewCount
                            broadcaster {
                                id
                                displayName
                                login
                                profileImageURL(width: 50)
                            }
                        }
                    }
                }
            }
        }`
    }]

    if(context.videosHasNext === undefined) {
        context.videosHasNext = true;
    }

    if(context.clipsHasNext === undefined) {
        context.clipsHasNext = true;
    }

    if(_settings.shouldIncludeChannelClips === false) {
        context.clipsHasNext = false;
    }

    if(context.videosHasNext === false) {
        gql = gql.filter(g => g.operationName != gqlVideoOperationName)
    }
    
    if(context.clipsHasNext === false) {
        gql = gql.filter(g => g.operationName != gqlClipOperationName)
    }

    const response = callGQL(gql)

    let videosJson = [];
    let clipsJson = [];
    
    if(context.videosHasNext) {
        const index = response.findIndex(e => e.extensions.operationName == gqlVideoOperationName);
        videosJson = response[index];
    }
    
    if(context.clipsHasNext) {
        const index = response.findIndex(e => e.extensions.operationName == gqlClipOperationName);
        clipsJson = response[index];
    }

    const edges = videosJson?.data?.user?.videos?.edges ?? [];
    const clips = clipsJson?.data?.user?.clips?.edges ?? [];

    // Batch-fetch playback tokens for videos to detect subscriber-only and build HLS URLs
    const videoEdges = edges.filter(e => e.node.owner != null);
    const subscriberOnlyIds = new Set();
    const videoTokens = {};

    if (videoEdges.length > 0) {
        const tokenGql = videoEdges.map(edge => ({
            operationName: 'PlaybackAccessToken',
            variables: {
                isLive: false,
                isVod: true,
                login: '',
                platform: 'web',
                playerType: 'site',
                vodID: edge.node.id,
            },
            query: 'query PlaybackAccessToken($login: String! $isLive: Boolean! $vodID: ID! $isVod: Boolean! $playerType: String!) { streamPlaybackAccessToken(channelName: $login params: {platform: "web" playerBackend: "mediaplayer" playerType: $playerType}) @include(if: $isLive) { value signature } videoPlaybackAccessToken(id: $vodID params: {platform: "web" playerBackend: "mediaplayer" playerType: $playerType}) @include(if: $isVod) { value signature } }',
        }));

        try {
            const tokenResponses = callGQL(tokenGql, true);
            const responses = Array.isArray(tokenResponses) ? tokenResponses : [tokenResponses];
            for (let i = 0; i < responses.length; i++) {
                const token = responses[i]?.data?.videoPlaybackAccessToken;
                if (token) {
                    const videoId = videoEdges[i].node.id;
                    if (isRestrictedToSubscriberOnly(token)) {
                        subscriberOnlyIds.add(videoId);
                    } else {
                        videoTokens[videoId] = token;
                    }
                }
            }
        } catch (e) {
            log('Failed to check subscriber-only status: ' + e);
        }
    }

    let videos = [...edges,...clips].filter(edge => {
        // Filter out items without owner/broadcaster
        if(edge.node.__typename == 'Clip') {
            return edge.node.broadcaster != null;
        } else {
            return edge.node.owner != null;
        }
    }).map((edge) => {

        let owner;
        let contentUrl;

        if(edge.node.__typename == 'Clip') {
            owner = edge.node.broadcaster;
            contentUrl = `https://www.twitch.tv/${owner.login}/clip/${edge.node.slug}`
        } else
        {
            owner = edge.node.owner;
            contentUrl = BASE_URL + 'videos/' + edge.node.id;
        }

        const uploadDate = edge?.node?.publishedAt ?? edge?.node?.createdAt ?? "";
        const duration = edge?.node?.lengthSeconds ?? edge?.node?.durationSeconds ?? "";
        const thumbnail = edge?.node?.previewThumbnailURL ?? edge?.node?.thumbnailURL ?? "";

        if (subscriberOnlyIds.has(edge.node.id)) {
            return new PlatformLockedContent({
                id: new PlatformID(PLATFORM, edge.node.id, config.id),
                name: edge.node.title,
                author: new PlatformAuthorLink(
                    new PlatformID(PLATFORM, owner.id, config.id, PLATFORM_CLAIMTYPE),
                    owner.displayName,
                    BASE_URL + owner.login,
                    owner.profileImageURL
                ),
                datetime: parseInt(new Date(uploadDate).getTime() / 1000),
                lockDescription: 'Subscriber only',
                unlockUrl: `https://subs.twitch.tv/${owner.login}`,
            });
        }

        // Return PlatformVideoDetails with HLS source if we have the playback token
        const token = videoTokens[edge.node.id];
        if (token && edge.node.__typename !== 'Clip') {
            return buildVodVideoDetails({
                id: edge.node.id,
                title: edge.node.title,
                thumbnail: thumbnail,
                ownerId: owner.id,
                ownerDisplayName: owner.displayName,
                ownerLogin: owner.login,
                ownerProfileImageURL: owner.profileImageURL,
                uploadDate: uploadDate,
                duration: duration,
                viewCount: edge.node.viewCount,
                url: contentUrl,
                description: edge.node.description,
                hlsUrl: buildVodHlsUrl(edge.node.id, token.signature, token.value),
                game: edge.node.game,
            });
        }

        return new PlatformVideo({
            id: new PlatformID(PLATFORM, edge.node.id, config.id),
            name: edge.node.title,
            thumbnails: new Thumbnails([new Thumbnail(thumbnail, 0)]),
            author: new PlatformAuthorLink(
                new PlatformID(PLATFORM, owner.id, config.id, PLATFORM_CLAIMTYPE),
                owner.displayName,
                BASE_URL + owner.login,
                owner.profileImageURL
            ),
            uploadDate: parseInt(new Date(uploadDate).getTime() / 1000),
            url: contentUrl,
            duration: duration,
            viewCount: edge.node.viewCount,
            isLive: false,
        })
    })

    if (context.VideoCursor === null) {
        // get the currently live stream
        try {
            const current_stream = getLiveVideo(BASE_URL + login, false)
            // remove first video
            videos = videos.slice(1)
            videos.unshift(current_stream)
        } catch (e) {
            log(e)
        }
    }

    if (edges.length > 0) {
        context.VideoCursor = edges[edges.length - 1].cursor
    }

    if (clips.length > 0) {
        context.ClipCursor = clips[clips.length - 1].cursor
    }
       
    context.videosHasNext = videosJson?.data?.user?.videos?.pageInfo?.hasNextPage ?? false;
    context.clipsHasNext = clipsJson?.data?.user?.clips?.pageInfo?.hasNextPage ?? false;
    const hasNext = context.videosHasNext || context.clipsHasNext;

    return new ChannelVideoPager(context, videos, hasNext)
}

/**
 * Gets a search pager
 * @param {import("./types.d.ts").SearchContext} context the query params
 * @returns {(PlatformVideo | PlatformChannel)[]} returns the search pager
 * @throws {ScriptException}
 */
function getSearchPagerAll(context) {
    const gql = {
        extensions: {
            persistedQuery: {
                sha256Hash: '6ea6e6f66006485e41dbe3ebd69d5674c5b22896ce7b595d7fce6411a3790138',
                version: 1,
            },
        },
        operationName: 'SearchResultsPage_SearchResults',
        variables: {
            query: context.q,
            options: null,
            requestID: '',
        },
        query: 'query SearchResultsPage_SearchResults( $query: String! $options: SearchForOptions $requestID: ID ) { searchFor( userQuery: $query platform: "web" options: $options requestID: $requestID ) { channels { ...searchForChannelsFragment } channelsWithTag { ...searchForChannelsWithTagFragment } games { ...searchForGamesFragment } videos { ...searchForVideosFragment } relatedLiveChannels { ...relatedLiveChannelsFragment } } } fragment relatedLiveChannelsFragment on SearchForResultRelatedLiveChannels { edges { trackingID item { ...searchRelatedLiveChannelFragment } } score } fragment searchForGamesFragment on SearchForResultGames { cursor edges { trackingID item { ...searchForGameFragment ...searchForVideoFragment ...searchForUserFragment } } score totalMatches } fragment searchForChannelsFragment on SearchForResultUsers { cursor edges { trackingID item { ...searchForUserFragment ...searchForVideoFragment ...searchForGameFragment } } score totalMatches } fragment searchForChannelsWithTagFragment on SearchForResultUsers { cursor edges { trackingID item { ...searchForUserFragment ...searchForVideoFragment ...searchForGameFragment } } score totalMatches } fragment searchForVideosFragment on SearchForResultVideos { cursor edges { trackingID item { ...searchForVideoFragment ...searchForUserFragment ...searchForGameFragment } } score totalMatches } fragment searchRelatedLiveChannelFragment on User { id stream { id viewersCount previewImageURL(height: 112 width: 200) game { name id } broadcaster { id primaryColorHex login displayName broadcastSettings { id title } roles { isPartner } } } watchParty { session { id contentRestriction } } } fragment searchForGameFragment on Game { id name displayName boxArtURL(height: 120 width: 90) tags(tagType: CONTENT) { id } viewersCount } fragment searchForScheduleSegmentFragment on ScheduleSegment { id startAt endAt title hasReminder categories { id name } } fragment searchForUserFragment on User { broadcastSettings { id title } displayName followers { totalCount } id lastBroadcast { id startedAt } login profileImageURL(width: 150) description channel { id schedule { id nextSegment { ...searchForScheduleSegmentFragment } } } self { canFollow follower { disableNotifications } } latestVideo: videos(first: 1 sort: TIME type: ARCHIVE) { edges { node { ...searchForFeaturedVideoFragment } } } topClip: clips(first: 1 criteria: { sort: VIEWS_DESC }) { edges { node { ...searchForFeaturedClipFragment } } } roles { isPartner } stream { game { id name displayName } id previewImageURL(height: 120 width: 214) freeformTags { id } type viewersCount } watchParty { session { id contentRestriction } } } fragment searchForFeaturedVideoFragment on Video { id lengthSeconds title previewThumbnailURL(width: 100 height: 56) } fragment searchForFeaturedClipFragment on Clip { id title durationSeconds thumbnailURL slug } fragment searchForVideoFragment on Video { createdAt owner { id displayName login roles { isPartner } } id game { id name displayName } lengthSeconds previewThumbnailURL(height: 120 width: 214) title viewCount }',
    }

    /** @type {import("./types.d.ts").AllSearchResponse} */
    const json = callGQL(gql)

    const sf = json.data.searchFor

    /** @type {PlatformVideo[]} */
    const results = []

    for (const e of sf.channels.edges) {
        if (e.item.stream !== null) {
            results.push(searchTaggedToPlatformVideo(e.item))
        }
    }

    for (const e of sf.channelsWithTag.edges) {
        results.push(searchTaggedToPlatformVideo(e.item))
    }

    // for (const e of sf.channels.edges) {
    //   results.push(searchTaggedToPlatformVideo(e.item))
    // }

    for (const e of sf.relatedLiveChannels.edges) {
        results.push(searchLiveToPlatformVideo(e.item))
    }

    for (const e of sf.videos.edges) {
        results.push(searchVideoToPlatformVideo(e.item))
    }

    return new SearchPagerAll(context, results)
}

/**
 * Gets a search pager for channels
 * @param {import("./types").SearchContext} context the query params
 * @returns {SearchPagerChannels} returns the search pager
 * @throws {ScriptException}
 */
function getSearchPagerChannels(context) {
    const gql = {
        extensions: {
            persistedQuery: {
                sha256Hash: '6ea6e6f66006485e41dbe3ebd69d5674c5b22896ce7b595d7fce6411a3790138',
                version: 1,
            },
        },
        operationName: 'SearchResultsPage_SearchResults',
        variables: {
            options: {
                targets: [
                    {
                        index: 'CHANNEL',
                        limit: context.page_size,
                        cursor: context?.cursor ?? null,
                    },
                ],
            },
            query: context.q,
            requestID: '',
        },
        query: 'query SearchResultsPage_SearchResults( $query: String! $options: SearchForOptions $requestID: ID ) { searchFor( userQuery: $query platform: "web" options: $options requestID: $requestID ) { channels { ...searchForChannelsFragment } channelsWithTag { ...searchForChannelsWithTagFragment } games { ...searchForGamesFragment } videos { ...searchForVideosFragment } relatedLiveChannels { ...relatedLiveChannelsFragment } } } fragment relatedLiveChannelsFragment on SearchForResultRelatedLiveChannels { edges { trackingID item { ...searchRelatedLiveChannelFragment } } score } fragment searchForGamesFragment on SearchForResultGames { cursor edges { trackingID item { ...searchForGameFragment ...searchForVideoFragment ...searchForUserFragment } } score totalMatches } fragment searchForChannelsFragment on SearchForResultUsers { cursor edges { trackingID item { ...searchForUserFragment ...searchForVideoFragment ...searchForGameFragment } } score totalMatches } fragment searchForChannelsWithTagFragment on SearchForResultUsers { cursor edges { trackingID item { ...searchForUserFragment ...searchForVideoFragment ...searchForGameFragment } } score totalMatches } fragment searchForVideosFragment on SearchForResultVideos { cursor edges { trackingID item { ...searchForVideoFragment ...searchForUserFragment ...searchForGameFragment } } score totalMatches } fragment searchRelatedLiveChannelFragment on User { id stream { id viewersCount previewImageURL(height: 112 width: 200) game { name id } broadcaster { id primaryColorHex login displayName broadcastSettings { id title } roles { isPartner } } } watchParty { session { id contentRestriction } } } fragment searchForGameFragment on Game { id name displayName boxArtURL(height: 120 width: 90) tags(tagType: CONTENT) { id } viewersCount } fragment searchForScheduleSegmentFragment on ScheduleSegment { id startAt endAt title hasReminder categories { id name } } fragment searchForUserFragment on User { broadcastSettings { id title } displayName followers { totalCount } id lastBroadcast { id startedAt } login profileImageURL(width: 150) description channel { id schedule { id nextSegment { ...searchForScheduleSegmentFragment } } } self { canFollow follower { disableNotifications } } latestVideo: videos(first: 1 sort: TIME type: ARCHIVE) { edges { node { ...searchForFeaturedVideoFragment } } } topClip: clips(first: 1 criteria: { sort: VIEWS_DESC }) { edges { node { ...searchForFeaturedClipFragment } } } roles { isPartner } stream { game { id name displayName } id previewImageURL(height: 120 width: 214) freeformTags { id } type viewersCount } watchParty { session { id contentRestriction } } } fragment searchForFeaturedVideoFragment on Video { id lengthSeconds title previewThumbnailURL(width: 100 height: 56) } fragment searchForFeaturedClipFragment on Clip { id title durationSeconds thumbnailURL slug } fragment searchForVideoFragment on Video { createdAt owner { id displayName login roles { isPartner } } id game { id name displayName } lengthSeconds previewThumbnailURL(height: 120 width: 214) title viewCount }',
    }

    /** @type {import("./types.d.ts").AllSearchResponse}*/
    const json = callGQL(gql)

    const results = json.data.searchFor.channels.edges.map((edge) => searchChannelToPlatformChannel(edge.item))

    context.cursor = json.data.searchFor.channels.cursor

    context.results_returned = results.length + context.results_returned

    return new SearchPagerChannels(results, json.data.searchFor.channels.totalMatches > context.results_returned, context)
}

//Pagers
class HomePagerPopular extends VideoPager {
    /**
     * @param {PlatformVideo[]} results the initial results
     * @param {boolean} hasNextPage if there is a next page
     * @param {import("./types.d.ts").HomeContext} context the context
     */
    constructor(results, hasNextPage, context) {
        super(results, hasNextPage, context)
    }

    nextPage() {
        return getHomePagerPopular(this.context)
    }
}

class ChannelVideoPager extends VideoPager {
    /**
     * @param {import("./types.d.ts").URLContext} context the context
     * @param {PlatformVideo[]} results the initial results
     * @param {boolean} hasNextPage if there is a next page
     */
    constructor(context, results, hasNextPage) {
        super(results, hasNextPage, context)
    }

    nextPage() {
        return getChannelPager(this.context)
    }
}

class SearchPagerAll extends VideoPager {
    /**
     * @param {import("./types.d.ts").SearchContext} context the query params
     * @param {(PlatformVideo | PlatformChannel)[]} results the initial results
     */
    constructor(context, results) {
        super(results, false, context)
    }

    nextPage() {
        return null
    }
}

class SearchPagerChannels extends ChannelPager {
    constructor(results, hasNextPage, context) {
        super(results, hasNextPage, context)
    }

    nextPage() {
        return getSearchPagerChannels(this.context)
    }
}

class ExtendableCommentPager extends CommentPager {
    constructor(context, results) {
        super(results, results.length >= context.page_size, context)
    }

    nextPage() {
        this.context.page = this.context.page + 1
        return getCommentPager(this.context)
    }
}

//* Converters

/**
 * Convert a Live Twitch to a PlatformVideo
 * @param { import("./types.d.ts").RelatedLiveSearchResponse } sl
 * @returns { PlatformVideo }
 */
function searchLiveToPlatformVideo(sl) {
    return new PlatformVideo({
        id: new PlatformID(PLATFORM, sl.id, config.id),
        name: sl.stream.broadcaster.broadcastSettings.title,
        thumbnails: new Thumbnails([new Thumbnail(sl.stream.previewImageURL, 0)]),
        author: new PlatformAuthorLink(
            new PlatformID(PLATFORM, sl.stream.broadcaster.id, config.id, PLATFORM_CLAIMTYPE),
            sl.stream.broadcaster.displayName,
            BASE_URL + sl.stream.broadcaster.login,
            sl.stream.broadcaster.profileImageURL || ''
        ),
        uploadDate: parseInt(new Date().getTime() / 1000),
        duration: 0,
        viewCount: sl.stream.viewersCount,
        url: BASE_URL + sl.stream.broadcaster.login,
        shareUrl: BASE_URL + sl.stream.broadcaster.login,
        isLive: true,
    })
}

/**
 * Convert a Video Twitch to a PlatformVideo
 * @param { import("./types.d.ts").VideoSearchResponse } sv
 * @returns { PlatformVideo }
 */
function searchVideoToPlatformVideo(sv) {
    return new PlatformVideo({
        id: new PlatformID(PLATFORM, sv.id, config.id),
        name: sv.title,
        thumbnails: new Thumbnails([new Thumbnail(sv.previewThumbnailURL, 0)]),
        author: new PlatformAuthorLink(new PlatformID(PLATFORM, sv.owner.id, config.id, PLATFORM_CLAIMTYPE), sv.owner.displayName, BASE_URL + sv.owner.login, ''),
        uploadDate: parseInt(new Date(sv.createdAt).getTime() / 1000),
        duration: parseInt(sv.lengthSeconds),
        viewCount: sv.viewCount,
        url: BASE_URL + sv.owner.login + '/video/' + sv.id,
        isLive: false,
    })
}

/**
 * Convert a Channel Twitch to a PlatformVideo
 * @param { import("./types.d.ts").ChannelSearchResponse } st
 * @returns { PlatformChannel }
 */
function searchTaggedToPlatformVideo(st) {
    return new PlatformVideo({
        id: new PlatformID(PLATFORM, st.stream.id, config.id),
        name: st.broadcastSettings.title,
        thumbnails: new Thumbnails([new Thumbnail(st.stream.previewImageURL, 0)]),
        author: new PlatformAuthorLink(new PlatformID(PLATFORM, st.id, config.id, PLATFORM_CLAIMTYPE), st.displayName, BASE_URL + st.login, st.profileImageURL || ''),
        uploadDate: parseInt(new Date().getTime() / 1000),
        duration: 0,
        viewCount: st.stream.viewersCount,
        url: BASE_URL + st.login,
        shareUrl: BASE_URL + st.login,
        isLive: true,
    })
}

/**
 * Convert a Channel Twitch to a PlatformChannel
 * @param { import("./types.d.ts").ChannelSearchResponse } sc
 * @returns { PlatformChannel }
 */
function searchChannelToPlatformChannel(sc) {
    return new PlatformChannel({
        id: new PlatformID(PLATFORM, sc.id, config.id, PLATFORM_CLAIMTYPE),
        name: sc.displayName,
        thumbnail: sc.profileImageURL,
        banner: '',
        subscribers: sc.followers.totalCount,
        description: sc.description,
        url: BASE_URL + sc.login,
        links: [],
    })
}

function extractChannelId(url) {
    const match = url.match(REGEX_URL_CHANNEL);
    if (match && match[1]) return match[1];
    throw new ScriptException(`Could not extract channel login from URL: ${url}`);
}

function trace(msg, { showToast = false } = {}) {
    if (_settings?.verboseNotifications || showToast) {
        bridge.toast(msg);
    }
    log(msg);
}

function ensureHttpOk(resp, label) {
    if (!resp.isOk) {
        trace(`${label} failed (${resp.code}): ${resp.body}`);
        throw new ScriptException(`${label} returned ${resp.code}`);
    }
}

function buildLiveHlsUrl(login, spat) {
    if (_settings?.useLegacyHlsUrl) {
        return `https://usher.ttvnw.net/api/channel/hls/${login}.m3u8?acmb=e30=&allow_source=true&fast_bread=true&p=&play_session_id=&player_backend=mediaplayer&playlist_include_framerate=true&reassignments_supported=true&sig=${spat.signature}&supported_codecs=h265,h264&token=${encodeURIComponent(spat.value)}&transcode_mode=cbr_v1&cdm=wv&player_version=1.20.0`;
    }
    ensureDeviceIds();
    const params = {
        acmb: ACMB_VALUE,
        allow_source: 'true',
        browser_family: 'firefox',
        browser_version: '149.0',
        cdm: 'wv',
        enable_score: 'true',
        fast_bread: 'true',
        include_unavailable: 'true',
        lang: 'en',
        os_name: 'Windows',
        os_version: 'NT 10.0',
        p: String(Math.floor(Math.random() * 9000000) + 1000000),
        platform: 'web',
        play_session_id: state.sessionId,
        player_backend: 'mediaplayer',
        player_version: TWITCH_PLAYER_VERSION,
        playlist_include_framerate: 'true',
        reassignments_supported: 'true',
        sig: spat.signature,
        supported_codecs: 'av1,h265,h264',
        token: spat.value,
        transcode_mode: 'cbr_v1',
    };
    const query = Object.keys(params).map(k => `${k}=${encodeURIComponent(params[k])}`).join('&');
    return `https://usher.ttvnw.net/api/v2/channel/hls/${login}.m3u8?${query}`;
}

function buildApiHeaders({ includeIntegrity = false } = {}) {
    const headers = {
        Accept: '*/*',
        DNT: '1',
        Host: 'gql.twitch.tv',
        Origin: 'https://www.twitch.tv',
        Referer: 'https://www.twitch.tv/',
        'Client-Id': CLIENT_ID,
        'Client-Version': TWITCH_CLIENT_VERSION,
        'Client-Session-Id': state.sessionId,
        'X-Device-Id': state.deviceId,
    };

    if (!_settings?.impersonateApiRequests) {
        headers['User-Agent'] = getUserAgent();
    }

    if (includeIntegrity) {
        headers['Client-Integrity'] = state.integrity;
    }

    return headers;
}

function mediaRequestModifier() {
    if (!IS_IMPERSONATION_AVAILABLE || !_settings?.impersonateMediaRequests) return undefined;
    return {
        options: {
            applyAuthClient: "",
            applyCookieClient: "",
            applyOtherHeaders: false,
            impersonateTarget: IMPERSONATION_TARGET,
        }
    };
}

/**
 * Checks if a URL matches any Twitch clip URL formats
 * @param {string} url - The URL to check
 * @returns {boolean} - True if the URL matches any regex, false otherwise
 */
function isTwitchClipDetailsUrl(url) {
    if (!url) return false;

    for (const regex of REGEX_URL_CLIP_DETAILS_LIST) {
        if (regex.test(url)) {
            return true;
        }
    }

    return false;
}

function isVideoUrl(url) {
    return REGEX_URL_VIDEO_DETAILS.test(url) || OLD_REGEX_URL_VIDEO_DETAILS.test(url);
}

function isChannelUrl(url) {
    // Match valid channel URLs while excluding specific paths
    return (
        REGEX_URL_CHANNEL.test(url) 
     || REGEX_URL_CHANNEL_CLIPS_FILTER.test(url) 
    )
    && !isTwitchClipDetailsUrl(url) 
    && !isVideoUrl(url);
}

/**
 * Extracts the clip ID from various Twitch clip URL formats
 * @param {string} url - The Twitch clip URL
 * @returns {string|null} - The clip ID if found, null otherwise
 */
function extractTwitchClipSlug(url) {
    if (!url) return null;

    for (const regex of REGEX_URL_CLIP_DETAILS_LIST) {
        const match = url.match(regex);
        if (match) {
            return match[2];
        }
    }

    return null;
}

function extractTwitchVideoId(url) {
    if (url) {
        for (const re of [REGEX_URL_VIDEO_DETAILS, OLD_REGEX_URL_VIDEO_DETAILS]) {
            const m = url.match(re);
            if (m) return m[2];
        }
    }
    throw new ScriptException(`Could not extract VOD id from URL: ${url}`);
}


/**
 * Gets recommendations based on game, tags, and other criteria
 * @param {Object} params - Recommendation parameters
 * @param {string} params.gameId - Game ID for recommendations
 * @param {string} params.gameName - Game name for recommendations
 * @param {string[]} params.tags - Tags for recommendations
 * @param {string} params.broadcasterId - Broadcaster ID to exclude
 * @param {string} params.excludeUrl - URL to exclude from results
 * @returns {VideoPager} Pager with recommended content
 */
function getRecommendationsPager(params) {
    const { gameId, gameName, tags, broadcasterId, excludeUrl } = params;

    // Build GraphQL query for recommendations
    // If we have a specific game ID, use the directory query for that game
    // Otherwise, use the general popular streams query
    let gql;

    if (gameId && gameName) {
        // Use directory query for specific game
        gql = {
            operationName: 'DirectoryPage_Game',
            variables: {
                name: gameName,
                options: {
                    includeRestricted: ['SUB_ONLY_LIVE'],
                    sort: 'VIEWER_COUNT',
                    recommendationsContext: {
                        platform: 'web',
                    },
                    requestID: 'RECOMMENDATIONS',
                    freeformTags: tags.length > 0 ? tags.slice(0, MAX_RECOMMENDATION_TAGS) : null,
                },
                limit: RECOMMENDATION_LIMIT,
            },
            query: `query DirectoryPage_Game($name: String!, $options: GameStreamOptions, $limit: Int) {
                game(name: $name) {
                    id
                    displayName
                    streams(first: $limit, options: $options) {
                        edges {
                            cursor
                            node {
                                id
                                title
                                previewImageURL(width: 320, height: 180)
                                viewersCount
                                broadcaster {
                                    id
                                    login
                                    displayName
                                    profileImageURL(width: 50)
                                }
                            }
                        }
                        pageInfo {
                            hasNextPage
                        }
                    }
                }
            }`,
        };
    } else {
        // Use general popular streams query (same as getHomePagerPopular)
        gql = {
            operationName: 'BrowsePage_Popular',
            variables: {
                limit: RECOMMENDATION_LIMIT,
                options: {
                    broadcasterLanguages: ['EN'],
                    freeformTags: tags.length > 0 ? tags.slice(0, MAX_RECOMMENDATION_TAGS) : null,
                    includeRestricted: ['SUB_ONLY_LIVE'],
                    recommendationsContext: {
                        platform: 'web',
                    },
                    requestID: 'RECOMMENDATIONS',
                    sort: 'RELEVANCE',
                    tags: [],
                },
                platformType: 'all',
            },
            query: `query BrowsePage_Popular($limit: Int, $cursor: Cursor, $platformType: PlatformType, $options: StreamOptions) {
                streams(first: $limit, after: $cursor, platformType: $platformType, options: $options) {
                    edges {
                        cursor
                        node {
                            id
                            title
                            previewImageURL(width: 320, height: 180)
                            viewersCount
                            broadcaster {
                                id
                                login
                                displayName
                                profileImageURL(width: 50)
                            }
                        }
                    }
                    pageInfo {
                        hasNextPage
                    }
                }
            }`,
        };
    }

    try {
        /** @type {import("./types.d.ts").BrowsePopularResponse}*/
        const json = callGQL(gql);
        let streams;

        // Handle different response structures based on query type
        if (gameId && gameName && json?.data?.game?.streams?.edges) {

            // DirectoryPage_Game query response
            streams = json.data.game.streams.edges;
        } else if (json?.data?.streams?.edges) {

            // BrowsePage_Popular query response
            streams = json.data.streams.edges;
        } else if (gameId && gameName && json.data.game === null) {

            // Game not found, fall back to popular streams
            return getHomePagerPopular({ cursor: null, page_size: 20 }, excludeUrl);
        } else {
            // No streams found

            return new VideoPager([], false, {});
        }

        streams = streams
            .filter((s) => s.node.broadcaster)
            .map((s) => {
                let n = s.node;
                return new PlatformVideo({
                    id: new PlatformID(PLATFORM, n.id, config.id),
                    name: n.title,
                    thumbnails: new Thumbnails([new Thumbnail(n.previewImageURL, 0)]),
                    author: new PlatformAuthorLink(
                        new PlatformID(PLATFORM, n.broadcaster.id, config.id, PLATFORM_CLAIMTYPE),
                        n.broadcaster.login,
                        BASE_URL + n.broadcaster.login,
                        n.broadcaster.profileImageURL
                    ),
                    uploadDate: parseInt(new Date().getTime() / 1000),
                    duration: 0,
                    viewCount: n.viewersCount,
                    url: BASE_URL + n.broadcaster.login,
                    shareUrl: BASE_URL + n.broadcaster.login,
                    isLive: true,
                });
            });

        // Filter out the original content and broadcaster
        if (excludeUrl) {
            // Normalize URLs for comparison (remove trailing slashes, convert to lowercase)
            const normalizeUrl = (url) => url.toLowerCase().replace(/\/$/, '');
            const normalizedExcludeUrl = normalizeUrl(excludeUrl);
            streams = streams.filter(stream => normalizeUrl(stream.url) !== normalizedExcludeUrl);
        }
        if (broadcasterId) {
            streams = streams.filter(stream => stream.author.id.value !== broadcasterId);
        }
        return new VideoPager(streams, false, {});
    } catch (e) {
        log(`Error getting recommendations: ${e.message}`);
        return new VideoPager([], false, {});
    }
}


function isRestrictedToSubscriberOnly(token) {
    const tokenValue = JSON.parse(token.value);
    const restricted = tokenValue?.chansub?.restricted_bitrates ?? [];
    return restricted.includes('chunked');
}

function buildVodHlsUrl(vodId, signature, tokenValue) {
    return `https://usher.ttvnw.net/vod/${vodId}.m3u8?acmb=e30=&allow_source=true&fast_bread=true&p=&play_session_id=&player_backend=mediaplayer&playlist_include_framerate=true&reassignments_supported=true&sig=${signature}&supported_codecs=h265,h264&token=${encodeURIComponent(tokenValue)}&transcode_mode=cbr_v1&cdm=wv&player_version=1.20.0`;
}

function buildVodVideoDetails({ id, title, thumbnail, ownerId, ownerDisplayName, ownerLogin, ownerProfileImageURL, uploadDate, duration, viewCount, url, description, hlsUrl, game }) {
    const sources = [new HLSSource({ name: 'source', duration: 0, url: hlsUrl, requestModifier: mediaRequestModifier() })];
    const result = new PlatformVideoDetails({
        id: new PlatformID(PLATFORM, id, config.id),
        name: title,
        thumbnails: new Thumbnails([new Thumbnail(thumbnail, 0)]),
        author: new PlatformAuthorLink(
            new PlatformID(PLATFORM, ownerId, config.id, PLATFORM_CLAIMTYPE),
            ownerDisplayName,
            BASE_URL + ownerLogin,
            ownerProfileImageURL
        ),
        uploadDate: parseInt(new Date(uploadDate).getTime() / 1000),
        duration: duration,
        viewCount: viewCount,
        url: url,
        isLive: false,
        description: description ?? '',
        video: new VideoSourceDescriptor(sources),
    });

    const vodMetadata = { game: game };

    if (IS_TESTING) {
        source.getContentRecommendations(url, vodMetadata);
    } else {
        result.getContentRecommendations = function () {
            return source.getContentRecommendations(url, vodMetadata);
        };

        result.getVODEvents = function () {
            return new TwitchVODEventPager(id);
        };
    }

    return result;
}

log('LOADED')