@serifpersia/dango 3.0.3

package/server/dist/providers/wh.provider.js

@@ -0,0 +1,600 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhProvider = exports.WH_GENRES = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const title_matching_1 = require("./title-matching");
+const base_provider_1 = require("./base-provider");
+const BASE_URL = 'https://watchhentai.net';
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+function cleanText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function resolveUrl(href) {
+    if (!href)
+        return '';
+    if (href.startsWith('http'))
+        return href;
+    if (href.startsWith('//'))
+        return `https:${href}`;
+    if (href.startsWith('/'))
+        return `${BASE_URL}${href}`;
+    return `${BASE_URL}/${href}`;
+}
+function unwrapTimthumb(raw) {
+    if (!raw)
+        return '';
+    const m = raw.match(/[?&]src=([^&]+)/i);
+    if (!m)
+        return raw;
+    try {
+        return decodeURIComponent(m[1]);
+    }
+    catch {
+        return m[1];
+    }
+}
+function extractImgUrl(html) {
+    const dataSrcM = html.match(/\bdata-src=["']([^"']+)["']/i);
+    if (dataSrcM)
+        return unwrapTimthumb(dataSrcM[1]);
+    const srcM = html.match(/\bsrc=["']([^"']+)["']/i);
+    if (srcM && !srcM[1].startsWith('data:'))
+        return unwrapTimthumb(srcM[1]);
+    return '';
+}
+function cleanUrl(raw) {
+    try {
+        return decodeURIComponent(raw.replace(/&/g, '&'));
+    }
+    catch {
+        return raw.replace(/&/g, '&');
+    }
+}
+function whDecodeMediaUrl(encoded) {
+    const normalized = encoded.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized.padEnd(normalized.length + ((4 - (normalized.length % 4)) % 4), '=');
+    const bytes = Buffer.from(padded, 'base64');
+    let xored = '';
+    for (let i = 0; i < bytes.length; i++) {
+        xored += String.fromCharCode(bytes[i] ^ ((13 + (i % 17)) & 255));
+    }
+    const reversed = xored.split('').reverse().join('');
+    return Buffer.from(reversed, 'base64').toString('utf8');
+}
+function extractDirectSrc(playerUrl) {
+    const clean = playerUrl.replace(/&amp;/g, '&');
+    try {
+        const source = new URL(clean).searchParams.get('source');
+        if (source)
+            return decodeURIComponent(source);
+    }
+    catch {
+        const m = clean.match(/[?&]source=([^&]+)/i);
+        if (m) {
+            try {
+                return decodeURIComponent(m[1]);
+            }
+            catch {
+                return m[1];
+            }
+        }
+    }
+    return '';
+}
+async function fetchText(url) {
+    const res = await fetch(url, {
+        headers: {
+            'User-Agent': UA,
+            Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Cache-Control': 'no-cache',
+        },
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}: ${url}`);
+    return res.text();
+}
+function extractArticles(html) {
+    const results = [];
+    const openTag = '<article';
+    const closeTag = '</article>';
+    let pos = 0;
+    while (pos < html.length) {
+        const start = html.toLowerCase().indexOf(openTag.toLowerCase(), pos);
+        if (start === -1)
+            break;
+        const end = html.toLowerCase().indexOf(closeTag.toLowerCase(), start);
+        if (end === -1)
+            break;
+        results.push(html.slice(start, end + closeTag.length));
+        pos = end + closeTag.length;
+    }
+    return results;
+}
+function browseUrl(query, page, genre) {
+    if (genre) {
+        return page > 1 ? `${BASE_URL}/genre/${genre}/page/${page}/` : `${BASE_URL}/genre/${genre}/`;
+    }
+    if (query) {
+        const base = `${BASE_URL}/?s=${encodeURIComponent(query)}`;
+        return page > 1 ? `${BASE_URL}/page/${page}/?s=${encodeURIComponent(query)}` : base;
+    }
+    return page > 1 ? `${BASE_URL}/series/page/${page}/` : `${BASE_URL}/series/`;
+}
+exports.WH_GENRES = [
+    '3d',
+    'ahegao',
+    'anal',
+    'blackmail',
+    'blowjob',
+    'bondage',
+    'censored',
+    'cosplay',
+    'creampie',
+    'dark-skin',
+    'deepthroat',
+    'dubbed',
+    'femdom',
+    'harem',
+    'horny-slut',
+    'incest',
+    'large-breasts',
+    'ntr',
+    'public-sex',
+    'rape',
+    'school-girls',
+    'tits-fuck',
+    'uncensored',
+    'vanilla-id-1',
+    'virgins',
+    'x-ray',
+    'yuri',
+];
+function parseSearchArticles(html) {
+    const results = [];
+    const articles = extractArticles(html);
+    for (const art of articles) {
+        const hrefM = art.match(/<a\s[^>]*\bhref=["']([^"']+)["']/i);
+        const href = hrefM ? hrefM[1] : '';
+        const h3M = art.match(/<h3(?:\s[^>]*)?>([^<]+)<\/h3>/i);
+        const title = h3M ? cleanText(h3M[1]) : '';
+        const poster = extractImgUrl(art);
+        const yearM = art.match(/buttonyear[^>]*>.*?(\d{4})/s);
+        const year = yearM ? yearM[1] : '';
+        if (!title) {
+            const altM = art.match(/\balt=["']([^"']+)["']/i);
+            if (altM) {
+                const altTitle = cleanText(altM[1]);
+                if (altTitle && href) {
+                    results.push({ title: altTitle, url: resolveUrl(href), poster, year });
+                }
+            }
+        }
+        else if (href && title) {
+            results.push({ title, url: resolveUrl(href), poster, year });
+        }
+    }
+    return results;
+}
+function extractPlayerData(html) {
+    let defaultSrc = '';
+    let thumbnail = '';
+    const jwMatch = html.match(/var\s+jw\s*=\s*(\{[\s\S]*?\})\s*(?:<\/script>|;)/);
+    if (jwMatch) {
+        const fileM = jwMatch[1].match(/"file"\s*:\s*"([^"]+)"/);
+        const imageM = jwMatch[1].match(/"image"\s*:\s*"([^"]+)"/);
+        if (fileM)
+            defaultSrc = cleanUrl(fileM[1].replace(/\\\//g, '/'));
+        if (imageM)
+            thumbnail = cleanUrl(imageM[1].replace(/\\\//g, '/'));
+    }
+    let duration = '';
+    const schemaMatch = html.match(/<script[^>]+type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/i);
+    if (schemaMatch) {
+        try {
+            const schema = JSON.parse(schemaMatch[1].trim());
+            if (!defaultSrc && schema.contentUrl)
+                defaultSrc = schema.contentUrl;
+            if (!thumbnail && schema.thumbnailUrl)
+                thumbnail = schema.thumbnailUrl;
+            if (schema.duration)
+                duration = schema.duration;
+        }
+        catch {
+            const durM = schemaMatch[1].match(/"duration"\s*:\s*"([^"]+)"/);
+            const cuM = schemaMatch[1].match(/"contentUrl"\s*:\s*"([^"]+)"/);
+            const thM = schemaMatch[1].match(/"thumbnailUrl"\s*:\s*"([^"]+)"/);
+            if (durM)
+                duration = durM[1];
+            if (cuM && !defaultSrc)
+                defaultSrc = cuM[1];
+            if (thM && !thumbnail)
+                thumbnail = thM[1];
+        }
+    }
+    const sources = [];
+    const sourcesBlockM = html.match(/sources\s*:\s*\[([\s\S]*?)\]/);
+    if (sourcesBlockM) {
+        const entryRe = /\{([\s\S]*?)\}/g;
+        let em;
+        while ((em = entryRe.exec(sourcesBlockM[1])) !== null) {
+            const entry = em[1];
+            const fileM = entry.match(/["']?file["']?\s*:\s*["']([^"']+)["']/);
+            const typeM = entry.match(/["']?type["']?\s*:\s*["']([^"']+)["']/);
+            const labelM = entry.match(/["']?label["']?\s*:\s*["']([^"']+)["']/);
+            if (fileM) {
+                sources.push({
+                    src: cleanUrl(fileM[1].replace(/\\\//g, '/')),
+                    type: typeM ? typeM[1] : 'video/mp4',
+                    label: labelM ? labelM[1] : 'default',
+                });
+            }
+        }
+    }
+    if (sources.length === 0 && defaultSrc) {
+        const labelGuess = defaultSrc.match(/_(\d+p)\./)?.[1] ?? 'default';
+        sources.push({ src: defaultSrc, type: 'video/mp4', label: labelGuess });
+    }
+    if (sources.length === 0) {
+        const videoUrlRe = /https?:\/\/[^"' ]+\.(mp4|m3u8)[^"' ]*/gi;
+        let vm;
+        const seen = new Set();
+        while ((vm = videoUrlRe.exec(html)) !== null) {
+            const url = cleanUrl(vm[0]);
+            if (seen.has(url))
+                continue;
+            seen.add(url);
+            const label = url.match(/_(\d{3,4}p)\./)?.[1] ?? 'default';
+            sources.push({
+                src: url,
+                type: url.includes('.m3u8') ? 'application/x-mpegURL' : 'video/mp4',
+                label,
+            });
+        }
+    }
+    return { sources, defaultSrc, thumbnail, duration };
+}
+class WhProvider extends base_provider_1.BaseProvider {
+    name = 'Wh';
+    bestMatch(results, query) {
+        if (!results.length)
+            return null;
+        if (results.length === 1)
+            return { ...results[0], score: 0 };
+        const q = query.toLowerCase().trim();
+        let best = results[0];
+        let bestScore = -1;
+        for (const item of results) {
+            const title = item.title.toLowerCase();
+            let score = -1;
+            if (title === q)
+                score = 3;
+            else if (title.startsWith(q))
+                score = 2;
+            else if (title.includes(q))
+                score = 1;
+            if (score > bestScore) {
+                bestScore = score;
+                best = item;
+                if (score === 3)
+                    break;
+            }
+        }
+        return { ...best, score: bestScore };
+    }
+    async browse(options) {
+        try {
+            const query = (options.query || '').trim();
+            const page = Math.max(1, options.page || 1);
+            const genre = (options.genre || '').trim().toLowerCase();
+            const cacheKey = `wh_browse_${genre || query}_${page}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached)
+                return cached;
+            const html = await fetchText(browseUrl(query, page, genre || undefined));
+            const results = parseSearchArticles(html);
+            const shows = results.map((r) => {
+                const slug = r.url.split('/').filter(Boolean).pop() || '';
+                return {
+                    _id: slug,
+                    id: slug,
+                    name: r.title,
+                    englishName: r.title,
+                    thumbnail: r.poster,
+                    type: 'TV',
+                    year: r.year ? Number(r.year) : null,
+                    isAdult: true,
+                    availableEpisodesDetail: { sub: [], dub: [] },
+                };
+            });
+            const output = { shows, hasMore: results.length >= 50 };
+            this.cache.set(cacheKey, output, 300);
+            return output;
+        }
+        catch (error) {
+            logger_1.default.error({ error }, '[WH] Browse failed');
+            return { shows: [], hasMore: false };
+        }
+    }
+    async search(options) {
+        try {
+            const query = (options.query || '').trim();
+            if (!query)
+                return [];
+            const html = await fetchText(`${BASE_URL}/?s=${encodeURIComponent(query)}`);
+            const results = parseSearchArticles(html);
+            if (results.length === 0)
+                return [];
+            const matchResult = (0, title_matching_1.pickBestMatch)(results, [query]);
+            if (!matchResult)
+                return [];
+            const matched = matchResult.item;
+            const slug = matched.url.split('/').filter(Boolean).pop() || '';
+            return [
+                {
+                    _id: slug,
+                    id: slug,
+                    name: matched.title,
+                    englishName: matched.title,
+                    thumbnail: matched.poster,
+                    type: 'TV',
+                    year: matched.year ? Number(matched.year) : null,
+                    availableEpisodesDetail: { sub: [], dub: [] },
+                },
+            ];
+        }
+        catch (error) {
+            logger_1.default.error({ error }, '[WH] Search failed');
+            return [];
+        }
+    }
+    async resolveShowId(title, romaji) {
+        const query = (romaji || title).trim();
+        if (!query)
+            return null;
+        const targets = [title, romaji].filter((t) => !!t);
+        for (const variant of (0, title_matching_1.buildQueryVariants)(title, romaji)) {
+            const html = await fetchText(`${BASE_URL}/?s=${encodeURIComponent(variant)}`);
+            const results = parseSearchArticles(html);
+            if (results.length === 0)
+                continue;
+            const matchResult = (0, title_matching_1.pickBestMatch)(results, targets);
+            if (matchResult) {
+                return matchResult.item.url.split('/').filter(Boolean).pop() || null;
+            }
+        }
+        return null;
+    }
+    async getEpisodes(showId) {
+        try {
+            if (!showId)
+                return null;
+            const cacheKey = `wh_eps_${showId}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached) {
+                return { episodes: cached.episodes, description: cached.description };
+            }
+            const html = await fetchText(`${BASE_URL}/series/${showId}/`);
+            const videosLinks = html.match(/\/videos\/[^"'\s]+/gi) || [];
+            const episodeMap = {};
+            const episodeNumbers = [];
+            videosLinks.forEach((link) => {
+                const slug = link.replace(/^\/videos\//, '').replace(/\/$/, '');
+                const numM = slug.match(/episode[-\s]?(\d+)/i);
+                const num = numM ? numM[1] : '';
+                if (num && slug && !episodeMap[num]) {
+                    episodeMap[num] = slug;
+                    episodeNumbers.push(num);
+                }
+            });
+            const description = '';
+            const result = {
+                episodes: episodeNumbers,
+                description,
+            };
+            this.cache.set(cacheKey, {
+                episodes: episodeNumbers,
+                description,
+                episodeMap,
+            }, 120);
+            return result;
+        }
+        catch (error) {
+            logger_1.default.error({ error, showId }, '[WH] getEpisodes failed');
+            return null;
+        }
+    }
+    async getEpisodeSlug(seriesSlug, episodeNumber) {
+        try {
+            const cacheKey = `wh_epmap_${seriesSlug}`;
+            let cached = this.cache.get(cacheKey) || {};
+            const buildEpisodeMap = async () => {
+                const html = await fetchText(`${BASE_URL}/series/${seriesSlug}/`);
+                const videosLinks = html.match(/\/videos\/[^"'\s]+/gi) || [];
+                const map = {};
+                videosLinks.forEach((link) => {
+                    const slug = link.replace(/^\/videos\//, '').replace(/\/$/, '');
+                    const numM = slug.match(/episode[-\s]?(\d+)/i);
+                    const num = numM ? numM[1] : '';
+                    if (num && slug) {
+                        map[num] = slug;
+                    }
+                });
+                this.cache.set(cacheKey, map, 3600);
+                return map;
+            };
+            if (Object.keys(cached).length === 0) {
+                cached = await buildEpisodeMap();
+            }
+            if (cached[episodeNumber])
+                return cached[episodeNumber];
+            const target = parseFloat(episodeNumber);
+            const keys = Object.keys(cached);
+            for (const key of keys) {
+                if (parseFloat(key) === target)
+                    return cached[key];
+            }
+            const sorted = keys.sort((a, b) => Number(a) - Number(b));
+            const first = Number(sorted[0]);
+            if (target < first && sorted.length > 0)
+                return cached[sorted[0]];
+            cached = await buildEpisodeMap();
+            if (cached[episodeNumber])
+                return cached[episodeNumber];
+            for (const key of Object.keys(cached)) {
+                if (parseFloat(key) === target)
+                    return cached[key];
+            }
+            const sorted2 = Object.keys(cached).sort((a, b) => Number(a) - Number(b));
+            const first2 = Number(sorted2[0]);
+            if (target < first2 && sorted2.length > 0)
+                return cached[sorted2[0]];
+            return null;
+        }
+        catch (error) {
+            logger_1.default.error({ error, seriesSlug, episodeNumber }, '[WH] getEpisodeSlug failed');
+            return null;
+        }
+    }
+    async getStreamUrls(showId, episodeNumber, _mode) {
+        try {
+            let targetEpisode = episodeNumber;
+            if (episodeNumber === '0')
+                targetEpisode = '1';
+            const episodeSlug = await this.getEpisodeSlug(showId, targetEpisode);
+            if (!episodeSlug) {
+                logger_1.default.warn({ showId, episodeNumber }, '[WH] Could not resolve episode slug');
+                return null;
+            }
+            const cacheKey = `wh_stream_${showId}_${targetEpisode}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached)
+                return cached;
+            const watchUrl = `${BASE_URL}/videos/${episodeSlug}/`;
+            const watchHtml = await fetchText(watchUrl);
+            const plyrUrlMatch = watchHtml.match(/https:\/\/watchhentai\.net\/player\/\d+\/\d+\/(?:mp4|gdrive)\/?/);
+            const jwUrlMatch = watchHtml.match(/https:\/\/watchhentai\.net\/jwplayer\/\?[^'")\s]+/);
+            let playerHtml = watchHtml;
+            let directFallback = '';
+            let playerUrl = '';
+            if (plyrUrlMatch) {
+                playerUrl = cleanUrl(plyrUrlMatch[0]);
+            }
+            else if (jwUrlMatch) {
+                playerUrl = cleanUrl(jwUrlMatch[0]);
+                directFallback = extractDirectSrc(playerUrl);
+            }
+            if (playerUrl) {
+                try {
+                    const res = await fetch(playerUrl, {
+                        headers: {
+                            'User-Agent': UA,
+                            Referer: watchUrl,
+                            Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+                            'Accept-Language': 'en-US,en;q=0.5',
+                        },
+                        signal: AbortSignal.timeout(30000),
+                    });
+                    if (res.ok)
+                        playerHtml = await res.text();
+                }
+                catch {
+                    // ignore
+                }
+            }
+            const links = [];
+            if (plyrUrlMatch) {
+                const jwSourcesMatch = playerHtml.match(/var\s+whJwSources\s*=\s*(\[[\s\S]*?\])\s*;/);
+                if (jwSourcesMatch) {
+                    try {
+                        const entries = JSON.parse(jwSourcesMatch[1]);
+                        for (const entry of entries) {
+                            if (!entry.file)
+                                continue;
+                            const url = whDecodeMediaUrl(entry.file);
+                            if (!/^https?:\/\//.test(url))
+                                continue;
+                            links.push({
+                                resolutionStr: entry.label || 'Auto',
+                                link: url,
+                                hls: url.includes('.m3u8'),
+                                headers: { Referer: BASE_URL + '/' },
+                            });
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                if (links.length === 0) {
+                    const seen = new Set();
+                    const urlRe = /https?:\/\/[^"' ]+\.(?:mp4|m3u8)[^"' ]*/gi;
+                    let vm;
+                    while ((vm = urlRe.exec(playerHtml)) !== null) {
+                        const url = cleanUrl(vm[0]);
+                        if (seen.has(url))
+                            continue;
+                        seen.add(url);
+                        links.push({
+                            resolutionStr: url.match(/[_-](\d{3,4}p)\./)?.[1] ?? 'Auto',
+                            link: url,
+                            hls: url.includes('.m3u8'),
+                            headers: { Referer: BASE_URL + '/' },
+                        });
+                    }
+                }
+            }
+            if (links.length === 0) {
+                const playerData = extractPlayerData(playerHtml);
+                for (const src of playerData.sources) {
+                    links.push({
+                        resolutionStr: src.label || 'Auto',
+                        link: src.src,
+                        hls: src.type === 'application/x-mpegURL' ||
+                            src.type === 'm3u8' ||
+                            src.src.includes('.m3u8'),
+                        headers: { Referer: BASE_URL + '/' },
+                    });
+                }
+            }
+            if (links.length === 0 && directFallback) {
+                links.push({
+                    resolutionStr: directFallback.match(/_(\d+p)\./)?.[1] ?? 'Auto',
+                    link: directFallback,
+                    hls: directFallback.includes('.m3u8'),
+                    headers: { Referer: BASE_URL + '/' },
+                });
+            }
+            if (links.length === 0) {
+                return null;
+            }
+            const result = [
+                {
+                    sourceName: 'WH (Direct)',
+                    links,
+                    type: 'player',
+                    actualEpisodeNumber: targetEpisode,
+                },
+            ];
+            if (playerUrl) {
+                result.push({
+                    sourceName: 'WH (Iframe)',
+                    links: [{ resolutionStr: 'Auto', link: playerUrl, hls: false }],
+                    type: 'iframe',
+                    actualEpisodeNumber: targetEpisode,
+                });
+            }
+            this.cache.set(cacheKey, result, 3600);
+            return result;
+        }
+        catch (error) {
+            logger_1.default.error({ error, showId, episodeNumber }, '[WH] getStreamUrls failed');
+            return null;
+        }
+    }
+}
+exports.WhProvider = WhProvider;