@gxaym1/anime 1.0.0

package/README.md

@@ -0,0 +1,186 @@
+# @gxaym1/anime
+
+Orx Scraper — **topcinemaa.cam** anime scraper.  
+Browse, search, get details, extract download links by quality, and resolve VidTube direct `.mp4` URLs.  
+Pure ESM, plain JavaScript, no build step.
+
+## Install
+
+```bash
+npm install @gxaym1/anime
+```
+
+## Quick start
+
+```js
+import Anime from "@gxaym1/anime";
+
+// 1. Browse anime category (paginated)
+const page1 = await Anime.browse({ page: 1 });
+console.log(page1.results);   // [{ title, url, thumbnail, quality, genre, rating }, ...]
+console.log(page1.hasNext);   // true/false
+
+// 2. Search
+const results = await Anime.search("dragon ball");
+console.log(results.results);
+
+// 3. Details of a post
+const film = await Anime.details("https://topcinemaa.cam/film-slug/");
+console.log(film.title, film.story, film.genres, film.year);
+
+// 4. Download links (per quality + VidTube multi-quality link)
+const dl = await Anime.downloadFromPost("https://topcinemaa.cam/film-slug/");
+console.log(dl.vidtube);       // "https://down.vidtube.one/d/XXXXX.html"
+console.log(dl.byQuality);     // { "1080p": [{ server:"UpDown", url:"..." }, ...] }
+console.log(dl.all);           // flat array
+
+// 5. Resolve VidTube direct .mp4 links with quality labels
+const vt = await Anime.vidtube(dl.vidtube);
+console.log(vt.links);         // [{ quality:"1080p", url:"https://...mp4", type:"video/mp4" }, ...]
+
+// 6. All-in-one (details + download + vidtube) in one call
+const full = await Anime.getAll("https://topcinemaa.cam/film-slug/");
+console.log(full.details.title);
+console.log(full.download.byQuality);
+console.log(full.vidtube?.links);
+```
+
+## Named imports
+
+```js
+import { browse, search, details, download, downloadFromPost, vidtubeLinks } from "@gxaym1/anime";
+```
+
+## Sub-path imports
+
+```js
+import { browse }           from "@gxaym1/anime/browse";
+import { search }           from "@gxaym1/anime/search";
+import { details }          from "@gxaym1/anime/details";
+import { download, downloadFromPost } from "@gxaym1/anime/download";
+import { vidtubeLinks }     from "@gxaym1/anime/vidtube";
+```
+
+---
+
+## API
+
+### `browse(options?)`
+
+Browse the anime category: `https://topcinemaa.cam/category/افلام-انمي-2/`
+
+| Option | Type | Default |
+|---|---|---|
+| page | number | 1 |
+| timeout | number | 30000 |
+| headers | object | — |
+| proxy | string | — |
+
+**Returns:**
+```js
+{ results: AnimeCard[], page: number, hasNext: boolean }
+```
+
+---
+
+### `search(query, options?)`
+
+Full-text search on topcinemaa.cam.
+
+**Returns:**
+```js
+{ query: string, results: AnimeCard[], page: number, hasNext: boolean }
+```
+
+---
+
+### `details(postUrl, options?)`
+
+Get full info from the anime post page.
+
+**Returns:**
+```js
+{
+  title:        string,
+  url:          string,
+  thumbnail?:   string,
+  story?:       string,      // Arabic plot summary
+  quality?:     string,      // e.g. "1080p WEB-DL"
+  genres:       string[],
+  year?:        string,
+  duration?:    string,
+  language?:    string,
+  rating?:      string,
+  watchUrl?:    string,      // /watch/ page
+  downloadUrl?: string       // /download/ page
+}
+```
+
+---
+
+### `download(downloadPageUrl, options?)`
+
+Scrape a `/download/` page for all download links.
+
+**Returns:**
+```js
+{
+  vidtube?:  string,                              // VidTube multi-quality URL
+  byQuality: Record<string, { server, url }[]>,  // e.g. { "1080p": [...] }
+  all:       { quality, server, url }[]           // flat list
+}
+```
+
+---
+
+### `downloadFromPost(postUrl, options?)`
+
+Same as `download()` but auto-appends `/download/` to the post URL.
+
+---
+
+### `vidtubeLinks(vidtubeUrl, options?)`
+
+Resolve a VidTube URL into direct per-quality `.mp4` links.
+
+Accepts `down.vidtube.one/d/ID.html` or `down.vidtube.one/embed-ID.html`.
+
+**Returns:**
+```js
+{
+  sourceUrl:    string,
+  downloadUrl?: string,
+  embedUrl?:    string,
+  links: [{ quality: "1080p", url: "https://...mp4", type: "video/mp4" }, ...]
+}
+```
+
+---
+
+### `getAll(postUrl, options?)`
+
+One-shot call that runs `details` + `downloadFromPost` + `vidtubeLinks` in sequence.
+
+**Returns:**
+```js
+{ details: AnimeDetails, download: DownloadResult, vidtube?: VidTubeResult }
+```
+
+---
+
+## Data shapes
+
+```js
+// AnimeCard (from browse/search)
+{ title, url, thumbnail?, quality?, genre?, rating? }
+
+// DownloadLink
+{ server: "UpDown", url: "https://updown.cam/..." }
+
+// VidTubeLink
+{ quality: "1080p", url: "https://...mp4", type: "video/mp4" }
+```
+
+## License
+
+MIT © gxaym1

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@gxaym1/anime",
+  "version": "1.0.0",
+  "description": "Orx Scraper — topcinemaa.cam anime scraper: browse, search, details, download links with qualities, and VidTube direct link resolver.",
+  "author": "gxaym1",
+  "license": "MIT",
+  "type": "module",
+  "main": "./src/index.js",
+  "module": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./browse": "./src/scrapers/browse.js",
+    "./search": "./src/scrapers/search.js",
+    "./details": "./src/scrapers/details.js",
+    "./download": "./src/scrapers/download.js",
+    "./vidtube": "./src/scrapers/vidtube.js",
+    "./utils/http": "./src/utils/http.js",
+    "./utils/parser": "./src/utils/parser.js"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "scraper",
+    "orx",
+    "anime",
+    "topcinemaa",
+    "vidtube",
+    "download",
+    "esm"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.7.2",
+    "cheerio": "^1.0.0"
+  }
+}

