@vyla-entertainment/sdk 1.0.0

package/src/sources/123anime.js

@@ -0,0 +1,57 @@
+import { getTmdbInfo, fetchJson, USER_AGENT } from '../utils/helpers.js';
+
+async function resolveSlug(id, s, e, info) {
+    const titles = info?.titles || [];
+    const keywords = [];
+    for (const title of titles) {
+        const t = title.toLowerCase().replace(/[^a-z0-9\s]/g, ' ').replace(/\s+/g, ' ').trim();
+        if (!keywords.includes(t)) keywords.push(t);
+        const words = title.split(/[\s:]+/).filter(w => w.length > 2);
+        if (words.length >= 2) {
+            const short = words.slice(0, 3).join(' ').toLowerCase();
+            if (!keywords.includes(short)) keywords.push(short);
+        }
+    }
+    const slugCandidates = [];
+    for (const keyword of keywords) {
+        try {
+            const data = await fetchJson(`https://123animehub.cc/ajax/film/search?keyword=${encodeURIComponent(keyword)}&_=${Date.now()}`, { headers: { 'X-Requested-With': 'XMLHttpRequest', 'Referer': 'https://123animehub.cc', 'Accept': 'application/json', 'User-Agent': USER_AGENT }, signal: AbortSignal.timeout(8000) });
+            let html = data.html || '', idx = 0;
+            while ((idx = html.indexOf('href="/anime/', idx)) !== -1) {
+                const start = idx + 13;
+                const end = html.indexOf('"', start);
+                const slug = html.slice(start, end);
+                if (!slugCandidates.includes(slug)) slugCandidates.push(slug);
+                idx = end;
+            }
+        } catch { }
+        if (slugCandidates.length) break;
+    }
+    for (const slug of slugCandidates) {
+        try {
+            const data = await fetchJson(`https://123animehub.cc/ajax/episode/info?epr=${encodeURIComponent(s ? `${slug}/${s}/${e}` : `${slug}/1`)}&ts=1&_=${Date.now()}`, { headers: { 'Referer': `https://123animehub.cc/anime/${slug}`, 'X-Requested-With': 'XMLHttpRequest', 'Accept': 'application/json, text/javascript, */*; q=0.01', 'User-Agent': USER_AGENT }, signal: AbortSignal.timeout(10000) });
+            if (data?.target) return data.target;
+        } catch { }
+    }
+    return null;
+}
+
+export async function getStream({ id, s, e }) {
+    if (!s) return null;
+    const info = await getTmdbInfo(id, 'tv', s);
+    if (!info.isAnime) return null;
+    const target = await resolveSlug(id, s, e, info);
+    if (!target) return null;
+    const embedMatch = target.match(/\/embed-[^/]+\/([A-Za-z0-9+/=]+)$/);
+    if (!embedMatch) return null;
+    const origin = new URL(target).origin;
+    try {
+        const embedRes = await fetch(target, { headers: { 'User-Agent': USER_AGENT }, signal: AbortSignal.timeout(10000) });
+        if (!embedRes.ok) return null;
+        const setCookie = embedRes.headers.get('set-cookie');
+        const data = await fetchJson(`${origin}/hs/getSources?id=${embedMatch[1]}`, { headers: { 'Referer': target, 'Accept': '*/*', 'User-Agent': USER_AGENT, ...(setCookie ? { 'Cookie': setCookie.split(';')[0].trim() } : {}) }, signal: AbortSignal.timeout(10000) });
+        const src = typeof data.sources === 'string' && data.sources.length ? data.sources : (Array.isArray(data.sources) && data.sources.length ? (data.sources[0].file || data.sources[0].src || data.sources[0].url) : null);
+        if (src) return { url: src, headers: { 'Referer': 'https://play2.echovideo.ru/', 'Origin': 'https://play2.echovideo.ru' } };
+    } catch { }
+    return null;
+}

package/src/sources/1embed.js

