kaizoku-core 0.1.0

package/README.md

@@ -0,0 +1,105 @@
+# @kaizoku/core
+
+The core TypeScript engine powering [kaizoku.site](https://kaizoku.site). It contains modular, tree-shakeable scrapers for popular anime providers, video extractors, AniList integration, and metadata mapping.
+
+## Features
+
+- **9+ Anime Providers**: Anikoto, Anizone, AnimeOnsen, AnimeUnity, Gojo, AnimeGG, AniDB, AnimeSaturn, and AnimePahe.
+- **AniList Meta API**: Search, fetch details, get popular/trending titles directly from AniList.
+- **AniZip Mapping**: Seamless AniList-to-Provider mapping with TVDB metadata enrichment (descriptions, screencaps, air dates, episode length).
+- **AniSkip Skip-Times**: Automatic integration with AniSkip API to fetch and inject intro/outro skip times into video streams.
+- **Auto Proxying**: Built-in Anikuro proxy.
+
+## Installation
+
+```bash
+npm install @kaizoku/core
+# or
+pnpm add @kaizoku/core
+# or
+yarn add @kaizoku/core
+```
+
+## Quick Start
+
+### 1. Configuration
+Set up global settings such as custom AniList proxy URLs or custom proxy options:
+
+```typescript
+import { configure } from '@kaizoku/core';
+
+configure({
+  proxy: {
+    enabled: true,
+    generateSourceProxies: true // automatically appends anikuro proxy links
+  }
+});
+```
+
+### 2. Querying AniList
+Get trending anime, popular items this season, or details:
+
+```typescript
+import { anilist } from '@kaizoku/core';
+
+// Get trending anime (paginated)
+const trending = await anilist.getTrending(1, 10);
+
+// Get detailed metadata
+const details = await anilist.getAnimeDetail(166240);
+```
+
+### 3. Fetching Episodes by Provider (with AniZip Enrichment)
+Map an AniList ID directly to a provider and retrieve fully enriched episode data:
+
+```typescript
+import { anilist } from '@kaizoku/core';
+
+// Map AniList ID to 'anizone' and get AniZip enriched episodes
+const episodes = await anilist.fetchEpisodesByProvider('166240', 'anizone');
+console.log(episodes[0]);
+/*
+{
+  id: "...",
+  number: 1,
+  title: "...",
+  image: "...", // TVDB Screencap
+  airDate: "...",
+  duration: 1500, // Enriched in seconds
+  description: "...",
+  providerName: "anizone"
+}
+*/
+```
+
+### 4. Fetching Episode Streams (with AniSkip)
+Retrieve video stream URLs for a provider's episode. The response is automatically normalized to a unified `VideoStream` interface:
+
+```typescript
+import { animesaturn } from '@kaizoku/core/providers/animesaturn'; // or from index/exports
+
+// Fetch sources and apply AniSkip skip times
+const malId = 55701;
+const episodeNumber = 1;
+const stream = await animesaturn.fetchSources('episode-id', 'sub', 'server-name');
+
+// If you want AniSkip boundary ranges, they will be attached as:
+// stream.intro -> { start: 2633, end: 2723 }
+// stream.outro -> { start: 1328, end: 1418 }
+```
+
+## Build & Test
+
+To build the project:
+```bash
+pnpm run build
+```
+
+To run the Vitest test suite:
+```bash
+pnpm run test
+```
+
+## Documentation
+
+Full documentation, guides, and API references are available on [docs.kaizoku.site](https://docs.kaizoku.site) (coming soon!).

package/dist/extractors/kwik.d.ts

@@ -0,0 +1,6 @@
+import { VideoStream } from "../types/types.js";
+/**
+ * Kwik.cx — AnimePahe's video host. The stream URL is hidden behind a packed-JS
+ * script; once unpacked, it's a `const source = '....m3u8'` literal.
+ */
+export declare function extractKwik(streamUrl: string): Promise<VideoStream>;

package/dist/extractors/kwik.js

@@ -0,0 +1,33 @@
+import { load } from "cheerio";
+import { getText } from "../utils/http.js";
+import { unpackJs } from "../utils/unpack.js";
+import { encodeAnikuro } from "../utils/proxy.js";
+import { getVideoType } from "../utils/shared.js";
+const REFERER = "https://animepahe.pw/";
+/**
+ * Kwik.cx — AnimePahe's video host. The stream URL is hidden behind a packed-JS
+ * script; once unpacked, it's a `const source = '....m3u8'` literal.
+ */
+export async function extractKwik(streamUrl) {
+    const html = await getText(streamUrl, { Referer: REFERER });
+    const $ = load(html);
+    let streamLink;
+    // Matches the original's behavior exactly: every <script> is checked, and if more
+    // than one happens to match the packed-eval pattern, the last one wins (no early exit).
+    $("script").each((_, el) => {
+        const scriptText = $(el).html() ?? "";
+        if (!/eval\(function\(p,a,c,k,e,d\)/.test(scriptText))
+            return;
+        const unpacked = unpackJs(scriptText);
+        const match = unpacked.match(/const\s+source\s*=\s*'([^']+\.m3u8)'/);
+        streamLink = match?.[1]?.replace(/\{|\}|"|file:/g, "");
+    });
+    if (!streamLink)
+        throw new Error("Kwik: unable to extract stream URL");
+    const proxiedUrl = encodeAnikuro(streamLink, "https://kwik.cx/");
+    return {
+        sources: [{ url: streamLink, isM3U8: true, quality: "single", proxiedUrl, type: getVideoType(streamLink) }],
+        subtitles: [],
+        headers: { Referer: "https://kwik.cx/" },
+    };
+}

package/dist/extractors/megaplay.d.ts

@@ -0,0 +1,2 @@
+import type { VideoStream } from "../types/types.js";
+export declare function extractMegaPlay(videoUrl: URL, referer: string): Promise<VideoStream>;

package/dist/extractors/megaplay.js

@@ -0,0 +1,32 @@
+import { getJson, getText } from "../utils/http.js";
+import { getVideoType, parseEmbedMediaId } from "../utils/shared.js";
+import { encodeAnikuro } from "../utils/proxy.js";
+const BASE_URL = "https://megaplay.buzz/stream";
+export async function extractMegaPlay(videoUrl, referer) {
+    const initialHtml = await getText(videoUrl.href, {
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "X-Requested-With": "XMLHttpRequest",
+        Referer: `${referer}/`,
+    });
+    const id = parseEmbedMediaId(initialHtml);
+    if (!id)
+        throw new Error("MegaPlay: could not resolve media id");
+    const result = await getJson(`${BASE_URL}/getSources?id=${id}&id=${id}`, {
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "X-Requested-With": "XMLHttpRequest",
+        Referer: videoUrl.href,
+    });
+    const fileUrl = result.sources.file;
+    const proxiedUrl = encodeAnikuro(fileUrl, `${videoUrl.origin}/`);
+    return {
+        sources: [{ url: fileUrl, isM3U8: fileUrl.includes("m3u8"), quality: "default", proxiedUrl, type: getVideoType(fileUrl) }],
+        subtitles: (result.tracks ?? []).map((t) => ({
+            url: t.file,
+            lang: t.label,
+            isDefault: t.default,
+        })),
+        intro: result.intro,
+        outro: result.outro,
+        headers: { Referer: `${videoUrl.origin}/` },
+    };
+}

package/dist/extractors/streamwish.d.ts

@@ -0,0 +1,4 @@
+import type { VideoStream } from "../types/types.js";
+export declare function extractStreamWish(streamUrl: string, options?: {
+    headersOverride?: Record<string, string>;
+}): Promise<VideoStream>;

package/dist/extractors/streamwish.js

@@ -0,0 +1,86 @@
+import { load } from "cheerio";
+import { getText } from "../utils/http.js";
+import { unpackJs } from "../utils/unpack.js";
+import { encodeAnikuro } from "../utils/proxy.js";
+function extractEnglishSubtitleLink(tracksBlock) {
+    const match = tracksBlock.match(/\{[^}]*file\s*:\s*"([^"]+)"[^}]*label\s*:\s*"English"[^}]*kind\s*:\s*"captions"/i);
+    return match?.[1];
+}
+/** Some StreamWish variants store the real URL in a separate `var links = {...}` object
+ *  and reference it symbolically (e.g. "links.auto") instead of a literal URL. */
+function extractLinksObject(source) {
+    const match = source.match(/var\s+links\s*=\s*\{([\s\S]*?)\};/);
+    if (!match)
+        return {};
+    const body = match[1];
+    const entries = {};
+    const entryPattern = /"?(\w+)"?\s*:\s*"((?:\\.|[^"\\])*)"/g;
+    let entryMatch;
+    while ((entryMatch = entryPattern.exec(body)) !== null) {
+        entries[entryMatch[1]] = entryMatch[2];
+    }
+    return entries;
+}
+function hasScheme(value) {
+    try {
+        return Boolean(new URL(value).protocol);
+    }
+    catch {
+        return false; // a bare expression like "links.auto" won't parse as an absolute URL
+    }
+}
+export async function extractStreamWish(streamUrl, options = {}) {
+    if (!streamUrl)
+        throw new Error("StreamWish: invalid stream link");
+    const html = await getText(streamUrl);
+    const $ = load(html);
+    let streamLink = "";
+    let unpackedData = "";
+    let subtitleUrl;
+    $("script").each((_, el) => {
+        if (streamLink)
+            return; // already resolved on an earlier script tag
+        const scriptText = $(el).html() ?? "";
+        // Strategy 1: unobfuscated `file: "..."` sitting right in the script.
+        const directFileMatch = scriptText.match(/file:\s*"(.*?)"/);
+        if (directFileMatch) {
+            unpackedData = scriptText;
+            streamLink = directFileMatch[1];
+        }
+        else if (/eval\(function\(p,a,c,k,e,d\)/.test(scriptText)) {
+            // Strategy 2: packed-eval obfuscation — unpack, then pull the sources[] block.
+            const unpacked = unpackJs(scriptText);
+            unpackedData = unpacked;
+            const sourcesMatch = unpacked.match(/sources:\s*\[([\s\S]*?)\]/);
+            streamLink = (sourcesMatch?.[1] ?? "").replace(/\{|\}|"|file:/g, "");
+        }
+        // Regardless of which strategy fired: pull subtitles, and resolve a symbolic
+        // "links.xxx" reference if streamLink isn't a real URL.
+        const tracksMatch = unpackedData.match(/tracks:\[([\s\S]*?)\]/);
+        if (tracksMatch) {
+            subtitleUrl = extractEnglishSubtitleLink(tracksMatch[1]);
+        }
+        if (streamLink && !hasScheme(streamLink)) {
+            const linksTable = extractLinksObject(unpackedData);
+            for (const variable of streamLink.split("||")) {
+                const parts = variable.split(".");
+                if (parts.length === 2 && parts[0].trim() === "links") {
+                    streamLink = linksTable[parts[1].trim()] ?? "";
+                }
+            }
+        }
+    });
+    if (!streamLink)
+        throw new Error("StreamWish: couldn't get any streams");
+    const subtitles = subtitleUrl ? [{ url: subtitleUrl, lang: "English", isDefault: true }] : [];
+    const headers = options.headersOverride ?? {
+        Referer: streamUrl,
+        Origin: `https://${new URL(streamUrl).host}`,
+    };
+    const proxiedUrl = encodeAnikuro(streamLink, streamUrl);
+    return {
+        sources: [{ url: streamLink, isM3U8: streamLink.includes("m3u8"), quality: "multi-quality", proxiedUrl }],
+        subtitles,
+        headers,
+    };
+}

package/dist/extractors/vidtube.d.ts

@@ -0,0 +1,2 @@
+import type { VideoStream } from "../types/types.js";
+export declare function extractVidtube(streamUrl: string): Promise<VideoStream>;

package/dist/extractors/vidtube.js

@@ -0,0 +1,24 @@
+import { load } from "cheerio";
+import { getJson, getText } from "../utils/http.js";
+import { encodeAnikuro } from "../utils/proxy.js";
+export async function extractVidtube(streamUrl) {
+    const html = await getText(streamUrl);
+    const $ = load(html);
+    const id = $("#megaplay-player").attr("data-id");
+    if (!id)
+        throw new Error("Vidtube: failed to extract video id from the page");
+    // The original reads the last URL path segment as a sub/dub "type" flag for the API call.
+    const type = new URL(streamUrl).pathname.split("/").filter(Boolean).pop();
+    const data = await getJson(`https://vidtube.site/stream/getSourcesNew?id=${id}&type=${type}`, { "X-Requested-With": "XMLHttpRequest" });
+    const playlist = data.sources?.file;
+    if (!playlist)
+        throw new Error("Vidtube: no video sources found");
+    const captions = (data.tracks ?? []).filter((t) => t.kind === "captions");
+    const subtitleUrl = captions.find((t) => t.lang?.toLowerCase() === "english")?.file ?? captions.find((t) => t.default)?.file;
+    const proxiedUrl = encodeAnikuro(playlist, "https://vidtube.site/");
+    return {
+        sources: [{ url: playlist, isM3U8: playlist.includes("m3u8"), quality: "multi-quality", proxiedUrl }],
+        subtitles: subtitleUrl ? [{ url: subtitleUrl, lang: "English", isDefault: true }] : [],
+        headers: { Referer: "https://vidtube.site/", Origin: "https://vidtube.site" },
+    };
+}

package/dist/extractors/vidwish.d.ts

@@ -0,0 +1,2 @@
+import type { VideoStream } from "../types/types.js";
+export declare function extractVidWish(videoUrl: URL, referer: string): Promise<VideoStream>;

package/dist/extractors/vidwish.js

@@ -0,0 +1,32 @@
+import { getJson, getText } from "../utils/http.js";
+import { getVideoType, parseEmbedMediaId } from "../utils/shared.js";
+import { encodeAnikuro } from "../utils/proxy.js";
+const BASE_URL = "https://vidwish.live/stream";
+export async function extractVidWish(videoUrl, referer) {
+    const initialUrl = `${videoUrl.href}?autostart=true`;
+    const initialHtml = await getText(initialUrl, {
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        Referer: `${referer}/`,
+    });
+    const id = parseEmbedMediaId(initialHtml);
+    if (!id)
+        throw new Error("VidWish: could not resolve media id");
+    const result = await getJson(`${BASE_URL}/getSources?id=${id}&id=${id}`, {
+        Accept: "application/json, text/javascript, */*; q=0.01",
+        "X-Requested-With": "XMLHttpRequest",
+        Referer: initialUrl,
+    });
+    const fileUrl = result.sources.file;
+    const proxiedUrl = encodeAnikuro(fileUrl, `${videoUrl.origin}/`);
+    return {
+        sources: [{ url: fileUrl, isM3U8: fileUrl.includes("m3u8"), quality: "default", proxiedUrl, type: getVideoType(fileUrl) }],
+        subtitles: (result.tracks ?? []).map((t) => ({
+            url: t.file,
+            lang: t.label,
+            isDefault: t.default,
+        })),
+        intro: result.intro,
+        outro: result.outro,
+        headers: { Referer: `${videoUrl.origin}/` },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./types/types.js";
+export { extractKwik } from "./extractors/kwik.js";
+export { extractStreamWish } from "./extractors/streamwish.js";
+export { extractVidtube } from "./extractors/vidtube.js";
+export { extractMegaPlay } from "./extractors/megaplay.js";
+export { extractVidWish } from "./extractors/vidwish.js";
+export { configure } from "./lib/config.js";
+export * as anilist from "./providers/meta/anilist/anilist.js";
+export * from "./providers/meta/anilist/types.js";
+export * as anikoto from './providers/anime/anikoto.js';
+export * as anizone from './providers/anime/anizone.js';
+export * as animeonsen from './providers/anime/animeonsen.js';
+export * as animeunity from './providers/anime/animeunity.js';
+export * as gojo from './providers/anime/gojo.js';
+export * as animegg from './providers/anime/animegg.js';
+export * as anidb from './providers/anime/anidb.js';
+export * as animesaturn from './providers/anime/animesaturn.js';
+export * as animepahe from './providers/anime/animepahe.js';

package/dist/index.js

@@ -0,0 +1,18 @@
+export * from "./types/types.js";
+export { extractKwik } from "./extractors/kwik.js";
+export { extractStreamWish } from "./extractors/streamwish.js";
+export { extractVidtube } from "./extractors/vidtube.js";
+export { extractMegaPlay } from "./extractors/megaplay.js";
+export { extractVidWish } from "./extractors/vidwish.js";
+export { configure } from "./lib/config.js";
+export * as anilist from "./providers/meta/anilist/anilist.js";
+export * from "./providers/meta/anilist/types.js";
+export * as anikoto from './providers/anime/anikoto.js';
+export * as anizone from './providers/anime/anizone.js';
+export * as animeonsen from './providers/anime/animeonsen.js';
+export * as animeunity from './providers/anime/animeunity.js';
+export * as gojo from './providers/anime/gojo.js';
+export * as animegg from './providers/anime/animegg.js';
+export * as anidb from './providers/anime/anidb.js';
+export * as animesaturn from './providers/anime/animesaturn.js';
+export * as animepahe from './providers/anime/animepahe.js';

package/dist/lib/config.d.ts

@@ -0,0 +1,22 @@
+export interface ProxyConfig {
+    enabled?: boolean;
+    /** Custom proxy URL for the package to route standard requests through */
+    customUrl?: string;
+    /** Whether to append the hardcoded  anikuro. proxies to the video sources */
+    generateSourceProxies?: boolean;
+}
+export interface ConfigOptions {
+    /** Proxy Configuration */
+    proxy?: ProxyConfig;
+    /** Optional custom AniList URL */
+    anilistProxyUrl?: string;
+}
+declare class KaizokuConfig {
+    proxy: ProxyConfig;
+    anilistUrl: string;
+    configure(options: ConfigOptions): void;
+}
+export declare const config: KaizokuConfig;
+/** Global configure function for the Kaizoku package */
+export declare function configure(options: ConfigOptions): void;
+export {};

package/dist/lib/config.js

@@ -0,0 +1,21 @@
+// Global state
+class KaizokuConfig {
+    proxy = {
+        enabled: true,
+        generateSourceProxies: true
+    };
+    anilistUrl = "https://graphql.anilist.co";
+    configure(options) {
+        if (options.anilistProxyUrl) {
+            this.anilistUrl = options.anilistProxyUrl;
+        }
+        if (options.proxy) {
+            this.proxy = { ...this.proxy, ...options.proxy };
+        }
+    }
+}
+export const config = new KaizokuConfig();
+/** Global configure function for the Kaizoku package */
+export function configure(options) {
+    config.configure(options);
+}

package/dist/providers/anime/anidb.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/anidb.js

@@ -0,0 +1,88 @@
+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://anidb.app';
+const HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
+};
+export async function search(query) {
+    const html = await getText(`${BASE_URL}/browse?q=${encodeURIComponent(query)}`, HEADERS);
+    const $ = load(html);
+    const results = [];
+    $('.anime-grid a').each((_, elem) => {
+        const id = $(elem).attr('href')?.split('/').pop();
+        const title = $(elem).find('p').text().trim();
+        const image = $(elem).find('img').attr('src');
+        if (id) {
+            results.push({
+                id,
+                title,
+                image: image || '',
+            });
+        }
+    });
+    return { results };
+}
+export async function fetchAnimeInfo(aliasId) {
+    const id = aliasId.split('-').pop();
+    const res = await httpGet(`${BASE_URL}/api/frontend/anime/${id}/episodes`, HEADERS);
+    const json = await res.json();
+    const info = {
+        id: aliasId,
+        title: '', // Not returned by this endpoint natively
+        episodes: [],
+    };
+    if (!json.episodes)
+        return info;
+    info.episodes = json.episodes.map(ep => ({
+        id: ep.id.toString(),
+        number: parseInt(ep.number, 10),
+        filler: ep.filler ?? false,
+    }));
+    info.totalEpisodes = info.episodes.length;
+    return info;
+}
+export async function fetchEpisodeSources(episodeId, malId, episodeNumber) {
+    const res = await httpGet(`${BASE_URL}/api/frontend/episode/${episodeId}/languages`, HEADERS);
+    const json = await res.json();
+    const stream = { sources: [], subtitles: [] };
+    if (!json.languages)
+        return stream;
+    const promises = json.languages.map(async (lang) => {
+        const embedUrl = lang.embed_url;
+        if (!embedUrl)
+            return;
+        try {
+            const embedHtml = await getText(embedUrl, HEADERS);
+            const $ = load(embedHtml);
+            let foundMatch = false;
+            $('body script').each((_, script) => {
+                if (foundMatch)
+                    return;
+                const scriptContent = $(script).text();
+                const match = scriptContent.match(/file:\s*'([^']+\.m3u8[^']*)'/);
+                if (match && match[1]) {
+                    const quality = lang.name?.toString() || 'default';
+                    const proxiedUrl = encodeAnikuro(match[1], embedUrl);
+                    stream.sources.push({
+                        url: match[1],
+                        quality,
+                        type: getVideoType(match[1]),
+                        isM3U8: true,
+                        proxiedUrl,
+                    });
+                    foundMatch = true;
+                }
+            });
+        }
+        catch (e) {
+            // ignore failing embeds
+            console.log("error in anidb", 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/anikoto.d.ts

@@ -0,0 +1,41 @@
+import { AnimeResult, AnimeInfo, PageResult, VideoStream } from '../../types/types.js';
+type AnikotoServers = 'vidstream-2' | 'vidcloud-1';
+type SubOrDub = 'sub' | 'dub' | 'raw';
+export declare function fetchHome(): Promise<{
+    spotlight: AnimeResult[];
+    recentlyUpdated: AnimeResult[];
+    upcoming: AnimeResult[];
+    sections: {
+        recentlyAdded: AnimeResult[];
+        recentlyReleased: AnimeResult[];
+        recentlyCompleted: AnimeResult[];
+    };
+    topAnime: {
+        day: AnimeResult[];
+        week: AnimeResult[];
+        month: AnimeResult[];
+    };
+}>;
+export declare function fetchSchedule(timezone: number): Promise<{
+    data: any[];
+}>;
+export declare function search(query: string, page?: number): Promise<PageResult<AnimeResult>>;
+export declare function searchSuggestions(query: string): Promise<{
+    data: AnimeResult[];
+}>;
+export declare function fetchAnimeInfo(id: string): Promise<AnimeInfo>;
+export declare function fetchMostPopular(page?: number): Promise<PageResult<AnimeResult>>;
+export declare function fetchRecentlyUpdated(page?: number): Promise<PageResult<AnimeResult>>;
+export declare function fetchRecentlyAdded(page?: number): Promise<PageResult<AnimeResult>>;
+export declare function fetchUpcoming(page?: number): Promise<PageResult<AnimeResult>>;
+export declare function fetchReleasing(page?: number): Promise<PageResult<AnimeResult>>;
+export declare function fetchRecentlyCompleted(page?: number): Promise<PageResult<AnimeResult>>;
+export declare function fetchAtoZList(sort?: string, page?: number): Promise<PageResult<AnimeResult>>;
+export declare function fetchServers(episodeId: string): Promise<{
+    sub: any[];
+    dub: any[];
+    raw: any[];
+    episodeNumber: number;
+}>;
+export declare function fetchSources(episodeId: string, version?: SubOrDub, serverName?: AnikotoServers): Promise<VideoStream>;
+export {};