vega-providers/dist/autoEmbed/allGetStream.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.allGetStream = void 0;
exports.getRiveStream = getRiveStream;
const types_1 = require("../types");
const allGetStream = async ({ link: id, type, providerContext, }) => {
    try {
        const streams = [];
        const { imdbId, season, episode, title, tmdbId, year } = JSON.parse(id);
        await getRiveStream(tmdbId, episode, season, type, streams, providerContext);
        return streams;
    }
    catch (err) {
        console.error(err);
        return [];
    }
};
exports.allGetStream = allGetStream;
async function getRiveStream(tmdId, episode, season, type, Streams, providerContext) {
    const secret = generateSecretKey(Number(tmdId));
    const servers = [
        'flowcast',
        'shadow',
        'asiacloud',
        'hindicast',
        'anime',
        'animez',
        'guard',
        'curve',
        'hq',
        'ninja',
        'alpha',
        'kaze',
        'zenesis',
        'genesis',
        'zenith',
        'ghost',
        'halo',
        'kinoecho',
        'ee3',
        'volt',
        'putafilme',
        'ophim',
        'kage',
    ];
    const baseUrl = await providerContext.getBaseUrl('rive');
    const cors = process.env.CORS_PRXY ? process.env.CORS_PRXY + '?url=' : '';
    console.log('CORS: ' + cors);
    const route = type === 'series'
        ? `/api/backendfetch?requestID=tvVideoProvider&id=${tmdId}&season=${season}&episode=${episode}&secretKey=${secret}&service=`
        : `/api/backendfetch?requestID=movieVideoProvider&id=${tmdId}&secretKey=${secret}&service=`;
    const url = cors
        ? cors + encodeURIComponent(baseUrl + route)
        : baseUrl + route;
    await Promise.all(servers.map(async (server) => {
        console.log('Rive: ' + url + server);
        try {
            const res = await providerContext.axios.get(url + server, {
                timeout: 4000,
                headers: providerContext.commonHeaders,
            });
            const subtitles = [];
            if (res.data?.data?.captions) {
                res.data?.data?.captions.forEach((sub) => {
                    subtitles.push({
                        language: sub?.label?.slice(0, 2) || 'Und',
                        uri: sub?.file,
                        title: sub?.label || 'Undefined',
                        type: sub?.file?.endsWith('.vtt')
                            ? types_1.TextTrackType.VTT
                            : types_1.TextTrackType.SUBRIP,
                    });
                });
            }
            res.data?.data?.sources.forEach((source) => {
                Streams.push({
                    server: source?.source + '-' + source?.quality,
                    link: source?.url,
                    type: source?.format === 'hls' ? 'm3u8' : 'mp4',
                    quality: source?.quality,
                    subtitles: subtitles,
                });
            });
        }
        catch (e) {
            console.log(e);
        }
    }));
}
function generateSecretKey(id) {
    // Array of secret key fragments - updated array from the new implementation
    const c = [
        'Yhv40uKAZa',
        'nn8YU4yBA',
        'uNeH',
        'ehK',
        'jT0',
        'n5G',
        '99R',
        'MvB1M',
        'DQtPCh',
        'GBRjk4k4I',
        'CzIOoa95UT',
        'BLE8s',
        'GDZlc7',
        'Fz45T',
        'JW6lWn',
        'DE3g4uw0i',
        '18KxmYizv',
        '8ji',
        'JUDdNMnZ',
        'oGpBippPgm',
        '7De8Pg',
        'Zv6',
        'VHT9TVN',
        'bYH6m',
        'aK1',
        'WcWH6jU',
        'Q47YEMi4k',
        'vRD3A',
        'CGOsfJO',
        'BLn8',
        'RgK0drv7l',
        'oPTfGCn3a',
        'MkpMDkttW9',
        'VNI1fPM',
        'XNFi6',
        '6cq',
        '4LvTksXoEI',
        '1rRa2KOZB0',
        'zoOGRb8HT2',
        'mhcXDtvz',
        'NUmexFY2Ur',
        '6BIMdvSZ',
        'Tr0zU2vjRd',
        'QPR',
        'fhOqJR',
        'R9VnFY',
        'xkZ99D6S',
        'umY7E',
        '5Ds8qyDq',
        'Cc6jy09y3',
        'yvU3iR',
        'Bg07zY',
        'GccECglg',
        'VYd',
        '6vOiXqz',
        '7xX',
        'UdRrbEzF',
        'fE6wc',
        'BUd25Rb',
        'lxq5Zum89o',
    ];
    // Handle undefined input
    if (id === undefined) {
        return 'rive';
    }
    try {
        let fragment, insertPos;
        // Convert input to string
        const idStr = String(id);
        // Updated string hash function to match the new implementation
        /* eslint-disable no-bitwise */
        const generateStringHash = function (input) {
            input = String(input);
            let hash = 0;
            for (let i = 0; i < input.length; i++) {
                const char = input.charCodeAt(i);
                hash =
                    ((char + (hash << 6) + (hash << 16) - hash) ^ (char << i % 5)) >>> 0;
            }
            hash ^= hash >>> 13;
            hash = (1540483477 * hash) >>> 0;
            return (hash ^= hash >>> 15).toString(16).padStart(8, '0');
        };
        // Updated MurmurHash-like function to match the new implementation
        const applyMurmurHash = function (input) {
            const str = String(input);
            let hash = 3735928559 ^ str.length;
            for (let i = 0; i < str.length; i++) {
                let char = str.charCodeAt(i);
                char ^= ((i + 31) * 131) & 255;
                hash =
                    (668265261 *
                        (hash = (((hash << 7) | (hash >>> 25)) >>> 0) ^ char)) >>>
                        0;
            }
            hash ^= hash >>> 16;
            hash = (2246822507 * hash) >>> 0;
            hash ^= hash >>> 13;
            hash = (3266489909 * hash) >>> 0;
            return (hash ^= hash >>> 16).toString(16).padStart(8, '0');
        };
        /* eslint-enable no-bitwise */
        // Generate the encoded hash using the new implementation
        const encodedHash = btoa(applyMurmurHash(generateStringHash(idStr)));
        // Different handling for non-numeric vs numeric inputs
        if (isNaN(Number(id))) {
            // For non-numeric inputs, sum the character codes
            const charSum = idStr
                .split('')
                .reduce((sum, char) => sum + char.charCodeAt(0), 0);
            // Select array element or fallback to base64 encoded input
            fragment = c[charSum % c.length] || btoa(idStr);
            // Calculate insertion position
            insertPos = Math.floor((charSum % encodedHash.length) / 2);
        }
        else {
            // For numeric inputs, use the number directly
            const numId = Number(id);
            fragment = c[numId % c.length] || btoa(idStr);
            // Calculate insertion position
            insertPos = Math.floor((numId % encodedHash.length) / 2);
        }
        // Construct the final key by inserting the selected value into the base64 string
        return (encodedHash.slice(0, insertPos) + fragment + encodedHash.slice(insertPos));
    }
    catch (error) {
        // Return fallback value if any errors occur
        return 'topSecret';
    }
}