@vyla-entertainment/sdk 1.0.0

package/src/sources/vidapi.js

@@ -0,0 +1,115 @@
+import { fetchJson, USER_AGENT } from '../utils/helpers.js';
+
+const API_BASE = 'https://streamdata.vaplayer.ru/api.php';
+const EMBED_ORIGIN = 'https://nextgencloudfabric.com';
+
+export const VERIFY_HEADERS = {
+    'User-Agent': USER_AGENT,
+    'Referer': `${EMBED_ORIGIN}/`,
+    'Origin': EMBED_ORIGIN
+};
+
+function extractStreamUrls(obj, urls = new Set()) {
+    if (!obj) return urls;
+    if (typeof obj === 'string') {
+        if (obj.startsWith('http') && (obj.includes('.m3u8') || obj.includes('.mp4') || obj.includes('.mpd'))) {
+            urls.add(obj);
+        }
+    } else if (Array.isArray(obj)) {
+        for (const item of obj) extractStreamUrls(item, urls);
+    } else if (typeof obj === 'object') {
+        for (const val of Object.values(obj)) {
+            extractStreamUrls(val, urls);
+        }
+    }
+    return urls;
+}
+
+export async function getStream({ id, s, e }) {
+    try {
+        const isTv = s != null && e != null;
+        const type = isTv ? 'tv' : 'movie';
+
+        const url = `${API_BASE}?tmdb=${id}&type=${type}${isTv ? `&season=${s}&episode=${e}` : ''}`;
+
+        const data = await fetchJson(url, {
+            headers: {
+                'Accept': '*/*',
+                'Origin': EMBED_ORIGIN,
+                'Referer': `${EMBED_ORIGIN}/`,
+                'User-Agent': USER_AGENT
+            },
+            signal: AbortSignal.timeout(10000)
+        });
+
+        const streamUrls = Array.from(extractStreamUrls(data));
+        if (!streamUrls.length) return null;
+
+        let subs = [];
+        if (data.subtitles && Array.isArray(data.subtitles)) {
+            subs = data.subtitles;
+        } else if (data.captions && Array.isArray(data.captions)) {
+            subs = data.captions;
+        }
+
+        const subtitles = subs.map(sub => ({
+            url: sub.url || sub.file || sub.src,
+            lang: sub.display || sub.label || sub.language || sub.lang || 'Unknown'
+        })).filter(s => s.url);
+
+        const allUrls = streamUrls.map(streamUrl => {
+            let type = 'mp4';
+            if (streamUrl.includes('.mpd')) type = 'dash';
+            else if (streamUrl.includes('.m3u8')) type = 'hls';
+
+            return {
+                url: streamUrl,
+                server: 'VidAPI',
+                quality: 'Auto',
+                type,
+                headers: VERIFY_HEADERS,
+                subtitles: subtitles.length > 0 ? subtitles : undefined,
+                skipProxy: false
+            };
+        });
+
+        return allUrls.length ? { allUrls } : null;
+    } catch {
+        return null;
+    }
+}
+
+export async function getSources() {
+    return ['VidAPI'];
+}
+
+export async function proxyStream({ url, res, proxyUtils: { fetchUpstream, rewriteM3u8 } }) {
+    try {
+        const upstream = await fetchUpstream(url, 0, VERIFY_HEADERS);
+        if (!upstream) return res.end();
+
+        const ct = (upstream.headers?.['content-type'] || '').toLowerCase();
+        const isM3u8 = ct.includes('mpegurl') || ct.includes('m3u8') || /\.m3u8?(\?|$)/i.test(url);
+
+        if (isM3u8) {
+            const chunks = [];
+            for await (const c of upstream) chunks.push(c);
+            let body = Buffer.concat(chunks).toString('utf8');
+
+            res.setHeader('Content-Type', 'application/vnd.apple.mpegurl');
+            res.setHeader('Access-Control-Allow-Origin', '*');
+
+            return res.end(rewriteM3u8(body, url, '&va=1&tt=1'));
+        }
+
+        res.setHeader('Content-Type', ct || 'application/octet-stream');
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Cache-Control', 'public, max-age=3600');
+        upstream.pipe(res);
+    } catch {
+        if (!res.headersSent) {
+            res.statusCode = 502;
+            res.end();
+        }
+    }
+}

