@vyla-entertainment/sdk 1.0.0

package/src/sources/goated.js

@@ -0,0 +1,262 @@
+import crypto from "crypto";
+
+export const ID = "goated";
+export const DOMAIN = "https://goated.cx";
+export const RETURN_ALL_URLS = true;
+
+const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+
+const enc = new TextEncoder();
+const info = enc.encode("goated-api-v1");
+const salt = enc.encode("goated-stream-salt");
+
+const generateRandomIP = () => {
+    const p = () => Math.floor(Math.random() * 255);
+    let first = p();
+    while ([0, 10, 127, 169, 172, 192].includes(first)) first = p();
+    return `${first}.${p()}.${p()}.${p()}`;
+};
+
+let cachedSession = null;
+let sessionExpiresAt = 0;
+let cachedProviders = null;
+let providersExpiresAt = 0;
+
+async function getValidSession(sessionIp) {
+    const now = Date.now();
+    if (cachedSession && now < sessionExpiresAt) {
+        return cachedSession;
+    }
+    try {
+        const chalRes = await fetch(`${DOMAIN}/api/auth/challenge`, {
+            headers: {
+                "User-Agent": UA,
+                "X-Forwarded-For": sessionIp,
+                "X-Real-IP": sessionIp,
+                Origin: DOMAIN,
+                Referer: DOMAIN + "/",
+            },
+            signal: AbortSignal.timeout(7000),
+        });
+
+        if (!chalRes.ok) throw new Error();
+        const chalData = await chalRes.json();
+        const { challenge, difficulty } = chalData;
+        const targetPrefix = "0".repeat(Math.ceil((difficulty || 16) / 4));
+        let nonceStr = "";
+
+        for (let i = 0; i < 5000000; i++) {
+            const nonce = Math.random().toString(36).substring(2, 10);
+            const hash = crypto.createHash("sha256").update(`${challenge}:${nonce}`).digest("hex");
+            if (hash.startsWith(targetPrefix)) {
+                nonceStr = nonce;
+                break;
+            }
+        }
+
+        if (!nonceStr) throw new Error();
+
+        const res = await fetch(`${DOMAIN}/api/auth/session`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "User-Agent": UA,
+                "X-Forwarded-For": sessionIp,
+                "X-Real-IP": sessionIp,
+                Origin: DOMAIN,
+                Referer: DOMAIN + "/",
+            },
+            body: JSON.stringify({ challenge, nonce: nonceStr }),
+            signal: AbortSignal.timeout(7000),
+        });
+
+        if (!res.ok) throw new Error();
+        const data = await res.json();
+        if (!data.token) throw new Error();
+
+        cachedSession = data.token;
+        sessionExpiresAt = now + (data.expiresIn || 600) * 1000 - 30000;
+        return cachedSession;
+    } catch (e) {
+        throw new Error();
+    }
+}
+
+async function getProviders() {
+    const now = Date.now();
+    if (cachedProviders && now < providersExpiresAt) return cachedProviders;
+    try {
+        const res = await fetch(`${DOMAIN}/api/providers`, {
+            headers: { "User-Agent": UA },
+            signal: AbortSignal.timeout(5000)
+        });
+        if (!res.ok) return [];
+        const data = await res.json();
+        cachedProviders = data.providers || [];
+        providersExpiresAt = now + 3600 * 1000;
+        return cachedProviders;
+    } catch (e) {
+        return [];
+    }
+}
+
+async function deriveKey(tokenString) {
+    const rawKey = await crypto.subtle.importKey("raw", enc.encode(tokenString), "HKDF", false, ["deriveKey"]);
+    return crypto.subtle.deriveKey(
+        { name: "HKDF", hash: "SHA-256", salt, info },
+        rawKey,
+        { name: "AES-GCM", length: 256 },
+        false,
+        ["encrypt", "decrypt"],
+    );
+}
+
+async function encryptParams(payloadObj, key) {
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const data = enc.encode(JSON.stringify(payloadObj));
+    const ct = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, data);
+    const combined = new Uint8Array(iv.length + ct.byteLength);
+    combined.set(iv);
+    combined.set(new Uint8Array(ct), iv.length);
+    return Buffer.from(combined).toString("base64");
+}
+
+async function decryptUrl(b64Url, key) {
+    const raw = Buffer.from(b64Url, "base64");
+    const iv = raw.slice(0, 12);
+    const ct = raw.slice(12);
+    try {
+        const plain = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ct);
+        return Buffer.from(plain).toString("utf8");
+    } catch {
+        return null;
+    }
+}
+
+async function decryptDeep(obj, key) {
+    if (!obj || typeof obj !== "object") return obj;
+    if (Array.isArray(obj)) return Promise.all(obj.map(x => decryptDeep(x, key)));
+
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if ((k === "url" || k === "file") && typeof v === "string" && v.length > 40) {
+            try {
+                const dec = await decryptUrl(v, key);
+                out[k] = dec ? dec : v;
+            } catch {
+                out[k] = v;
+            }
+        } else if (k === "links" && Array.isArray(v)) {
+            out[k] = await Promise.all(v.map(async x => {
+                if (typeof x === "string" && x.length > 40) {
+                    try {
+                        const dec = await decryptUrl(x, key);
+                        return dec ? dec : x;
+                    } catch {
+                        return x;
+                    }
+                }
+                return x;
+            }));
+        } else {
+            out[k] = await decryptDeep(v, key);
+        }
+    }
+    return out;
+}
+
+export async function getStream({ id, s, e, clientIP }) {
+    try {
+        const sessionIp = generateRandomIP();
+        const sessionJwt = await getValidSession(sessionIp);
+        const actualKey = await deriveKey(sessionJwt);
+
+        const isTv = s && e && s !== "null" && e !== "null";
+        const contentType = isTv ? "tv" : "movies";
+        const refererPath = isTv ? `tv/${id}-${s}-${e}/play` : `movie/${id}/play`;
+
+        let providers = await getProviders();
+        let activeProviders = providers.filter(p => p.active && (p.endpoints || []).includes(contentType));
+        if (activeProviders.length === 0) activeProviders = [{ name: null }];
+
+        const fetchProviderStream = async (provider) => {
+            try {
+                const payload = isTv
+                    ? { type: "tv", id: id.toString(), season: s.toString(), episode: e.toString() }
+                    : { type: "movie", id: id.toString() };
+
+                if (provider.name) payload.provider = provider.name;
+
+                const dParam = await encryptParams(payload, actualKey);
+
+                const streamRes = await fetch(`${DOMAIN}/api/stream?d=${encodeURIComponent(dParam)}`, {
+                    headers: {
+                        Authorization: `Bearer ${sessionJwt}`,
+                        "User-Agent": UA,
+                        "X-Forwarded-For": sessionIp,
+                        "X-Real-IP": sessionIp,
+                        Origin: DOMAIN,
+                        Referer: `${DOMAIN}/${refererPath}`,
+                    },
+                    signal: AbortSignal.timeout(10000)
+                });
+
+                if (!streamRes.ok) return [];
+                let rawData = await streamRes.json();
+
+                if (rawData.enc) {
+                    const raw = Buffer.from(rawData.enc, "base64");
+                    const decIv = raw.slice(0, 12);
+                    const decCt = raw.slice(12);
+                    const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv: decIv }, actualKey, decCt);
+                    rawData = JSON.parse(Buffer.from(decrypted).toString("utf-8"));
+                }
+
+                const streamData = await decryptDeep(rawData, actualKey);
+
+                if (!streamData.ok || !streamData.streams || streamData.streams.length === 0) return [];
+
+                const validStreams = [];
+                for (const stream of streamData.streams) {
+                    if (!stream.url) continue;
+                    if (stream.quality && stream.quality.toUpperCase() !== "AUTO" && streamData.streams.some(st => st.quality && st.quality.toUpperCase() === "AUTO")) continue;
+
+                    let finalUrl = stream.url;
+                    if (finalUrl.startsWith("/api/")) finalUrl = `${DOMAIN}${finalUrl}`;
+
+                    validStreams.push({
+                        url: finalUrl,
+                        headers: {
+                            "User-Agent": UA,
+                            Referer: DOMAIN + "/",
+                            Origin: DOMAIN,
+                        },
+                        server: stream.source || stream.server || provider.nickname || provider.name || "Goated",
+                        quality: stream.quality || "Auto",
+                        type: finalUrl.includes(".mp4") ? "mp4" : "hls",
+                        skipVerify: true,
+                        skipProxy: true,
+                    });
+                }
+                return validStreams;
+            } catch (err) {
+                return [];
+            }
+        };
+
+        const promises = activeProviders.map(p => fetchProviderStream(p));
+        const results = await Promise.allSettled(promises);
+
+        const allUrls = [];
+        for (const res of results) {
+            if (res.status === "fulfilled" && res.value.length > 0) {
+                allUrls.push(...res.value);
+            }
+        }
+
+        if (allUrls.length > 0) {
+            return { ...allUrls[0], allUrls };
+        }
+    } catch (err) { }
+    return null;
+}

