@serifpersia/dango 3.0.3

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

@@ -0,0 +1,440 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpProvider = exports.OP_TAGS = exports.OP_ORDERS = 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://oppai.stream';
+const SEARCH_URL = `${BASE_URL}/actions/search.php`;
+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';
+async function fetchText(url) {
+    const res = await fetch(url, {
+        headers: {
+            'User-Agent': UA,
+            Referer: `${BASE_URL}/`,
+            Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+        },
+        redirect: 'manual',
+        signal: AbortSignal.timeout(30000),
+    });
+    const text = await res.text();
+    const isRedirect = res.status === 301 || res.status === 302 || res.status === 307 || res.status === 308;
+    if (!res.ok && !isRedirect)
+        throw new Error(`HTTP ${res.status}: ${url}`);
+    return text;
+}
+function parseSearchResults(html) {
+    const entries = [];
+    const re = /<div\s+class='in-grid episode-shown'\s+id='([^']+)'[^>]*idgt='([^']+)'[^>]*folder='([^']+)'[^>]*ep='([^']+)'[^>]*name='([^']+)'[^>]*desc='([^']*)'[^>]*>[\s\S]*?<a\s+href='(https?:\/\/oppai\.stream\/watch\?e=[^']+)'/g;
+    let m;
+    while ((m = re.exec(html)) !== null) {
+        entries.push({
+            id: m[1],
+            idgt: m[2],
+            folder: m[3],
+            ep: m[4],
+            name: m[5],
+            desc: m[6],
+            watchUrl: m[7],
+        });
+    }
+    return entries;
+}
+function folderToTitleSlug(folder) {
+    return folder
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+function titleSlugToFolder(slug) {
+    return slug.replace(/-/g, ' ');
+}
+exports.OP_ORDERS = ['recent', 'popular', 'views', 'rating', 'random'];
+exports.OP_TAGS = [
+    '4k',
+    'ahegao',
+    'anal',
+    'armpitmasturbation',
+    'bdsm',
+    'bigboobs',
+    'blackhair',
+    'blondehair',
+    'blowjob',
+    'bluehair',
+    'bondage',
+    'boobjob',
+    'brownhair',
+    'censored',
+    'comedy',
+    'cosplay',
+    'cowgirl',
+    'creampie',
+    'darkskin',
+    'demon',
+    'doggy',
+    'dominantgirl',
+    'doublepenetration',
+    'elf',
+    'facial',
+    'fantasy',
+    'filmed',
+    'footjob',
+    'futanari',
+    'gangbang',
+    'glasses',
+    'greenhair',
+    'gyaru',
+    'handjob',
+    'harem',
+    'hd',
+    'incest',
+    'inflation',
+    'loli',
+    'maid',
+    'masturbation',
+    'milf',
+    'mindbreak',
+    'mindcontrol',
+    'missionary',
+    'monster',
+    'nekomimi',
+    'ntr',
+    'nurse',
+    'old',
+    'orgy',
+    'pinkhair',
+    'plot',
+    'ponytail',
+    'pov',
+    'pregnant',
+    'publicsex',
+    'purplehair',
+    'rape',
+    'redhair',
+    'reverserape',
+    'rimjob',
+    'scat',
+    'schoolgirl',
+    'shorthair',
+    'shota',
+    'smallboobs',
+    'softcore',
+    'succubus',
+    'swimsuit',
+    'teacher',
+    'tentacle',
+    'threesome',
+    'toys',
+    'uglybastard',
+    'uncensored',
+    'vanilla',
+    'virgin',
+    'whitehair',
+    'x-ray',
+    'yuri',
+];
+function buildSeriesMap(entries) {
+    const map = new Map();
+    for (const e of entries) {
+        const key = e.folder.toLowerCase();
+        const existing = map.get(key) || [];
+        existing.push(e);
+        map.set(key, existing);
+    }
+    return map;
+}
+function bestMatch(series, query) {
+    if (!series.length)
+        return null;
+    const q = query.toLowerCase().trim();
+    let best = series[0];
+    let bestScore = -1;
+    for (const item of series) {
+        const title = item.title.toLowerCase();
+        let score = 0;
+        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 };
+}
+class OpProvider extends base_provider_1.BaseProvider {
+    name = 'Op';
+    async browse(options) {
+        try {
+            const query = (options.query || '').trim();
+            const page = Math.max(1, options.page || 1);
+            const limit = Math.min(50, Math.max(1, options.limit || 24));
+            const order = exports.OP_ORDERS.includes(options.order || '') ? options.order : 'recent';
+            const genres = (options.genres || '').trim();
+            const blacklist = (options.blacklist || '').trim();
+            const studio = (options.studio || '').trim();
+            const cacheKey = `op_browse_${query}_${page}_${limit}_${order}_${genres}_${blacklist}_${studio}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached)
+                return cached;
+            const params = new URLSearchParams({
+                text: query,
+                order,
+                page: String(page),
+                limit: String(limit),
+                genres,
+                blacklist,
+                studio,
+                ibt: '0',
+                swa: '1',
+            });
+            const html = await fetchText(`${SEARCH_URL}?${params.toString()}`);
+            const entries = parseSearchResults(html);
+            const totalMatch = html.match(/amo='(\d+)'/);
+            const total = totalMatch ? parseInt(totalMatch[1]) : entries.length;
+            const seriesMap = buildSeriesMap(entries);
+            const shows = Array.from(seriesMap.entries()).map(([key, eps]) => {
+                const sorted = [...eps].sort((a, b) => parseFloat(a.ep) - parseFloat(b.ep));
+                const first = sorted[0];
+                return {
+                    _id: key,
+                    id: key,
+                    name: first.name,
+                    englishName: first.name,
+                    thumbnail: `https://myspacecat.pictures/${encodeURIComponent(first.folder)}/thumbnail_${first.ep}.png`,
+                    type: 'TV',
+                    year: null,
+                    isAdult: true,
+                    availableEpisodesDetail: {
+                        sub: sorted.map((e) => e.ep),
+                        dub: [],
+                    },
+                };
+            });
+            const output = { shows, total, hasMore: page * limit < total };
+            this.cache.set(cacheKey, output, 300);
+            return output;
+        }
+        catch (error) {
+            logger_1.default.error({ error }, '[OP] Browse failed');
+            return { shows: [], total: 0, hasMore: false };
+        }
+    }
+    async search(options) {
+        try {
+            const query = (options.query || '').trim();
+            if (!query)
+                return [];
+            const cacheKey = `op_search_${query}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached)
+                return cached;
+            const url = `${SEARCH_URL}?text=${encodeURIComponent(query)}&order=recent&page=1&limit=23&genres=&blacklist=&studio=&ibt=0&swa=1`;
+            const html = await fetchText(url);
+            const entries = parseSearchResults(html);
+            if (entries.length === 0)
+                return [];
+            const seriesMap = buildSeriesMap(entries);
+            const uniqueSeries = Array.from(seriesMap.entries()).map(([key, eps]) => ({
+                title: eps[0].name,
+                key,
+            }));
+            const match = bestMatch(uniqueSeries, query) || uniqueSeries[0];
+            const episodes = seriesMap.get(match.key) || [];
+            const first = episodes[0];
+            const sortedEps = episodes
+                .sort((a, b) => parseFloat(a.ep) - parseFloat(b.ep))
+                .map((e) => e.ep);
+            const thumbnailUrl = `https://myspacecat.pictures/${encodeURIComponent(first.folder)}/thumbnail_${first.ep}.png`;
+            const result = [
+                {
+                    _id: match.key,
+                    id: match.key,
+                    name: first.name,
+                    englishName: first.name,
+                    thumbnail: thumbnailUrl,
+                    type: 'TV',
+                    year: null,
+                    availableEpisodesDetail: {
+                        sub: sortedEps,
+                        dub: [],
+                    },
+                },
+            ];
+            this.cache.set(cacheKey, result, 300);
+            return result;
+        }
+        catch (error) {
+            logger_1.default.error({ error }, '[OP] 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 url = `${SEARCH_URL}?text=${encodeURIComponent(variant)}&order=recent&page=1&limit=23&genres=&blacklist=&studio=&ibt=0&swa=1`;
+            const html = await fetchText(url);
+            const entries = parseSearchResults(html);
+            if (entries.length === 0)
+                continue;
+            const seriesMap = buildSeriesMap(entries);
+            const nameCandidates = [];
+            for (const [key, eps] of seriesMap.entries()) {
+                const seenNames = new Set();
+                for (const ep of eps) {
+                    if (ep.name && !seenNames.has(ep.name.toLowerCase())) {
+                        seenNames.add(ep.name.toLowerCase());
+                        nameCandidates.push({ title: ep.name, key });
+                    }
+                }
+            }
+            const match = (0, title_matching_1.pickBestMatch)(nameCandidates, targets);
+            if (match) {
+                return match.item.key;
+            }
+        }
+        return null;
+    }
+    async getEpisodes(showId) {
+        try {
+            if (!showId)
+                return null;
+            const cacheKey = `op_eps_${showId}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached)
+                return cached;
+            const folder = titleSlugToFolder(showId);
+            const compact = folder.toLowerCase().replace(/[^a-z0-9]/g, '');
+            const searchEntries = async (text, limit) => {
+                const url = `${SEARCH_URL}?text=${encodeURIComponent(text)}&order=recent&page=1&limit=${limit}&genres=&blacklist=&studio=&ibt=0&swa=1`;
+                const html = await fetchText(url);
+                return parseSearchResults(html);
+            };
+            const words = folder
+                .split(/\s+/)
+                .filter((w) => w.length >= 3)
+                .sort((a, b) => b.length - a.length);
+            let matched = [];
+            for (const text of [folder, ...words]) {
+                const entries = await searchEntries(text, 50);
+                matched = entries.filter((e) => e.folder.toLowerCase().replace(/[^a-z0-9]/g, '') === compact);
+                if (matched.length > 0)
+                    break;
+            }
+            if (matched.length === 0)
+                return null;
+            matched.sort((a, b) => parseFloat(a.ep) - parseFloat(b.ep));
+            const episodes = matched.map((e) => e.ep);
+            const watchMap = {};
+            for (const e of matched) {
+                if (e.watchUrl)
+                    watchMap[e.ep] = e.watchUrl;
+            }
+            this.cache.set(`op_watch_${showId}`, watchMap, 3600);
+            const desc = matched[0]?.desc || '';
+            const result = { episodes, description: desc };
+            this.cache.set(cacheKey, result, 3600);
+            return result;
+        }
+        catch (error) {
+            logger_1.default.error({ error, showId }, '[OP] getEpisodes failed');
+            return null;
+        }
+    }
+    async getStreamUrls(showId, episodeNumber, _mode) {
+        try {
+            const cacheKey = `op_stream_${showId}_${episodeNumber}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached)
+                return cached;
+            let watchMap = this.cache.get(`op_watch_${showId}`);
+            if (!watchMap) {
+                await this.getEpisodes(showId);
+                watchMap = this.cache.get(`op_watch_${showId}`);
+            }
+            const watchUrl = watchMap?.[episodeNumber];
+            const folder = titleSlugToFolder(showId);
+            const url = watchUrl ??
+                `${BASE_URL}/watch?e=${encodeURIComponent(folderToTitleSlug(folder))}-${episodeNumber}`;
+            const html = await fetchText(url);
+            // Parse availableres JS object: {"1080":"https://...webm","4k":"https://...webm","720":"https://...mp4"}
+            const availResMatch = html.match(/var\s+availableres\s*=\s*(\{[^;]+\})/);
+            const links = [];
+            if (availResMatch) {
+                try {
+                    const raw = availResMatch[1].replace(/\\\//g, '/');
+                    const availRes = JSON.parse(raw);
+                    const qualityMap = {
+                        '720': '720p',
+                        '1080': '1080p',
+                        '4k': '4K',
+                    };
+                    for (const [key, videoUrl] of Object.entries(availRes)) {
+                        if (!videoUrl || !key)
+                            continue;
+                        const label = qualityMap[key] || key;
+                        links.push({ resolutionStr: label, link: videoUrl, hls: false });
+                    }
+                    const resOrder = { '720p': 1, '1080p': 2, '4K': 3 };
+                    links.sort((a, b) => (resOrder[a.resolutionStr] || 99) - (resOrder[b.resolutionStr] || 99));
+                }
+                catch {
+                    // ignore
+                }
+            }
+            // Fallback: try <source> tags
+            if (links.length === 0) {
+                const sourceRe = /src="(https?:\/\/[^"]+\.(mp4|webm)[^"]*)"/gi;
+                let sourceMatch;
+                while ((sourceMatch = sourceRe.exec(html)) !== null) {
+                    const ext = sourceMatch[2].toLowerCase();
+                    links.push({
+                        resolutionStr: ext === 'mp4' ? '720p' : '1080p',
+                        link: sourceMatch[1],
+                        hls: false,
+                    });
+                }
+            }
+            if (links.length === 0)
+                return null;
+            const subtitles = [];
+            const subRe = /src='(https?:\/\/[^']+\.vtt[^']*)'[^>]*kind='subtitles'[^>]*srclang='([^']+)'/g;
+            let subMatch;
+            while ((subMatch = subRe.exec(html)) !== null) {
+                subtitles.push({
+                    language: subMatch[2],
+                    label: subMatch[2].toUpperCase(),
+                    url: subMatch[1],
+                });
+            }
+            const result = [
+                {
+                    sourceName: 'OP (Direct)',
+                    links,
+                    subtitles: subtitles.length > 0 ? subtitles : undefined,
+                    type: 'player',
+                    actualEpisodeNumber: episodeNumber,
+                },
+            ];
+            this.cache.set(cacheKey, result, 3600);
+            return result;
+        }
+        catch (error) {
+            logger_1.default.error({ error, showId, episodeNumber }, '[OP] getStreamUrls failed');
+            return null;
+        }
+    }
+}
+exports.OpProvider = OpProvider;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/server/dist/providers/title-matching.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCompact = normalizeCompact;
+exports.tokenize = tokenize;
+exports.bigramDice = bigramDice;
+exports.distinctiveTokens = distinctiveTokens;
+exports.titleSimilarity = titleSimilarity;
+exports.pickBestMatch = pickBestMatch;
+exports.buildQueryVariants = buildQueryVariants;
+function normalizeCompact(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+function tokenize(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length >= 2);
+}
+function bigramDice(a, b) {
+    if (a.length < 2 || b.length < 2)
+        return a === b ? 1 : 0;
+    const grams = (s) => {
+        const map = new Map();
+        for (let i = 0; i < s.length - 1; i++) {
+            const g = s.slice(i, i + 2);
+            map.set(g, (map.get(g) || 0) + 1);
+        }
+        return map;
+    };
+    const A = grams(a);
+    const B = grams(b);
+    let totalA = 0;
+    let totalB = 0;
+    let shared = 0;
+    A.forEach((c) => (totalA += c));
+    B.forEach((c) => (totalB += c));
+    A.forEach((c, g) => {
+        const other = B.get(g);
+        if (other)
+            shared += Math.min(c, other);
+    });
+    return (2 * shared) / (totalA + totalB);
+}
+const STOPWORDS = new Set([
+    'the',
+    'animation',
+    'no',
+    'wa',
+    'ga',
+    'wo',
+    'ni',
+    'de',
+    'to',
+    'e',
+    'o',
+    'x',
+    'ii',
+    'yo',
+    'ova',
+    'oad',
+    'hd',
+    'ep',
+    'episode',
+    'season',
+    'part',
+    'hen',
+    'a',
+]);
+const SEASON_TOKENS = new Set([
+    'season',
+    '2nd',
+    '3rd',
+    '4th',
+    '5th',
+    'ii',
+    'iii',
+    'iv',
+    'v',
+    'vi',
+    'vii',
+    'viii',
+    'ix',
+    'x',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine',
+    'ten',
+]);
+function distinctiveTokensExcludingSeason(s) {
+    return [...new Set(tokenize(s).filter((w) => !STOPWORDS.has(w) && !SEASON_TOKENS.has(w)))];
+}
+const ROMAN_TO_NUM = {
+    ii: 2,
+    iii: 3,
+    iv: 4,
+    v: 5,
+    vi: 6,
+    vii: 7,
+    viii: 8,
+    ix: 9,
+    x: 10,
+};
+const WORD_TO_NUM = {
+    two: 2,
+    three: 3,
+    four: 4,
+    five: 5,
+    six: 6,
+    seven: 7,
+    eight: 8,
+    nine: 9,
+    ten: 10,
+};
+function detectSeasonMarker(s) {
+    const t = s.toLowerCase();
+    // "season 2", "season ii", "season 2nd", "season three"
+    const seasonNum = t.match(/\bseason\s*(\d+|ii|iii|iv|v|vi|vii|viii|ix|x|two|three|four|five|six|seven|eight|nine|ten)\b/);
+    if (seasonNum) {
+        const token = seasonNum[1];
+        const n = ROMAN_TO_NUM[token];
+        const w = WORD_TO_NUM[token];
+        return String(n ?? w ?? token);
+    }
+    const ord = t.match(/\b(\d+)(st|nd|rd|th)\b/);
+    if (ord)
+        return ord[1];
+    const trailing = t.match(/\b(ii|iii|iv|v|vi|vii|viii|ix|x)\b(?!\s*(st|nd|rd|th|season))/);
+    if (trailing)
+        return String(ROMAN_TO_NUM[trailing[1]]);
+    // bare trailing number, e.g. "...Another World 2"
+    const trailingNum = t.match(/\b(\d+)\s*(season)?\s*$/);
+    if (trailingNum)
+        return trailingNum[1];
+    return '';
+}
+function distinctiveTokens(s) {
+    return [...new Set(tokenize(s).filter((w) => !STOPWORDS.has(w)))];
+}
+function titleSimilarity(query, candidate) {
+    const q = normalizeCompact(query);
+    const c = normalizeCompact(candidate);
+    if (!q || !c)
+        return 0;
+    if (q === c)
+        return 1;
+    let score = bigramDice(q, c);
+    if (q.startsWith(c) || c.startsWith(q)) {
+        const prefixScore = 0.5 + 0.5 * (Math.min(q.length, c.length) / Math.max(q.length, c.length));
+        if (prefixScore > score)
+            score = prefixScore;
+    }
+    const qD = distinctiveTokensExcludingSeason(query);
+    const cD = distinctiveTokensExcludingSeason(candidate);
+    if (qD.length > 0 && cD.length >= 2) {
+        const cSet = new Set(cD);
+        let hits = 0;
+        for (const t of qD) {
+            if (cSet.has(t))
+                hits++;
+        }
+        const coverage = hits / Math.min(qD.length, cD.length);
+        if (coverage > score)
+            score = coverage;
+    }
+    const qMarker = detectSeasonMarker(query);
+    if (qMarker) {
+        const cMarker = detectSeasonMarker(candidate);
+        if (cMarker === qMarker) {
+            score += 0.25;
+        }
+        else if (!cMarker && score >= 0.5) {
+            score -= 0.25;
+        }
+    }
+    return score >= 1 ? 0.99 : score;
+}
+function pickBestMatch(candidates, targets, minScore = 0.6) {
+    if (!candidates.length)
+        return null;
+    const cleanTargets = targets.filter((t) => !!t && t.trim().length > 0);
+    if (!cleanTargets.length)
+        return null;
+    let best = null;
+    for (const item of candidates) {
+        if (!item.title)
+            continue;
+        let score = 0;
+        for (const target of cleanTargets) {
+            const s = titleSimilarity(target, item.title);
+            if (s > score)
+                score = s;
+        }
+        if (!best || score > best.score)
+            best = { item, score };
+    }
+    return best && best.score >= minScore ? best : null;
+}
+function buildQueryVariants(title, romaji) {
+    const seen = new Set();
+    const out = [];
+    const push = (q) => {
+        const v = q.replace(/\s+/g, ' ').trim();
+        if (v && !seen.has(v.toLowerCase())) {
+            seen.add(v.toLowerCase());
+            out.push(v);
+        }
+    };
+    if (romaji && romaji.trim())
+        push(romaji);
+    push(title);
+    const stripped = (s) => s.replace(/[^\p{L}\p{N}\s]/gu, ' ');
+    push(stripped(title));
+    if (romaji)
+        push(stripped(romaji));
+    const words = stripped(title).split(/\s+/).filter(Boolean);
+    if (words.length > 3)
+        push(words.slice(0, 3).join(' '));
+    if (words.length > 4)
+        push(words.slice(0, 4).join(' '));
+    const tokens = distinctiveTokens(title)
+        .concat(romaji ? distinctiveTokens(romaji) : [])
+        .filter((w) => w.length >= 4);
+    const unique = [...new Set(tokens)];
+    unique.sort((a, b) => b.length - a.length);
+    for (const t of unique.slice(0, 4))
+        push(t);
+    return out;
+}