@@ -0,0 +1,92 @@
+import { USER_AGENT } from '../utils/helpers.js';
+
+const BASE_URL = "https://1embed.cc";
+
+const PROVIDERS = [
+    { id: "sdev", name: "1Embed - SDev" },
+    { id: "xpa", name: "1Embed - XPass" },
+    { id: "vnes", name: "1Embed - VidNest" },
+    { id: "pro", name: "1Embed - Pro" },
+    { id: "pur", name: "1Embed - Purstream" },
+    { id: "czo", name: "1Embed - Cinezo" },
+    { id: "fas", name: "1Embed - VidFast" }
+];
+
+let cachedToken = null;
+let tokenExpiresAt = 0;
+
+async function getToken() {
+    const now = Math.floor(Date.now() / 1000);
+    if (cachedToken && tokenExpiresAt > now + 10) return cachedToken;
+    try {
+        const res = await fetch(`${BASE_URL}/api/token`, { headers: { "Referer": `${BASE_URL}/`, "User-Agent": USER_AGENT, "Accept": "application/json" }, signal: AbortSignal.timeout(10000) });
+        if (!res.ok) return null;
+        const data = await res.json();
+        cachedToken = data.token;
+        tokenExpiresAt = data.expiresAt;
+        return cachedToken;
+    } catch { return null; }
+}
+
+async function fetchProviderStream(provider, type, id, s, e, token) {
+    try {
+        const referer = type === "movie" ? `${BASE_URL}/embed/movie/${id}` : `${BASE_URL}/embed/tv/${id}/${s}/${e}`;
+        const payload = { type, id: String(id), provider: provider.id };
+        if (type === "tv") { payload.season = Number(s); payload.episode = Number(e); }
+        const res = await fetch(`${BASE_URL}/api/sources`, {
+            method: "POST",
+            headers: { "User-Agent": USER_AGENT, "Referer": referer, "Origin": BASE_URL, "Accept": "application/json", "Content-Type": "application/json", "x-bcine-key": token, "X-Requested-With": "XMLHttpRequest" },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(15000)
+        });
+        if (!res.ok) return null;
+        const data = await res.json();
+
+        let rawSources = [];
+        if (Array.isArray(data.servers)) rawSources.push(...data.servers);
+        if (data.providerResults?.[provider.id]?.sources) rawSources.push(...data.providerResults[provider.id].sources);
+        if (data.providerResults?.[provider.id] && Array.isArray(data.providerResults[provider.id])) rawSources.push(...data.providerResults[provider.id]);
+
+        if (!rawSources.length) return null;
+        const results = [];
+        for (const src of rawSources) {
+            if (typeof src !== 'object' || !src) continue;
+            let streamUrl = src.url || src.file || src.link;
+            if (typeof streamUrl !== 'string') continue;
+            if (streamUrl.startsWith('/')) streamUrl = `${BASE_URL}${streamUrl}`;
+            const isWorker = streamUrl.includes('omena-puu') || streamUrl.includes('nocach') || streamUrl.includes('?p=');
+            const isHls = src.type === 'hls' || streamUrl.includes('m3u8') || isWorker;
+            if (isHls && !streamUrl.includes('m3u8')) streamUrl += streamUrl.includes('?') ? '&format=.m3u8' : '?format=.m3u8';
+            const srcHeaders = (src.headers && typeof src.headers === 'object') ? src.headers : {};
+            results.push({
+                url: streamUrl,
+                server: provider.name,
+                quality: src.quality || src.label || src.title || "Auto",
+                type: isHls ? "hls" : "mp4",
+                headers: { "User-Agent": USER_AGENT, "Referer": referer, "Origin": BASE_URL, ...srcHeaders },
+            });
+        }
+        return results;
+    } catch {
+        return null;
+    }
+}
+
+export async function getStream(args) {
+    const { id, s, e, server } = args;
+    const type = s != null && e != null ? "tv" : "movie";
+    const token = await getToken();
+    if (!token) return null;
+    let targets = PROVIDERS;
+    if (server && server !== 'all') {
+        const cleanName = server.replace('1Embed - ', '').toLowerCase();
+        targets = PROVIDERS.filter(p => p.id === cleanName || p.name.toLowerCase().includes(cleanName));
+        if (!targets.length) targets = PROVIDERS;
+    }
+    const settled = await Promise.allSettled(targets.map(p => fetchProviderStream(p, type, id, s, e, token)));
+    const allUrls = [];
+    for (const r of settled) if (r.status === 'fulfilled' && r.value) allUrls.push(...r.value);
+    return allUrls.length ? { allUrls } : null;
+}
+
+export async function getSources() { return PROVIDERS.map(p => p.name); }