package/src/sources/vidcore.js

@@ -0,0 +1,43 @@
+import { fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
+
+const API_BASE = 'https://enc-dec.app/api';
+const HEADERS = { 'User-Agent': USER_AGENT, 'Referer': 'https://vidcore.net/', 'X-Requested-With': 'XMLHttpRequest' };
+
+async function getDynamicServers(id, s, e) {
+    try {
+        const html = await fetchText(s != null && e != null ? `https://vidcore.net/tv/${id}/${s}/${e}/` : `https://vidcore.net/movie/${id}/`, { headers: HEADERS });
+
+        const match = html.match(/\\"(?:en|token)\\":\\"(.*?)\\"/) || html.match(/"(?:en|token)":"(.*?)"/);
+        if (!match?.[1]) return null;
+
+        const encData = await fetchJson(`${API_BASE}/enc-vidcore?text=${encodeURIComponent(match[1])}`);
+        if (!encData?.result) return null;
+        const { servers: serversUrl, stream: streamUrl, token } = encData.result;
+        const reqHeaders = { ...HEADERS, 'X-CSRF-Token': token };
+        const serversEncrypted = await fetchText(serversUrl, { method: 'POST', headers: reqHeaders });
+        const decData = await fetchJson(`${API_BASE}/dec-vidcore`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: serversEncrypted }) });
+        return decData?.result ? { servers: decData.result, streamUrl, reqHeaders } : null;
+    } catch { return null; }
+}
+
+export async function getStream({ id, s, e }) {
+    const data = await getDynamicServers(id, s, e);
+    if (!data?.servers?.length) return null;
+    for (const srv of data.servers) {
+        try {
+            const streamEncrypted = await fetchText(`${data.streamUrl}/${srv.data}`, { method: 'POST', headers: data.reqHeaders });
+            const decData = await fetchJson(`${API_BASE}/dec-vidcore`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: streamEncrypted }) });
+            const url = decData?.result?.url;
+            if (url) {
+                const r = await fetch(url, { headers: { ...HEADERS, 'Range': 'bytes=0-511' }, signal: AbortSignal.timeout(5000) });
+                if (r.ok || r.status === 206) return { url, subtitles: (decData.result.captions || []).map(c => ({ url: c.file, lang: c.label || 'Unknown' })), headers: { ...HEADERS, 'Origin': 'https://vidcore.net' }, server: srv.name };
+            }
+        } catch { }
+    }
+    return null;
+}
+
+export async function getSources(args) {
+    const data = await getDynamicServers(args.id, args.s, args.e);
+    return data?.servers ? data.servers.map(s => s.name) : [];
+}

package/src/sources/videasy.js

