kaizoku-core 0.1.0

package/dist/providers/anime/anikoto.js

@@ -0,0 +1,259 @@
+import { load } from 'cheerio';
+import { httpGet, getText } from '../../utils/http.js';
+import { extractMegaPlay } from '../../extractors/megaplay.js';
+import { extractVidWish } from '../../extractors/vidwish.js';
+const BASE_URL = 'https://anikototv.to';
+// --- Internal Parsing Helpers ---
+function parseHomeAnimeSections(html, selector) {
+    const $ = load(html);
+    const items = [];
+    $(selector).each((_, element) => {
+        const ep = $(element).find('.ep-status');
+        const href = $(element).find('div.info > a').attr('href');
+        const id = href?.includes('ep') ? href.split('/').at(-2) : href?.split('/').at(-1);
+        items.push({
+            id: id || '',
+            title: $(element).find('div.info > a').text().trim() || '',
+            romaji: $(element).find('div.info > a').attr('data-jp') || '',
+            image: $(element).find('img').attr('src') || '',
+            type: $(element).find('.meta .right').text().trim() || '',
+            episodes_sub: Number(ep.filter('.sub').text().trim()) || 0,
+            episodes_dub: Number(ep.filter('.dub').text().trim()) || 0,
+        });
+    });
+    return items;
+}
+function parseNewAddedItems(html, selector) {
+    const $ = load(html);
+    const items = [];
+    $(selector).each((_, element) => {
+        items.push({
+            id: $(element).attr('href')?.split('/').filter(Boolean).at(-1) || '',
+            title: $(element).find('.name.d-title').text().trim() || '',
+            romaji: $(element).find('.name.d-title').attr('data-jp') || '',
+            image: $(element).find('.poster img').attr('src') || '',
+            type: $(element).find('.meta.one-line .dot:nth-child(2)').text().trim() || '',
+        });
+    });
+    return items;
+}
+function parseTopAnimeSegment(html, tabName) {
+    const $ = load(html);
+    const selector = `#top-anime .tab-content[data-name="${tabName}"] .scaff.items .item`;
+    const results = [];
+    $(selector).each((_, element) => {
+        results.push({
+            id: $(element).attr('href')?.split('/').at(-1) || '',
+            title: $(element).find('.name').text().trim() || '',
+            romaji: $(element).find('.name').attr('data-jp')?.trim() || '',
+            image: $(element).find('.poster img').attr('src') ?? '',
+            type: $(element).find('.meta .dot:not(.ep-wrap)').first().text().trim() || '',
+        });
+    });
+    return results;
+}
+function parsePaginatedSections(html) {
+    const $ = load(html);
+    const selector = 'div#list-items > div.item';
+    const anime = [];
+    $(selector).each((_, element) => {
+        const href = $(element).find('div.ani.poster.tip > a').attr('href');
+        const id = href?.includes('ep') ? href.split('/').at(-2) : href?.split('/').at(-1);
+        anime.push({
+            id: id || '',
+            title: $(element).find('div.b1 > a.name.d-title').text().trim() || '',
+            romaji: $(element).find('div.b1 > a.name.d-title').attr('data-jp') || '',
+            image: $(element).find('div.ani.poster.tip img').attr('src') || '',
+            type: $(element).find('div.meta div.right').text().trim() || '',
+        });
+    });
+    const activeText = $('.pagination .page-item.active .page-link').first().text().trim();
+    const currentPage = Number(activeText) || 1;
+    const lastPageText = $('.pagination .page-item a[title="Last"]').attr('href')?.match(/page=(\d+)/)?.[1];
+    const lastPage = lastPageText ? Number(lastPageText) : null;
+    const nextHref = $('.pagination .page-item a[rel="next"]').attr('href');
+    const hasNextPage = Boolean(nextHref) || (lastPage !== null && Number.isFinite(lastPage) && currentPage < lastPage);
+    return { hasNextPage, currentPage, totalPages: lastPage || currentPage, results: anime };
+}
+// --- Exported Methods ---
+export async function fetchHome() {
+    const result = await getText(`${BASE_URL}/home`);
+    const $ = load(result);
+    const spotlight = [];
+    $('div#hotest > div.swiper-wrapper > div.swiper-slide.item').each((_, element) => {
+        const icons = $(element).find('div.meta.icons');
+        spotlight.push({
+            id: $(element).find('div.actions > a').attr('href')?.split('/').at(-1) || '',
+            title: $(element).find('div.info > h2.title.d-title').text().trim() || '',
+            romaji: $(element).find('div.info > h2.title.d-title').attr('data-jp') || '',
+            image: $(element).find('div.image > div').attr('style')?.match(/url\(['"]?(.*?)['"]?\)/)?.[1] ?? '',
+            description: $(element).find('div.synopsis').text().trim() || '',
+        });
+    });
+    return {
+        spotlight,
+        recentlyUpdated: parseHomeAnimeSections(result, 'section#recent-update div.ani.items > div.item'),
+        upcoming: parseHomeAnimeSections(result, 'section#upcoming-anime div.ani.items > div.item'),
+        sections: {
+            recentlyAdded: parseNewAddedItems(result, 'section.top-table[data-name="new-added"] div.body .scaff.items a.item'),
+            recentlyReleased: parseNewAddedItems(result, 'section.top-table[data-name="new-release"] div.body .scaff.items a.item'),
+            recentlyCompleted: parseNewAddedItems(result, 'section.top-table[data-name="completed"] div.body .scaff.items a.item'),
+        },
+        topAnime: {
+            day: parseTopAnimeSegment(result, 'day'),
+            week: parseTopAnimeSegment(result, 'week'),
+            month: parseTopAnimeSegment(result, 'month'),
+        }
+    };
+}
+export async function fetchSchedule(timezone) {
+    const res = await httpGet(`${BASE_URL}/ajax/schedule?tz=${timezone}`, { 'X-Requested-With': 'XMLHttpRequest' });
+    const json = await res.json();
+    const $ = load(json.result);
+    const days = [];
+    const dayHeaders = [];
+    $('#schedule .days .day').each((_, element) => {
+        const $day = $(element);
+        const dayName = $day.find('.inner .wday').text().trim() || $day.find('.wday').text().trim();
+        const date = $day.find('.inner .date').text().trim() || $day.find('.date').text().trim();
+        if (!dayName && !date)
+            return;
+        dayHeaders.push({ day: dayName, date });
+    });
+    const animes = [];
+    $('#schedule .body .items .item').each((_, el) => {
+        const $el = $(el);
+        const href = $el.attr('href') ?? '';
+        const slug = href.replace(/^https?:\/\/[^/]+/, '').replace(/^\/watch\//, '').replace(/\/ep-\d+$/, '').replace(/\/$/, '');
+        animes.push({
+            id: slug,
+            title: $el.find('.title, .d-title').text().trim(),
+            episode: $el.find('.ep span').text().trim() || '',
+            time: $el.find('.time').text().trim() || '',
+        });
+    });
+    const perDay = Math.ceil(animes.length / Math.max(1, dayHeaders.length));
+    dayHeaders.forEach((d, i) => {
+        days.push({ ...d, anime: animes.slice(i * perDay, (i + 1) * perDay) });
+    });
+    return { data: days };
+}
+export async function search(query, page = 1) {
+    const url = page > 1 ? `${BASE_URL}/filter?keyword=${query}?page=${page}` : `${BASE_URL}/filter?keyword=${query}`;
+    const html = await getText(url);
+    return parsePaginatedSections(html);
+}
+export async function searchSuggestions(query) {
+    const res = await httpGet(`${BASE_URL}/ajax/anime/search?keyword=${query}`, { 'X-Requested-With': 'XMLHttpRequest' });
+    const result = await res.json();
+    const $ = load(result.result.html);
+    const items = [];
+    $('.scaff.items a.item').each((_, element) => {
+        const href = $(element).attr('href') || '';
+        items.push({
+            id: href.split('/watch/').pop() || '',
+            title: $(element).find('.name.d-title').text().trim() || '',
+            romaji: $(element).find('.name.d-title').attr('data-jp') || '',
+            image: $(element).find('.poster img').attr('src') || '',
+        });
+    });
+    return { data: items };
+}
+export async function fetchAnimeInfo(id) {
+    const html = await getText(`${BASE_URL}/watch/${id}`);
+    const $ = load(html);
+    const root = $('div#w-info div.binfo');
+    const numericId = $('div#watch-main').attr('data-id');
+    const seriesId = $('div#watch-main').attr('data-url')?.split('/').at(-1);
+    const info = {
+        id: seriesId || id,
+        title: root.find('div.info > h1.title.d-title').text().trim() || '',
+        romaji: root.find('div.info > h1.title.d-title').attr('data-jp') || '',
+        image: root.find('div.poster > span > img').attr('src') || '',
+        description: root.find('div.content').text().trim() || '',
+        genres: root.find('div.meta > div').filter((_, el) => $(el).text().includes('Genres:')).find('a').map((_, el) => $(el).text().trim()).get(),
+        status: root.find('div.meta > div').filter((_, el) => $(el).text().includes('Status:')).find('span').text().trim() || '',
+        episodes: []
+    };
+    if (numericId) {
+        const epRes = await httpGet(`${BASE_URL}/ajax/episode/list/${numericId}?vrf=`, { 'X-Requested-With': 'XMLHttpRequest' });
+        const epJson = await epRes.json();
+        const $ep = load(epJson.result);
+        $ep('div.body ul.ep-range li').each((_, element) => {
+            const $a = $ep(element).find('a');
+            info.episodes.push({
+                id: $a.attr('data-ids')?.replace('&eps=', '-episode-') || '',
+                number: Number($a.attr('data-num')) || 0,
+                title: $ep(element).attr('title') || '',
+                hasSub: Number($a.attr('data-sub')) === 1,
+                hasDub: Number($a.attr('data-dub')) === 1,
+            });
+        });
+    }
+    return info;
+}
+export async function fetchMostPopular(page = 1) { return parsePaginatedSections(await getText(`${BASE_URL}/most-viewed${page > 1 ? '?page=' + page : ''}`)); }
+export async function fetchRecentlyUpdated(page = 1) { return parsePaginatedSections(await getText(`${BASE_URL}/latest-updated${page > 1 ? '?page=' + page : ''}`)); }
+export async function fetchRecentlyAdded(page = 1) { return parsePaginatedSections(await getText(`${BASE_URL}/new-release${page > 1 ? '?page=' + page : ''}`)); }
+export async function fetchUpcoming(page = 1) { return parsePaginatedSections(await getText(`${BASE_URL}/status/not-yet-aired${page > 1 ? '?page=' + page : ''}`)); }
+export async function fetchReleasing(page = 1) { return parsePaginatedSections(await getText(`${BASE_URL}/status/currently-airing${page > 1 ? '?page=' + page : ''}`)); }
+export async function fetchRecentlyCompleted(page = 1) { return parsePaginatedSections(await getText(`${BASE_URL}/status/finished-airing${page > 1 ? '?page=' + page : ''}`)); }
+export async function fetchAtoZList(sort, page = 1) {
+    const cat = sort ? (sort.length === 1 ? sort.toUpperCase() : '0-9') : undefined;
+    const base = cat ? `az-list/${cat}` : `az-list`;
+    return parsePaginatedSections(await getText(`${BASE_URL}/${base}${page > 1 ? '?page=' + page : ''}`));
+}
+export async function fetchServers(episodeId) {
+    const res = await httpGet(`${BASE_URL}/ajax/server/list?servers=${episodeId}`, { 'X-Requested-With': 'XMLHttpRequest' });
+    const json = await res.json();
+    const $ = load(json.result);
+    const servers = { sub: [], dub: [], raw: [], episodeNumber: 0 };
+    const episodeText = $('div.tip b').first().text().trim();
+    const match = episodeText.match(/(\d+)/);
+    if (match)
+        servers.episodeNumber = parseInt(match[1], 10);
+    $('div.servers div.type').each((_, element) => {
+        const $type = $(element);
+        const type = $type.attr('data-type');
+        $type.find('ul li').each((_, li) => {
+            const $li = $(li);
+            const server = {
+                serverId: $li.attr('data-sv-id'),
+                serverName: $li.text().trim().toLowerCase(),
+                mediaId: $li.attr('data-cmid'),
+                eid: $li.attr('data-link-id'),
+            };
+            if (type === 'sub')
+                servers.sub.push(server);
+            else if (type === 'dub')
+                servers.dub.push(server);
+            else
+                servers.raw.push(server);
+        });
+    });
+    return servers;
+}
+export async function fetchSources(episodeId, version = 'sub', serverName = 'vidstream-2') {
+    if (episodeId.startsWith('http')) {
+        const serverUrl = new URL(episodeId);
+        if (serverName === 'vidcloud-1') {
+            return extractVidWish(serverUrl, `${BASE_URL}/`);
+        }
+        return extractMegaPlay(serverUrl, `${BASE_URL}/`);
+    }
+    const serverInfo = await fetchServers(episodeId);
+    let targetEid = null;
+    const list = serverInfo[version] || [];
+    for (const s of list) {
+        if (s.serverName === serverName || targetEid === null) {
+            targetEid = s.eid;
+            if (s.serverName === serverName)
+                break;
+        }
+    }
+    if (!targetEid)
+        throw new Error(`No server found for version ${version}`);
+    const res = await httpGet(`${BASE_URL}/ajax/server?get=${targetEid}`, { 'X-Requested-With': 'XMLHttpRequest' });
+    const result = await res.json();
+    return fetchSources(result.result.url, version, serverName);
+}

package/dist/providers/anime/animegg.d.ts

@@ -0,0 +1,6 @@
+import { AnimeResult, AnimeInfo, VideoStream } from '../../types/types.js';
+export declare function search(query: string): Promise<{
+    results: AnimeResult[];
+}>;
+export declare function fetchAnimeInfo(aliasId: string): Promise<AnimeInfo>;
+export declare function fetchEpisodeSources(episodeId: string, dub?: boolean, malId?: number, episodeNumber?: number): Promise<VideoStream>;

package/dist/providers/anime/animegg.js

@@ -0,0 +1,107 @@
+import { load } from 'cheerio';
+import { httpGet, getText } from '../../utils/http.js';
+import { encodeAnikuro } from '../../utils/proxy.js';
+import { applyAniSkip, getVideoType } from '../../utils/shared.js';
+const BASE_URL = 'https://www.animegg.org';
+export async function search(query) {
+    const res = await httpGet(`${BASE_URL}/search/auto/?q=${encodeURIComponent(query)}`);
+    const items = await res.json();
+    const results = items.map(it => {
+        const img = (it.thumbnailUrl?.startsWith('//')) ? `https:${it.thumbnailUrl}` : it.thumbnailUrl;
+        return {
+            id: it.url?.startsWith('/') ? `${BASE_URL}${it.url}` : '', // Using full URL as alias/id based on original logic
+            title: it.name,
+            image: img || '',
+        };
+    }).filter(it => it.id !== '');
+    return { results };
+}
+export async function fetchAnimeInfo(aliasId) {
+    // aliasId is the full URL in AnimeGG logic
+    const html = await getText(aliasId);
+    const $ = load(html);
+    const info = {
+        id: aliasId,
+        title: $('.title-english').text().trim() || $('.title').text().trim(),
+        episodes: [],
+    };
+    const tab = $('.newmanga').first();
+    if (!tab.length)
+        throw new Error('Could not find the episodes section.');
+    tab.children().each((i, elem) => {
+        const $div = $(elem).children().first();
+        const $a = $div.children().first();
+        if (!$div.length || !$a.length)
+            return;
+        const title = $div.find('.anititle').first().text().trim();
+        const href = $a.attr('href');
+        const url = href ? `${BASE_URL}${href}` : '';
+        if (url) {
+            info.episodes.push({
+                id: url,
+                number: tab.children().length - i,
+                title: title.replace('[Filler]', '').trim(),
+                hasDub: $div.find('.btn-xs.btn-dubbed').length > 0,
+                filler: title.startsWith('[Filler]'),
+            });
+        }
+    });
+    info.totalEpisodes = info.episodes.length;
+    return info;
+}
+export async function fetchEpisodeSources(episodeId, dub = false, malId, episodeNumber) {
+    const html = await getText(episodeId);
+    const $ = load(html);
+    const videos = $('#videos');
+    if (!videos.length)
+        throw new Error('Could not find streams!');
+    const stream = { sources: [], subtitles: [] };
+    let foundStream = false;
+    // We use a regular for loop to handle async sequentially or we can use Promise.all
+    const promises = [];
+    videos.children().each((_, elem) => {
+        $(elem).children('a').each((_, item) => {
+            const isSub = $(item).attr('data-version') === 'subbed';
+            if (dub !== !isSub)
+                return;
+            const id = $(item).attr('data-id');
+            if (!id)
+                return;
+            const streamPageUrl = `${BASE_URL}/embed/${id}`;
+            promises.push((async () => {
+                const streamHtml = await getText(streamPageUrl);
+                const $stream = load(streamHtml);
+                $stream('script').each((_, script) => {
+                    const body = $(script).html() || '';
+                    const match = body.match(/var\s+videoSources\s*=\s*(\[\s*[\s\S]*?\s*\]);/m);
+                    if (!match)
+                        return;
+                    const raw = match[1];
+                    const cleaned = raw.replace(/(\w+):/g, '"$1":').replace(/'/g, '"');
+                    try {
+                        const sourceList = JSON.parse(cleaned);
+                        for (const src of sourceList) {
+                            const videoUrl = `${BASE_URL}${src.file}`;
+                            const proxiedUrl = encodeAnikuro(videoUrl, streamPageUrl);
+                            stream.sources.push({
+                                url: videoUrl,
+                                quality: src.label || 'default',
+                                isM3U8: src.file.includes('.m3u8'),
+                                type: getVideoType(videoUrl),
+                                proxiedUrl,
+                            });
+                        }
+                    }
+                    catch (e) {
+                        // ignore parse errors
+                        console.log("error in getting episode sources for animegg", e);
+                    }
+                });
+            })());
+        });
+    });
+    await Promise.all(promises);
+    if (stream.sources.length === 0)
+        throw new Error('No video sources found');
+    return applyAniSkip(stream, malId, episodeNumber);
+}

package/dist/providers/anime/animeonsen.d.ts

@@ -0,0 +1,6 @@
+import { AnimeResult, AnimeInfo, VideoStream } from '../../types/types.js';
+export declare function search(query: string): Promise<{
+    results: AnimeResult[];
+}>;
+export declare function fetchAnimeInfo(aliasId: string): Promise<AnimeInfo>;
+export declare function fetchEpisodeSources(episodeId: string, malId?: number, episodeNumber?: number): Promise<VideoStream>;

package/dist/providers/anime/animeonsen.js

@@ -0,0 +1,95 @@
+import { httpGet } from '../../utils/http.js';
+import { encodeAnikuro } from '../../utils/proxy.js';
+import { applyAniSkip, getVideoType } from '../../utils/shared.js';
+let animeOnsenToken = null;
+let tokenExpiration = 0;
+async function checkAndUpdateToken() {
+    const currentTime = Date.now() / 1000;
+    if (!animeOnsenToken || tokenExpiration < (currentTime + 3600)) {
+        const res = await fetch('https://auth.animeonsen.xyz/oauth/token', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            body: new URLSearchParams({
+                client_id: 'f296be26-28b5-4358-b5a1-6259575e23b7',
+                client_secret: '349038c4157d0480784753841217270c3c5b35f4281eaee029de21cb04084235',
+                grant_type: 'client_credentials'
+            }).toString()
+        });
+        if (!res.ok)
+            throw new Error('Could not generate AO token');
+        const json = await res.json();
+        animeOnsenToken = json.access_token;
+        tokenExpiration = json.expires_in + currentTime;
+    }
+}
+export async function search(query) {
+    await checkAndUpdateToken();
+    const cleanQuery = query.replace(/-/g, '');
+    const url = `https://api.animeonsen.xyz/v4/search/${encodeURIComponent(cleanQuery)}`;
+    const res = await httpGet(url, {
+        'Authorization': `Bearer ${animeOnsenToken}`
+    });
+    const json = await res.json();
+    const results = json.result.map(item => ({
+        id: item.content_id,
+        title: item.content_title_en ?? item.content_title,
+        image: `https://api.animeonsen.xyz/v4/image/210x300/${item.content_id}`,
+    }));
+    return { results };
+}
+export async function fetchAnimeInfo(aliasId) {
+    await checkAndUpdateToken();
+    const url = `https://api.animeonsen.xyz/v4/content/${aliasId}/episodes`;
+    const res = await httpGet(url, {
+        'Authorization': `Bearer ${animeOnsenToken}`
+    });
+    const json = await res.json();
+    const info = {
+        id: aliasId,
+        title: '',
+        episodes: []
+    };
+    let i = 1;
+    for (const [key, item] of Object.entries(json)) {
+        const epTitle = item.contentTitle_episode_en;
+        info.episodes.push({
+            id: `${key}+${aliasId}`,
+            number: parseInt(key, 10) || i,
+            title: epTitle || '',
+        });
+        i++;
+    }
+    info.totalEpisodes = info.episodes.length;
+    return info;
+}
+export async function fetchEpisodeSources(episodeId, malId, episodeNumber) {
+    const [episodeNum, animeId] = episodeId.split('+');
+    if (!animeId || !episodeNum)
+        throw new Error('Invalid episodeId format for AnimeOnsen (expected epNum+animeId)');
+    const baseUrl = `https://cdn.animeonsen.xyz/video/mp4-dash/${animeId}/${episodeNum}/manifest.mpd`;
+    const subtitleUrl = `https://api.animeonsen.xyz/v4/subtitles/${animeId}/en-US/${episodeNum}`;
+    const proxiedUrl = encodeAnikuro(baseUrl, 'https://www.animeonsen.xyz/');
+    const stream = {
+        sources: [
+            {
+                url: baseUrl,
+                quality: 'single',
+                isM3U8: false,
+                proxiedUrl,
+                type: getVideoType(baseUrl)
+            }
+        ],
+        subtitles: [
+            {
+                url: subtitleUrl,
+                lang: 'English',
+            }
+        ],
+        headers: {
+            'Referer': 'https://www.animeonsen.xyz/'
+        }
+    };
+    return applyAniSkip(stream, malId, episodeNumber);
+}

package/dist/providers/anime/animepahe.d.ts

@@ -0,0 +1,6 @@
+import { AnimeResult, AnimeInfo, VideoStream } from '../../types/types.js';
+export declare function search(query: string): Promise<{
+    results: AnimeResult[];
+}>;
+export declare function fetchAnimeInfo(aliasId: string): Promise<AnimeInfo>;
+export declare function fetchEpisodeSources(episodeId: string, dub?: boolean, malId?: number, episodeNumber?: number): Promise<VideoStream>;

package/dist/providers/anime/animepahe.js

@@ -0,0 +1,102 @@
+import { load } from 'cheerio';
+import { httpGet, getText } from '../../utils/http.js';
+import { extractKwik } from '../../extractors/kwik.js';
+import { applyAniSkip } from '../../utils/shared.js';
+const BASE_URL = 'https://animepahe.pw';
+const HEADERS = {
+    'Cookie': '__ddg1=;__ddg2_=',
+    'Referer': `${BASE_URL}/`,
+};
+export async function search(query) {
+    const cleanQuery = query.replace(/-/g, '');
+    const url = `${BASE_URL}/api?m=search&q=${encodeURIComponent(cleanQuery)}`;
+    const res = await httpGet(url, HEADERS);
+    const json = await res.json();
+    const results = (json.data || []).map(result => ({
+        id: result.session,
+        title: result.title || '',
+        image: result.poster || '',
+    }));
+    return { results };
+}
+export async function fetchAnimeInfo(aliasId) {
+    const info = {
+        id: aliasId,
+        title: '',
+        episodes: [],
+    };
+    let list = [];
+    const url = `${BASE_URL}/api?m=release&id=${aliasId}&sort=episode_asc`;
+    const firstRes = await httpGet(url, HEADERS);
+    const firstJson = await firstRes.json();
+    list = list.concat(firstJson.data || []);
+    const totalPages = firstJson.last_page || 1;
+    for (let i = 1; i < totalPages; i++) {
+        if (i > 6)
+            break; // limit to 6 pages based on original code
+        const res = await httpGet(`${url}&page=${i + 1}`, HEADERS);
+        const json = await res.json();
+        list = list.concat(json.data || []);
+    }
+    const totalEps = list.length;
+    for (let i = 0; i < totalEps; i++) {
+        const item = list[i];
+        const episodeLink = `${BASE_URL}/play/${aliasId}/${item.session}`;
+        info.episodes.push({
+            id: episodeLink,
+            number: totalEps - i,
+            title: item.title || '',
+            image: item.snapshot || '',
+            hasDub: item.audio !== 'jpn',
+            filler: item.filler !== 0,
+        });
+    }
+    // Return episodes reversed (latest first) as per the original dart code
+    info.episodes = info.episodes.reverse();
+    info.totalEpisodes = info.episodes.length;
+    return info;
+}
+export async function fetchEpisodeSources(episodeId, dub = false, malId, episodeNumber) {
+    const html = await getText(episodeId, HEADERS);
+    const $ = load(html);
+    const links = [];
+    $('div#resolutionMenu > button').each((_, el) => {
+        const link = $(el).attr('data-src') || '';
+        const text = $(el).text();
+        const parts = text.split('·');
+        if (parts.length < 2)
+            return;
+        const server = parts[0].trim();
+        const quality = parts[1].trim();
+        const hasDub = quality.split(' ').includes('eng');
+        if (dub === hasDub) {
+            links.push({ link, server, quality });
+        }
+    });
+    const stream = { sources: [], subtitles: [] };
+    const promises = links.map(async (e) => {
+        try {
+            const extracted = await extractKwik(e.link);
+            if (extracted.sources.length > 0) {
+                // Usually Kwik only returns one source but we map it just in case
+                for (const src of extracted.sources) {
+                    stream.sources.push({
+                        url: src.url,
+                        quality: e.quality,
+                        isM3U8: src.isM3U8,
+                        proxiedUrl: src.proxiedUrl,
+                        type: src.type
+                    });
+                }
+            }
+        }
+        catch (error) {
+            // Ignore kwik extraction errors for specific servers
+            console.log("error in fetching animepahe sources", error);
+        }
+    });
+    await Promise.all(promises);
+    if (stream.sources.length === 0)
+        throw new Error('No video sources found');
+    return applyAniSkip(stream, malId, episodeNumber);
+}

package/dist/providers/anime/animesaturn.d.ts

@@ -0,0 +1,8 @@
+import { AnimeResult, AnimeInfo, PageResult, VideoStream } from '../../types/types.js';
+export declare function search(query: string): Promise<PageResult<AnimeResult>>;
+export declare function fetchAnimeInfo(id: string): Promise<AnimeInfo>;
+export declare function fetchEpisodeServers(episodeId: string): Promise<{
+    name: string;
+    url: string;
+}[]>;
+export declare function fetchEpisodeSources(episodeId: string, malId?: number, episodeNumber?: number): Promise<VideoStream>;