package/src/api.js

@@ -0,0 +1,75 @@
+import axios from "axios";
+
+const WP_API      = "https://topcinemaa.cam/wp-json/wp/v2";
+const ANIME_CAT   = 5;  // افلام انمي — category ID confirmed from /wp-json/wp/v2/categories
+const EMBED_PARAM = "_embed=wp:featuredmedia,wp:term";
+const BASE_FIELDS = "id,date,slug,link,title,excerpt,featured_media,categories,tags";
+
+const DEFAULT_HEADERS = {
+  "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+  Accept:       "application/json",
+};
+
+/**
+ * Raw GET against the WP REST API.
+ * @param {string} path
+ * @param {Record<string,string|number>} params
+ * @param {object} [options]
+ * @returns {Promise<{ data: any[], total: number, totalPages: number }>}
+ */
+export async function wpGet(path, params = {}, options = {}) {
+  const url = `${WP_API}${path}`;
+  const res = await axios.get(url, {
+    params,
+    timeout: options.timeout ?? 20000,
+    headers: { ...DEFAULT_HEADERS, ...(options.headers ?? {}) },
+    ...(options.proxy
+      ? (() => { const u = new URL(options.proxy); return { proxy: { host: u.hostname, port: Number(u.port), protocol: u.protocol.replace(":", "") } }; })()
+      : {}),
+  });
+
+  return {
+    data:       res.data,
+    total:      Number(res.headers["x-wp-total"]      ?? 0),
+    totalPages: Number(res.headers["x-wp-totalpages"] ?? 1),
+  };
+}
+
+/**
+ * Convert a raw WP post object into a clean AnimeCard.
+ * @param {object} post
+ * @returns {AnimeCard}
+ *
+ * @typedef {{
+ *   id:          number,
+ *   title:       string,
+ *   url:         string,
+ *   date:        string,
+ *   thumbnail?:  string,
+ *   excerpt?:    string,
+ *   genres:      string[]
+ * }} AnimeCard
+ */
+export function toCard(post) {
+  const media  = post._embedded?.["wp:featuredmedia"]?.[0];
+  const terms  = post._embedded?.["wp:term"]?.flat() ?? [];
+  const genres = terms
+    .filter(t => t.taxonomy === "post_tag" || t.taxonomy === "category")
+    .map(t => t.name)
+    .filter(n => n !== "افلام انمي");
+
+  const excerptHtml = post.excerpt?.rendered ?? "";
+  const excerpt     = excerptHtml.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+
+  return {
+    id:         post.id,
+    title:      post.title?.rendered ?? "",
+    url:        post.link,
+    date:       post.date,
+    thumbnail:  media?.source_url ?? media?.media_details?.sizes?.medium?.source_url ?? undefined,
+    excerpt:    excerpt || undefined,
+    genres,
+  };
+}
+
+export { WP_API, ANIME_CAT, EMBED_PARAM, BASE_FIELDS };