package/src/sources/hexa.js

@@ -0,0 +1,82 @@
+import crypto from 'node:crypto';
+import { fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
+
+const API_BASE = 'https://enc-dec.app/api';
+const DOMAINS = ['hexa.su', 'flixer.su'];
+
+async function getChallengeToken() {
+    try {
+        const data = await fetchJson(`${API_BASE}/enc-hexa`, { signal: AbortSignal.timeout(6000) });
+        return data?.status === 200 ? data.result.token : null;
+    } catch { return null; }
+}
+
+export async function getStream({ id, s, e, server }) {
+    try {
+        const apiKey = crypto.randomBytes(32).toString('hex');
+        const capToken = await getChallengeToken();
+        if (!capToken) return null;
+
+        const isTv = s != null && e != null;
+        let decrypted = null;
+
+        for (const domain of DOMAINS) {
+            try {
+                const url = isTv
+                    ? `https://theemoviedb.${domain}/api/tmdb/tv/${id}/season/${s}/episode/${e}/images`
+                    : `https://theemoviedb.${domain}/api/tmdb/movie/${id}/images`;
+
+                const encrypted = await fetchText(url, {
+                    headers: {
+                        'User-Agent': USER_AGENT,
+                        'Referer': `https://${domain}/`,
+                        'Accept': 'text/plain',
+                        'X-Fingerprint-Lite': 'e9136c41504646444',
+                        'X-Api-Key': apiKey,
+                        'X-Cap-Token': capToken
+                    },
+                    signal: AbortSignal.timeout(10000)
+                });
+
+                if (!encrypted) continue;
+
+                const decData = await fetchJson(`${API_BASE}/dec-hexa`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ text: encrypted, key: apiKey }),
+                    signal: AbortSignal.timeout(8000)
+                });
+
+                if (decData?.status === 200 && decData.result?.sources?.length) {
+                    decrypted = decData.result;
+                    break;
+                }
+            } catch { continue; }
+        }
+
+        if (!decrypted?.sources?.length) return null;
+
+        let sources = decrypted.sources.map(src => ({
+            url: src.url,
+            server: `Hexa - ${src.name || src.server || 'Server'}`,
+            type: src.url.includes('.m3u8') ? 'hls' : 'mp4',
+            quality: src.quality || 'Auto',
+            subtitles: (decrypted.subtitles || []).map(sub => ({
+                url: sub.url,
+                lang: sub.label || sub.lang || 'Unknown'
+            })),
+            skipProxy: false
+        }));
+
+        if (server && server !== 'all') {
+            const cleanName = server.replace('Hexa - ', '');
+            sources = sources.filter(u => u.server.includes(cleanName));
+        }
+
+        return sources.length ? { allUrls: sources } : null;
+    } catch { return null; }
+}
+
+export async function getSources() {
+    return ['Hexa'];
+}