@@ -0,0 +1,98 @@
+import { getTmdbInfo, fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
+
+const WINGS_BASE = "https://api.wingsdatabase.com";
+const HEADERS = { "Accept": "*/*", "Origin": "https://player.videasy.to", "Referer": "https://player.videasy.to/", "User-Agent": USER_AGENT };
+const SERVERS = [
+    { id: 'jett', name: 'Jett' },
+    { id: 'cdn', name: 'Yoru' },
+    { id: 'tejo', name: 'Tejo' },
+    { id: 'neon2', name: 'Neon' },
+    { id: 'ym', name: 'Sage' },
+    { id: 'downloader2', name: 'Cypher' },
+    { id: 'm4uhd', name: 'Breach' },
+    { id: 'hdmovie', name: 'Vyse' },
+    { id: 'meine', name: 'Killjoy' },
+    { id: 'lamovie', name: 'Omen' },
+    { id: 'superflix', name: 'Raze' }
+];
+
+export async function getStream({ id, s, e, server }) {
+    try {
+        const isTv = s != null && e != null;
+        const info = await getTmdbInfo(id, isTv ? 'tv' : 'movie');
+        if (!info?.titles?.length) return null;
+
+        const seedData = await fetchJson(`${WINGS_BASE}/seed?mediaId=${id}`, { headers: HEADERS, signal: AbortSignal.timeout(5000) });
+        const seed = seedData?.seed;
+        if (!seed) return null;
+
+        const encTitle = encodeURIComponent(encodeURIComponent(info.titles[0]));
+        let targets = SERVERS;
+
+        if (server && server !== 'all') {
+            const cleanName = server.replace('VidEasy - ', '');
+            targets = SERVERS.filter(sv => sv.name === cleanName);
+            if (!targets.length) targets = SERVERS;
+        }
+
+        const settled = await Promise.allSettled(targets.map(async srv => {
+            if (srv.id === 'cdn' && isTv) throw new Error();
+
+            let url = `${WINGS_BASE}/${srv.id}/sources-with-title?title=${encTitle}&mediaType=${isTv ? 'tv' : 'movie'}&year=${info.year || ''}&tmdbId=${id}&imdbId=${info.imdbId || "tt0000000"}&enc=2&seed=${seed}`;
+            if (isTv) url += `&episodeId=${e}&seasonId=${s}`;
+
+            const encText = await fetchText(url, { headers: HEADERS, signal: AbortSignal.timeout(10000) });
+            const decJson = await fetchJson("https://enc-dec.app/api/dec-videasy", {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ text: encText, id: String(id), seed }),
+                signal: AbortSignal.timeout(10000)
+            });
+
+            if (decJson.status !== 200 || !decJson.result) throw new Error();
+
+            let sourcesArray = [];
+            let subsArray = [];
+
+            if (Array.isArray(decJson.result)) {
+                sourcesArray = decJson.result;
+            } else if (decJson.result.sources && Array.isArray(decJson.result.sources)) {
+                sourcesArray = decJson.result.sources;
+                if (decJson.result.subtitles && Array.isArray(decJson.result.subtitles)) {
+                    subsArray = decJson.result.subtitles.map(sub => ({
+                        url: sub.url || sub.file,
+                        lang: sub.language || sub.lang || sub.label || 'Unknown'
+                    })).filter(sub => sub.url);
+                }
+            } else {
+                sourcesArray = [decJson.result];
+            }
+
+            return sourcesArray.map(res => {
+                const streamUrl = res.url || res.file || res.link || res.playlist || res.stream;
+                return streamUrl ? {
+                    url: streamUrl,
+                    quality: res.quality || "Auto",
+                    server: `VidEasy - ${srv.name}`,
+                    type: streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
+                    headers: HEADERS,
+                    subtitles: subsArray.length > 0 ? subsArray : undefined,
+                    skipProxy: false,
+                    skipVerify: true,
+                    skipHlsCheck: true
+                } : null;
+            }).filter(Boolean);
+        }));
+
+        const allUrls = [];
+        for (const r of settled) {
+            if (r.status === 'fulfilled' && r.value) allUrls.push(...r.value);
+        }
+
+        return allUrls.length ? { allUrls } : null;
+    } catch { return null; }
+}
+
+export async function getSources() {
+    return SERVERS.map(s => `VidEasy - ${s.name}`);
+}

package/src/sources/vidfast.js