package/src/index.js

@@ -0,0 +1,47 @@
+export { browse }                         from "./scrapers/browse.js";
+export { search }                         from "./scrapers/search.js";
+export { details }                        from "./scrapers/details.js";
+export { download, downloadFromPost }     from "./scrapers/download.js";
+export { vidtubeLinks, isVidTubeUrl }     from "./scrapers/vidtube.js";
+export { fetchHtml, createClient }        from "./utils/http.js";
+export { load, absoluteUrl, cleanText }   from "./utils/parser.js";
+
+import { browse }                     from "./scrapers/browse.js";
+import { search }                     from "./scrapers/search.js";
+import { details }                    from "./scrapers/details.js";
+import { download, downloadFromPost } from "./scrapers/download.js";
+import { vidtubeLinks, isVidTubeUrl } from "./scrapers/vidtube.js";
+
+/**
+ * All-in-one helper: details + download links + resolved VidTube direct links.
+ *
+ * @param {string} postUrl
+ * @param {object} [options]
+ * @returns {Promise<{
+ *   details:   import("./scrapers/details.js").AnimeDetails,
+ *   download:  import("./scrapers/download.js").DownloadResult,
+ *   vidtube?:  import("./scrapers/vidtube.js").VidTubeResult
+ * }>}
+ */
+async function getAll(postUrl, options = {}) {
+  const det = await details(postUrl, options);
+  const dl  = await downloadFromPost(postUrl, options);
+  let vt    = undefined;
+  if (dl.vidtube) {
+    try { vt = await vidtubeLinks(dl.vidtube, options); } catch { /* ignore */ }
+  }
+  return { details: det, download: dl, vidtube: vt };
+}
+
+const Anime = {
+  browse:      (options)        => browse(options),
+  search:      (query, options) => search(query, options),
+  details:     (url, options)   => details(url, options),
+  download:    (url, options)   => download(url, options),
+  downloadFromPost: (url, options) => downloadFromPost(url, options),
+  vidtube:     (url, options)   => vidtubeLinks(url, options),
+  getAll:      (url, options)   => getAll(url, options),
+};
+
+export default Anime;
+export { Anime };

package/src/scrapers/browse.js

