kaizoku-core 0.1.0

package/dist/providers/meta/anilist.js

@@ -0,0 +1,94 @@
+import { fetchApi } from '../../utils/http.js';
+import * as anizone from '../anime/anizone.js';
+import * as anikoto from '../anime/anikoto.js';
+import * as animeonsen from '../anime/animeonsen.js';
+// Add other providers as needed
+const ANIZIP_BASE = 'https://api.ani.zip/mappings?anilist_id=';
+const ANILIST_GRAPHQL = 'https://graphql.anilist.co';
+/**
+ * The available providers in the meta wrapper.
+ */
+export const PROVIDERS = {
+    anizone,
+    anikoto,
+    animeonsen
+};
+export async function getAniZipData(anilistId) {
+    try {
+        const res = await fetchApi(`${ANIZIP_BASE}${anilistId}`);
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Tries to find the anime on a specific provider by searching its titles.
+ */
+export async function mapToProvider(anilistId, providerName) {
+    const anizip = await getAniZipData(anilistId);
+    if (!anizip)
+        return null;
+    const provider = PROVIDERS[providerName.toLowerCase()];
+    if (!provider) {
+        throw new Error(`Provider ${providerName} not found.`);
+    }
+    // Try english title first, then romaji
+    const titlesToTry = [
+        anizip.titles.english,
+        anizip.titles.romaji,
+        // Remove special characters for better search
+        anizip.titles.english?.replace(/[^a-zA-Z0-9 ]/g, ''),
+        anizip.titles.romaji?.replace(/[^a-zA-Z0-9 ]/g, '')
+    ].filter(Boolean);
+    for (const title of titlesToTry) {
+        try {
+            const results = await provider.search(title);
+            if (results && results.length > 0) {
+                // To be safe, we could use string similarity here, but for now we take the first match
+                return results[0].id;
+            }
+        }
+        catch (err) {
+            console.warn(`Failed to search provider ${providerName} for title: ${title}`);
+        }
+    }
+    return null;
+}
+/**
+ * Fetches episodes from a provider and enriches them with AniZip metadata (titles, images, filler).
+ */
+export async function fetchEpisodes(anilistId, providerName) {
+    const providerId = await mapToProvider(anilistId, providerName);
+    if (!providerId) {
+        throw new Error(`Could not map AniList ID ${anilistId} to ${providerName}`);
+    }
+    const provider = PROVIDERS[providerName.toLowerCase()];
+    const anizip = await getAniZipData(anilistId);
+    const info = await provider.fetchAnimeInfo(providerId);
+    const enrichedEpisodes = info.episodes.map(ep => {
+        // Enriched with AniZip data if available
+        const azEp = anizip?.episodes?.[ep.number.toString()];
+        return {
+            ...ep,
+            title: azEp?.title_en || azEp?.title_ro || azEp?.title || ep.title,
+            description: azEp?.overview || ep.description,
+            image: azEp?.image || ep.image,
+            isFiller: azEp?.isFiller ?? ep.isFiller,
+        };
+    });
+    return enrichedEpisodes;
+}
+export async function fetchEpisodeSources(episodeId, providerName, extraArgs) {
+    const provider = PROVIDERS[providerName.toLowerCase()];
+    if (!provider) {
+        throw new Error(`Provider ${providerName} not found.`);
+    }
+    // Pass extraArgs (like animeId for AnimePahe) if the provider needs it
+    if (extraArgs) {
+        return provider.fetchEpisodeSources(extraArgs, episodeId);
+    }
+    return provider.fetchEpisodeSources(episodeId);
+}

package/dist/types/types.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Shared types every extractor (and, later, every provider) normalizes into.
+ */
+export interface Source {
+    url: string;
+    /** Always derived by checking the url itself — no extractor sources this independently. */
+    isM3U8: boolean;
+    /** e.g. "1080p", "multi-quality", "single", "default" — free text, providers don't agree on a fixed vocabulary. */
+    quality: string;
+    type?: "hls" | "mp4" | "dash" | "unknown";
+    proxiedUrl?: string;
+}
+export interface Subtitle {
+    url: string;
+    lang: string;
+    isDefault?: boolean;
+}
+/** Populated by Anizone (chapters/thumbnails tracks) — most providers leave this empty. */
+export interface Track {
+    url: string;
+    type: string;
+}
+export interface VideoStream {
+    sources: Source[];
+    subtitles: Subtitle[];
+    tracks?: Track[];
+    intro?: {
+        start: number;
+        end: number;
+    };
+    outro?: {
+        start: number;
+        end: number;
+    };
+    download?: string;
+    /** Referer / Origin / User-Agent — whatever this specific stream needs to actually play. */
+    headers?: Record<string, string>;
+}
+export type ProviderName = 'anikoto' | 'anizone' | 'animeonsen' | 'animeunity' | 'gojo' | 'animegg' | 'anidb' | 'animesaturn' | 'animepahe';
+export interface Episode {
+    id: string;
+    number: number;
+    title?: string;
+    image?: string;
+    airDate?: string;
+    hasDub?: boolean;
+    hasSub?: boolean;
+    /** we need to use anizip data here to satisfy this  */
+    filler?: boolean;
+    /**most providers dont have seconds so we kinda need to use anizip here  */
+    duration?: number;
+    description?: string;
+    providerName?: ProviderName;
+}
+export interface ProviderStats {
+    name: string;
+    baseUrl: string;
+    isWorking: boolean;
+}
+export interface AnimeResult {
+    id: string;
+    title: string | {
+        romaji?: string;
+        english?: string;
+        native?: string;
+        userPreferred?: string;
+    };
+    url?: string;
+    image?: string;
+    releaseDate?: string;
+    type?: string;
+    status?: string;
+    [key: string]: any;
+}
+export interface AnimeInfo extends AnimeResult {
+    description?: string;
+    genres?: string[];
+    totalEpisodes?: number;
+    episodes: Episode[];
+    [key: string]: any;
+}
+export interface PageResult<T> {
+    currentPage?: number;
+    hasNextPage?: boolean;
+    totalPages?: number;
+    totalResults?: number;
+    results: T[];
+}

package/dist/types/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared types every extractor (and, later, every provider) normalizes into.
+ */
+export {};

package/dist/utils/http.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Minimal fetch wrapper shared by every extractor/provider.
+ * Uses Node's global fetch directly — no extra HTTP dependency.
+ */
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly url: string;
+    constructor(status: number, statusText: string, url: string);
+}
+export declare function httpGet(url: string, headers?: Record<string, string>): Promise<Response>;
+export declare function getText(url: string, headers?: Record<string, string>): Promise<string>;
+export declare function getJson<T = unknown>(url: string, headers?: Record<string, string>): Promise<T>;

package/dist/utils/http.js

@@ -0,0 +1,39 @@
+/**
+ * Minimal fetch wrapper shared by every extractor/provider.
+ * Uses Node's global fetch directly — no extra HTTP dependency.
+ */
+const DEFAULT_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:144.0) Gecko/20100101 Firefox/144.0",
+    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.5",
+};
+export class HttpError extends Error {
+    status;
+    statusText;
+    url;
+    constructor(status, statusText, url) {
+        super(`HTTP ${status} ${statusText} — ${url}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.url = url;
+        this.name = "HttpError";
+    }
+}
+export async function httpGet(url, headers = {}) {
+    return fetch(url, {
+        method: "GET",
+        headers: { ...DEFAULT_HEADERS, ...headers },
+    });
+}
+export async function getText(url, headers) {
+    const res = await httpGet(url, headers);
+    if (!res.ok)
+        throw new HttpError(res.status, res.statusText, url);
+    return res.text();
+}
+export async function getJson(url, headers) {
+    const res = await httpGet(url, headers);
+    if (!res.ok)
+        throw new HttpError(res.status, res.statusText, url);
+    return (await res.json());
+}

package/dist/utils/proxy.d.ts

@@ -0,0 +1,9 @@
+export declare function encodeMiruro(url: string, referer: string): string;
+export declare function encodeAnikuro(url: string, referer: string): string | undefined;
+export declare function encodeLunar(url: string, referer: string): string;
+export declare function encodeAnimanga(url: string, referer: string): string;
+/**
+ * Generates anikuro proxy URL for a given video URL and referer,
+ * respecting the global proxy configuration.
+ */
+export declare function generateProxiedUrl(url: string, referer?: string): string | undefined;

package/dist/utils/proxy.js

@@ -0,0 +1,43 @@
+import { Buffer } from 'node:buffer';
+import { config } from '../lib/config.js';
+const miruroKey = Buffer.from("a54d389c18527d9fd3e7f0643e27edbe", "hex");
+export function encodeMiruro(url, referer) {
+    const encodeParam = (text) => {
+        const b = Buffer.from(text, 'utf-8');
+        const c = Buffer.alloc(b.length);
+        for (let i = 0; i < b.length; i++) {
+            c[i] = b[i] ^ miruroKey[i % 16];
+        }
+        return c.toString('base64url');
+    };
+    return `https://pro.ultracloud.cc/m3u8/?u=${encodeParam(url)}&r=${encodeParam(referer)}`;
+}
+export function encodeAnikuro(url, referer) {
+    if (!config.proxy.enabled || !config.proxy.generateSourceProxies) {
+        return undefined;
+    }
+    const b64 = Buffer.from(`${url}|${referer}`).toString('base64');
+    const ext = url.toLowerCase().includes('.m3u8') ? '.m3u8' : '.mp4';
+    return `https://proxy.anikuro.to/${b64}${ext}`;
+}
+function customQuote(str) {
+    return encodeURIComponent(str).replace(/%3A/g, ':').replace(/%2F/g, '/');
+}
+export function encodeLunar(url, referer) {
+    return `https://cluster.lunaranime.ru/api/proxy/hls/custom?url=${customQuote(url)}&referer=${customQuote(referer)}`;
+}
+export function encodeAnimanga(url, referer) {
+    const headers = JSON.stringify({ Referer: referer });
+    return `https://upcloud.animanga.fun/proxy?url=${customQuote(url)}&headers=${customQuote(headers)}`;
+}
+/**
+ * Generates anikuro proxy URL for a given video URL and referer,
+ * respecting the global proxy configuration.
+ */
+export function generateProxiedUrl(url, referer) {
+    if (!config.proxy.enabled || !config.proxy.generateSourceProxies) {
+        return undefined;
+    }
+    const ref = referer || url;
+    return encodeAnikuro(url, ref);
+}

package/dist/utils/shared.d.ts

@@ -0,0 +1,15 @@
+import { VideoStream } from "../types/types.js";
+/** MegaPlay and VidWish both embed the numeric media id the same way. */
+export declare function parseEmbedMediaId(html: string): string | null;
+export declare function getVideoType(url: string): "hls" | "mp4" | "dash" | "unknown";
+export declare function getAniSkipTimes(malId: number, episodeNumber: number): Promise<{
+    op: {
+        start: number;
+        end: number;
+    } | null;
+    ed: {
+        start: number;
+        end: number;
+    } | null;
+} | null>;
+export declare function applyAniSkip(stream: VideoStream, malId?: number, episodeNumber?: number): Promise<VideoStream>;

package/dist/utils/shared.js

@@ -0,0 +1,64 @@
+import { load } from "cheerio";
+/** MegaPlay and VidWish both embed the numeric media id the same way. */
+export function parseEmbedMediaId(html) {
+    const $ = load(html);
+    const id = $("body div.mg3-player > div.fix-area").attr("data-id")?.trim();
+    const fileId = $("title").text().match(/File\s+(\d+)/i)?.[1];
+    return id || fileId || null;
+}
+export function getVideoType(url) {
+    if (url.includes('.m3u8'))
+        return 'hls';
+    if (url.includes('.mpd'))
+        return 'dash';
+    if (url.includes('.mp4'))
+        return 'mp4';
+    return 'unknown';
+}
+export async function getAniSkipTimes(malId, episodeNumber) {
+    try {
+        const url = `https://api.aniskip.com/v2/skip-times/${malId}/${episodeNumber}?types=op&types=ed&episodeLength=0`;
+        const res = await fetch(url);
+        if (!res.ok)
+            return null;
+        const json = await res.json();
+        if (!json.found || !json.results)
+            return null;
+        let op = null;
+        let ed = null;
+        for (const item of json.results) {
+            const interval = {
+                start: Math.round(item.interval.startTime),
+                end: Math.round(item.interval.endTime)
+            };
+            if (item.skipType === 'op')
+                op = interval;
+            else if (item.skipType === 'ed')
+                ed = interval;
+        }
+        return { op, ed };
+    }
+    catch (err) {
+        console.error('AniSkip fetch error:', err);
+        return null;
+    }
+}
+export async function applyAniSkip(stream, malId, episodeNumber) {
+    if (!malId || !episodeNumber)
+        return stream;
+    try {
+        const skipTimes = await getAniSkipTimes(malId, episodeNumber);
+        if (skipTimes) {
+            if (skipTimes.op)
+                stream.intro = { start: skipTimes.op.start, end: skipTimes.op.end };
+            if (skipTimes.ed)
+                stream.outro = { start: skipTimes.ed.start, end: skipTimes.ed.end };
+        }
+    }
+    catch (e) {
+        // We swallow the error because failing to get skip times 
+        // shouldn't stop the user from watching the episode.
+        console.debug(`AniSkip fetch failed for MAL:${malId} EP:${episodeNumber}`, e);
+    }
+    return stream;
+}

package/dist/utils/unpack.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Port of the classic Dean Edwards "P.A.C.K.E.R." unpacker — decodes the
+ * eval(function(p,a,c,k,e,d){...}(...)) obfuscation used by Kwik and StreamWish.
+ * Ported line-for-line from the Dart JsUnpack source rather than rewritten,
+ * since this is dense offset-based string logic where a "cleaner" rewrite is
+ * exactly how subtle bugs get introduced. Round-trip tested against a hand-built
+ * packed sample — see the PR notes for the test.
+ */
+export declare function unpackJs(source: string): string;

package/dist/utils/unpack.js

@@ -0,0 +1,59 @@
+/**
+ * Port of the classic Dean Edwards "P.A.C.K.E.R." unpacker — decodes the
+ * eval(function(p,a,c,k,e,d){...}(...)) obfuscation used by Kwik and StreamWish.
+ * Ported line-for-line from the Dart JsUnpack source rather than rewritten,
+ * since this is dense offset-based string logic where a "cleaner" rewrite is
+ * exactly how subtle bugs get introduced. Round-trip tested against a hand-built
+ * packed sample — see the PR notes for the test.
+ */
+const ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+function toBase10(word) {
+    return word.split("").reduce((out, char) => out * ALPHABET.length + ALPHABET.indexOf(char), 0);
+}
+function filterArgs(source) {
+    const match = source.match(/}\s*\('(.*)',\s*(.*?),\s*(\d+),\s*'(.*?)'\.split\('\|'\)/);
+    if (!match)
+        throw new Error("Corrupted p.a.c.k.e.r. data.");
+    return {
+        payload: match[1],
+        symtab: match[4].split("|"),
+        // match[2] (radix) and match[3] (word count) are part of the packer format but are
+        // never actually read anywhere below — toBase10 always assumes base62, radix and all.
+        // Preserved faithfully from the source rather than "fixed", since it's unverified
+        // against a live sample and evidently works for whatever this was built against.
+    };
+}
+/**
+ * NOTE: ported as-is from a quirk in the source. This matches a secondary
+ * `var _xxx=["..."];` wrapper some packer variants prepend, then strips a number of
+ * characters equal to the length of the matched *variable name* (e.g. 7 chars for
+ * "_0x1234") off the front of the string. That's very likely not what was intended —
+ * you'd expect it to strip the actual declaration using the match's end index, not the
+ * name's length. Kept unchanged since I can't verify it against a live packed sample,
+ * but if unpacked output ever comes out mysteriously truncated, this is the first place
+ * to look.
+ */
+function stripSecondaryStringTable(source) {
+    const match = source.match(/var *(_\w+)=\["(.*?)"];/s);
+    if (!match)
+        return source;
+    return source.slice(match[1].length);
+}
+export function unpackJs(source) {
+    const { payload, symtab } = filterArgs(source);
+    const unescaped = payload.replaceAll("\\\\", "\\").replaceAll("\\'", "'");
+    let result = unescaped;
+    let correction = 0;
+    const wordPattern = /\b\w+\b/g;
+    let match;
+    while ((match = wordPattern.exec(unescaped)) !== null) {
+        const word = match[0];
+        const start = match.index;
+        const end = start + word.length;
+        const index = toBase10(word);
+        const lookup = index < symtab.length ? symtab[index] || word : word;
+        result = result.slice(0, start + correction) + lookup + result.slice(end + correction);
+        correction += lookup.length - word.length;
+    }
+    return stripSecondaryStringTable(result);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "kaizoku-core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./providers/*": "./dist/providers/*.js",
+    "./extractors/*": "./dist/extractors/*.js",
+    "./utils/*": "./dist/utils/*.js",
+    "./types": "./dist/types/types.js"
+  },
+  "license": "MIT",
+  "authors": [
+    "https://github.com/Pirate193"
+  ],
+  "dependencies": {
+    "cheerio": "^1.0.0-rc.12"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "@vitest/ui": "^4.1.9",
+    "typescript": "^5.3.3",
+    "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/"
+  }
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        testTimeout: 30000,
+    }
+});