@@ -0,0 +1,53 @@
+import { fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
+
+const API_BASE = 'https://enc-dec.app/api';
+const DOMAIN = 'https://vidfast.vc';
+const HEADERS = { 'User-Agent': USER_AGENT, 'Referer': `${DOMAIN}/`, 'X-Requested-With': 'XMLHttpRequest' };
+
+async function getVidfastMeta(id, s, e) {
+    try {
+        const embedUrl = s != null && e != null ? `${DOMAIN}/tv/${id}/${s}/${e}/` : `${DOMAIN}/movie/${id}/`;
+        const html = await fetchText(embedUrl, { headers: { 'User-Agent': USER_AGENT } });
+
+        const match = html.match(/\\"(?:en|token)\\":\\"(.*?)\\"/) || html.match(/"(?:en|token)":"(.*?)"/);
+        if (!match?.[1]) return null;
+
+        const encData = await fetchJson(`${API_BASE}/enc-vidfast?text=${encodeURIComponent(match[1])}`);
+        if (encData.status !== 200 || !encData.result) return null;
+
+        const { servers: serversUrl, stream: streamUrl, token } = encData.result;
+        const reqHeaders = { ...HEADERS, 'X-CSRF-Token': token };
+
+        const serversEncrypted = await fetchText(serversUrl, { method: 'POST', headers: reqHeaders });
+        const decServersData = await fetchJson(`${API_BASE}/dec-vidfast`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: serversEncrypted }) });
+
+        if (decServersData.status !== 200 || !decServersData.result) return null;
+        return { servers: decServersData.result, streamUrl, reqHeaders };
+    } catch { return null; }
+}
+
+export async function getStream({ id, s, e, server }) {
+    const meta = await getVidfastMeta(id, s, e);
+    if (!meta?.servers?.length) return null;
+    const { servers, streamUrl, reqHeaders } = meta;
+    let targets = servers;
+    if (server && server !== 'all') {
+        const cleanName = server.replace('VidFast - ', '');
+        targets = servers.filter(srv => srv.name === cleanName);
+        if (!targets.length) targets = servers;
+    }
+    const results = await Promise.allSettled(targets.map(async srv => {
+        const streamEncrypted = await fetchText(`${streamUrl}/${srv.data}`, { method: 'POST', headers: reqHeaders });
+        const decStreamData = await fetchJson(`${API_BASE}/dec-vidfast`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: streamEncrypted }) });
+        if (decStreamData.status !== 200 || !decStreamData.result?.url) throw new Error();
+        return { url: decStreamData.result.url, server: `VidFast - ${srv.name || 'Server'}`, type: decStreamData.result.url.includes('.m3u8') ? 'hls' : 'mp4', subtitles: (decStreamData.result.captions || []).map(c => ({ url: c.file, lang: c.label || 'Unknown' })), headers: { ...HEADERS, 'Origin': DOMAIN } };
+    }));
+    const allUrls = [];
+    for (const r of results) if (r.status === 'fulfilled') allUrls.push(r.value);
+    return allUrls.length ? { allUrls } : null;
+}
+
+export async function getSources(args) {
+    const meta = await getVidfastMeta(args.id, args.s, args.e);
+    return meta?.servers ? meta.servers.map(srv => `VidFast - ${srv.name}`) : [];
+}

package/src/sources/vidlink.js

@@ -0,0 +1,28 @@
+import { fetchJson, USER_AGENT } from '../utils/helpers.js';
+
+const BASE = "https://vidlink.pro";
+const HEADERS = { 'User-Agent': USER_AGENT, Origin: BASE, Referer: `${BASE}/` };
+
+export async function getStream({ id, s, e }) {
+    try {
+        const encData = await fetchJson(`https://enc-dec.app/api/enc-vidlink?text=${id}`, { signal: AbortSignal.timeout(6000) });
+        if (encData?.status !== 200 || !encData?.result) return null;
+        const data = await fetchJson(s ? `${BASE}/api/b/tv/${encData.result}/${s}/${e || 1}` : `${BASE}/api/b/movie/${encData.result}`, { headers: HEADERS, signal: AbortSignal.timeout(10000) });
+        const stream = data?.stream;
+        if (!stream) return null;
+        if (stream.type === 'file' && stream.qualities) {
+            let picked = null;
+            for (const q of ['1080', '720', '480', '360']) if (stream.qualities[q]?.url) { picked = stream.qualities[q].url; break; }
+            if (!picked) picked = stream.qualities[Object.keys(stream.qualities)[0]]?.url;
+            if (picked) return { allUrls: [{ url: picked, type: 'mp4', audio: 'sub', server: 'Vidlink', skipHlsCheck: true, skipCache: true }] };
+        } else if (stream.playlist) {
+            return { allUrls: [{ url: stream.playlist, type: 'hls', audio: 'sub', server: 'Vidlink', skipHlsCheck: true, skipCache: true }] };
+        }
+        return null;
+    } catch { return null; }
+}
+
+export async function getSources(args) {
+    const stream = await getStream(args);
+    return stream?.allUrls ? [...new Set(stream.allUrls.map(u => u.server))] : [];
+}