@@ -0,0 +1,52 @@
+import { wpGet, toCard, ANIME_CAT, BASE_FIELDS } from "../api.js";
+
+/**
+ * Browse the anime category via WP REST API (paginated, newest first).
+ *
+ * @param {{
+ *   page?:     number,
+ *   perPage?:  number,
+ *   orderby?:  "date"|"title"|"modified",
+ *   order?:    "asc"|"desc",
+ *   timeout?:  number,
+ *   headers?:  Record<string, string>,
+ *   proxy?:    string
+ * }} [options]
+ * @returns {Promise<{
+ *   results:    import("../api.js").AnimeCard[],
+ *   page:       number,
+ *   perPage:    number,
+ *   total:      number,
+ *   totalPages: number,
+ *   hasNext:    boolean
+ * }>}
+ */
+export async function browse(options = {}) {
+  const page    = options.page    ?? 1;
+  const perPage = options.perPage ?? 20;
+  const orderby = options.orderby ?? "date";
+  const order   = options.order   ?? "desc";
+
+  const { data, total, totalPages } = await wpGet(
+    "/posts",
+    {
+      categories: ANIME_CAT,
+      per_page:   perPage,
+      page,
+      orderby,
+      order,
+      _fields:    BASE_FIELDS,
+      _embed:     "wp:featuredmedia,wp:term",
+    },
+    options
+  );
+
+  return {
+    results:    data.map(toCard),
+    page,
+    perPage,
+    total,
+    totalPages,
+    hasNext:    page < totalPages,
+  };
+}

package/src/scrapers/details.js

@@ -0,0 +1,91 @@
+import { load, extractText, extractAttr, absoluteUrl, cleanText } from "../utils/parser.js";
+import { fetchHtml } from "../utils/http.js";
+
+const BASE_URL = "https://topcinemaa.cam";
+
+/**
+ * Get full details for an anime page.
+ *
+ * @param {string} pageUrl  Full URL of the anime post
+ * @param {{
+ *   timeout?: number,
+ *   headers?: Record<string, string>,
+ *   proxy?:   string
+ * }} [options]
+ * @returns {Promise<AnimeDetails>}
+ *
+ * @typedef {{
+ *   title:        string,
+ *   url:          string,
+ *   thumbnail?:   string,
+ *   story?:       string,
+ *   quality?:     string,
+ *   genres:       string[],
+ *   year?:        string,
+ *   duration?:    string,
+ *   language?:    string,
+ *   rating?:      string,
+ *   watchUrl?:    string,
+ *   downloadUrl?: string
+ * }} AnimeDetails
+ */
+export async function details(pageUrl, options = {}) {
+  const html = await fetchHtml(pageUrl, options);
+  const $    = load(html);
+
+  const title = cleanText(
+    extractText($("h1.post-title a").first()) ||
+    extractAttr($("meta[property='og:title']"), "content")
+  );
+
+  const thumbnail =
+    extractAttr($("meta[property='og:image']"), "content") ||
+    extractAttr($(".image img").first(), "data-src")        ||
+    extractAttr($(".image img").first(), "src");
+
+  const story = cleanText(extractText($(".story").first()));
+
+  const genres = [];
+  $(".RightTaxContent li a[href*='genre']").each((_i, el) => {
+    const g = cleanText($(el).text());
+    if (g) genres.push(g);
+  });
+
+  let quality = "", year = "", duration = "", language = "", rating = "";
+
+  $(".RightTaxContent li").each((_i, el) => {
+    const text = cleanText($(el).text());
+    const span = cleanText($(el).find("span").first().text());
+
+    if (span.includes("جودة")) {
+      quality = cleanText($(el).find("a").first().text());
+    } else if (span.includes("صدور") || span.includes("سنة")) {
+      year = cleanText($(el).find("a").first().text());
+    } else if (span.includes("توقيت") || span.includes("مدة")) {
+      duration = cleanText($(el).find("strong").first().text() || text.replace(span, ""));
+    } else if (span.includes("لغة")) {
+      language = cleanText($(el).find("a, strong").first().text());
+    }
+  });
+
+  const ratingRaw = cleanText(extractText($(".imdbR").first()));
+  rating = ratingRaw.replace(/[^\d.]/g, "") || undefined;
+
+  const watchUrl    = extractAttr($(".BTNSDownWatch a.watch"), "href") || undefined;
+  const downloadUrl = extractAttr($(".BTNSDownWatch a.download"), "href") || undefined;
+
+  return {
+    title,
+    url:         pageUrl,
+    thumbnail:   thumbnail ? absoluteUrl(BASE_URL, thumbnail) : undefined,
+    story:       story     || undefined,
+    quality:     quality   || undefined,
+    genres,
+    year:        year      || undefined,
+    duration:    duration  || undefined,
+    language:    language  || undefined,
+    rating:      rating    || undefined,
+    watchUrl,
+    downloadUrl,
+  };
+}

