better-ani-scraped 1.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/DOCUMENTATION.md

@@ -0,0 +1,241 @@
+# Ani-Scraped Documentation
+
+A set of utility functions for scraping anime data from multiple sources (only [anime-sama](https://anime-sama.fr) and [animepahe](https://animepahe.ru) available at the moment). This tool allows you to search for anime, retrieve information, get episodes, and more.
+
+---
+
+## Summary
+- [Main class](#main-class)
+- [`AnimeScrapper("animesama")` methods](#animescrapperanimesama-methods)
+- [`AnimeScrapper("animepahe")` methods](#animescrapperanimepahe-methods)
+- [Functions](#functions)
+
+---
+
+## Main class
+
+### `AnimeScraper(source)`
+Creates a scrapper for the given source (only "animesama" and "animepahe" available at the moment).
+
+---
+
+## `AnimeScrapper("animesama")` methods
+
+- [searchAnime](#searchanimequery-limit--10)
+- [getSeasons](#getseasonsanimeurl-language--vostfr)
+- [getEmbed](#getembedanimeurl-hostpriority--sibnet-vidmoly)
+- [getAnimeInfo](#getanimeinfoanimeurl)
+- [getAvailableLanguages](#getavailablelanguagesseasonurl-wantedlanguages--vostfr-vf-va-vkr-vcn-vqc)
+- [getAllAnime](#getallanimeoutput--anime_listjson-get_seasons--false)
+- [getLatestEpisodes](#getlatestepisodeslanguagefilter--null)
+- [getRandomAnime](#getrandomanime)
+- [getEpisodeTitles](#getepisodetitlesanimeurl)
+
+### `searchAnime(query, limit = 10)`
+Searches for anime titles that match the given query.
+
+- **Parameters:**
+  - `query` *(string)*: The search keyword.
+  - `limit` *(number)*: Maximum number of results to return (default: 10).
+- **Returns:**  
+  An array of anime objects:
+  ```js
+  [
+    {
+      title: string,
+      altTitles: string[],
+      genres: string[],
+      url: string,
+      cover: string
+    },
+    ...
+  ]
+  ```
+
+---
+
+### `getSeasons(animeUrl, language = "vostfr")`
+Fetches all available seasons of an anime in the specified language.
+
+- **Parameters:**
+  - `animeUrl` *(string)*: The full URL of the anime.
+  - `language` *(string)*: Language to filter by (default: "vostfr").
+- **Returns:**  
+  Either an array of season objects:
+  ```js
+  [
+    { 
+      title: string, 
+      url: string 
+    },
+    ...
+  ]
+  ```
+  Or an error object if the language is not available.
+
+---
+
+### `getEmbed(animeUrl, hostPriority = ["sibnet", "vidmoly"])`
+Retrieves embed URLs for episodes, prioritizing by host.
+
+- **Parameters:**
+  - `animeUrl` *(string)*: URL of the anime’s season/episode page.
+  - `hostPriority` *(string[])*: Array of preferred hostnames.
+- **Returns:**  
+  An array of embed video:
+  ```js
+  {
+    title: string,
+    url: string,
+  }
+  ```
+---
+
+### `getAnimeInfo(animeUrl)`
+Extracts basic information from an anime page.
+
+- **Parameters:**
+  - `animeUrl` *(string)*: The URL of the anime.
+- **Returns:**  
+  An object containing:
+  ```js
+  {
+    title: string,
+    altTitles: string[],
+    cover: string,
+    genres: string[],
+    synopsis: string
+  }
+  ```
+
+---
+
+### `getAvailableLanguages(seasonUrl, wantedLanguages = ["vostfr", "vf", "va", "vkr", "vcn", "vqc"])`
+Checks which languages are available for a given anime season (not recommended to use the default value of wantedLanguages, the more languages there is the more the function is long to run, only checks for languages you want).
+
+- **Parameters:**
+  - `seasonUrl` *(string)*: The season anime URL.
+  - `wantedLanguages` *(string[])*: Language codes to check (e.g., ["vostfr", "vf", "va", ...]).
+- **Returns:**  
+  Array of objects containing available languages and their episode count:
+  ```js
+  [
+    {
+      language: string,
+      episodeCount: int
+    }
+    ...
+  ]
+  ```
+
+---
+
+### `getAllAnime(output = "anime_list.json", get_seasons = false)`
+Fetches the full anime catalog, optionally including season information.
+
+- **Parameters:**
+  - `output` *(string)*: File name to save the result as JSON.
+  - `get_seasons` *(boolean)*: If `true`, also fetches seasons for each anime (very slow, ETA is still unknown).
+- **Returns:**  
+  `true` if successful, `false` otherwise.
+
+---
+
+### `getLatestEpisodes(languageFilter = null)`
+Scrapes the latest released episodes, optionally filtered by language.
+
+- **Parameters:**
+  - `languageFilter` *(string[]|null)*: If set, filters episodes by language in the array. If null, returns all episodes. 
+- **Returns:**  
+  Array of episode objects:
+  ```js
+  {
+    title: string,
+    url: string,
+    cover: string,
+    language: string,
+    episode: string
+  }
+  ```
+
+---
+
+### `getRandomAnime()`
+Fetches a random anime from the catalogue.
+
+- **Returns:**  
+  An anime object:
+  ```js
+  {
+    title: string,
+    altTitles: string[],
+    genres: string[],
+    url: string,
+    cover: string
+  }
+  ```
+
+---
+
+### `getEpisodeTitles(AnimeUrl)`
+Fetches the names of all episodes in a season
+
+- **Parameters:**
+  - `animeUrl` *(string)*: URL of the anime’s season/episode page.
+- **Returns:**  
+  An array of episode titles.
+
+---
+
+## `AnimeScrapper("animepahe")` methods
+
+- [searchAnime](#searchanimequery)
+
+
+### `searchAnime(query)`
+Searches for anime titles that match the given query.
+
+- **Parameters:**
+  - `query` *(string)*: The search keyword.
+- **Returns:**  
+  An array of anime objects:
+  ```js
+  [
+    {
+      id: int,
+      title: string,
+      type: string,
+      episodes: int,
+      status: string,
+      season: string,
+      year: int,
+      score: float,
+      session: string,
+      cover: string,
+      url: string
+    },
+    ...
+  ]
+  ```
+
+---
+
+## Functions
+
+- [getVideoUrlFromEmbed](#getvideourlfromembedsource-embedurl)
+
+### `getVideoUrlFromEmbed(source, embedUrl)`
+Retrieves the video URL of the source's embed.
+
+- **Parameters:**
+  - `source` *(string)*: The embed source (only "sibnet" available at the moment)
+  - `embedUrl` *(string)*: The embed url of the given source.
+- **Returns:**  
+  A video URL as a string.
+
+---
+---
+---
+---
+
+> ⚠️ This project scrapes data from online sources. Use at your own risk.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 rgpegasus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+<h1 align="center">
+Better-Ani-Scraped
+</h1>
+<p align="center">
+A set of utility functions for scraping anime data from multiple sources. This tool allows you to search for anime, retrieve information, get episodes, and more.
+<p>
+<p align="center">
+  <a href="https://www.npmjs.com/package/ani-scraped"><img src="https://img.shields.io/npm/v/ani-scraped"></a>
+  <a href="https://www.npmjs.com/package/ani-scraped"><img src="https://img.shields.io/npm/dw/ani-scraped"></a>
+<p>
+
+<p align="center">
+  <a href="#installation">Installation</a> | <a href="#example-usage">Example Usage</a> | <a href="#documentation">Documentation</a> | <a href="#license">License</a> | <a href="#legal-disclaimer">Legal Disclaimer</a>
+</p>
+
+
+## Installation
+See [Legal Disclaimer](#legal-disclaimer).
+```
+npm install better-ani-scraped@latest
+```
+
+## Example Usage
+View files in the [examples](https://github.com/rgpegasus/better-ani-scraped/tree/main/examples) folder.
+
+## Documentation
+Full API reference available in the [documentation](DOCUMENTATION.md) file.
+
+## License
+This package is under the [MIT license](LICENSE).
+
+## Legal Disclaimer
+This package is intended for **educational purposes only**. Scraping content from websites such as Animesama and Animepahe may be a violation of their terms of service, intellectual property rights, or other applicable laws. By using this package, you acknowledge that you are solely responsible for ensuring that your use complies with all relevant laws and regulations, including but not limited to:
+- The Terms of Service of the websites being scraped
+- Copyright laws regarding the content on the websites
+- Any other applicable laws or regulations in your country or jurisdiction
+
+The author of this package assumes **no responsibility for any legal issues**, damages, or consequences arising from the use of this package.
+
+Please make sure you review the websites' terms of service and obtain permission from the website owners if necessary before using this package. If in doubt, consult with a legal professional regarding the legality of web scraping in your jurisdiction.
+
+## TODO
+- Implement more animepahe methods
+
+
+
+### Special thanks to
+- [Hxpe Dev](https://github.com/hxpe_dev)

package/examples/example_usage_01.js

@@ -0,0 +1,23 @@
+import { AnimeScraper, getVideoUrlFromEmbed } from "../index.js"; // REPLACE BY "from 'better-ani-scraped';"
+
+const main = async () => {
+  const scraper = new AnimeScraper('animesama');
+
+  const search = await scraper.searchAnime("frieren");
+  console.log("Search Results:", search);
+
+  const animeUrl = Object.values(search)[0].url;
+  const seasons = await scraper.getSeasons(animeUrl, "vostfr");
+  console.log("Seasons:", seasons);
+
+  const embeds = await scraper.getEmbed(seasons[0].url, [
+    "sibnet",
+    "vidmoly",
+  ]);
+  console.log("Embed Links:", embeds);
+
+  const videoUrl = await getVideoUrlFromEmbed("sibnet", embeds[11])
+  console.log("Video URL:", videoUrl);
+};
+
+main().catch(console.error);

package/examples/example_usage_02.js

@@ -0,0 +1,14 @@
+import { AnimeScraper } from "../index.js"; // REPLACE BY "from 'better-ani-scraped';"
+
+const main = async () => {
+  const scraper = new AnimeScraper('animesama');
+
+  const animeUrl = "https://anime-sama.fr/catalogue/sword-art-online";
+  const animeInfo = await scraper.getAnimeInfo(animeUrl);
+  console.log(animeInfo);
+
+  const animeLanguages = await scraper.getAvailableLanguages(`${animeUrl}/saison1/vostfr`, ["vostfr", "vf"]);
+  console.log(animeLanguages);
+};
+
+main().catch(console.error);

package/examples/example_usage_03.js

@@ -0,0 +1,9 @@
+import { AnimeScraper } from "../index.js"; // REPLACE BY "from 'better-ani-scraped';"
+
+const main = async () => {
+  const scraper = new AnimeScraper('animesama');
+
+  await scraper.getAllAnime("output_anime_list.json", false);
+};
+
+main().catch(console.error);

package/examples/example_usage_04.js

@@ -0,0 +1,13 @@
+import { AnimeScraper } from "../index.js"; // REPLACE BY "from 'better-ani-scraped';"
+
+const main = async () => {
+  const scraper = new AnimeScraper('animesama');
+
+  const new_episodes = await scraper.getLatestEpisodes(["vostfr", "vf"]);
+  console.log(new_episodes);
+
+  const random_episode = await scraper.getRandomAnime();
+  console.log(random_episode);
+};
+
+main().catch(console.error);

package/index.js

@@ -0,0 +1,7 @@
+import { getVideoUrlFromEmbed } from "./utils/dispatcher.js";
+import { AnimeScraper } from "./scrapers/scrapers.js";
+
+export {
+  AnimeScraper,
+  getVideoUrlFromEmbed,
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "better-ani-scraped",
+  "version": "1.0.0",
+  "description": "Scrape anime data from different sources (only anime-sama.fr for the moment)",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "anime",
+    "scraper",
+    "anime-sama",
+    "ani-scraped",
+    "better-ani-scraped"
+  ],
+  "author": "rgpegasus",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "axios": "^1.8.4",
+    "cheerio": "^1.0.0",
+    "puppeteer": "^24.6.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rgpegasus/better-ani-scraped"
+  }
+}

package/scrapers/animepahe.js

@@ -0,0 +1,31 @@
+import puppeteer from "puppeteer";
+
+const BASE_URL = "https://animepahe.ru";
+
+export async function searchAnime(query) {
+  const browser = await puppeteer.launch({ headless: true });
+  const page = await browser.newPage();
+  
+  // Go to any page, we need to load a page to enable network interception
+  await page.goto(BASE_URL);
+
+  // Intercept the API request using Puppeteer
+  const searchResults = await page.evaluate(async (query) => {
+    const response = await fetch(`https://animepahe.ru/api?m=search&q=${query}`);
+    const data = await response.json();
+
+    // Map over the data, rename 'poster' to 'cover', and remove 'poster' field
+    return data.data.map(anime => {
+      const { poster, ...rest } = anime;  // Destructure 'poster' and keep the rest of the properties
+      return {
+        ...rest,
+        cover: poster,
+        url: `https://animepahe.ru/anime/${anime.session}`
+      };
+    });
+  }, query);
+
+  await browser.close();
+
+  return searchResults;
+}

package/scrapers/animesama.js

@@ -0,0 +1,431 @@
+import axios from "axios";
+import * as cheerio from "cheerio";
+import fs from "fs";
+import puppeteer from'puppeteer';
+
+const BASE_URL = "https://anime-sama.fr";
+const CATALOGUE_URL = `${BASE_URL}/catalogue`;
+
+function getHeaders(referer = BASE_URL) {
+  return {
+    "User-Agent": "Mozilla/5.0",
+    "Accept-Language": "fr-FR,fr;q=0.9,en;q=0.8",
+    Referer: referer,
+  };
+}
+
+export async function searchAnime(query, limit = 10) {
+  const url = `${CATALOGUE_URL}/?type%5B%5D=Anime&search=${encodeURIComponent(
+    query
+  )}`;
+  const res = await axios.get(url, { headers: getHeaders(CATALOGUE_URL) });
+  const $ = cheerio.load(res.data);
+  const results = [];
+
+  $("a.flex.divide-x").each((i, el) => {
+    if (i >= limit) return false;
+
+    const anchor = $(el);
+    const link = anchor.attr("href");
+    const title = anchor.find("h1").first().text().trim();
+    const altRaw = anchor
+      .find("p.text-xs.opacity-40.italic")
+      .first()
+      .text()
+      .trim();
+    const cover = anchor.find("img").first().attr("src");
+
+    const altTitles = altRaw
+      ? altRaw
+          .split(",")
+          .map((t) => t.trim())
+          .filter(Boolean)
+      : [];
+
+    const genreRaw = anchor
+      .find("p.text-xs.font-medium.text-gray-300")
+      .first()
+      .text()
+      .trim();
+    const genres = genreRaw
+      ? genreRaw
+          .split(",")
+          .map((g) => g.trim())
+          .filter(Boolean)
+      : [];
+
+    if (title && link) {
+      results.push({
+        title,
+        altTitles,
+        genres,
+        url: link.startsWith("http") ? link : `${CATALOGUE_URL}${link}`,
+        cover,
+      });
+    }
+  });
+
+  return results;
+}
+
+export async function getSeasons(animeUrl, language = "vostfr") {
+  const res = await axios.get(animeUrl, { headers: getHeaders(CATALOGUE_URL) });
+  const html = res.data;
+
+  // Only keep the part before the Kai section
+  const mainAnimeOnly = html.split("Anime Version Kai")[0];
+
+  const $ = cheerio.load(mainAnimeOnly);
+  const scriptTags = $("script")
+    .toArray()
+    .filter((script) => {
+      return $(script).html().includes("panneauAnime");
+    });
+
+  const animeName = animeUrl.split("/")[4];
+  const seasons = [];
+  let languageAvailable = false;
+
+  for (let script of scriptTags) {
+    const content = $(script).html();
+
+    // Remove anything inside comments either ("/* */" or "//")
+    const uncommentedContent = content
+      .replace(/\/\*[\s\S]*?\*\//g, "")
+      .replace(/\/\/.*$/gm, "");
+
+    const matches = [
+      ...uncommentedContent.matchAll(/panneauAnime\("([^"]+)", "([^"]+)"\);/g),
+    ];
+
+    for (let match of matches) {
+      const title = match[1];
+      const href = match[2].split("/")[0];
+      const fullUrl = `${CATALOGUE_URL}/${animeName}/${href}/${language}`;
+
+      try {
+        const check = await axios.head(fullUrl, {
+          headers: getHeaders(animeUrl),
+        });
+        if (check.status === 200) {
+          languageAvailable = true;
+          seasons.push({ title, url: fullUrl });
+        }
+      } catch (err) {
+        // Ignore missing URLs
+      }
+    }
+  }
+
+  if (!languageAvailable) {
+    return { error: `Language "${language}" is not available for this anime.` };
+  }
+
+  return seasons;
+}
+
+async function getEpisodeTitles(animeUrl) {
+    let browser;
+    try {
+        browser = await puppeteer.launch({
+            headless: true, 
+            args: ['--no-sandbox', '--disable-setuid-sandbox']
+        });
+        const page = await browser.newPage();
+        await page.setRequestInterception(true);
+        page.on('request', (req) => {
+            const blocked = ['image', 'stylesheet', 'font', 'media'];
+            if (blocked.includes(req.resourceType())) {
+                req.abort();
+            } else {
+                req.continue();
+            }
+        });
+        await page.goto(animeUrl, { waitUntil: 'domcontentloaded' });
+        await page.waitForSelector('#selectEpisodes');
+        // Récupération des titres d'épisodes
+        const titres = await page.$$eval('#selectEpisodes option', options =>
+            options.map(o => o.textContent.trim())
+        );
+        return titres;
+    } catch (error) {
+        console.error('Erreur dans la récupération des titres:', error);
+        return [];
+    } finally {
+        if (browser) await browser.close();  
+    }
+}
+
+export async function getEmbed(animeUrl, hostPriority = ["sibnet", "vidmoly"]) {
+    let res, episodesJs;
+    try {
+        res = await axios.get(animeUrl, {
+            headers: getHeaders(animeUrl.split("/").slice(0, 5).join("/")),
+        });
+
+        const $ = cheerio.load(res.data);
+        const scriptTag = $('script[src*="episodes.js"]').attr("src");
+
+        if (!scriptTag) throw new Error("No episodes script found");
+        const scriptUrl = animeUrl.endsWith("/") ? animeUrl + scriptTag : animeUrl + "/" + scriptTag;
+    
+        episodesJs = await axios.get(scriptUrl, { headers: getHeaders(animeUrl) }).then(r => r.data);
+
+        const match = episodesJs.match(/var\s+eps\d+\s*=\s*(\[[^\]]+\])/);
+        if (!match) throw new Error("No episode array found");
+
+        const arrayString = match[1];
+        let links = [];
+
+        try {
+            links = eval(arrayString); 
+        } catch (e) {
+            console.warn("Could not parse episode links array:", e);
+        }
+        const titles = await getEpisodeTitles(animeUrl);
+
+        const results = titles.slice(0, links.length).map((title, i) => ({
+            title,
+            url: [links[i]]
+        }));
+        for (const host of hostPriority) {
+            const filtered = results.filter(ep =>
+                ep.url.some(link => link.includes(host))
+            );
+            if (filtered.length) return filtered;
+        }
+        return results;
+    } catch (error) {
+        console.error('Erreur lors de la récupération des données d\'épisodes:', error);
+        return [];
+    }
+}
+
+export async function getAnimeInfo(animeUrl) {
+  const res = await axios.get(animeUrl, { headers: getHeaders(CATALOGUE_URL) });
+  const $ = cheerio.load(res.data);
+
+  const cover = $("#coverOeuvre").attr("src");
+  const title = $("#titreOeuvre").text();
+  const altRaw = $("#titreAlter").text();
+  const altTitles = altRaw
+    ? altRaw
+        .split(",")
+        .map((t) => t.trim())
+        .filter(Boolean)
+    : [];
+
+  const genres = $("h2:contains('Genres')")
+    .next("a")
+    .text()
+    .trim()
+    .split(",")
+    .map((genre) => genre.trim());
+
+  const synopsis = $("h2:contains('Synopsis')").next("p").text().trim();
+
+  return {
+    title,
+    altTitles,
+    cover,
+    genres,
+    synopsis,
+  };
+}
+
+export async function getAvailableLanguages(
+  seasonUrl,
+  wantedLanguages = ["vostfr", "vf", "va", "vkr", "vcn", "vqc"]
+) {
+  const languageLinks = [];
+
+  // Iterate over each possible language and check if the page exists
+  for (let language of wantedLanguages) {
+    const languageUrl = seasonUrl.replace("vostfr", `${language}`);
+    try {
+      const res = await axios.get(languageUrl, {
+        headers: getHeaders(CATALOGUE_URL),
+      });
+      if (res.status === 200) {
+        const episodeCount = (await getEmbed(languageUrl)).length;
+        languageLinks.push({ language: language.toUpperCase(), episodeCount: episodeCount });
+      }
+    } catch (error) {
+      // If an error occurs (like a 404), we skip that language
+      continue;
+    }
+  }
+
+  return languageLinks;
+}
+
+export async function getAllAnime(
+  output = "anime_list.json",
+  get_seasons = false
+) {
+  // BE CAREFUL, GET_SEASONS TAKES A VERY VERY LONG TIME TO FINISH
+  let animeLinks = [];
+  let page = 1;
+
+  try {
+    while (true) {
+      const url = page === 1 ? CATALOGUE_URL : `${CATALOGUE_URL}?page=${page}`;
+      const res = await axios.get(url, { headers: getHeaders(CATALOGUE_URL) });
+      const $ = cheerio.load(res.data);
+
+      const containers = $("div.shrink-0.m-3.rounded.border-2");
+
+      if (containers.length === 0) {
+        // console.log("No more anime found, stopping.");
+        break;
+      }
+
+      containers.each((_, el) => {
+        const anchor = $(el).find("a");
+        const title = anchor.find("h1").text().trim();
+        const link = anchor.attr("href");
+
+        const tagText = anchor
+          .find("p")
+          .filter((_, p) => $(p).text().includes("Anime"))
+          .first()
+          .text();
+
+        if (title && link && tagText.includes("Anime")) {
+          const fullUrl = link.startsWith("http") ? link : `${BASE_URL}${link}`;
+          animeLinks.push({ title: title, url: fullUrl });
+        }
+      });
+
+      page++;
+      await new Promise((r) => setTimeout(r, 300));
+    }
+
+    // Deduplicate
+    const uniqueLinks = animeLinks.filter(
+      (item, index, self) => index === self.findIndex((i) => i.url === item.url)
+    );
+
+    if (get_seasons) {
+      // console.log("Fetching seasons for each anime...");
+      for (let anime of uniqueLinks) {
+        try {
+          const seasons = await getSeasons(anime.url);
+          anime.seasons = Array.isArray(seasons) ? seasons : [];
+        } catch (err) {
+          console.warn(
+            `⚠️ Failed to fetch seasons for ${anime.name}: ${err.message}`
+          );
+          anime.seasons = [];
+        }
+
+        // Optional delay to avoid rate-limiting
+        await new Promise((r) => setTimeout(r, 300));
+      }
+    }
+
+    fs.writeFileSync(output, JSON.stringify(uniqueLinks, null, 2), "utf-8");
+    return true;
+  } catch (err) {
+    console.error("Error occurred:", err.message);
+    return false;
+  }
+}
+
+export async function getLatestEpisodes(languageFilter = null) {
+  try {
+    const res = await axios.get(BASE_URL, { headers: getHeaders() });
+    const $ = cheerio.load(res.data);
+
+    const container = $("#containerAjoutsAnimes");
+    const episodes = [];
+
+    container.find("a").each((_, el) => {
+      const link = $(el).attr("href");
+      const title = $(el).find("h1").text().trim();
+      const cover = $(el).find("img").attr("src");
+
+      const buttons = $(el).find("button");
+      const language = $(buttons[0]).text().trim().toLowerCase(); // Normalisation
+      const episode = $(buttons[1]).text().trim();
+
+      if (
+        title &&
+        link &&
+        cover &&
+        language &&
+        episode &&
+        (languageFilter === null || languageFilter.map(l => l.toLowerCase()).includes(language.toLowerCase()))
+      ) {
+        episodes.push({
+          title: title,
+          url: link,
+          cover,
+          language,
+          episode,
+        });
+      }
+    });
+
+    return episodes;
+  } catch (err) {
+    console.error("Failed to fetch today episodes:", err.message);
+    return [];
+  }
+}
+
+export async function getRandomAnime() {
+  try {
+    const res = await axios.get(
+      `${CATALOGUE_URL}/?type[]=Anime&search=&random=1`,
+      { headers: getHeaders(CATALOGUE_URL) }
+    );
+    const $ = cheerio.load(res.data);
+
+    const container = $("div.shrink-0.m-3.rounded.border-2").first();
+    const anchor = container.find("a");
+    const link = anchor.attr("href");
+    const title = anchor.find("h1").first().text().trim();
+    const altRaw = anchor
+      .find("p.text-xs.opacity-40.italic")
+      .first()
+      .text()
+      .trim();
+    const cover = anchor.find("img").first().attr("src");
+
+    const altTitles = altRaw
+      ? altRaw
+          .split(",")
+          .map((t) => t.trim())
+          .filter(Boolean)
+      : [];
+
+    const genreRaw = anchor
+      .find("p.text-xs.font-medium.text-gray-300")
+      .first()
+      .text()
+      .trim();
+
+    const genres = genreRaw
+      ? genreRaw
+          .split(",")
+          .map((g) => g.trim())
+          .filter(Boolean)
+      : [];
+
+    if (title && link) {
+      return {
+        title,
+        altTitles,
+        genres,
+        url: link.startsWith("http") ? link : `${CATALOGUE_URL}${link}`,
+        cover,
+      };
+    } else {
+      throw new Error("No anime found in random response.");
+    }
+  } catch (err) {
+    console.error("Failed to fetch random anime:", err.message);
+    return null;
+  }
+}

package/scrapers/scrapers.js

@@ -0,0 +1,86 @@
+import * as animesama from "./animesama.js";
+import * as animepahe from "./animepahe.js";
+
+export class AnimeScraper {
+  constructor(source) {
+    if (source === 'animepahe') {
+      this.source = animepahe;
+    } else if (source === 'animesama') {
+      this.source = animesama;
+    } else {
+      throw new Error('Invalid source. Choose either "animepahe" or "animesama".');
+    }
+  }
+
+  async searchAnime(query, ...rest) {
+    try {
+      return await this.source.searchAnime(query, ...rest);
+    } catch (error) {
+      console.error(`This scraper does not have the searchAnime function implemented or an error happened -> ${error}`);
+      return null;
+    }
+  }
+
+  async getSeasons(animeUrl, ...rest) {
+    try {
+      return await this.source.getSeasons(animeUrl, ...rest);
+    } catch (error) {
+      console.error(`This scraper does not have the getSeasons function implemented or an error happened -> ${error}`);
+      return null;
+    }
+  }
+
+  async getEmbed(animeUrl, ...rest) {
+    try {
+      return await this.source.getEmbed(animeUrl, ...rest);
+    } catch (error) {
+      console.error(`This scraper does not have the getEmbed function implemented or an error happened -> ${error}`);
+      return null;
+    }
+  }
+
+  async getAnimeInfo(animeUrl) {
+    try {
+      return await this.source.getAnimeInfo(animeUrl);
+    } catch (error) {
+      console.error(`This scraper does not have the getAnimeInfo function implemented or an error happened -> ${error}`);
+      return null;
+    }
+  }
+
+  async getAvailableLanguages(animeUrl, ...rest) {
+    try {
+      return await this.source.getAvailableLanguages(animeUrl, ...rest);
+    } catch (error) {
+      console.error(`This scraper does not have the getAvailableLanguages function implemented or an error happened -> ${error}`);
+      return null;
+    }
+  }
+
+  async getAllAnime(...rest) {
+    try {
+      return await this.source.getAllAnime(...rest);
+    } catch (error) {
+      console.error(`This scraper does not have the getAllAnime function implemented or an error happened -> ${error}`);
+      return null;
+    }
+  }
+
+  async getLatestEpisodes(...rest) {
+    try {
+      return await this.source.getLatestEpisodes(...rest);
+    } catch (error) {
+      console.error(`This scraper does not have the getLatestEpisodes function implemented or an error happened -> ${error}`);
+      return null;
+    }
+  }
+
+  async getRandomAnime() {
+    try {
+      return await this.source.getRandomAnime();
+    } catch (error) {
+      console.error(`This scraper does not have the getRandomAnime function implemented or an error happened -> ${error}`);
+      return null;
+    }
+  }
+}

package/utils/dispatcher.js

@@ -0,0 +1,9 @@
+import * as extractor from "./extractVideoUrl.js";
+
+export async function getVideoUrlFromEmbed(source, embedUrl) {
+  if (source === "sibnet") {
+    return await extractor.getSibnetVideo(embedUrl);
+  }
+
+  throw new Error(`Unsupported embed source: ${source}`);
+}

package/utils/extractVideoUrl.js

@@ -0,0 +1,67 @@
+import axios from "axios";
+import * as cheerio from "cheerio";
+
+export async function getSibnetVideo(embedUrl) {
+  let intermediaries = [];
+  let realUrl = "";
+
+  const getIntermediary = async () => {
+    try {
+      const { data } = await axios.get(embedUrl, { headers: getHeaders(embedUrl) });
+      const $ = cheerio.load(data);
+      const script = $("script")
+        .toArray()
+        .map((s) => $(s).html())
+        .find((s) => s.includes("player.src"));
+      const match = script?.match(/player\.src\(\[{src:\s*["']([^"']+)["']/);
+      if (match) intermediaries.push(`https://video.sibnet.ru${match[1]}`);
+      return !!match;
+    } catch {
+      return false;
+    }
+  };
+
+  const followRedirection = async () => {
+    if (!intermediaries.length) return false;
+    try {
+      const first = await axios.get(intermediaries[0], {
+        headers: getHeaders(embedUrl),
+        maxRedirects: 0,
+        validateStatus: (s) => s >= 200 && s < 303,
+      });
+
+      const redirect1 = correct(first.headers.location);
+      intermediaries.push(redirect1);
+
+      const second = await axios.get(redirect1, {
+        headers: getHeaders(intermediaries[0]),
+        maxRedirects: 0,
+        validateStatus: (s) => s >= 200 && s < 303,
+      });
+
+      realUrl =
+        second.status === 302
+          ? correct(second.headers.location)
+          : second.status === 200
+          ? intermediaries.pop()
+          : "";
+      return !!realUrl;
+    } catch {
+      return false;
+    }
+  };
+
+  const correct = (url) => (url.startsWith("https:") ? url : `https:${url}`);
+
+  const getHeaders = (referer) => ({
+    Accept: "*/*",
+    Referer: referer,
+    Range: "bytes=0-",
+    "User-Agent":
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  });
+
+  return (await getIntermediary()) && (await followRedirection())
+    ? realUrl
+    : null;
+}