kaizoku-core 0.1.0

package/dist/providers/anime/animesaturn.js

@@ -0,0 +1,160 @@
+import { load } from 'cheerio';
+import { getText } from '../../utils/http.js';
+import { encodeAnikuro } from '../../utils/proxy.js';
+import { applyAniSkip, getVideoType } from '../../utils/shared.js';
+const BASE_URL = 'https://www.animesaturn.net/';
+export async function search(query) {
+    const html = await getText(`${BASE_URL}animelist?search=${encodeURIComponent(query)}`);
+    const $ = load(html);
+    const results = [];
+    $('ul.list-group li').each((_, element) => {
+        const id = $(element).find('a.thumb').attr('href')?.split('/').pop();
+        if (id) {
+            results.push({
+                id,
+                title: $(element).find('h3 a').text().trim(),
+                image: $(element).find('img.copertina-archivio').attr('src') || '',
+                url: $(element).find('h3 a').attr('href') || '',
+            });
+        }
+    });
+    return { hasNextPage: false, results };
+}
+export async function fetchAnimeInfo(id) {
+    const html = await getText(`${BASE_URL}anime/${id}`);
+    const $ = load(html);
+    const info = {
+        id,
+        title: $('div.container.anime-title-as > b').text().trim(),
+        genres: $('div.container a.badge.badge-light').map((_, el) => $(el).text().trim()).get(),
+        image: $('img.img-fluid').attr('src') || '',
+        coverImage: $('div.banner').attr('style')?.match(/background:\s*url\(['"]?([^'")]+)['"]?\)/i)?.[1] || '',
+        description: $('#full-trama').text().trim(),
+        episodes: [],
+    };
+    $('.tab-pane.fade').each((_, element) => {
+        $(element).find('.bottone-ep').each((_, epElement) => {
+            const link = $(epElement).attr('href');
+            const episodeNumber = $(epElement).text().trim().replace('Episodio ', '').trim();
+            info.episodes.push({
+                id: link?.split('/').pop() || '',
+                number: parseInt(episodeNumber, 10) || 0,
+            });
+        });
+    });
+    info.episodes.sort((a, b) => a.number - b.number);
+    info.totalEpisodes = info.episodes.length;
+    return info;
+}
+export async function fetchEpisodeServers(episodeId) {
+    const html = await getText(`${BASE_URL}ep/${episodeId}`, {
+        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:144.0) Gecko/20100101 Firefox/144.0',
+        Referer: BASE_URL,
+    });
+    const $ = load(html);
+    const servers = [];
+    const mainWatchUrl = $("a:contains('Guarda lo streaming')").attr('href');
+    if (mainWatchUrl) {
+        servers.push({ name: 'Server 1', url: mainWatchUrl });
+        const watchHtml = await getText(mainWatchUrl, {
+            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:144.0) Gecko/20100101 Firefox/144.0',
+            Referer: `${BASE_URL}ep/${episodeId}`,
+        });
+        const $watch = load(watchHtml);
+        $watch('.dropdown-menu .dropdown-item').each((_, el) => {
+            const serverUrl = $watch(el).attr('href');
+            const serverName = $watch(el).text().trim();
+            if (serverUrl && serverName && !servers.some(s => s.url === serverUrl)) {
+                servers.push({ name: serverName, url: serverUrl });
+            }
+        });
+        const altPlayerUrl = $watch("a:contains('Player alternativo')").attr('href');
+        if (altPlayerUrl && !servers.some(s => s.url === altPlayerUrl)) {
+            servers.push({ name: 'Player Alternativo', url: altPlayerUrl });
+        }
+        $watch('iframe').each((_, el) => {
+            const src = $watch(el).attr('src');
+            if (src && (src.includes('streamtape') || src.includes('mixdrop') || src.includes('doodstream'))) {
+                const serverName = src.includes('streamtape') ? 'StreamTape' : src.includes('mixdrop') ? 'MixDrop' : 'DoodStream';
+                if (!servers.some(s => s.url === src)) {
+                    servers.push({ name: serverName, url: src });
+                }
+            }
+        });
+    }
+    return servers;
+}
+export async function fetchEpisodeSources(episodeId, malId, episodeNumber) {
+    const html = await getText(`${BASE_URL}ep/${episodeId}`, {
+        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:144.0) Gecko/20100101 Firefox/144.0',
+        Referer: BASE_URL,
+    });
+    const $episode = load(html);
+    let watchUrl = $episode("a:contains('Guarda lo streaming')").attr('href') ||
+        $episode("div:contains('Guarda lo streaming')").parent('a').attr('href') ||
+        $episode("a[href*='watch']").attr('href');
+    if (!watchUrl)
+        throw new Error('Watch URL not found');
+    const watchHtml = await getText(watchUrl, {
+        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:144.0) Gecko/20100101 Firefox/144.0',
+        Referer: `${BASE_URL}ep/${episodeId}`,
+    });
+    const $watch = load(watchHtml);
+    const stream = {
+        sources: [],
+        subtitles: [],
+        headers: {
+            Referer: watchUrl,
+            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:144.0) Gecko/20100101 Firefox/144.0',
+        },
+    };
+    $watch('video source').each((_, element) => {
+        const src = $watch(element).attr('src');
+        const proxiedUrl = encodeAnikuro(src, watchUrl);
+        if (src && (src.includes('.mp4') || src.includes('.m3u8'))) {
+            stream.sources.push({ url: src, isM3U8: src.includes('.m3u8'), quality: 'default', proxiedUrl, type: getVideoType(src) });
+        }
+    });
+    const videoSrc = $watch('video#myvideo').attr('src');
+    const proxiedUrl = encodeAnikuro(videoSrc, watchUrl);
+    if (videoSrc && (videoSrc.includes('.mp4') || videoSrc.includes('.m3u8')) && !stream.sources.some(s => s.url === videoSrc)) {
+        stream.sources.push({ url: videoSrc, isM3U8: videoSrc.includes('.m3u8'), quality: 'default', proxiedUrl, type: getVideoType(videoSrc) });
+    }
+    $watch('script').each((_, element) => {
+        const scriptText = $watch(element).text();
+        if (scriptText.includes('jwplayer') || scriptText.includes('file:')) {
+            const lines = scriptText.split('\n');
+            for (const line of lines) {
+                if (line.includes('file:')) {
+                    const url = line.split('file:')[1].trim().replace(/['"]/g, '').replace(/,/g, '').trim();
+                    const proxiedUrl = encodeAnikuro(url, watchUrl);
+                    if (url && (url.includes('.mp4') || url.includes('.m3u8')) && !stream.sources.some(s => s.url === url)) {
+                        stream.sources.push({ url, isM3U8: url.includes('.m3u8'), quality: 'default', proxiedUrl, type: getVideoType(url) });
+                    }
+                }
+            }
+        }
+        const mp4Match = scriptText.match(/https?:\/\/[^"'\s]+\.mp4[^"'\s]*/g);
+        mp4Match?.forEach(url => {
+            const proxiedUrl = encodeAnikuro(url, watchUrl);
+            if (!stream.sources.some(s => s.url === url))
+                stream.sources.push({ url, isM3U8: false, quality: 'default', proxiedUrl, type: "mp4" });
+        });
+        const m3u8Match = scriptText.match(/https?:\/\/[^"'\s]+\.m3u8[^"'\s]*/g);
+        m3u8Match?.forEach(url => {
+            const proxiedUrl = encodeAnikuro(url, watchUrl);
+            if (!stream.sources.some(s => s.url === url))
+                stream.sources.push({ url, isM3U8: true, quality: 'default', proxiedUrl, type: "hls" });
+        });
+    });
+    if (stream.sources.length === 0)
+        throw new Error('No video sources found');
+    const m3u8Source = stream.sources.find(s => s.isM3U8);
+    if (m3u8Source && m3u8Source.url.includes('playlist.m3u8')) {
+        stream.subtitles.push({
+            url: m3u8Source.url.replace('playlist.m3u8', 'subtitles.vtt'),
+            lang: 'Italian',
+        });
+    }
+    return applyAniSkip(stream, malId, episodeNumber);
+}

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

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

package/dist/providers/anime/animeunity.js

@@ -0,0 +1,108 @@
+import { load } from 'cheerio';
+import { getText } from '../../utils/http.js';
+import { encodeAnikuro } from '../../utils/proxy.js';
+import { applyAniSkip, getVideoType } from '../../utils/shared.js';
+const BASE_URL = 'https://www.animeunity.to';
+export async function search(query) {
+    const html = await getText(`${BASE_URL}/archivio?title=${encodeURIComponent(query)}`);
+    const $ = load(html);
+    const records = $('archivio').attr('records');
+    if (!records)
+        return { hasNextPage: false, results: [] };
+    const items = JSON.parse(records);
+    const results = [];
+    for (const item of items) {
+        results.push({
+            id: `${item.id}-${item.slug}`,
+            title: item.title ?? item.title_eng,
+            url: `${BASE_URL}/anime/${item.id}-${item.slug}`,
+            image: item.imageurl,
+            coverImage: item.imageurl_cover,
+            rating: parseFloat(item.score),
+            releaseDate: item.date,
+            hasDub: item.dub,
+            hasSub: !item.dub,
+        });
+    }
+    return { hasNextPage: false, results };
+}
+export async function fetchAnimeInfo(id, page = 1) {
+    const url = `${BASE_URL}/anime/${id}`;
+    const html = await getText(url);
+    const $ = load(html);
+    const totalEpisodes = parseInt($('video-player')?.attr('episodes_count') || '0', 10);
+    const totalPages = Math.max(1, Math.round(totalEpisodes / 120) + 1);
+    if (page < 1 || page > totalPages) {
+        throw new Error(`Argument 'page' for ${id} must be between 1 and ${totalPages}! (You passed ${page})`);
+    }
+    const animeInfo = {
+        id,
+        title: $('h1.title')?.text().trim() || '',
+        url,
+        genres: $('.info-wrapper.pt-3.pb-3 small').map((_, el) => $(el).text().replace(',', '').trim()).get(),
+        totalEpisodes,
+        image: $('img.cover').attr('src') || '',
+        coverImage: $('.banner').attr('src') ?? $('.banner').attr('style')?.replace('background: url(', '').replace(')', ''),
+        description: $('.description').text().trim() || '',
+        episodes: [],
+    };
+    const episodesPerPage = 120;
+    const lastPageEpisode = page * episodesPerPage;
+    const firstPageEpisode = lastPageEpisode - 119;
+    const apiHtml = await getText(`${BASE_URL}/info_api/${id}/1?start_range=${firstPageEpisode}&end_range=${lastPageEpisode}`);
+    // The response might be JSON depending on how their backend is structured, but consumet parses it as res2.data.episodes
+    // In our case getText returns a string, so we must parse it
+    try {
+        const json = JSON.parse(apiHtml);
+        const items = json.episodes || [];
+        for (const item of items) {
+            animeInfo.episodes.push({
+                id: `${id}/${item.id}`,
+                number: parseInt(item.number, 10) || 0,
+            });
+        }
+    }
+    catch (e) {
+        // Silently fail if JSON parsing fails, meaning no episodes returned or wrong endpoint
+    }
+    return animeInfo;
+}
+export async function fetchEpisodeSources(episodeId, malId, episodeNumber) {
+    const html = await getText(`${BASE_URL}/anime/${episodeId}`);
+    const $ = load(html);
+    const streamUrl = $('video-player').attr('embed_url');
+    if (!streamUrl)
+        throw new Error('Stream URL not found');
+    const embedHtml = await getText(streamUrl);
+    const $embed = load(embedHtml);
+    const scriptText = $embed('script:contains("window.video")').text();
+    const domain = scriptText.match(/url:\s*'(.*?)'/)?.[1];
+    const token = scriptText.match(/token':\s*'(.*?)'/)?.[1] || scriptText.match(/token":\s*"(.*?)"/)?.[1];
+    const expires = scriptText.match(/expires':\s*'(.*?)'/)?.[1] || scriptText.match(/expires":\s*"(.*?)"/)?.[1];
+    if (!domain || !token || !expires)
+        throw new Error('Failed to extract token/domain/expires');
+    const defaultUrl = `${domain}${domain.includes('?') ? '&' : '?'}token=${token}&referer=&expires=${expires}&h=1`;
+    const m3u8Content = await getText(defaultUrl);
+    const stream = {
+        sources: [],
+        subtitles: [],
+        download: $embed('script:contains("window.downloadUrl ")').text().match(/downloadUrl\s*=\s*'(.*?)'/)?.[1],
+    };
+    if (m3u8Content.includes('EXTM3U')) {
+        const videoList = m3u8Content.split('#EXT-X-STREAM-INF:');
+        for (const video of videoList) {
+            if (video.includes('BANDWIDTH')) {
+                const url = video.split('\n')[1]?.trim();
+                const resolutionMatch = video.match(/RESOLUTION=\d+x(\d+)/);
+                const quality = resolutionMatch ? `${resolutionMatch[1]}p` : 'auto';
+                if (url) {
+                    const proxiedUrl = encodeAnikuro(url, streamUrl);
+                    stream.sources.push({ url, quality, isM3U8: true, proxiedUrl, type: getVideoType(url) });
+                }
+            }
+        }
+    }
+    const defaultProxiedUrl = encodeAnikuro(defaultUrl, streamUrl);
+    stream.sources.push({ url: defaultUrl, quality: 'default', isM3U8: true, proxiedUrl: defaultProxiedUrl, type: "hls" });
+    return applyAniSkip(stream, malId, episodeNumber);
+}

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

@@ -0,0 +1,12 @@
+import { AnimeResult, AnimeInfo, VideoStream } from '../../types/types.js';
+export declare function search(query: string): Promise<{
+    data: AnimeResult[];
+}>;
+export declare function fetchUpdates(): Promise<{
+    data: any[];
+    recentlyAdded: AnimeResult[];
+}>;
+export declare function fetchAnimeInfo(animeId: string): Promise<{
+    data: AnimeInfo;
+}>;
+export declare function fetchSources(episodeId: string, malId?: number, episodeNumber?: number): Promise<VideoStream>;

package/dist/providers/anime/anizone.js

@@ -0,0 +1,146 @@
+import { load } from 'cheerio';
+import { getText } from '../../utils/http.js';
+import { encodeAnikuro } from '../../utils/proxy.js';
+import { applyAniSkip } from '../../utils/shared.js';
+const BASE_URL = 'https://anizone.to';
+function createSlug(title) {
+    return title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+}
+export async function search(query) {
+    const url = new URL(`${BASE_URL}/anime`);
+    url.searchParams.append('search', query.trim());
+    const html = await getText(url.toString());
+    const $ = load(html);
+    const selector = 'div.grid.grid-cols-1.gap-4 > div.relative.overflow-hidden.h-26.rounded-lg.px-4.py-3.bg-slate-900.drop-shadow-lg';
+    const anime = [];
+    $(selector).each((_, element) => {
+        const title = $(element).find('div.h-6.inline.truncate > a').text().trim() ||
+            $(element).find('div.absolute.-inset-y-0.-right-0.w-80 > img').attr('alt') || '';
+        const id = $(element).find('div.h-6.inline.truncate > a').attr('href')?.split('/').at(-1) ||
+            $(element).attr('wire:key')?.split('-').at(-1) || '';
+        const infoSpans = $(element).find('div.inline.text-xs.h-4.line-clamp-1 span').map((_, el) => $(el).text().trim()).get();
+        const genres = $(element).find('div.flex.flex-wrap.gap-2.line-clamp-1.h-6 a').map((_, el) => $(el).text().trim()).get().filter(g => g.toLowerCase() !== 'manga');
+        anime.push({
+            id: title ? `${createSlug(title)}-${id}` : id,
+            title,
+            image: $(element).find('div.absolute.-inset-y-0.-right-0.w-80 > img').attr('src') || '',
+            type: infoSpans[0] ? (infoSpans[0].toLowerCase().includes('tv') ? 'TV' : infoSpans[0]) : '',
+            releaseDate: infoSpans[1] || '',
+            status: infoSpans[3] || '',
+            genres: genres,
+            totalEpisodes: infoSpans[2] ? parseInt(infoSpans[2].replace(/\D/g, ''), 10) : 0,
+        });
+    });
+    return { data: anime };
+}
+export async function fetchUpdates() {
+    const html = await getText(`${BASE_URL}/`);
+    const $ = load(html);
+    const recentlyAdded = [];
+    $('div.swiper-wrapper.flex div.space-y-3.pb-6.swiper-slide').each((_, el) => {
+        const id = $(el).find('a').first().attr('href')?.split('/').at(-1) || '';
+        const title = $(el).find('a[title]').attr('title') || $(el).find('img').attr('alt') || '';
+        recentlyAdded.push({
+            id: title ? `${createSlug(title)}-${id}` : '',
+            title,
+            image: $(el).find('a > img').attr('src') || '',
+        });
+    });
+    const latestEpisodes = [];
+    $('div.md\\:w-2\\/3.lg\\:w-3\\/4 ul li').each((_, el) => {
+        const $el = $(el);
+        const episodeNumber = $el.find('a.group').attr('href')?.split('/').at(-1);
+        const animeId = $el.find('div .title').first().attr('href')?.split('/').at(-1);
+        const title = $el.find('div .title').first().text().trim() || '';
+        const teaserMatch = $el.find('img').attr(':src')?.match(/'([^']*teaser\.webp)'/);
+        latestEpisodes.push({
+            id: title ? `${createSlug(title)}-${animeId}-episode-${episodeNumber}` : '',
+            number: episodeNumber ? Number(episodeNumber) : 0,
+            title: $el.find('div .title').last().text().trim() || '',
+            image: $el.find('img').attr('src') || '',
+            teaser: teaserMatch ? teaserMatch[1] : '',
+            airDate: $el.find('.flex.flex-row.text-xs span').eq(0).text().trim() || '',
+        });
+    });
+    return { data: latestEpisodes, recentlyAdded };
+}
+export async function fetchAnimeInfo(animeId) {
+    const id = animeId.split('-').at(-1);
+    const html = await getText(`${BASE_URL}/anime/${id}`);
+    const $ = load(html);
+    const synopsisHtml = $('.text-sm.md\\:text-base.xl\\:text-lg > div').html() || '';
+    const infoSpans = $('.text-slate-100.text-xs.lg\\:text-base.flex.flex-wrap > span');
+    const title = $('div.mx-auto img').attr('alt') || $('h1').text().trim();
+    const fetchedId = $('div.flex.mt-8 a').attr('href')?.split('/')[4];
+    const typeText = $(infoSpans[0]).find('.inline-block').text().trim();
+    const epText = $(infoSpans[2]).find('.inline-block').text().trim();
+    const animeInfo = {
+        id: `${createSlug(title)}-${fetchedId}`,
+        title,
+        type: typeText.toLowerCase().includes('tv') ? 'TV' : typeText,
+        status: $(infoSpans[1]).find('.inline-block').text().trim(),
+        image: $('div.mx-auto img').attr('src') || '',
+        coverImage: $('div.absolute img').attr('src') || '',
+        totalEpisodes: epText ? parseInt(epText.replace(/\D/g, ''), 10) : 0,
+        releaseDate: $(infoSpans[3]).find('.inline-block').text().trim(),
+        description: synopsisHtml.replace(/<br\s*\/?>/g, '\n').replace(/\n\s*\n/g, '\n').trim(),
+        genres: $('.flex-wrap.gap-2.justify-center.lg\\:justify-start a').map((_, el) => $(el).text().trim()).get().filter(g => g.toLowerCase() !== 'manga'),
+        episodes: []
+    };
+    $('ul.grid > li').each((_, el) => {
+        const $el = $(el);
+        const url = $el.find('a').attr('href');
+        const epTitle = $el.find('h3').text().trim();
+        const episodeNumber = url ? url.split('/').at(-1) : null;
+        animeInfo.episodes.push({
+            id: `${animeInfo.id}-episode-${episodeNumber}`,
+            number: episodeNumber ? Number(episodeNumber) : 0,
+            title: epTitle,
+            image: $el.find('div.absolute img').attr('src') || '',
+            airDate: $el.find('span').filter((_, span) => /^\d{4}-\d{2}-\d{2}$/.test($(span).text().trim())).first().text().trim()
+        });
+    });
+    return { data: animeInfo };
+}
+export async function fetchSources(episodeId, malId, episodeNumber) {
+    const match = episodeId.match(/([a-z0-9]+)-episode-(\d+)/i);
+    if (!match)
+        throw new Error('Invalid episodeId format');
+    const id = `${match[1]}/${match[2]}`;
+    const html = await getText(`${BASE_URL}/anime/${id}`);
+    const $ = load(html);
+    const player = $('media-player');
+    const videoUrl = player.attr('src');
+    const poster = player.find('media-poster').attr('src');
+    const subtitles = [];
+    player.find('track[kind="subtitles"]').each((_, el) => {
+        const $el = $(el);
+        subtitles.push({
+            url: $el.attr('src') || '',
+            lang: $el.attr('label') || '',
+            isDefault: $el.is('[default]'),
+        });
+    });
+    const chapters = player.find('track[kind="chapters"]').attr('src');
+    const thumbnails = player.find('media-video-layout').attr('thumbnails');
+    const proxiedUrl = encodeAnikuro(videoUrl, `${BASE_URL}/`);
+    const stream = {
+        sources: [],
+        subtitles,
+        tracks: [],
+        headers: { Referer: `${BASE_URL}/` }
+    };
+    if (videoUrl) {
+        stream.sources.push({
+            url: videoUrl,
+            isM3U8: videoUrl.includes('m3u8'),
+            quality: 'auto',
+            proxiedUrl
+        });
+    }
+    if (chapters)
+        stream.tracks.push({ url: chapters, type: 'chapters' });
+    if (thumbnails)
+        stream.tracks.push({ url: thumbnails, type: 'thumbnails' });
+    return applyAniSkip(stream, malId, episodeNumber);
+}

package/dist/providers/anime/gojo.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(animeId: string, episodeNumber: number, dub?: boolean, malId?: number): Promise<VideoStream>;

package/dist/providers/anime/gojo.js

@@ -0,0 +1,83 @@
+import { httpGet } from '../../utils/http.js';
+import { applyAniSkip, getVideoType } from '../../utils/shared.js';
+const API_URL = 'https://animetsu.live/v2/api/anime';
+const PROXY_URL = 'https://swiftstream.top/proxy';
+const HEADERS = {
+    'Origin': 'https://animetsu.live',
+    'Referer': 'https://animetsu.live/',
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
+};
+export async function search(query) {
+    const res = await httpGet(`${API_URL}/search/?query=${encodeURIComponent(query)}`, HEADERS);
+    const json = await res.json();
+    const results = json.results.map(item => ({
+        id: item.id.toString(),
+        title: item.title?.english || item.title?.romaji || '',
+        image: item.cover_image?.medium || '',
+    }));
+    return { results };
+}
+export async function fetchAnimeInfo(aliasId) {
+    const res = await httpGet(`${API_URL}/eps/${aliasId}`, HEADERS);
+    const json = await res.json();
+    const info = {
+        id: aliasId,
+        title: '', // The API doesn't return the anime title here, just episodes
+        episodes: [],
+    };
+    info.episodes = json.map(item => {
+        let img = item.img;
+        if (img?.startsWith('/')) {
+            img = `${PROXY_URL}${img}`;
+        }
+        return {
+            id: aliasId, // the animeId is used as the episode identifier along with the number
+            number: item.ep_num,
+            title: item.name || '',
+            image: img || '',
+            hasDub: true,
+            filler: item.is_filler,
+        };
+    });
+    info.totalEpisodes = info.episodes.length;
+    return info;
+}
+export async function fetchEpisodeSources(animeId, episodeNumber, dub = false, malId) {
+    const serverListRes = await httpGet(`${API_URL}/servers/${animeId}/${episodeNumber}`, HEADERS);
+    const serversJson = await serverListRes.json();
+    const stream = { sources: [], subtitles: [] };
+    const sourceType = dub ? 'dub' : 'sub';
+    const promises = serversJson.map(async (server) => {
+        try {
+            const url = `${API_URL}/oppai/${animeId}/${episodeNumber}?server=${server.id}&source_type=${sourceType}`;
+            const res = await httpGet(url, HEADERS);
+            const json = await res.json();
+            if (!json.sources || json.sources.length === 0)
+                return;
+            const englishSub = json.subs?.find(it => it.lang === 'English')?.url || json.subs?.[0]?.url;
+            if (englishSub && stream.subtitles.length === 0) {
+                stream.subtitles.push({
+                    url: englishSub.startsWith('/') ? `${PROXY_URL}${englishSub}` : englishSub,
+                    lang: 'English',
+                });
+            }
+            for (const src of json.sources) {
+                const srcUrl = src.url.startsWith('/') ? `${PROXY_URL}${src.url}` : src.url;
+                stream.sources.push({
+                    url: srcUrl,
+                    quality: src.quality?.trim() === 'master' ? 'multi-quality' : src.quality,
+                    isM3U8: srcUrl.includes('.m3u8'),
+                    type: getVideoType(srcUrl)
+                });
+            }
+        }
+        catch (e) {
+            // ignore server failures
+            console.log("error fetching animetsu sources", 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/meta/anilist/anilist.d.ts

@@ -0,0 +1,28 @@
+import { Episode, ProviderName } from '../../../types/types.js';
+import { PagedMedia, MediaBase, SearchFilters, MediaDetail } from './types.js';
+export declare const getTrending: (page: number, perPage: number) => Promise<PagedMedia>;
+export declare const getPopularThisSeason: (page: number, perPage: number) => Promise<PagedMedia>;
+export declare const getUpcoming: (page: number, perPage: number) => Promise<PagedMedia>;
+export declare const getAllTimePopular: (page: number, perPage: number) => Promise<PagedMedia>;
+export declare const getMostFavorite: (page: number, perPage: number) => Promise<PagedMedia>;
+export declare const getTopRated: (page: number, perPage: number) => Promise<PagedMedia>;
+export declare const getCurrentlyAiring: (page: number, perPage: number) => Promise<PagedMedia>;
+export declare const getHeroAnime: (count?: number) => Promise<MediaBase[]>;
+export declare const searchAnime: (filters?: SearchFilters) => Promise<PagedMedia>;
+export declare const getAnimeDetail: (id: number) => Promise<MediaDetail>;
+export declare const getGenres: () => Promise<string[]>;
+export declare const getTags: () => Promise<string[]>;
+export declare const getSettingsAssets: () => Promise<{
+    banners: unknown[];
+    avatars: any;
+}>;
+interface AniZipEpisode {
+    title?: Record<string, string>;
+    image?: string;
+    airdate?: string;
+    length?: number;
+    overview?: string;
+}
+export declare function fetchAniZipData(anilistId: string): Promise<Record<string, AniZipEpisode> | null>;
+export declare function fetchEpisodesByProvider(anilistId: string, providerName: ProviderName): Promise<Episode[]>;
+export {};