package/src/scrapers/download.js

@@ -0,0 +1,75 @@
+import { load, extractText, extractAttr, cleanText } from "../utils/parser.js";
+import { fetchHtml } from "../utils/http.js";
+
+/**
+ * Scrape all download links from a topcinemaa.cam /download/ page.
+ *
+ * Returns:
+ *  - `vidtube`  — the VidTube multi-quality link (use vidtubeLinks() to resolve direct .mp4 URLs)
+ *  - `byQuality` — map of quality → array of { server, url }
+ *
+ * @param {string} downloadPageUrl  URL ending in /download/
+ * @param {{
+ *   timeout?: number,
+ *   headers?: Record<string, string>,
+ *   proxy?:   string
+ * }} [options]
+ * @returns {Promise<DownloadResult>}
+ *
+ * @typedef {{ server: string, url: string }} DownloadLink
+ * @typedef {{
+ *   vidtube?:   string,
+ *   byQuality:  Record<string, DownloadLink[]>,
+ *   all:        Array<{ quality: string, server: string, url: string }>
+ * }} DownloadResult
+ */
+export async function download(downloadPageUrl, options = {}) {
+  const html = await fetchHtml(downloadPageUrl, options);
+  const $    = load(html);
+
+  let vidtube = undefined;
+
+  const proLink = $(".proServer .downloadsLink[href]").first();
+  if (proLink.length) {
+    const href = extractAttr(proLink, "href");
+    if (href && href.includes("vidtube")) vidtube = href;
+  }
+
+  /** @type {Record<string, DownloadLink[]>} */
+  const byQuality = {};
+  /** @type {Array<{ quality: string, server: string, url: string }>} */
+  const all = [];
+
+  $(".DownloadBlock").each((_i, blockEl) => {
+    const block = $(blockEl);
+
+    const qualityRaw = cleanText(extractText(block.find(".download-title span").first()));
+    const quality    = qualityRaw || "unknown";
+
+    if (!byQuality[quality]) byQuality[quality] = [];
+
+    block.find(".download-items li a.downloadsLink[href]").each((_j, el) => {
+      const a      = $(el);
+      const url    = extractAttr(a, "href");
+      const server = cleanText(extractText(a.find(".text span").first()));
+      if (!url) return;
+
+      byQuality[quality].push({ server, url });
+      all.push({ quality, server, url });
+    });
+  });
+
+  return { vidtube, byQuality, all };
+}
+
+/**
+ * Convenience: given a post's base URL, automatically appends /download/ and scrapes it.
+ *
+ * @param {string} postUrl  e.g. https://topcinemaa.cam/film-slug/
+ * @param {object} [options]
+ * @returns {Promise<DownloadResult>}
+ */
+export async function downloadFromPost(postUrl, options = {}) {
+  const base = postUrl.endsWith("/") ? postUrl : postUrl + "/";
+  return download(base + "download/", options);
+}

package/src/scrapers/search.js