package/src/sources/vidnest.js

@@ -0,0 +1,77 @@
+import { fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
+
+const BASE_URL = 'https://vidnest.fun';
+const API_BASE_URL = 'https://new.vidnest.fun';
+const REQUEST_HEADERS = { 'User-Agent': USER_AGENT, 'Accept': 'application/json, text/javascript, */*; q=0.01', 'Accept-Language': 'en-US,en;q=0.9', 'Referer': `${BASE_URL}/`, 'Origin': BASE_URL };
+const CDN_PROXY_HEADERS = { 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0', 'accept': '*/*', 'accept-language': 'en-US,en;q=0.5', 'origin': 'https://megaplay.buzz', 'referer': 'https://megaplay.buzz/' };
+
+export const CDN_HEADERS = [
+    { pattern: /letsgocdn\d+\.shop/i, headers: { 'Referer': BASE_URL, 'Origin': BASE_URL, 'User-Agent': USER_AGENT } },
+    { pattern: /cdn\.mewstream\.buzz/i, headers: { 'Referer': BASE_URL, 'Origin': BASE_URL, 'User-Agent': USER_AGENT } }
+];
+
+const ALPHABET = 'RB0fpH8ZEyVLkv7c2i6MAJ5u3IKFDxlS1NTsnGaqmXYdUrtzjwObCgQP94hoeW+/=';
+const REV_MAP = new Uint8Array(256);
+for (let i = 0; i < ALPHABET.length; i++) REV_MAP[ALPHABET.charCodeAt(i)] = i;
+
+function decrypt(payload) {
+    const len = payload.length;
+    const bytes = new Uint8Array(len);
+    let j = 0;
+    for (let i = 0; i < len; i += 4) {
+        const c0 = REV_MAP[payload.charCodeAt(i)] ?? 64;
+        const c1 = REV_MAP[payload.charCodeAt(i + 1)] ?? 64;
+        const c2 = REV_MAP[payload.charCodeAt(i + 2)] ?? 64;
+        const c3 = REV_MAP[payload.charCodeAt(i + 3)] ?? 64;
+        bytes[j++] = (c0 << 2) | (c1 >> 4);
+        if (c2 !== 64) bytes[j++] = ((c1 & 15) << 4) | (c2 >> 2);
+        if (c3 !== 64) bytes[j++] = ((c2 & 3) << 6) | c3;
+    }
+    return JSON.parse(new TextDecoder().decode(bytes.subarray(0, j)));
+}
+
+async function tmdbToAnilist(tmdbId, season) {
+    try {
+        const data = await fetchJson(`https://api.ani.zip/mappings?tmdb_id=${tmdbId}&type=tv&season=${season || 1}`, { signal: AbortSignal.timeout(6000) });
+        return data?.mappings?.[0]?.anilist_id || null;
+    } catch { return null; }
+}
+
+const SERVER_KEYS = ['hollymoviehd', 'allmovies', 'catflix', 'purstream', 'lamda', 'vidlink', 'klikxxi'];
+
+export async function getStream({ id, s, e, tmdbApiKey, audio }) {
+    if (s) {
+        const k = tmdbApiKey;
+        const showData = k ? await fetchJson(`https://api.themoviedb.org/3/tv/${id}?api_key=${k}`, { signal: AbortSignal.timeout(5000) }).catch(() => null) : null;
+        if (showData?.genres?.some(g => g.id === 16)) {
+            const anilistId = await tmdbToAnilist(id, s);
+            if (anilistId) {
+                try {
+                    const json = await fetchJson(`${API_BASE_URL}/hianime/anime/${anilistId}/${e || 1}/${audio === 'dub' ? 'dub' : 'sub'}`, { headers: REQUEST_HEADERS, signal: AbortSignal.timeout(15000) });
+                    const data = json.encrypted ? decrypt(json.data) : json.data;
+                    const file = data?.sources?.[0]?.file;
+                    if (file) return { url: `https://megacloud.animanga.fun/proxy?url=${encodeURIComponent(file)}&headers=${encodeURIComponent(JSON.stringify(CDN_PROXY_HEADERS))}`, headers: REQUEST_HEADERS };
+                } catch { }
+            }
+        }
+    }
+    if (audio === 'dub') return null;
+    const segment = s ? `tv/${id}/${s}/${e || 1}` : `movie/${id}`;
+    const settled = await Promise.allSettled(SERVER_KEYS.map(async server => {
+        const json = await fetchJson(`${API_BASE_URL}/${server}/${segment}`, { headers: REQUEST_HEADERS, signal: AbortSignal.timeout(10000) });
+        const data = json.encrypted ? decrypt(json.data) : json.data;
+        const file = data?.sources?.[0]?.file ?? data?.streams?.[0]?.url ?? data?.url?.[0]?.link ?? data?.data?.stream?.playlist;
+        if (file) return { url: file, server, headers: REQUEST_HEADERS };
+        throw new Error();
+    }));
+    const allUrls = [];
+    for (const r of settled) if (r.status === 'fulfilled') allUrls.push(r.value);
+    return allUrls.length ? { allUrls } : null;
+}
+
+export async function getSources(args) {
+    const res = await getStream(args);
+    return res?.allUrls ? res.allUrls.map(u => u.server) : [];
+}
+
+export const VERIFY_HEADERS = { ...REQUEST_HEADERS };

package/src/sources/vidrift.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const BASE = "https://embed.vidrift.in";
+
+const DEFAULT_HEADERS = {
+    "Accept": "*/*",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Cache-Control": "no-cache",
+    "Pragma": "no-cache",
+    "Referer": `${BASE}/`,
+    "Origin": BASE,
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36 Edg/150.0.0.0"
+};
+
+function decodeStreams(encodedStr) {
+    try {
+        const base64Str = encodedStr.replace(/-/g, '+').replace(/_/g, '/');
+
+        const binaryStr = typeof atob === 'function'
+            ? atob(base64Str)
+            : Buffer.from(base64Str, 'base64').toString('binary');
+
+        const bytes = new Uint8Array(binaryStr.length);
+        for (let i = 0; i < binaryStr.length; i++) {
+            bytes[i] = binaryStr.charCodeAt(i);
+        }
+
+        const key = bytes[0];
+        let decodedStr = '';
+        for (let i = 1; i < bytes.length; i++) {
+            decodedStr += String.fromCharCode(bytes[i] ^ key);
+        }
+
+        return JSON.parse(decodedStr);
+    } catch (e) {
+        return [];
+    }
+}
+
+export async function getStream(args) {
+    const { id, s, e, server: serverName } = args;
+    const type = s != null && e != null ? "tv" : "movie";
+
+    const endpoint = type === "tv"
+        ? `${BASE}/embed/tv/${id}/${s}/${e}`
+        : `${BASE}/embed/movie/${id}`;
+
+    try {
+        const res = await fetch(endpoint, {
+            headers: {
+                ...DEFAULT_HEADERS,
+                "Accept": "text/html",
+            },
+            signal: AbortSignal.timeout(10000)
+        });
+
+        if (!res.ok) return null;
+
+        const html = await res.text();
+
+        const match = html.match(/var\s+_s\s*=\s*['"]([^'"]+)['"]/);
+        if (!match) return null;
+
+        const encodedStreams = match[1];
+        const streamsData = decodeStreams(encodedStreams);
+
+        if (!Array.isArray(streamsData) || !streamsData.length) {
+            return null;
+        }
+
+        const allUrls = streamsData.map((stream, index) => ({
+            url: stream.url.startsWith("http")
+                ? stream.url
+                : `${BASE}${stream.url}`,
+            server: stream.label || `VidRift - Server ${index + 1}`,
+            type: "hls",
+            headers: DEFAULT_HEADERS
+        }));
+
+        if (serverName && serverName !== "all") {
+            const filtered = allUrls.filter(x => x.server === serverName);
+            return filtered.length ? { allUrls: filtered } : null;
+        }
+
+        return { allUrls };
+    } catch (err) {
+        return null;
+    }
+}
+
+export async function getSources(args) {
+    const res = await getStream(args);
+    if (!res?.allUrls) return ["VidRift - Server 1"];
+    return res.allUrls.map(x => x.server);
+}

package/src/sources/vidrock.js

@@ -0,0 +1,145 @@
+import { webcrypto } from 'node:crypto';
+import { fetchJson, USER_AGENT } from '../utils/helpers.js';
+
+const GCM_HEX_KEY = '7f3e9c2a8b5d1f4e6a9c3b7d2e5f8a1c4b6d9e2f5a8c1b4d7e9f2a5c8b1d4e7f';
+const BASE_URL = 'https://vidrock.ru/';
+const PROXY_PREFIX = 'https://proxy.vidrock.store/';
+
+let cryptoKey = null;
+
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+
+    return bytes;
+}
+
+function base64UrlToBytes(value) {
+    let base64 = value.replace(/-/g, '+').replace(/_/g, '/');
+
+    const padding = base64.length % 4;
+
+    if (padding === 2) {
+        base64 += '==';
+    } else if (padding === 3) {
+        base64 += '=';
+    } else if (padding === 1) {
+        throw new Error('Invalid base64url');
+    }
+
+    return new Uint8Array(Buffer.from(base64, 'base64'));
+}
+
+async function getKey() {
+    if (cryptoKey) return cryptoKey;
+
+    const keyBytes = hexToBytes(GCM_HEX_KEY);
+
+    cryptoKey = await webcrypto.subtle.importKey(
+        'raw',
+        keyBytes,
+        'AES-GCM',
+        false,
+        ['decrypt']
+    );
+
+    return cryptoKey;
+}
+
+async function decryptStreamUrl(value) {
+    try {
+        const data = base64UrlToBytes(value);
+
+        if (data.length < 28) {
+            throw new Error('Ciphertext too short');
+        }
+
+        const iv = data.slice(0, 12);
+        const ciphertext = data.slice(12);
+
+        const key = await getKey();
+
+        const decrypted = await webcrypto.subtle.decrypt(
+            {
+                name: 'AES-GCM',
+                iv
+            },
+            key,
+            ciphertext
+        );
+
+        return new TextDecoder().decode(decrypted);
+    } catch (error) {
+        return null;
+    }
+}
+
+export async function getStream({ id, s, e }) {
+    try {
+        const path = s
+            ? `tv/${id}/${s}/${e || 1}`
+            : `movie/${id}`;
+
+        const apiData = await fetchJson(`${BASE_URL}api/${path}`, {
+            headers: {
+                'User-Agent': USER_AGENT,
+                Referer: BASE_URL,
+                Origin: BASE_URL
+            }
+        });
+
+        if (!apiData || typeof apiData !== 'object') {
+            return null;
+        }
+
+        const streams = [];
+
+        for (const [provider, info] of Object.entries(apiData)) {
+            if (!info?.url) {
+                continue;
+            }
+
+            const decryptedUrl = await decryptStreamUrl(info.url);
+
+            if (!decryptedUrl) {
+                continue;
+            }
+
+            let url = decryptedUrl;
+
+            if (url.startsWith(PROXY_PREFIX)) {
+                url = decodeURIComponent(
+                    url.slice(PROXY_PREFIX.length).replace(/^\/+/, '')
+                );
+            }
+
+            const isXpass = url.includes('xpass.top');
+
+            streams.push({
+                name: provider,
+                url,
+                file: url,
+                stream: url,
+                src: url,
+                quality: info.type || 'auto',
+                type: info.type || 'hls',
+                headers: {
+                    'User-Agent': USER_AGENT,
+                    Referer: isXpass
+                        ? 'https://play.xpass.top/'
+                        : BASE_URL,
+                    Origin: isXpass
+                        ? 'https://play.xpass.top'
+                        : 'https://vidrock.ru'
+                }
+            });
+        }
+
+        return streams.length ? { streams } : null;
+    } catch (error) {
+        return null;
+    }
+}