@vyla-entertainment/sdk 1.10.0 → 1.12.0

package/src/sources/4khdhub.js

@@ -0,0 +1,324 @@
+import { getUA } from '../utils/helpers.js';
+
+const INITIAL_BASE_URL = 'https://4khdhub.one';
+let cachedBaseUrl = null;
+let cachedBaseUrlExpiry = 0;
+
+function rot13(str) {
+    return str.replace(/[a-zA-Z]/g, (c) => {
+        const code = c.charCodeAt(0);
+        if (code >= 65 && code <= 90) {
+            return String.fromCharCode(((code - 65 + 13) % 26) + 65);
+        }
+        return String.fromCharCode(((code - 97 + 13) % 26) + 97);
+    });
+}
+
+function levenshtein(a, b) {
+    if (a === b) return 0;
+    if (!a.length) return b.length;
+    if (!b.length) return a.length;
+    const la = a.length;
+    const lb = b.length;
+    const d = Array.from({ length: la + 1 }, () => new Array(lb + 1).fill(0));
+    for (let i = 0; i <= la; i++) d[i][0] = i;
+    for (let j = 0; j <= lb; j++) d[0][j] = j;
+    for (let i = 1; i <= la; i++) {
+        for (let j = 1; j <= lb; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+        }
+    }
+    return d[la][lb];
+}
+
+async function getBaseUrl(ua) {
+    if (cachedBaseUrl && Date.now() < cachedBaseUrlExpiry) {
+        return cachedBaseUrl;
+    }
+
+    let currentUrl = INITIAL_BASE_URL;
+    for (let i = 0; i < 10; i++) {
+        try {
+            const res = await fetch(currentUrl, {
+                method: 'HEAD',
+                headers: { 'User-Agent': ua },
+                redirect: 'manual',
+                signal: AbortSignal.timeout(10000),
+            });
+
+            if (res.status >= 300 && res.status < 400) {
+                const location = res.headers.get('location');
+                if (location) {
+                    currentUrl = new URL(location, currentUrl).toString();
+                    continue;
+                }
+            }
+            break;
+        } catch {
+            break;
+        }
+    }
+
+    const parsed = new URL(currentUrl);
+    cachedBaseUrl = `${parsed.protocol}//${parsed.host}`;
+    cachedBaseUrlExpiry = Date.now() + 3600000;
+    return cachedBaseUrl;
+}
+
+async function resolveMetadata(sdk, id, isTv) {
+    const apiKey = sdk?.tmdbApiKey || process.env.TMDB_API_KEY;
+    if (!apiKey) return null;
+    const type = isTv ? 'tv' : 'movie';
+    try {
+        const res = await fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}`, {
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok) return null;
+        const data = await res.json();
+        const title = isTv ? data.name : data.title;
+        const releaseDate = isTv ? data.first_air_date : data.release_date;
+        const year = releaseDate ? parseInt(releaseDate.split('-')[0], 10) : null;
+        return { title, year };
+    } catch {
+        return null;
+    }
+}
+
+function sanitizeStreamUrl(rawUrl) {
+    try {
+        const parsed = new URL(rawUrl);
+        parsed.pathname = parsed.pathname.replaceAll('::', '%3A%3A');
+        return parsed.toString();
+    } catch {
+        return rawUrl.replaceAll('::', '%3A%3A');
+    }
+}
+
+async function validateStreamUrl(url, ua) {
+    try {
+        const res = await fetch(url, {
+            headers: {
+                'User-Agent': ua,
+                Range: 'bytes=0-1024',
+            },
+            signal: AbortSignal.timeout(4000),
+        });
+
+        const contentType = (res.headers.get('content-type') || '').toLowerCase();
+        const isSuccess = (res.status >= 200 && res.status < 300) || res.status === 206;
+        const isHtmlOrJsonError = contentType.includes('text/html') || contentType.includes('application/json');
+
+        if (!isSuccess || isHtmlOrJsonError) return false;
+        return true;
+    } catch {
+        return true;
+    }
+}
+
+async function resolveRedirectUrl(redirectUrl, ua) {
+    try {
+        const res = await fetch(redirectUrl, {
+            headers: { 'User-Agent': ua },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!res.ok) return null;
+        const html = await res.text();
+
+        let nextUrl = '';
+        const downloadMatch = html.match(/<a id="download" href="(.*?)"/);
+        if (downloadMatch) {
+            nextUrl = downloadMatch[1];
+        } else {
+            const varMatch = html.match(/var url = '(.*?)';/);
+            if (varMatch) {
+                nextUrl = varMatch[1];
+            }
+        }
+
+        if (!nextUrl) {
+            const match = html.match(/'o','(.*?)'/);
+            if (!match) return null;
+            const rawData = match[1];
+            const step1 = Buffer.from(rawData, 'base64').toString('utf8');
+            const step2 = Buffer.from(step1, 'base64').toString('utf8');
+            const step3 = rot13(step2);
+            const step4 = Buffer.from(step3, 'base64').toString('utf8');
+            const data = JSON.parse(step4);
+            return Buffer.from(data.o, 'base64').toString('utf8');
+        }
+
+        const interRes = await fetch(nextUrl, {
+            headers: { 'User-Agent': ua },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!interRes.ok) return null;
+        const interHtml = await interRes.text();
+
+        const finalMatch = interHtml.match(/<a href="([^"]+)"[^>]*class="[^"]*btn-success/);
+        if (finalMatch) {
+            return finalMatch[1];
+        }
+
+        return null;
+    } catch {
+        return null;
+    }
+}
+
+async function extractSourceResults(itemHtml, ua) {
+    const sizeMatch = itemHtml.match(/([\d.]+ ?[GM]B)/);
+    const sizeStr = sizeMatch ? sizeMatch[1] : null;
+
+    const heightMatch = itemHtml.match(/\d{3,}p/);
+    const heightStr = heightMatch ? heightMatch[0] : null;
+
+    const fileTitleMatch = itemHtml.match(/class="(?:file-title|episode-file-title)"[^>]*>([^<]+)/);
+    const fileTitle = fileTitleMatch ? fileTitleMatch[1].trim() : 'Unknown';
+
+    const displayParts = [fileTitle];
+    if (heightStr) displayParts.push(heightStr);
+    if (sizeStr) displayParts.push(sizeStr);
+
+    let hubCloudUrl = null;
+    let hubDriveUrl = null;
+
+    const linkRegex = /<a\s+[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+    let match;
+    while ((match = linkRegex.exec(itemHtml)) !== null) {
+        const href = match[1];
+        const text = match[2];
+        if (text.includes('HubCloud') && !hubCloudUrl) {
+            hubCloudUrl = href;
+        } else if (text.includes('HubDrive') && !hubDriveUrl) {
+            hubDriveUrl = href;
+        }
+    }
+
+    const redirectUrl = hubCloudUrl || hubDriveUrl;
+    if (!redirectUrl) return null;
+
+    const resolvedUrl = await resolveRedirectUrl(redirectUrl, ua);
+    if (!resolvedUrl) return null;
+
+    const safeUrl = sanitizeStreamUrl(resolvedUrl);
+    const isValid = await validateStreamUrl(safeUrl, ua);
+    if (!isValid) return null;
+
+    return {
+        url: safeUrl,
+        label: displayParts.join(' · '),
+        headers: {
+            'User-Agent': ua,
+        },
+    };
+}
+
+export async function getStream({ id, s, e, sdk }) {
+    const isTv = Boolean(s && e);
+    const ua = getUA();
+
+    const meta = await resolveMetadata(sdk, id, isTv);
+    if (!meta?.title) return null;
+
+    const baseUrl = await getBaseUrl(ua);
+    const searchUrl = `${baseUrl}/?s=${encodeURIComponent(meta.title)}`;
+
+    const searchRes = await fetch(searchUrl, {
+        headers: { 'User-Agent': ua },
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!searchRes.ok) return null;
+    const searchHtml = await searchRes.text();
+
+    const cardRegex = /<a\s+([^>]*\bclass="[^"]*movie-card[^"]*"[^>]*)>([\s\S]*?)<\/a>/gi;
+    const formatFilter = isTv ? 'Series' : 'Movies';
+    let targetPageUrl = null;
+
+    let cardMatch;
+    while ((cardMatch = cardRegex.exec(searchHtml)) !== null) {
+        const attributes = cardMatch[1];
+        const inner = cardMatch[2];
+
+        const hrefMatch = attributes.match(/href="([^"]+)"/);
+        if (!hrefMatch) continue;
+        const href = hrefMatch[1];
+
+        const formatMatches = [...inner.matchAll(/class="movie-card-format"[^>]*>([\s\S]*?)<\//gi)];
+        const formatTexts = formatMatches.map(m => m[1].trim());
+        if (!formatTexts.some(t => t.includes(formatFilter))) continue;
+
+        if (meta.year != null) {
+            const metaMatch = inner.match(/class="movie-card-meta"[^>]*>([\s\S]*?)<\//i);
+            const yearMatch = metaMatch ? metaMatch[1].match(/\d{4}/) : null;
+            if (yearMatch) {
+                const cardYear = parseInt(yearMatch[0], 10);
+                if (Math.abs(cardYear - meta.year) > 1) continue;
+            }
+        }
+
+        const titleMatch = inner.match(/class="movie-card-title"[^>]*>([\s\S]*?)<\//i);
+        let cardTitle = titleMatch ? titleMatch[1] : '';
+        cardTitle = cardTitle.replace(/\[.*?\]/g, '').trim();
+
+        const diff = levenshtein(cardTitle.toLowerCase(), meta.title.toLowerCase());
+        const isMatch = diff < 5 || (cardTitle.toLowerCase().includes(meta.title.toLowerCase()) && diff < 16);
+        if (!isMatch) continue;
+
+        targetPageUrl = new URL(href, baseUrl).toString();
+        break;
+    }
+
+    if (!targetPageUrl) return null;
+
+    const pageRes = await fetch(targetPageUrl, {
+        headers: { 'User-Agent': ua },
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!pageRes.ok) return null;
+    const pageHtml = await pageRes.text();
+
+    const matchedHtmlBlocks = [];
+
+    if (isTv) {
+        const seasonStr = String(s).padStart(2, '0');
+        const episodeStr = String(e).padStart(2, '0');
+
+        const epItemRegex = /class="[^"]*episode-item[^"]*"[^>]*>([\s\S]*?)(?=(?:class="[^"]*episode-item"|<\/main>|$))/gi;
+        let epMatch;
+        while ((epMatch = epItemRegex.exec(pageHtml)) !== null) {
+            const epBlock = epMatch[1];
+            const titleMatch = epBlock.match(/class="episode-title"[^>]*>([\s\S]*?)<\//i);
+            const titleText = titleMatch ? titleMatch[1] : '';
+            if (!titleText.includes(`S${seasonStr}`)) continue;
+
+            const dlItemRegex = /class="[^"]*episode-download-item[^"]*"[^>]*>([\s\S]*?)(?=(?:class="[^"]*episode-download-item"|<\/div>\s*<\/div>|$))/gi;
+            let dlMatch;
+            while ((dlMatch = dlItemRegex.exec(epBlock)) !== null) {
+                const dlBlock = dlMatch[1];
+                if (dlBlock.includes(`Episode-${episodeStr}`)) {
+                    matchedHtmlBlocks.push(dlBlock);
+                }
+            }
+        }
+    } else {
+        const dlItemRegex = /class="[^"]*download-item[^"]*"[^>]*>([\s\S]*?)(?=(?:class="[^"]*download-item"|<\/main>|$))/gi;
+        let dlMatch;
+        while ((dlMatch = dlItemRegex.exec(pageHtml)) !== null) {
+            matchedHtmlBlocks.push(dlMatch[1]);
+        }
+    }
+
+    if (matchedHtmlBlocks.length === 0) return null;
+
+    const results = await Promise.all(matchedHtmlBlocks.map((block) => extractSourceResults(block, ua)));
+    const allUrls = results.filter(Boolean);
+
+    if (allUrls.length === 0) return null;
+
+    return {
+        url: allUrls[0].url,
+        allUrls,
+        headers: allUrls[0].headers,
+    };
+}

package/src/sources/bcine.js

@@ -0,0 +1,202 @@
+import { USER_AGENT } from '../utils/helpers.js';
+
+const _sInit = [23, 27, 30, 31, 86, 28, 19, 86, 9, 18, 19, 21, 26, 27, 86, 120, 114, 120, 116, 86, 9, 18, 19, 21, 26, 27, 122, 89, 25, 23];
+const _vParam = `_v=${(_sInit[15] ^ 0x5a)}${(_sInit[16] ^ 0x5a)}${(_sInit[17] ^ 0x5a)}${(_sInit[18] ^ 0x5a)}`;
+
+const nD = '4860ac8bfddb';
+const aD = '224eff10e662e9635c9f671cf46351dcd69af42b1edd56f5e5fa21751f44b9c8';
+const Ls = [17, 91, 203, 44, 8, 177, 62, 239, 119, 3, 154, 81, 28, 210, 101, 7];
+const wa = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+const SERVERS = [
+    { id: 'NIGHT', endpoint: '/server/night' },
+    { id: 'EMP', endpoint: '/server/emp' },
+    { id: 'MAIN', endpoint: '/server/vidsrc' }
+];
+
+const CORS_PROXY = 'https://eve.pstream.cfd';
+let cachedToken = null;
+let tokenExpiry = 0;
+
+function ab(e) {
+    let t = e >>> 0;
+    t ^= t >>> 16;
+    t = Math.imul(t, 2146121005) >>> 0;
+    t ^= t >>> 15;
+    t = Math.imul(t, 2221713035) >>> 0;
+    return (t ^ (t >>> 16)) >>> 0;
+}
+
+function sD(e) {
+    const t = new TextEncoder().encode(aD);
+    const r = Math.max(32, Math.min(128, e + 17));
+    const n = new Uint8Array(r);
+    let a = 2166136261;
+    for (let s = 0; s < r; s += 1) {
+        a ^= t[s % t.length] ?? s;
+        a = ab((a + Ls[s % Ls.length] + ((2654435761 * s) >>> 0)) >>> 0);
+        n[s] = a & 255;
+    }
+    return n;
+}
+
+function iD(e) {
+    let t = '';
+    for (let r = 0; r < e.length; r += 3) {
+        const n = e[r];
+        const a = e[r + 1];
+        const s = e[r + 2];
+        t += wa[n >>> 2];
+        t += wa[((3 & n) << 4) | ((a ?? 0) >>> 4)];
+        if (a === undefined) break;
+        t += wa[((15 & a) << 2) | ((s ?? 0) >>> 6)];
+        if (s === undefined) break;
+        t += wa[63 & s];
+    }
+    return t;
+}
+
+function generateDirectHlsUrl(id, s, e) {
+    const isTv = s != null && e != null;
+    const tmdbId = Math.floor(Number(id));
+    const season = isTv ? Math.floor(Number(s || 1)) : 0;
+    const episode = isTv ? Math.floor(Number(e || 1)) : 0;
+
+    const str = `${nD}:${isTv ? 's' : 'm'}:${tmdbId}:${season}:${episode}`;
+    const a = new TextEncoder().encode(str);
+    const sArr = sD(a.length);
+    const i = new Uint8Array(a.length + 2);
+    i[0] = a.length & 255;
+    i[1] = (a.length >>> 8) & 255;
+    let o = (2654435769 ^ a.length) >>> 0;
+    for (let l = 0; l < a.length; l += 1) {
+        o = ab((o + sArr[l % sArr.length] + Ls[l % Ls.length] + l) >>> 0);
+        i[l + 2] = (a[l] ^ (255 & o)) ^ sArr[(7 * l + 3) % sArr.length];
+    }
+
+    return `https://glendale-plumbing.com/c/v1/${iD(i)}/master.m3u8`;
+}
+
+async function fetchInternalToken() {
+    if (cachedToken && Date.now() < tokenExpiry) return cachedToken;
+    try {
+        const res = await fetch('https://1embed.cc/api/token', {
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Referer': 'https://1embed.cc/',
+                'Accept': 'application/json, text/plain, */*'
+            },
+            signal: AbortSignal.timeout(4000)
+        });
+        if (res.ok) {
+            const data = await res.json();
+            if (data?.token) {
+                cachedToken = data.token;
+                tokenExpiry = Date.now() + 1800 * 1000;
+                return cachedToken;
+            }
+        }
+    } catch { }
+
+    try {
+        const proxiedUrl = `${CORS_PROXY}/?destination=${encodeURIComponent('https://1embed.cc/api/token')}`;
+        const res = await fetch(proxiedUrl, {
+            headers: {
+                'X-Referer': 'https://1embed.cc/',
+                'X-User-Agent': USER_AGENT
+            },
+            signal: AbortSignal.timeout(4000)
+        });
+        if (res.ok) {
+            const data = await res.json();
+            if (data?.token) {
+                cachedToken = data.token;
+                tokenExpiry = Date.now() + 1800 * 1000;
+                return cachedToken;
+            }
+        }
+    } catch { }
+
+    return '';
+}
+
+export async function getStream(args) {
+    const { id, s, e, clientIP } = args;
+    const isTv = s != null && e != null;
+    const isMovie = !isTv;
+    const allUrls = [];
+
+    const directHlsUrl = generateDirectHlsUrl(id, s, e);
+    const masterUrlWithMark = `${directHlsUrl}?${_vParam}`;
+
+    allUrls.push({
+        url: masterUrlWithMark,
+        server: 'Bcine (Direct Master)',
+        quality: 'Auto',
+        type: 'hls',
+        headers: {
+            'User-Agent': USER_AGENT,
+            'Referer': 'https://bcine.ru/',
+            'Origin': 'https://bcine.ru',
+            ...(clientIP && { 'X-Forwarded-For': clientIP })
+        }
+    });
+
+    const token = await fetchInternalToken();
+
+    await Promise.allSettled(
+        SERVERS.map(async (server) => {
+            const query = isTv
+                ? `id=${id}?type=tv&s=${s || 1}&e=${e || 1}`
+                : `id=${id}?type=movie`;
+
+            const stParam = token ? `&_st=${token}` : '';
+            const targetUrl = `https://1embed.cc${server.endpoint}/${query}${stParam}`;
+
+            const headers = {
+                'User-Agent': USER_AGENT,
+                'Referer': 'https://bcine.ru/',
+                'Accept': 'application/json, text/plain, */*',
+                ...(token && { 'X-Stream-Token': token }),
+                ...(clientIP && { 'X-Forwarded-For': clientIP })
+            };
+
+            let res = await fetch(targetUrl, { headers, signal: AbortSignal.timeout(5000) }).catch(() => null);
+            if (!res || !res.ok) {
+                const proxiedUrl = `${CORS_PROXY}/?destination=${encodeURIComponent(targetUrl)}`;
+                res = await fetch(proxiedUrl, {
+                    headers: {
+                        'X-Referer': 'https://bcine.ru/',
+                        'X-User-Agent': USER_AGENT
+                    },
+                    signal: AbortSignal.timeout(5000)
+                }).catch(() => null);
+            }
+
+            if (res && res.ok) {
+                try {
+                    const data = await res.json();
+                    if (data && data.success !== false) {
+                        const streamUrl = data.streams?.proxy_m3u8 || data.streams?.raw_m3u8 || data.streams?.m3u8 || data.streamUrl;
+                        if (streamUrl && typeof streamUrl === 'string') {
+                            const urlWithMark = streamUrl.includes('?') ? `${streamUrl}&${_vParam}` : `${streamUrl}?${_vParam}`;
+                            allUrls.push({
+                                url: urlWithMark,
+                                server: `Bcine (${data.selectedSource || data.provider || server.id})`,
+                                quality: 'Auto',
+                                type: streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
+                                headers: {
+                                    'User-Agent': USER_AGENT,
+                                    'Referer': 'https://bcine.ru/',
+                                    'Origin': 'https://bcine.ru'
+                                }
+                            });
+                        }
+                    }
+                } catch { }
+            }
+        })
+    );
+
+    return allUrls.length ? { allUrls } : null;
+}