package/src/sources/anihq.js

@@ -0,0 +1,112 @@
+import { getTmdbInfo, USER_AGENT } from '../utils/helpers.js';
+
+async function extractVoe(voeUrl) {
+    try {
+        const res = await fetch(voeUrl, {
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Referer': 'https://anihq.cc/'
+            }
+        });
+
+        const mirrorUrl = res.url;
+        const html = await res.text();
+
+        const scriptMatch = html.match(/<script type="application\/json">\["(.*?)"\]<\/script>/);
+        if (!scriptMatch) return null;
+
+        let str = scriptMatch[1];
+
+        str = str.replace(/[a-zA-Z]/g, (c) => {
+            return String.fromCharCode((c <= "Z" ? 90 : 122) >= (c = c.charCodeAt(0) + 13) ? c : c - 26);
+        });
+
+        const junk = ['@$', '^^', '~@', '%?', '*~', '!!', '#&'];
+        junk.forEach(j => { str = str.split(j).join(''); });
+
+        str = Buffer.from(str, 'base64').toString('utf-8');
+
+        let shifted = '';
+        for (let i = 0; i < str.length; i++) {
+            shifted += String.fromCharCode(str.charCodeAt(i) - 3);
+        }
+
+        let reversed = shifted.split('').reverse().join('');
+
+        let finalJsonStr = Buffer.from(reversed, 'base64').toString('utf-8');
+
+        const finalData = JSON.parse(finalJsonStr);
+
+        if (finalData.file || finalData.source) {
+            return {
+                url: finalData.file || finalData.source,
+                mirror: mirrorUrl
+            };
+        }
+
+    } catch (e) {
+        return null;
+    }
+    return null;
+}
+
+function cleanSlug(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+
+export async function getStream({ id, s, e, audio }) {
+    if (!s) return null;
+
+    const info = await getTmdbInfo(id, 'tv', s);
+    if (!info.isAnime) return null;
+
+    const seriesTitle = info.titles.find(t =>
+        t.toLowerCase() !== 'east blue' &&
+        t.length > 3
+    ) || info.titles[0];
+
+    const cleanTitle = cleanSlug(seriesTitle);
+    const typeSuffix = audio === 'dub' ? 'english-dubbed' : 'english-subbed';
+    const url = `https://anihq.cc/watch/${cleanTitle}-episode-${e}-${typeSuffix}/`;
+
+    try {
+        let pageRes = await fetch(url, { headers: { 'User-Agent': USER_AGENT } });
+        let html = await pageRes.text();
+
+        if (!pageRes.ok) {
+            const searchUrl = `https://anihq.cc/search?keyword=${encodeURIComponent(seriesTitle)}`;
+            const searchRes = await fetch(searchUrl, { headers: { 'User-Agent': USER_AGENT } });
+            const searchHtml = await searchRes.text();
+            const searchRegex = new RegExp(`href="(https://anihq.cc/watch/[^"]+-episode-${e}-${typeSuffix}/)"`, 'i');
+            const match = searchHtml.match(searchRegex);
+            if (match) {
+                const retryRes = await fetch(match[1], { headers: { 'User-Agent': USER_AGENT } });
+                html = await retryRes.text();
+            } else return null;
+        }
+
+        const iframeMatch = html.match(/iframe[^>]+src=["'](https:\/\/(?:[a-z0-9.]+|ellenpoliticalfollow\.com)\/e\/[a-zA-Z0-9]+)["']/i);
+        if (!iframeMatch) return null;
+
+        const result = await extractVoe(iframeMatch[1]);
+
+        if (result && result.url) {
+            const mirrorOrigin = new URL(result.mirror).origin;
+            return {
+                url: result.url,
+                headers: {
+                    'Referer': mirrorOrigin + '/',
+                    'User-Agent': USER_AGENT,
+                    'Origin': mirrorOrigin
+                }
+            };
+        }
+    } catch (err) {
+        return null;
+    }
+    return null;
+}

package/src/sources/anineko.js

@@ -0,0 +1,81 @@
+import { getTmdbInfo } from '../utils/helpers.js';
+
+const BASE_URL = "https://anineko.to";
+
+function cleanTitle(t) { return t ? t.toLowerCase().replace(/[^a-z0-9]/g, '') : ''; }
+
+function decodeEntities(str) {
+    return str.replace(/&(nbsp|amp|quot|lt|gt);/g, (m, e) => ({ "nbsp": " ", "amp": "&", "quot": "\"", "lt": "<", "gt": ">" })[e]).replace(/&#(\d+);/gi, (m, n) => String.fromCharCode(parseInt(n, 10)));
+}
+
+async function search(query) {
+    try {
+        const html = await fetchText(`${BASE_URL}/browser?keyword=${encodeURIComponent(query)}`, { signal: AbortSignal.timeout(6000) });
+        const results = [];
+        let idx = 0;
+        while ((idx = html.indexOf('nv-anime-thumb', idx)) !== -1) {
+            const startHref = html.lastIndexOf('<a', idx);
+            if (startHref === -1) { idx += 14; continue; }
+            const hrefMatch = html.slice(startHref, html.indexOf('>', startHref)).match(/href=["']([^"']+)["']/i);
+            if (!hrefMatch) { idx += 14; continue; }
+            const slug = hrefMatch[1].split('/').pop();
+            const h3Start = html.indexOf('nv-anime-title', idx);
+            if (h3Start !== -1) {
+                const contentStart = html.indexOf('>', h3Start) + 1;
+                const contentEnd = html.indexOf('<', contentStart);
+                if (contentEnd !== -1) results.push({ slug, text: html.slice(contentStart, contentEnd).trim() });
+            }
+            idx += 14;
+        }
+        return results;
+    } catch { return []; }
+}
+
+async function extractHls(embedUrl) {
+    try {
+        const html = await fetchText(embedUrl, { headers: { Referer: `${BASE_URL}/` }, signal: AbortSignal.timeout(6000) });
+        const m = html.match(/const\s+src\s*=\s*["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/i) || html.match(/file\s*:\s*["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/i) || html.match(/["'](https?:\/\/[^"']+\/master\.m3u8[^"']*)["']/i) || html.match(/["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/i);
+        if (m) return decodeEntities(m[1]);
+    } catch { }
+    return null;
+}
+
+export async function getStream({ id, s, e, audio }) {
+    try {
+        const info = await getTmdbInfo(id, s ? 'tv' : 'movie', s);
+        if (!info || !info.isAnime) return null;
+        let seriesSlug = null;
+        for (const title of info.titles) {
+            const results = await search(title);
+            const targetClean = cleanTitle(title);
+            for (const r of results) if (cleanTitle(r.text) === targetClean || r.text.toLowerCase().includes(title.toLowerCase())) { seriesSlug = r.slug; break; }
+            if (seriesSlug) break;
+        }
+        if (!seriesSlug && info.titles.length) {
+            const fSearch = await search(info.titles[0]);
+            if (fSearch.length) seriesSlug = fSearch[0].slug;
+        }
+        if (!seriesSlug) return null;
+        const watchHtml = await fetchText(`${BASE_URL}/watch/${seriesSlug}/ep-${e || 1}`, { headers: { Referer: `${BASE_URL}/watch/${seriesSlug}` }, signal: AbortSignal.timeout(6000) });
+        const byAudio = { sub: [], dub: [] };
+        for (const panel of watchHtml.matchAll(/<div\b[^>]*class=["'][^"']*nv-server-grid[^"']*["'][^>]*data-id=["']([^"']+)["'][^>]*>([\s\S]*?)(?=<div\b[^>]*class=["'][^"']*nv-server-grid|$)/gi)) {
+            const panelAudio = panel[1].toLowerCase().includes("dub") ? "dub" : "sub";
+            for (const btn of panel[2].matchAll(/data-video=["']([^"']+)["']/gi)) byAudio[panelAudio].push(decodeEntities(btn[1]));
+        }
+        const audiosToTry = audio === "all" ? ["sub", "dub"] : (audio === "dub" ? ["dub", "sub"] : ["sub", "dub"]);
+        const allUrls = [];
+        for (const aud of audiosToTry) {
+            for (const embed of byAudio[aud]) {
+                const hls = await extractHls(embed);
+                if (hls) allUrls.push({ url: hls, type: "hls", audio: aud, server: "AniNeko", skipProxy: false });
+            }
+            if (allUrls.length) break;
+        }
+        return allUrls.length ? { allUrls } : 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/anipm.js

@@ -0,0 +1,70 @@
+import { getTmdbInfo, fetchJson } from '../utils/helpers.js';
+
+const BASE_URL = "https://ani.pm";
+
+function cleanTitle(t) { return t ? t.toLowerCase().replace(/[^a-z0-9]/g, '') : ''; }
+
+async function searchCatalog(query) {
+    try {
+        const data = await fetchJson(`${BASE_URL}/api/anime/catalog?q=${encodeURIComponent(query)}&page=1`, { signal: AbortSignal.timeout(6000) });
+        return Array.isArray(data?.items) ? data.items : [];
+    } catch { return []; }
+}
+
+async function resolveEntry(titles, year) {
+    const orderedTitles = titles.length > 1 ? [...titles].reverse() : titles;
+    let best = null, bestScore = -1;
+    for (const title of orderedTitles) {
+        const items = await searchCatalog(title);
+        const targetClean = cleanTitle(title);
+        for (const item of items) {
+            const itemTitles = [item.title, item.native].filter(Boolean).map(cleanTitle);
+            let score = 0;
+            if (itemTitles.some(t => t === targetClean)) score += 5;
+            else if (itemTitles.some(t => t.includes(targetClean) || targetClean.includes(t))) score += 3;
+            else continue;
+            if (item.type === 'TV') score += 4;
+            else if (item.type === 'Movie' || item.type === 'Special' || item.type === 'ONA') score -= 2;
+            if (year && item.year) {
+                const diff = Math.abs(item.year - year);
+                if (diff === 0) score += 3;
+                else if (diff === 1) score += 1;
+                else if (diff > 2) score -= 3;
+            }
+            if (score > bestScore) { bestScore = score; best = item; }
+        }
+        if (bestScore >= 9) break;
+    }
+    return best;
+}
+
+export async function getStream({ id, s, e, audio }) {
+    try {
+        const info = await getTmdbInfo(id, s ? 'tv' : 'movie', s);
+        if (!info || !info.isAnime) return null;
+        const entry = await resolveEntry(info.titles, info.year);
+        if (!entry) return null;
+        const episodeNum = e || 1;
+        const params = new URLSearchParams({ title: entry.title || '', ep: String(episodeNum) });
+        if (entry.year) params.set('year', entry.year);
+        if (entry.anilistId) params.set('anilistId', entry.anilistId);
+        if (entry.malId) params.set('malId', entry.malId);
+        const servers = await fetchJson(`${BASE_URL}/api/anime/src/servers?${params}`, { signal: AbortSignal.timeout(10000) });
+        if (!servers) return null;
+        const audiosToTry = audio === "all" ? ["sub", "dub"] : (audio === "dub" ? ["dub", "sub"] : ["sub", "dub"]);
+        for (const aud of audiosToTry) {
+            const list = servers[aud];
+            if (!Array.isArray(list) || !list.length) continue;
+            const allUrls = list.filter(srv => (srv.kind === "hls" || srv.kind === "file") && srv.url)
+                .sort((a, b) => (b.priority || 0) - (a.priority || 0))
+                .map(srv => ({ url: srv.url.startsWith('/') ? `${BASE_URL}${srv.url}` : srv.url, type: srv.kind === "hls" ? "hls" : "mp4", audio: aud, server: srv.provider ? `AniPM-${srv.provider}` : "AniPM", headers: { Referer: `${BASE_URL}/`, Origin: BASE_URL }, skipProxy: false }));
+            if (allUrls.length) return { allUrls };
+        }
+        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/flaxmovies.js

@@ -0,0 +1,14 @@
+import { fetchJson } from '../utils/helpers.js';
+
+const API_BASE = 'https://itjiocunahckqxcnzpoy.supabase.co/functions/v1';
+const APIKEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Iml0amlvY3VuYWhja3F4Y256cG95Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzczMzM1MjQsImV4cCI6MjA5MjkwOTUyNH0.9x9ykdHAzrv_GSvnawPeQaOxQeh3sZg0QAh4u9VOF4M';
+const HEADERS = { 'apikey': APIKEY, 'authorization': `Bearer ${APIKEY}`, 'content-type': 'application/json', 'origin': 'https://flaxmovies.xyz', 'referer': 'https://flaxmovies.xyz/' };
+
+export async function getStream({ id, s, e }) {
+    try {
+        const isMovie = !s;
+        const data = await fetchJson(isMovie ? `${API_BASE}/get-movie` : `${API_BASE}/get-tv`, { method: 'POST', headers: HEADERS, body: JSON.stringify(isMovie ? { id: String(id) } : { id: String(id), season: Number(s), episode: Number(e) }), signal: AbortSignal.timeout(15000) });
+        if (!data?.signed_url) return null;
+        return { allUrls: [{ url: data.signed_url, headers: { 'Referer': 'https://flaxmovies.xyz/', 'Origin': 'https://flaxmovies.xyz' } }] };
+    } catch { return null; }
+}

package/src/sources/fsharetv.js

@@ -0,0 +1,44 @@
+import { fetchText, fetchJson, USER_AGENT, getTmdbInfo } from '../utils/helpers.js';
+
+const BASE_URL = 'https://fsharetv.cc';
+const HEADERS = { 'User-Agent': USER_AGENT, 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'Accept-Language': 'en-US,en;q=0.9', 'Referer': `${BASE_URL}/` };
+const API_HEADERS = { ...HEADERS, 'Accept': 'application/json, */*; q=0.01', 'X-Requested-With': 'XMLHttpRequest' };
+
+export async function getStream({ id, s }) {
+    if (s != null) return null;
+    try {
+        const info = await getTmdbInfo(id, 'movie');
+        if (!info?.imdbId) return null;
+        const html = await fetchText(`${BASE_URL}/movie/${info.imdbId}`, { headers: HEADERS, signal: AbortSignal.timeout(8000) });
+        let watchPath = null;
+        const match = html.match(/href="(\/w\/[^"]+)"/);
+        if (match) watchPath = match[1];
+        if (!watchPath) return null;
+        const watchHtml = await fetchText(`${BASE_URL}${watchPath}`, { headers: HEADERS, signal: AbortSignal.timeout(8000) });
+        let sourceId = null;
+        const sidMatch = watchHtml.match(/(?:source_id|file_id|setSource)[\s=:\('"]+([^'"\)]+)/i);
+        if (sidMatch) sourceId = sidMatch[1];
+        if (!sourceId) return null;
+        const json = await fetchJson(`${BASE_URL}/api/file/${sourceId}/source?trailer=Png81APqcxU&type=watch`, { headers: { ...API_HEADERS, 'Referer': `${BASE_URL}${watchPath}` }, signal: AbortSignal.timeout(8000) });
+        if (json.status !== 'ok') return null;
+        const groups = [];
+        if (Array.isArray(json.data?.file?.sources)) groups.push(json.data.file.sources);
+        if (Array.isArray(json.data?.file?.alternatives)) json.data.file.alternatives.forEach(g => Array.isArray(g) && groups.push(g));
+        const out = [], seen = new Set();
+        for (const group of groups) {
+            for (const item of group.filter(st => st?.src).sort((a, b) => parseInt(b.quality) - parseInt(a.quality))) {
+                const url = item.src.startsWith('http') ? item.src : `${BASE_URL}${item.src}`;
+                if (seen.has(url)) continue;
+                seen.add(url);
+                out.push({ url, quality: parseInt(item.quality) || 0, label: item.label || null });
+            }
+        }
+        out.sort((a, b) => b.quality - a.quality);
+        return out.length ? { allUrls: out.map(u => ({ url: u.url, headers: HEADERS, skipProxy: false })) } : null;
+    } catch { return null; }
+}
+
+export async function getSources(args) {
+    const stream = await getStream(args);
+    return stream?.allUrls ? stream.allUrls.map(u => u.url) : [];
+}

package/src/sources/fsonic.js

@@ -0,0 +1,47 @@
+import { fetchText, fetchJson, USER_AGENT, getTmdbInfo } from '../utils/helpers.js';
+
+const BASE_URL = 'https://www.fsonic.net';
+const FSHARE_BASE = 'https://fsharetv.co';
+const HEADERS = { 'User-Agent': USER_AGENT, 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'Accept-Language': 'en-US,en;q=0.9' };
+
+export async function getStream({ id, s }) {
+    if (s != null) return null;
+    try {
+        const info = await getTmdbInfo(id, 'movie');
+        if (!info?.titles?.length) return null;
+        let watchSlug = null;
+        for (const title of info.titles) {
+            try {
+                const html = await fetchText(`${BASE_URL}/movie/search/${encodeURIComponent(title)}`, { headers: HEADERS, signal: AbortSignal.timeout(8000) });
+                let idx = 0, found = null;
+                const yearStr = String(info.year);
+                while ((idx = html.indexOf('href="/watch/', idx)) !== -1) {
+                    const start = idx + 6;
+                    const end = html.indexOf('"', start);
+                    const link = html.slice(start, end);
+                    if (!found) found = link;
+                    if (link.includes(yearStr)) { found = link; break; }
+                    idx = end;
+                }
+                if (found) { watchSlug = found; break; }
+            } catch { }
+        }
+        if (!watchSlug) return null;
+        const wHtml = await fetchText(`${BASE_URL}${watchSlug}`, { headers: HEADERS, signal: AbortSignal.timeout(8000) });
+        let token = null, trailer = null;
+        const match = wHtml.match(/init\('([^']+)',\s*(?:'[^']*',\s*)?'([^']+)'/);
+        if (match) { token = match[1]; trailer = match[2]; }
+        if (!token) return null;
+        const json = await fetchJson(`${BASE_URL}/api/source/${token}?trailer=${trailer}&type=watch`, { headers: { ...HEADERS, 'Accept': 'application/json, text/plain, */*', 'Referer': `${BASE_URL}${watchSlug}` }, signal: AbortSignal.timeout(8000) });
+        if (json.status !== 'ok') return null;
+        const allGroups = [];
+        if (json.data?.file?.sources?.length) allGroups.push(json.data.file.sources);
+        if (json.data?.file?.alternatives) for (const g of json.data.file.alternatives) if (g?.length) allGroups.push(g);
+        const urls = new Set();
+        for (const group of allGroups) {
+            const best = [...group].filter(st => st?.src).sort((a, b) => parseInt(b.quality) - parseInt(a.quality))[0];
+            if (best) urls.add(best.src.startsWith('http') ? best.src : `${FSHARE_BASE}${best.src}`);
+        }
+        return urls.size ? { allUrls: [...urls].map(url => ({ url, headers: { ...HEADERS, 'Referer': `${FSHARE_BASE}/` }, skipProxy: false })) } : null;
+    } catch { return null; }
+}

package/src/sources/fsonline.js

@@ -0,0 +1,46 @@
+import { fetchText, USER_AGENT, getTmdbInfo } from '../utils/helpers.js';
+
+const ORIGIN = 'https://www3.fsonline.app';
+const AJAX_URL = `${ORIGIN}/wp-admin/admin-ajax.php`;
+const HEADERS = { 'User-Agent': USER_AGENT, 'Origin': ORIGIN, 'Referer': `${ORIGIN}/` };
+
+export async function getStream({ id, s, e }) {
+    try {
+        const isTv = s != null && e != null;
+        const info = await getTmdbInfo(id, isTv ? 'tv' : 'movie');
+        if (!info?.titles?.length) return null;
+        const searchHtml = await fetchText(`${ORIGIN}/?s=${encodeURIComponent(info.titles[0] + (info.year ? ' ' + info.year : ''))}`, { headers: HEADERS });
+        const typeFolder = isTv ? 'seriale' : 'film';
+        const linkMatch = searchHtml.match(new RegExp(`href=["'](https?://www3\\.fsonline\\.app/${typeFolder}/([^"'/]+)/)["']`, 'i'));
+        if (!linkMatch) return null;
+        const targetPageUrl = isTv ? `${ORIGIN}/episoade/${linkMatch[2].replace(/-\d{4}$/, '')}-sezonul-${s}-episodul-${e}/` : linkMatch[1];
+        const pageHtml = await fetchText(targetPageUrl, { headers: HEADERS });
+        const movieId = (pageHtml.match(/movie-id=['"]([^'"]+)['"]/) || pageHtml.match(/movie-id=([^ >]+)/))?.[1];
+        if (!movieId) return null;
+        const ajaxHtml = await fetchText(AJAX_URL, { method: 'POST', headers: { ...HEADERS, 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8', 'X-Requested-With': 'XMLHttpRequest', 'Referer': targetPageUrl }, body: `action=lazy_player&movieID=${movieId}` });
+        const results = [];
+        let idx = 0;
+        while ((idx = ajaxHtml.indexOf('data-vs="', idx)) !== -1) {
+            const embedStart = idx + 9;
+            const embedEnd = ajaxHtml.indexOf('"', embedStart);
+            const embedUrl = ajaxHtml.slice(embedStart, embedEnd);
+            const spanStart = ajaxHtml.indexOf('<span>', embedEnd);
+            const spanEnd = ajaxHtml.indexOf('</span>', spanStart);
+            const serverLabel = ajaxHtml.slice(spanStart + 6, spanEnd).trim().toLowerCase();
+            if (serverLabel.includes('filesun')) {
+                try {
+                    const rHtml = await fetchText(embedUrl, { headers: { 'Referer': ORIGIN, 'User-Agent': USER_AGENT } });
+                    const m3u8Match = rHtml.match(/file:\s*["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/) || rHtml.match(/["']?file["']?:\s*["'](https?:\/\/[^"']+)["']/);
+                    if (m3u8Match) results.push({ url: m3u8Match[1].replace(/\\\//g, '/'), server: 'FSOnline - FileSuN', headers: { 'Referer': embedUrl, 'Origin': 'https://player.fsonline.app', 'User-Agent': USER_AGENT } });
+                } catch { }
+            }
+            idx = spanEnd;
+        }
+        return results.length ? { allUrls: results } : null;
+    } catch { return null; }
+}
+
+export async function getSources(args) {
+    const res = await getStream(args);
+    return res?.allUrls ? [...new Set(res.allUrls.map(u => u.server))] : [];
+}