@@ -0,0 +1,49 @@
+import { wpGet, toCard, ANIME_CAT, EMBED_PARAM, BASE_FIELDS } from "../api.js";
+
+/**
+ * Search for anime using the WordPress REST API.
+ * Results are scoped to category 5 (افلام انمي) only — no series, no foreign films.
+ *
+ * @param {string} query
+ * @param {{
+ *   page?:     number,
+ *   perPage?:  number,
+ *   timeout?:  number,
+ *   headers?:  Record<string, string>,
+ *   proxy?:    string
+ * }} [options]
+ * @returns {Promise<{
+ *   query:      string,
+ *   results:    import("../api.js").AnimeCard[],
+ *   page:       number,
+ *   perPage:    number,
+ *   total:      number,
+ *   totalPages: number
+ * }>}
+ */
+export async function search(query, options = {}) {
+  const page    = options.page    ?? 1;
+  const perPage = options.perPage ?? 20;
+
+  const { data, total, totalPages } = await wpGet(
+    "/posts",
+    {
+      search:     query,
+      categories: ANIME_CAT,
+      per_page:   perPage,
+      page,
+      _fields:    BASE_FIELDS,
+      _embed:     "wp:featuredmedia,wp:term",
+    },
+    options
+  );
+
+  return {
+    query,
+    results:    data.map(toCard),
+    page,
+    perPage,
+    total,
+    totalPages,
+  };
+}

package/src/scrapers/vidtube.js

@@ -0,0 +1,123 @@
+import { load, extractText, extractAttr, absoluteUrl, cleanText } from "../utils/parser.js";
+import { fetchHtml } from "../utils/http.js";
+
+/**
+ * Resolve a VidTube download/embed URL into direct per-quality .mp4 links.
+ *
+ * Accepts any of:
+ *  - https://down.vidtube.one/d/FILE_ID.html            (download page)
+ *  - https://down.vidtube.one/embed-FILE_ID.html        (embed page)
+ *  - https://vidtube.one/embed-FILE_ID.html
+ *
+ * @param {string} vidtubeUrl
+ * @param {{
+ *   timeout?: number,
+ *   headers?: Record<string, string>,
+ *   proxy?:   string
+ * }} [options]
+ * @returns {Promise<VidTubeResult>}
+ *
+ * @typedef {{ quality: string, url: string, type: string }} VidTubeLink
+ * @typedef {{
+ *   sourceUrl: string,
+ *   downloadUrl?: string,
+ *   embedUrl?:   string,
+ *   links:       VidTubeLink[]
+ * }} VidTubeResult
+ */
+export async function vidtubeLinks(vidtubeUrl, options = {}) {
+  const { downloadUrl, embedUrl } = _normalizeUrls(vidtubeUrl);
+  const targetUrl = downloadUrl ?? embedUrl ?? vidtubeUrl;
+
+  const html = await fetchHtml(targetUrl, {
+    ...options,
+    headers: {
+      Referer: "https://topcinemaa.cam/",
+      Origin:  "https://topcinemaa.cam",
+      ...(options.headers ?? {}),
+    },
+  });
+
+  const links = [];
+
+  const $ = load(html);
+
+  $("a[href]").each((_i, el) => {
+    const a    = $(el);
+    const href = extractAttr(a, "href");
+    if (!href) return;
+
+    if (href.includes(".mp4") || href.includes("download") || href.includes("video")) {
+      const text    = cleanText(extractText(a));
+      const quality = _detectQuality(text, href);
+      links.push({ quality, url: absoluteUrl(targetUrl, href), type: "direct" });
+    }
+  });
+
+  $("source[src]").each((_i, el) => {
+    const src  = extractAttr($(el), "src");
+    const type = extractAttr($(el), "type");
+    const res  = extractAttr($(el), "res") || extractAttr($(el), "data-res") || "";
+    if (!src) return;
+    links.push({
+      quality: res ? `${res}p` : _detectQuality("", src),
+      url:     absoluteUrl(targetUrl, src),
+      type:    type || "video/mp4",
+    });
+  });
+
+  for (const m of html.matchAll(/"file"\s*:\s*"([^"]+\.mp4[^"]*)"/g))
+    links.push({ quality: _detectQuality("", m[1]), url: m[1], type: "video/mp4" });
+
+  for (const m of html.matchAll(/"([^"]+\.mp4[^"]*)"/g)) {
+    const url = m[1];
+    if (url.startsWith("http") && !links.some(l => l.url === url))
+      links.push({ quality: _detectQuality("", url), url, type: "video/mp4" });
+  }
+
+  const seen  = new Set();
+  const unique = links.filter(l => {
+    if (seen.has(l.url)) return false;
+    seen.add(l.url);
+    return true;
+  });
+
+  return { sourceUrl: vidtubeUrl, downloadUrl, embedUrl, links: unique };
+}
+
+/**
+ * Check if a URL is a VidTube URL.
+ * @param {string} url
+ * @returns {boolean}
+ */
+export function isVidTubeUrl(url) {
+  return url.includes("vidtube.one") || url.includes("down.vidtube");
+}
+
+function _normalizeUrls(url) {
+  const fileIdMatch =
+    url.match(/\/embed-([a-z0-9]+)\.html/) ||
+    url.match(/\/d\/([a-z0-9]+)\.html/)    ||
+    url.match(/\/([a-z0-9]{10,})\.html/);
+
+  if (!fileIdMatch) return { downloadUrl: url, embedUrl: undefined };
+
+  const id     = fileIdMatch[1];
+  const domain = url.includes("down.vidtube") ? "https://down.vidtube.one" : "https://vidtube.one";
+
+  return {
+    downloadUrl: `${domain}/d/${id}.html`,
+    embedUrl:    `${domain}/embed-${id}.html`,
+  };
+}
+
+function _detectQuality(text, href) {
+  const s = `${text} ${href}`.toLowerCase();
+  if (s.includes("4k") || s.includes("2160")) return "4K";
+  if (s.includes("1080"))  return "1080p";
+  if (s.includes("720"))   return "720p";
+  if (s.includes("480"))   return "480p";
+  if (s.includes("360"))   return "360p";
+  if (s.includes("240"))   return "240p";
+  return "auto";
+}

