vega-providers/dist/autoEmbed/stream.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getStream = void 0;
exports.getRiveStream = getRiveStream;
const types_1 = require("../types");
const getStream = 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.getStream = getStream;
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";
    }
}