package/src/sources/kisskh.js

@@ -0,0 +1,60 @@
+import { fetchJson, USER_AGENT, getTmdbInfo } from '../utils/helpers.js';
+
+export const SKIP_VERIFY = true;
+export const MULTI_URL = false;
+
+const ENC_API = "https://enc-dec.app/api";
+const BASE = "https://kisskh.do";
+const HEADERS = { 'User-Agent': USER_AGENT, Accept: 'application/json' };
+
+function cleanTitle(t) { return t ? t.toLowerCase().replace(/\(\d{4}\)/g, '').replace(/[^a-z0-9]/g, '') : ''; }
+
+async function encKey(episodeId, type) {
+    try {
+        const data = await fetchJson(`${ENC_API}/enc-kisskh?text=${episodeId}&type=${type}`, { signal: AbortSignal.timeout(6000) });
+        return data?.status === 200 ? data.result : null;
+    } catch { return null; }
+}
+
+export async function getStream({ id, s, e }) {
+    try {
+        const info = await getTmdbInfo(id, s ? 'tv' : 'movie', s);
+        if (!info) return null;
+        let drama = null, bestScore = -1;
+        for (const title of (info.titles.length > 1 ? [...info.titles].reverse() : info.titles)) {
+            const results = await fetchJson(`${BASE}/api/DramaList/Search?q=${encodeURIComponent(title)}`, { headers: HEADERS, signal: AbortSignal.timeout(6000) }).catch(() => []);
+            const targetClean = cleanTitle(title);
+            for (const item of results) {
+                const parts = (item.title || '').split(/\s*-\s*/).map(cleanTitle);
+                let score = 0;
+                if (parts.some(p => p === targetClean)) score += 5;
+                else if (parts.some(p => p.includes(targetClean) || targetClean.includes(p))) score += 3;
+                else continue;
+                if (score > bestScore) { bestScore = score; drama = item; }
+            }
+            if (drama && bestScore >= 5) break;
+        }
+        if (!drama) return null;
+        const detail = await fetchJson(`${BASE}/api/DramaList/Drama/${drama.id}`, { headers: HEADERS, signal: AbortSignal.timeout(8000) });
+        const episodeId = detail?.episodes?.find(ep => Math.floor(ep.number) === Number(e || 1))?.id;
+        if (!episodeId) return null;
+        const vidKey = await encKey(episodeId, 'vid');
+        if (!vidKey) return null;
+        const videoData = await fetchJson(`${BASE}/api/DramaList/Episode/${episodeId}.png?err=false&ts=&time=&kkey=${vidKey}`, { headers: HEADERS, signal: AbortSignal.timeout(10000) });
+        if (!videoData?.Video) return null;
+        let subtitles = [];
+        const subKey = await encKey(episodeId, 'sub');
+        if (subKey) {
+            try {
+                const subList = await fetchJson(`${BASE}/api/Sub/${episodeId}?kkey=${subKey}`, { headers: HEADERS, signal: AbortSignal.timeout(8000) });
+                if (Array.isArray(subList)) subtitles = subList.map(sub => ({ url: sub.src, label: sub.label, lang: sub.land, default: !!sub.default }));
+            } catch { }
+        }
+        return { allUrls: [{ url: videoData.Video, type: videoData.Video.includes('.m3u8') ? 'hls' : 'mp4', audio: 'sub', server: 'KissKH', skipProxy: false, subtitles }] };
+    } 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/lookmovie.js

@@ -0,0 +1,78 @@
+import { USER_AGENT, fetchText, fetchJson } from '../utils/helpers.js';
+
+const TMDB_BASE = 'https://api.themoviedb.org/3';
+const LM_DOMAINS = ['https://www.lookmovie2.to', 'https://lookmovie2.to', 'https://lookmovie.foundation'];
+const HEADERS_BASE = { 'User-Agent': USER_AGENT, 'Accept-Language': 'en-US,en;q=0.9' };
+
+async function searchLookMovie(type, title, year, clientIP) {
+    for (const base of LM_DOMAINS) {
+        try {
+            const headers = { ...HEADERS_BASE, 'Accept': 'application/json', 'Referer': `${base}/`, 'X-Requested-With': 'XMLHttpRequest', ...(clientIP && { 'X-Forwarded-For': clientIP }) };
+            const data = await fetchJson(`${base}/api/v1/${type}/do-search/?q=${encodeURIComponent(title)}`, { headers, signal: AbortSignal.timeout(4000) });
+            const results = data?.result;
+            if (results?.length) {
+                const match = results.find(r => String(r.year) === String(year)) ?? results.find(r => r.title?.toLowerCase() === title.toLowerCase()) ?? results[0];
+                if (match) return { match, base };
+            }
+        } catch { }
+    }
+    return null;
+}
+
+const STORAGE_RE = /window\[['"](?:movie|show)_storage['"]\]\s*=\s*\{([^}]+)\}/s;
+const ID_MOVIE_RE = /['"]?(?:id_movie|movieId)['"]?\s*[:=]\s*['"]?(\d+)['"]?/i;
+const SEASONS_RE = /seasons\s*:\s*(\[[\s\S]+?\])\s*[,}]/;
+
+function getEpisodeIdFast(html, s, e) {
+    const sMatch = html.match(STORAGE_RE);
+    if (sMatch) {
+        const block = sMatch[1], sm = block.match(SEASONS_RE);
+        if (sm) {
+            try {
+                const seasons = JSON.parse(sm[1]);
+                const season = seasons.find(x => String(x?.season ?? x?.meta?.season) === String(s));
+                if (season) {
+                    const ep = Array.isArray(season.episodes) ? season.episodes.find(x => String(x.episode) === String(e)) : (season.episodes?.[String(e)] || Object.values(season.episodes || {}).find(x => String(x.episode) === String(e)));
+                    if (ep) return String(ep.id_episode ?? ep.id);
+                }
+            } catch { }
+        }
+    }
+    const parts = html.split(/id_episode['"]?\s*[:=]\s*['"]?(\d+)['"]?/i);
+    for (let i = 1; i < parts.length; i += 2) {
+        const context = parts[i - 1].slice(-300) + parts[i + 1].slice(0, 300);
+        if (context.match(new RegExp(`['"]?episode['"]?\\s*[:=]\\s*['"]?${e}['"]?`, 'i')) && context.match(new RegExp(`['"]?season['"]?\\s*[:=]\\s*['"]?${s}['"]?`, 'i'))) return parts[i];
+    }
+    const am = html.match(new RegExp(`data-season=["']${s}["'][^>]*?data-episode=["']${e}["'][^>]*?data-id=["'](\\d+)["']`, 'i')) || html.match(new RegExp(`data-episode=["']${e}["'][^>]*?data-season=["']${s}["'][^>]*?data-id=["'](\\d+)["']`, 'i'));
+    return am ? am[1] : null;
+}
+
+export async function getStream({ id, s, e, tmdbApiKey, clientIP }) {
+    try {
+        const tmdbKey = tmdbApiKey;
+        if (!tmdbKey) return null;
+        const isTV = s != null && e != null;
+        const typeStr = isTV ? 'shows' : 'movies';
+        const tmdbData = await fetchJson(`${TMDB_BASE}/${isTV ? 'tv' : 'movie'}/${id}?api_key=${tmdbKey}`, { signal: AbortSignal.timeout(3000) });
+        const title = tmdbData?.title || tmdbData?.name;
+        const year = (tmdbData?.first_air_date || tmdbData?.release_date || '').slice(0, 4);
+        if (!title) return null;
+        const searchRes = await searchLookMovie(typeStr, title, year, clientIP);
+        if (!searchRes?.match?.slug) return null;
+        const { match, base } = searchRes;
+        const headers = { ...HEADERS_BASE, 'Accept': 'text/html', 'Referer': `${base}/`, ...(clientIP && { 'X-Forwarded-For': clientIP }) };
+        const html = await fetchText(`${base}/${typeStr}/play/${match.slug}`, { headers, signal: AbortSignal.timeout(8000) });
+        const storageMatch = html.match(STORAGE_RE);
+        if (!storageMatch) return null;
+        const hashMatch = storageMatch[1].match(/hash\s*:\s*['"]([^'"]+)['"]/);
+        const expiresMatch = storageMatch[1].match(/expires\s*:\s*(\d+)/);
+        if (!hashMatch || !expiresMatch) return null;
+        const streamId = isTV ? getEpisodeIdFast(html, s, e) : (match.id_movie || match.id || html.match(ID_MOVIE_RE)?.[1]);
+        if (!streamId) return null;
+        const accessHeaders = { ...HEADERS_BASE, 'Accept': 'application/json', 'Referer': `${base}/`, 'X-Requested-With': 'XMLHttpRequest', ...(clientIP && { 'X-Forwarded-For': clientIP }) };
+        const data = await fetchJson(`${base}/api/v1/security/${isTV ? 'episode' : 'movie'}-access?id_${isTV ? 'episode' : 'movie'}=${streamId}&hash=${hashMatch[1]}&expires=${expiresMatch[1]}`, { headers: accessHeaders, signal: AbortSignal.timeout(8000) });
+        const streams = data?.streams ?? data?.result?.streams ?? data?.data?.streams ?? data;
+        const allUrls = Object.entries(streams || {}).filter(([, v]) => typeof v === 'string' && v.includes('.m3u8')).map(([quality, url]) => ({ url, quality }));
+        return allUrls.length ? { allUrls } : null;
+    } catch { return null; }
+}

package/src/sources/mapple.js

@@ -0,0 +1,115 @@
+import { USER_AGENT } from '../utils/helpers.js';
+
+const BASE_URL = "https://mapple.club";
+const PROXY_HEADERS = { Referer: `${BASE_URL}/`, Origin: BASE_URL, "User-Agent": USER_AGENT };
+
+const K = new Uint32Array([0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2]);
+const W_BUF = new Uint32Array(64);
+
+function sha256Into(buf, total, out) {
+    let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a, h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
+    const dv = new DataView(buf.buffer, buf.byteOffset, total);
+    for (let off = 0; off < total; off += 64) {
+        for (let i = 0; i < 16; i++) W_BUF[i] = dv.getUint32(off + i * 4, false);
+        for (let i = 16; i < 64; i++) {
+            const a = W_BUF[i - 15], b = W_BUF[i - 2];
+            const s0 = ((a >>> 7) | (a << 25)) ^ ((a >>> 18) | (a << 14)) ^ (a >>> 3);
+            const s1 = ((b >>> 17) | (b << 15)) ^ ((b >>> 19) | (b << 13)) ^ (b >>> 10);
+            W_BUF[i] = (W_BUF[i - 16] + s0 + W_BUF[i - 7] + s1) | 0;
+        }
+        let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
+        for (let i = 0; i < 64; i++) {
+            const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (h + S1 + ch + K[i] + W_BUF[i]) | 0;
+            const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) | 0;
+            h = g; g = f; f = e; e = (d + t1) | 0; d = c; c = b; b = a; a = (t1 + t2) | 0;
+        }
+        h0 = (h0 + a) | 0; h1 = (h1 + b) | 0; h2 = (h2 + c) | 0; h3 = (h3 + d) | 0; h4 = (h4 + e) | 0; h5 = (h5 + f) | 0; h6 = (h6 + g) | 0; h7 = (h7 + h) | 0;
+    }
+    const odv = new DataView(out.buffer, out.byteOffset, 32);
+    odv.setUint32(0, h0 >>> 0, false); odv.setUint32(4, h1 >>> 0, false); odv.setUint32(8, h2 >>> 0, false); odv.setUint32(12, h3 >>> 0, false); odv.setUint32(16, h4 >>> 0, false); odv.setUint32(20, h5 >>> 0, false); odv.setUint32(24, h6 >>> 0, false); odv.setUint32(28, h7 >>> 0, false);
+}
+
+function solvePoW(challenge, difficulty) {
+    const encoder = new TextEncoder();
+    const cBuf = encoder.encode(challenge);
+    const maxLen = cBuf.length + 16;
+    const total = (maxLen + 1 + 8 + 63) & ~63;
+    const buf = new Uint8Array(total);
+    buf.set(cBuf);
+    const hash = new Uint8Array(32);
+    const maskBytes = Math.floor(difficulty / 8);
+    const maskBits = difficulty % 8;
+    const finalMask = maskBits > 0 ? (0xff << (8 - maskBits)) & 0xff : 0;
+    const dv = new DataView(buf.buffer);
+    for (let nonce = 0; nonce < 10000000; nonce++) {
+        const str = nonce.toString();
+        const len = cBuf.length + str.length;
+        for (let i = 0; i < str.length; i++) buf[cBuf.length + i] = str.charCodeAt(i);
+        buf[len] = 0x80;
+        for (let i = len + 1; i < total - 8; i++) buf[i] = 0;
+        dv.setUint32(total - 4, len * 8, false);
+        dv.setUint32(total - 8, 0, false);
+        sha256Into(buf, total, hash);
+        let ok = true;
+        for (let i = 0; i < maskBytes; i++) if (hash[i] !== 0) { ok = false; break; }
+        if (ok && (finalMask === 0 || (hash[maskBytes] & finalMask) === 0)) return { found: true, nonce: str };
+    }
+    return { found: false };
+}
+
+const SERVER_LIST = [{ id: "mapple", name: "Mapple" }, { id: "s1", name: "Nexus" }, { id: "s2", name: "Cipher" }, { id: "s3", name: "Pulse" }, { id: "s4", name: "Vertex" }, { id: "s10", name: "Chimp" }];
+
+export async function getStream(args) {
+    const { id, s, e, server } = args;
+    const isTv = s != null && e != null;
+    const mediaType = isTv ? "tv" : "movie";
+    const tvSlug = isTv ? `${s}-${e}` : "";
+    const pageUrl = isTv ? `${BASE_URL}/watch/tv/${id}/${s}/${e}` : `${BASE_URL}/watch/movie/${id}`;
+    try {
+        const pageRes = await fetch(pageUrl, { headers: PROXY_HEADERS, signal: AbortSignal.timeout(10000) });
+        if (!pageRes.ok) return null;
+        const html = await pageRes.text();
+        const reqMatch = html.match(/window\.__REQUEST_TOKEN__\s*=\s*"([^"]+)"/);
+        if (!reqMatch) return null;
+        const requestToken = reqMatch[1];
+        const initRes = await fetch(`${BASE_URL}/api/playback-init`, { method: "POST", headers: { "Content-Type": "application/json", ...PROXY_HEADERS, Referer: pageUrl }, body: JSON.stringify({ mediaId: Number(id), mediaType, requestToken }), signal: AbortSignal.timeout(10000) });
+        const initData = await initRes.json();
+        let streamToken = initData.token;
+        if (initData.requiresPow && initData.pow) {
+            const powRes = solvePoW(initData.pow.challenge, initData.pow.difficulty);
+            if (powRes.found) {
+                const solveRes = await fetch(`${BASE_URL}/api/playback-init`, { method: "POST", headers: { "Content-Type": "application/json", ...PROXY_HEADERS, Referer: pageUrl }, body: JSON.stringify({ mediaId: Number(id), mediaType, requestToken, pow: { challengeId: initData.pow.challengeId, nonce: powRes.nonce } }), signal: AbortSignal.timeout(10000) });
+                streamToken = (await solveRes.json()).token;
+            }
+        }
+        if (!streamToken) return null;
+        let targets = SERVER_LIST;
+        if (server && server !== "all") {
+            const clean = server.replace("Mapple - ", "");
+            targets = SERVER_LIST.filter(sv => sv.name === clean);
+            if (!targets.length) targets = SERVER_LIST;
+        }
+        const allUrls = [];
+        for (const srv of targets) {
+            try {
+                const streamUrl = `${BASE_URL}/api/stream?mediaId=${id}&mediaType=${mediaType}&tv_slug=${tvSlug}&source=${srv.id}&apikey=mptv_sk_a8f29c4e7b3d1f&requestToken=${requestToken}&token=${streamToken}`;
+                const streamRes = await fetch(streamUrl, { headers: { ...PROXY_HEADERS, Referer: pageUrl }, signal: AbortSignal.timeout(8000) });
+                const streamData = await streamRes.json();
+                if (streamData.success && streamData.data?.stream_url) {
+                    let fileUrl = streamData.data.stream_url;
+                    if (fileUrl.includes('omena-puu') || fileUrl.includes('nocach')) fileUrl += fileUrl.includes('?') ? '&format=.m3u8' : '?format=.m3u8';
+                    allUrls.push({ url: fileUrl, server: `Mapple - ${srv.name}`, headers: PROXY_HEADERS, skipProxy: false, skipVerify: true, skipHlsCheck: true });
+                }
+            } catch { }
+        }
+        return allUrls.length ? { allUrls } : null;
+    } catch { return null; }
+}
+
+export async function getSources() { return SERVER_LIST.map(s => `Mapple - ${s.name}`); }
+export const SKIP_VERIFY = true;
+export const MULTI_URL = true;