package/src/utils/http.js

@@ -0,0 +1,45 @@
+import axios from "axios";
+
+export const DEFAULT_HEADERS = {
+  "User-Agent":
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+  Accept:
+    "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+  "Accept-Language": "ar,en;q=0.9",
+  "Accept-Encoding": "gzip, deflate, br",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive",
+};
+
+/**
+ * Create an axios instance.
+ * @param {object} [options]
+ * @param {number}  [options.timeout]
+ * @param {object}  [options.headers]
+ * @param {string}  [options.proxy]
+ * @returns {import("axios").AxiosInstance}
+ */
+export function createClient(options = {}) {
+  const config = {
+    timeout: options.timeout ?? 30000,
+    headers: { ...DEFAULT_HEADERS, ...(options.headers ?? {}) },
+    maxRedirects: 10,
+  };
+  if (options.proxy) {
+    const u = new URL(options.proxy);
+    config.proxy = { host: u.hostname, port: Number(u.port), protocol: u.protocol.replace(":", "") };
+  }
+  return axios.create(config);
+}
+
+/**
+ * Fetch a URL and return the HTML string.
+ * @param {string} url
+ * @param {object} [options]
+ * @returns {Promise<string>}
+ */
+export async function fetchHtml(url, options = {}) {
+  const client = createClient(options);
+  const res = await client.get(url, { responseType: "text" });
+  return res.data;
+}

package/src/utils/parser.js

@@ -0,0 +1,21 @@
+import * as cheerio from "cheerio";
+
+/** @param {string} html @returns {import("cheerio").CheerioAPI} */
+export function load(html) { return cheerio.load(html); }
+
+/** @param {import("cheerio").Cheerio<any>} el @returns {string} */
+export function extractText(el) { return el.text().trim(); }
+
+/** @param {import("cheerio").Cheerio<any>} el @param {string} attr @returns {string} */
+export function extractAttr(el, attr) { return (el.attr(attr) ?? "").trim(); }
+
+/** @param {string} base @param {string} rel @returns {string} */
+export function absoluteUrl(base, rel) {
+  if (!rel) return "";
+  if (rel.startsWith("http://") || rel.startsWith("https://")) return rel;
+  if (rel.startsWith("//")) return "https:" + rel;
+  try { return new URL(rel, base).href; } catch { return rel; }
+}
+
+/** @param {string} text @returns {string} */
+export function cleanText(text) { return text.replace(/\s+/g, " ").trim(); }