@vyla-entertainment/sdk 1.8.0 → 1.9.0

package/README.md

@@ -1,8 +1,11 @@
-# vyla/sdk
-VylaSDK is a javascript base version of [Vyla](https://vyla.mintlify.app/)'s stream & scrape api, allowing developers to access content providers directly without using a REST api. This gives you the power & updates of Vyla without the headaches of api keys & server reliability.
+# Vyla SDK
+
+VylaSDK is a JavaScript/TypeScript SDK for accessing Vyla's stream providers, subtitles, and download sources directly from Node.js. Instead of using the Vyla REST API, developers can run the scraping layer directly in their own environment with full control over requests, execution, and provider management.
+
+### Installing
 
-## Installing
 To start, install VylaSDK through npm or pnpm:
+
 ```bash
 # npm
 npm install @vyla-entertainment/sdk
@@ -11,21 +14,22 @@ npm install @vyla-entertainment/sdk
 pnpm install @vyla-entertainment/sdk
 ```
 
-View our full documentation at https://docs.vyla.cc/sdk
+Please note we do not provide proxying, you have to do that on your end.
 
-# [DMCA](https://docs.vyla.cc/misc/dmca)
+**View our full documentation at:** https://docs.vyla.cc/sdk
+
+### [DMCA](https://docs.vyla.cc/misc/dmca)
 
 If your source is listed here, I sincerely apologize. I understand that its inclusion may be costing you a lot of money, and that was never my intention. Please contact me as soon as possible, and I'll remove it ASAP.
 
 This is a small hobby project that I built for learning and personal interest, not for profit. I genuinely want to respect the wishes of source owners and will address any removal requests as quickly as I can.
 
-This project is developed and maintained by [Vyla Entertainment](https://github.com/vyla-entertainment) (@vyla-entertainment).
+This project is developed and maintained by [Vyla Entertainment](https://github.com/vyla-entertainment).
 
 Original work and core authorship:
 
 [@endoverdosing](https://github.com/EndOverdosing)
-
 [@GavinGoGaming](https://github.com/GavinGoGaming)
 
-Full credits and acknowledgements:
+**Full credits and acknowledgements:**
 https://docs.vyla.cc/misc/credit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vyla-entertainment/sdk",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "scripts": {
     "test": "node test/index.js"
   },

package/src/config.js

@@ -60,6 +60,30 @@ export const SOURCES = [
         skipProxy: true
     },
 
+    {
+        key: 'anikoto-sub',
+        label: 'AniKoto (Sub)',
+        sourceFile: 'anikoto',
+        proxyParam: 'aksub',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true
+    },
+
+    {
+        key: 'anikoto-dub',
+        label: 'AniKoto (Dub)',
+        sourceFile: 'anikoto',
+        proxyParam: 'akdub',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true
+    },
+
     {
         key: 'anineko-sub',
         sourceFile: 'anineko',
@@ -114,6 +138,18 @@ export const SOURCES = [
         },
     },
 
+    {
+        key: 'anizone',
+        label: 'AniZone',
+        sourceFile: 'anizone',
+        proxyParam: 'az',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true
+    },
+
     {
         key: 'cinejoy',
         label: 'Cinejoy',
@@ -126,6 +162,25 @@ export const SOURCES = [
         skipProxy: true,
     },
 
+    {
+        key: 'cinesu',
+        label: 'CineSu',
+        sourceFile: 'cinesu',
+        proxyParam: 'cs',
+        timeout: 20000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: false,
+        skipProxy: true,
+        cdnHeaders: [{
+            pattern: /glendale-plumbing\.com/i,
+            headers: {
+                Referer: 'https://cine.su/',
+                Origin: 'https://cine.su',
+            },
+        }],
+    },
+
     {
         key: 'flaxmovies',
         label: 'FlaxMovies',
@@ -194,6 +249,18 @@ export const SOURCES = [
         retries: 2,
     },
 
+    {
+        key: 'kickassanime',
+        label: 'KickAssAnime',
+        sourceFile: 'kickassanime',
+        proxyParam: 'kaa',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true
+    },
+
     {
         key: 'kisskh',
         label: 'KissKH',
@@ -248,7 +315,6 @@ export const SOURCES = [
         jitter: 500,
         retries: 2,
         multiUrl: true,
-        skipProxy: true
     },
 
     {
@@ -302,6 +368,30 @@ export const SOURCES = [
         skipProxy: true
     },
 
+    {
+        key: 'reanime-sub',
+        label: 'Reanime (Sub)',
+        sourceFile: 'reanime',
+        proxyParam: 'resub',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true
+    },
+    
+    {
+        key: 'reanime-dub',
+        label: 'Reanime (Dub)',
+        sourceFile: 'reanime',
+        proxyParam: 'redub',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true
+    },
+
     {
         key: 'vidapi',
         label: 'VidAPI',
@@ -479,7 +569,6 @@ export const SOURCES = [
             Referer: 'https://player.vidzee.wtf',
             Origin: 'https://player.vidzee.wtf',
         },
-        disabled: true // Disabled temporarily due to decryption issues
     },
 
     {

package/src/sources/anikoto.js

@@ -0,0 +1,198 @@
+import { fetchJson, fetchText, getTmdbInfo, tmdbToAnilist, USER_AGENT } from '../utils/helpers.js';
+
+const ANIKOTO = "https://anikototv.to";
+const MEGAPLAY = "https://megaplay.buzz";
+const VIDWISH = "https://vidwish.live";
+const SPOOF_REF = "https://hianimes.re/";
+const HEADERS = { "User-Agent": USER_AGENT, Accept: "text/html,*/*" };
+
+function extractEpisodes(html) {
+    const episodes = [];
+    const re = /<a\s[^>]*data-id="[^"]*"[^>]*>/g;
+    let m;
+    while ((m = re.exec(html)) !== null) {
+        const tag = m[0];
+        const getAttr = (a) => {
+            const x = tag.match(new RegExp(`data-${a}="([^"]*)"`));
+            return x ? x[1] : "";
+        };
+        const id = getAttr("id"), num = getAttr("num");
+        if (!id || !num) continue;
+        episodes.push({ id, num: parseInt(num), slug: getAttr("slug"), hasSub: getAttr("sub") === "1", hasDub: getAttr("dub") === "1", ids: getAttr("ids") });
+    }
+    return episodes;
+}
+
+function extractSearchCandidates(html) {
+    const results = [];
+    const re = /<a class="item" href="https:\/\/anikototv\.to\/watch\/([^"]+)"([\s\S]*?)<\/a>/g;
+    let m;
+    while ((m = re.exec(html)) !== null) {
+        const block = m[2];
+        const enM = block.match(/class="name d-title"[^>]*>([^<]*)</);
+        const jpM = block.match(/data-jp="([^"]*)"/);
+        results.push({ slug: m[1], titleEn: enM ? enM[1].trim() : "", titleJp: jpM ? jpM[1].trim() : "" });
+    }
+    return results;
+}
+
+async function searchAnikoto(keyword) {
+    const data = await fetchJson(`${ANIKOTO}/ajax/anime/search?keyword=${encodeURIComponent(keyword)}`, {
+        headers: { ...HEADERS, "X-Requested-With": "XMLHttpRequest", Referer: `${ANIKOTO}/` }
+    }).catch(() => null);
+
+    const results = extractSearchCandidates(data?.result?.html ?? "");
+    const html = await fetchText(`${ANIKOTO}/filter?keyword=${encodeURIComponent(keyword)}`, { headers: { ...HEADERS, Referer: `${ANIKOTO}/` } }).catch(() => "");
+
+    for (const m of html.matchAll(/<a class="name d-title" href="https:\/\/anikototv\.to\/watch\/([^"/]+)(?:\/ep-\d+)?" data-jp="([^"]*)">([\s\S]*?)<\/a>/g)) {
+        results.push({
+            slug: m[1],
+            titleEn: m[3].replace(/<[^>]*>/g, "").trim(),
+            titleJp: m[2].trim()
+        });
+    }
+
+    const seen = new Set();
+    return results.filter((r) => {
+        if (seen.has(r.slug)) return false;
+        seen.add(r.slug);
+        return true;
+    });
+}
+
+async function findAnikotoShow(title) {
+    const candidates = await searchAnikoto(title);
+    if (!candidates.length) return null;
+    const chosenSlug = candidates[0].slug;
+
+    const pageHtml = await fetchText(`${ANIKOTO}/watch/${chosenSlug}`, { headers: { ...HEADERS, Referer: `${ANIKOTO}/` } });
+    const idM = pageHtml.match(/data-id="(\d+)"/);
+    if (!idM) return null;
+    return { slug: chosenSlug, showId: idM[1] };
+}
+
+async function extractVidWish(realId, audio) {
+    try {
+        const page = await fetchText(`${VIDWISH}/stream/s-2/${realId}/${audio}`, { headers: { ...HEADERS, Referer: SPOOF_REF } });
+        const m = page.match(/data-id="([^"]*)"/);
+        if (!m?.[1]) return null;
+        const fileId = m[1];
+        const data = await fetchJson(`${VIDWISH}/stream/getSources?id=${fileId}&id=${fileId}`, { headers: { ...HEADERS, Referer: `${VIDWISH}/`, "X-Requested-With": "XMLHttpRequest" } });
+        return { fileId, data };
+    } catch {
+        return null;
+    }
+}
+
+export async function getStream({ id, s, e, audio, tmdbApiKey }) {
+    try {
+        const isTv = !!s;
+        const mediaType = isTv ? 'tv' : 'movie';
+        const epNum = e ? Number(e) : 1;
+        const seasonNum = s ? Number(s) : 1;
+
+        let anilistId = null;
+        let titles = [];
+        const tmdbInfo = await getTmdbInfo(tmdbApiKey, id, mediaType, seasonNum);
+
+        if (tmdbInfo) {
+            titles = tmdbInfo.titles || [];
+            anilistId = await tmdbToAnilist(id, mediaType, seasonNum, titles, tmdbInfo.year);
+        }
+        if (!anilistId) {
+            anilistId = Number(id);
+        }
+
+        const audioPref = audio === 'dub' ? 'dub' : 'sub';
+        let embedUrl = `${MEGAPLAY}/stream/ani/${anilistId}/${epNum}/${audioPref}`;
+        let megaHtml = await fetchText(embedUrl, { headers: { ...HEADERS, Referer: SPOOF_REF } }).catch(() => '');
+
+        const frameSrc = megaHtml.match(/<iframe\b[^>]*src="([^"]+)"/i)?.[1];
+        if (!megaHtml.match(/data-id="([^"]*)"/) && frameSrc) {
+            embedUrl = frameSrc.startsWith("http") ? frameSrc : `${MEGAPLAY}${frameSrc}`;
+            megaHtml = await fetchText(embedUrl, { headers: { ...HEADERS, Referer: SPOOF_REF } }).catch(() => '');
+        }
+
+        const attrMatch = (name) => {
+            const m = megaHtml.match(new RegExp(`data-${name}="([^"]*)"`));
+            return m ? m[1] : null;
+        };
+
+        const fileId = attrMatch("id");
+        const realId = attrMatch("realid");
+
+        const urls = [];
+
+        if (fileId) {
+            const megaSources = await fetchJson(`${MEGAPLAY}/stream/getSources?id=${fileId}&id=${fileId}`, {
+                headers: { ...HEADERS, Referer: `${MEGAPLAY}/`, "X-Requested-With": "XMLHttpRequest" }
+            }).catch(() => null);
+
+            if (megaSources?.sources?.file) {
+                urls.push({
+                    url: megaSources.sources.file,
+                    server: 'AniKoto (Megaplay)',
+                });
+            }
+        }
+
+        if (realId) {
+            const vidwish = await extractVidWish(realId, audioPref);
+            if (vidwish?.data?.sources?.file) {
+                urls.push({
+                    url: vidwish.data.sources.file,
+                    server: 'AniKoto (VidWish)',
+                });
+            }
+        }
+
+        if (!urls.length && titles.length) {
+            const show = await findAnikotoShow(titles[0]);
+            if (show) {
+                const listData = await fetchJson(`${ANIKOTO}/ajax/episode/list/${show.showId}`, {
+                    headers: { ...HEADERS, "X-Requested-With": "XMLHttpRequest", Referer: `${ANIKOTO}/watch/${show.slug}` }
+                }).catch(() => null);
+
+                const episodes = extractEpisodes(listData?.result ?? "");
+                const ep = episodes.find((item) => item.num === epNum);
+                if (ep && ep.ids) {
+                    const serverData = await fetchJson(`${ANIKOTO}/ajax/server/list?servers=${encodeURIComponent(ep.ids)}`, {
+                        headers: { ...HEADERS, "X-Requested-With": "XMLHttpRequest", Referer: `${ANIKOTO}/` }
+                    }).catch(() => null);
+
+                    const items = [];
+                    const typeRe = /<div class="type" data-type="(sub|dub)">([\s\S]*?)<\/ul>\s*<\/div>/g;
+                    let typeM;
+                    while ((typeM = typeRe.exec(serverData?.result ?? "")) !== null) {
+                        if (typeM[1] !== audioPref) continue;
+                        for (const li of typeM[2].matchAll(/<li\s+([^>]*data-link-id[^>]*)>([\s\S]*?)<\/li>/g)) {
+                            const linkId = li[1].match(/data-link-id="([^"]+)"/)?.[1];
+                            const name = li[2].replace(/<[^>]+>/g, "").trim();
+                            if (linkId) items.push({ linkId, name });
+                        }
+                    }
+
+                    for (const item of items) {
+                        const resolved = await fetchJson(`${ANIKOTO}/ajax/server?get=${encodeURIComponent(item.linkId)}`, {
+                            headers: { ...HEADERS, "X-Requested-With": "XMLHttpRequest", Referer: `${ANIKOTO}/` }
+                        }).catch(() => null);
+                        if (resolved?.result?.url) {
+                            urls.push({
+                                url: resolved.result.url,
+                                server: `AniKoto (${item.name})`,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+
+        return urls.length ? { allUrls: urls } : null;
+    } catch (err) {
+        return null;
+    }
+}
+
+export async function getSources() {
+    return ['AniKoto'];
+}

package/src/sources/anizone.js

@@ -0,0 +1,109 @@
+import { fetchText, getTmdbInfo, USER_AGENT } from '../utils/helpers.js';
+
+const BASE = "https://anizone.to";
+const HEADERS = { "User-Agent": USER_AGENT, Referer: `${BASE}/` };
+
+function decodeEntities(encodedString) {
+    var translate_re = /&(nbsp|amp|quot|lt|gt);/g;
+    var translate = { "nbsp": " ", "amp": "&", "quot": "\"", "lt": "<", "gt": ">" };
+    return (encodedString || "").replace(translate_re, function (match, entity) {
+        return translate[entity];
+    }).replace(/&#(\d+);/g, function (match, dec) {
+        return String.fromCharCode(dec);
+    });
+}
+
+function processJsonArg(raw) {
+    const PH = "\x01U\x01";
+    let s = raw.replace(/\\\\u([0-9a-fA-F]{4})/g, `${PH}$1`);
+    s = s.replace(/\\u([0-9a-fA-F]{4})/g, (_, h) => String.fromCharCode(parseInt(h, 16)));
+    s = s.replace(/\x01U\x01([0-9a-fA-F]{4})/g, "\\u$1");
+    try { return JSON.parse(s); } catch { return {}; }
+}
+
+function pickTitle(titles) {
+    return titles["1"] || titles["5"] || titles["8"] || Object.values(titles)[0] || "";
+}
+
+function extractSlug(ctx) {
+    const m = ctx.match(/href="(?:https:\/\/anizone\.to)?\/anime\/([a-z0-9-]+)"/);
+    return m ? m[1] : null;
+}
+
+function extractJsonArg(xdata, key) {
+    const re = new RegExp(`${key}:\\s*JSON\\.parse\\('((?:[^'\\\\]|\\\\.)*)'\\)`);
+    const m = xdata.match(re);
+    return m ? m[1] : null;
+}
+
+async function search(query) {
+    const html = await fetchText(`${BASE}/anime?search=${encodeURIComponent(query)}`, { headers: HEADERS }).catch(() => "");
+    const results = [];
+    const xdataRe = /x-data="(\{[^"]*anmTitles[^"]*\})"/g;
+    let m;
+    while ((m = xdataRe.exec(html)) !== null) {
+        const ctxStart = Math.max(0, m.index - 300);
+        const ctxEnd = Math.min(html.length, m.index + m[0].length + 800);
+        const ctx = html.slice(ctxStart, ctxEnd);
+        const slug = extractSlug(ctx);
+        if (!slug) continue;
+        const xdata = decodeEntities(m[1]);
+        const raw = extractJsonArg(xdata, "anmTitles");
+        if (!raw) continue;
+        const titles = processJsonArg(raw);
+        const title = pickTitle(titles);
+        if (title) results.push({ slug, text: title });
+    }
+    return results;
+}
+
+async function scrapeWatch(slug, episodeNum) {
+    const html = await fetchText(`${BASE}/anime/${slug}/${episodeNum}`, { headers: HEADERS }).catch(() => "");
+    if (!html) return null;
+
+    const hlsMatch = html.match(/<media-player[^>]+src="([^"]+\.m3u8[^"]*)"/i);
+    const hls = hlsMatch ? decodeEntities(hlsMatch[1]) : null;
+
+    return hls;
+}
+
+export async function getStream({ id, s, e, tmdbApiKey }) {
+    try {
+        const isTv = !!s;
+        const mediaType = isTv ? 'tv' : 'movie';
+        const epNum = e ? Number(e) : 1;
+        const seasonNum = s ? Number(s) : 1;
+
+        const tmdbInfo = await getTmdbInfo(tmdbApiKey, id, mediaType, seasonNum);
+        const titles = tmdbInfo?.titles || [];
+
+        let slug = null;
+        for (const title of titles) {
+            const results = await search(title);
+            if (results.length) {
+                slug = results[0].slug;
+                break;
+            }
+        }
+
+        if (!slug) return null;
+
+        const hls = await scrapeWatch(slug, epNum);
+        if (!hls) return null;
+
+        return {
+            allUrls: [
+                {
+                    url: hls,
+                    server: 'AniZone',
+                }
+            ]
+        };
+    } catch (err) {
+        return null;
+    }
+}
+
+export async function getSources() {
+    return ['AniZone'];
+}

package/src/sources/cinesu.js

@@ -0,0 +1,94 @@
+import { USER_AGENT } from '../utils/helpers.js';
+
+const lS = [17, 91, 203, 44, 8, 177, 62, 239, 119, 3, 154, 81, 28, 210, 101, 7];
+
+function lA(e) {
+    let t = e >>> 0;
+    t ^= t >>> 16;
+    t = Math.imul(t, 0x7feb352d) >>> 0;
+    t ^= t >>> 15;
+    t = Math.imul(t, 0x846ca68b) >>> 0;
+    return (t ^ (t >>> 16)) >>> 0;
+}
+
+function lL(keyStr, targetLen) {
+    const encoder = new TextEncoder();
+    const i = encoder.encode(keyStr || "dev");
+    const rLen = Math.max(32, Math.min(128, targetLen + 17));
+    const r = new Uint8Array(rLen);
+    let s = 0x811c9dc5;
+    for (let e = 0; e < rLen; e += 1) {
+        const a = i[e % i.length] ?? e;
+        s ^= a;
+        s = lA((s + lS[e % lS.length] + ((0x9e3779b1 * e) >>> 0)) >>> 0);
+        r[e] = s & 255;
+    }
+    return r;
+}
+
+function base64UrlEncode(bytes) {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+    let i = "";
+    for (let r = 0; r < bytes.length; r += 3) {
+        const s = bytes[r];
+        const a = bytes[r + 1];
+        const n = bytes[r + 2];
+        i += chars[s >>> 2];
+        i += chars[((3 & s) << 4) | ((a ?? 0) >>> 4)];
+        if (a === undefined) break;
+        i += chars[((15 & a) << 2) | ((n ?? 0) >>> 6)];
+        if (n === undefined) break;
+        i += chars[63 & n];
+    }
+    return i;
+}
+
+export function generateCineSuUrl(type, tmdbId, season = 1, episode = 1) {
+    const kind = type === "show" || type === "tv" ? "show" : "movie";
+    const s = kind === "show" ? Math.max(1, Math.floor(season)) : 0;
+    const ep = kind === "show" ? Math.max(1, Math.floor(episode)) : 0;
+    const char = kind[0];
+
+    const payloadStr = `4860ac8bfddb:${char}:${Math.floor(Number(tmdbId))}:${s}:${ep}`;
+    const encoder = new TextEncoder();
+    const d = encoder.encode(payloadStr);
+
+    const key = "224eff10e662e9635c9f671cf46351dcd69af42b1edd56f5e5fa21751f44b9c8";
+    const u = lL(key, d.length);
+
+    const h = new Uint8Array(d.length + 2);
+    h[0] = 255 & d.length;
+    h[1] = (d.length >>> 8) & 255;
+
+    let c = (0x9e3779b9 ^ d.length) >>> 0;
+    for (let e = 0; e < d.length; e += 1) {
+        c = lA((c + u[e % u.length] + lS[e % lS.length] + e) >>> 0);
+        h[e + 2] = d[e] ^ (255 & c) ^ u[(7 * e + 3) % u.length];
+    }
+
+    const token = base64UrlEncode(h);
+    return `https://glendale-plumbing.com/c/v1/${token}/master.m3u8`;
+}
+
+export async function getStream({ id, s, e }) {
+    try {
+        const isTv = !!s;
+        const mediaType = isTv ? 'tv' : 'movie';
+        const m3u8Url = generateCineSuUrl(mediaType, id, s || 1, e || 1);
+
+        return {
+            allUrls: [
+                {
+                    url: m3u8Url,
+                    server: 'CineSu',
+                }
+            ]
+        };
+    } catch (err) {
+        return null;
+    }
+}
+
+export async function getSources() {
+    return ['CineSu'];
+}