getraw 0.1.0

package/src/extractors/archive-org.ts

@@ -0,0 +1,126 @@
+import { BaseExtractor, ExtractorError } from "../core/types";
+import type { InfoDict, Format, Thumbnail } from "../core/types";
+
+interface ArchiveFile {
+  name?: string;
+  format?: string;
+  size?: string;
+  length?: string;
+  width?: string;
+  height?: string;
+  bitrate?: string;
+  source?: string;
+}
+
+interface ArchiveMetadata {
+  metadata?: {
+    identifier?: string | string[];
+    title?: string | string[];
+    description?: string | string[];
+    creator?: string | string[];
+    date?: string | string[];
+    subject?: string | string[];
+  };
+  files?: ArchiveFile[];
+  d1?: string;
+  dir?: string;
+  server?: string;
+}
+
+const VIDEO_FORMATS = new Set(["h.264", "h.264 ia", "mpeg4", "mp4", "512kb mpeg4", "avi", "mov", "wmv", "webm", "ogg video", "ogv"]);
+const AUDIO_FORMATS = new Set(["mp3", "flac", "ogg vorbis", "vbr mp3", "64kbps mp3", "128kbps mp3", "256kbps mp3", "aiff", "wav"]);
+
+export class ArchiveOrgExtractor extends BaseExtractor {
+  readonly _VALID_URL = /https?:\/\/(?:www\.)?archive\.org\/(?:details|download)\/([^/?#]+)/;
+  readonly _NAME = "archive.org";
+
+  protected async _real_extract(url: string): Promise<InfoDict> {
+    const match = url.match(this._VALID_URL);
+    if (!match) throw new ExtractorError(`Invalid Archive.org URL: ${url}`);
+    const itemId = match[1];
+
+    const apiUrl = `https://archive.org/metadata/${itemId}`;
+    const response = await fetch(apiUrl, {
+      headers: { "User-Agent": "Mozilla/5.0" },
+    });
+
+    if (!response.ok) {
+      throw new ExtractorError(`Archive.org API error: ${response.status}`);
+    }
+
+    const data = (await response.json()) as ArchiveMetadata;
+
+    if (!data.metadata) {
+      throw new ExtractorError("Archive.org: no metadata found");
+    }
+
+    const pick = (v: string | string[] | undefined): string | undefined =>
+      Array.isArray(v) ? v[0] : v;
+
+    const identifier = pick(data.metadata.identifier) ?? itemId;
+    const title = pick(data.metadata.title) ?? itemId;
+    const description = pick(data.metadata.description);
+    const creator = pick(data.metadata.creator);
+    const date = pick(data.metadata.date);
+
+    const server = data.server ?? "ia800100.us.archive.org";
+    const dir = data.dir ?? `/0/items/${itemId}`;
+    const baseUrl = `https://${server}${dir}`;
+
+    const files = data.files ?? [];
+    const formats: Format[] = [];
+    const thumbnails: Thumbnail[] = [];
+
+    for (const file of files) {
+      if (!file.name) continue;
+
+      const fmt = (file.format ?? "").toLowerCase();
+      const fileUrl = `${baseUrl}/${encodeURIComponent(file.name)}`;
+
+      if (VIDEO_FORMATS.has(fmt)) {
+        formats.push({
+          format_id: file.name,
+          url: fileUrl,
+          ext: this.extFromName(file.name),
+          width: file.width ? parseInt(file.width) : undefined,
+          height: file.height ? parseInt(file.height) : undefined,
+          tbr: file.bitrate ? parseFloat(file.bitrate) : undefined,
+          filesize: file.size ? parseInt(file.size) : undefined,
+          format_note: file.format,
+          quality: file.source === "original" ? 2 : 1,
+        });
+      } else if (AUDIO_FORMATS.has(fmt)) {
+        formats.push({
+          format_id: file.name,
+          url: fileUrl,
+          ext: this.extFromName(file.name),
+          vcodec: "none",
+          filesize: file.size ? parseInt(file.size) : undefined,
+          format_note: file.format,
+          quality: file.source === "original" ? 2 : 1,
+        });
+      } else if (file.name.match(/\.(jpg|jpeg|png|gif)$/i) && file.name.includes("thumb")) {
+        thumbnails.push({ url: fileUrl });
+      }
+    }
+
+    const uploadDate = date ? date.slice(0, 10).replace(/-/g, "") : undefined;
+
+    return {
+      id: identifier,
+      title,
+      description,
+      uploader: creator,
+      upload_date: uploadDate,
+      thumbnails,
+      formats,
+      webpage_url: url,
+      extractor: this._NAME,
+    };
+  }
+
+  private extFromName(name: string): string {
+    const parts = name.split(".");
+    return parts.length > 1 ? parts[parts.length - 1].toLowerCase() : "mp4";
+  }
+}

package/src/extractors/bandcamp.ts

@@ -0,0 +1,130 @@
+import { BaseExtractor, ExtractorError } from "../core/types";
+import type { InfoDict, Format, Thumbnail } from "../core/types";
+
+interface BandcampTrackFile {
+  "mp3-128"?: string;
+  "mp3-v0"?: string;
+  "mp3-320"?: string;
+  [key: string]: string | undefined;
+}
+
+interface BandcampTrack {
+  id?: number;
+  title?: string;
+  duration?: number;
+  file?: BandcampTrackFile;
+  has_audio?: boolean;
+  track_num?: number;
+  artist?: string;
+}
+
+interface BandcampTralbum {
+  current?: {
+    id?: number;
+    title?: string;
+    about?: string;
+    release_date?: string;
+    art_id?: number;
+    type?: string;
+  };
+  artist?: string;
+  url?: string;
+  art_id?: number;
+  trackinfo?: BandcampTrack[];
+  packages?: unknown[];
+}
+
+export class BandcampExtractor extends BaseExtractor {
+  readonly _VALID_URL = /https?:\/\/(?:[^.]+\.bandcamp\.com\/(?:track|album)\/[^/?#]+|(?:www\.)?bandcamp\.com\/EmbeddedPlayer\/[^/?#]+)/;
+  readonly _NAME = "bandcamp";
+
+  protected async _real_extract(url: string): Promise<InfoDict> {
+    const response = await fetch(url, {
+      headers: { "User-Agent": "Mozilla/5.0" },
+    });
+
+    if (!response.ok) {
+      throw new ExtractorError(`Bandcamp fetch error: ${response.status}`);
+    }
+
+    const html = await response.text();
+
+    const tralbumMatch = html.match(/data-tralbum=["']([^"']+)["']/);
+    if (!tralbumMatch) {
+      throw new ExtractorError("Bandcamp: could not find data-tralbum attribute");
+    }
+
+    let tralbum: BandcampTralbum;
+    try {
+      tralbum = JSON.parse(tralbumMatch[1].replace(/&quot;/g, '"')) as BandcampTralbum;
+    } catch {
+      throw new ExtractorError("Bandcamp: failed to parse data-tralbum JSON");
+    }
+
+    const tracks = tralbum.trackinfo ?? [];
+    const isAlbum = url.includes("/album/") || (tralbum.current?.type === "album");
+    const artist = tralbum.artist ?? "Unknown Artist";
+    const artId = tralbum.art_id ?? tralbum.current?.art_id;
+    const thumbnailUrl = artId
+      ? `https://f4.bcbits.com/img/a${artId}_10.jpg`
+      : undefined;
+    const thumbnails: Thumbnail[] = thumbnailUrl ? [{ url: thumbnailUrl }] : [];
+
+    const buildTrackInfo = (track: BandcampTrack, index: number): InfoDict => {
+      const trackId = String(track.id ?? index);
+      const formats: Format[] = [];
+
+      if (track.file) {
+        const qualityOrder = ["mp3-320", "mp3-v0", "mp3-128"];
+        for (const quality of qualityOrder) {
+          const fileUrl = track.file[quality];
+          if (fileUrl) {
+            formats.push({
+              format_id: quality,
+              url: fileUrl,
+              ext: "mp3",
+              acodec: "mp3",
+              abr: quality === "mp3-320" ? 320 : quality === "mp3-128" ? 128 : undefined,
+              quality: quality === "mp3-320" ? 3 : quality === "mp3-v0" ? 2 : 1,
+            });
+          }
+        }
+      }
+
+      return {
+        id: trackId,
+        title: track.title ?? `Track ${index + 1}`,
+        uploader: track.artist ?? artist,
+        duration: track.duration,
+        thumbnails,
+        formats,
+        playlist_index: track.track_num ?? index + 1,
+        webpage_url: url,
+        extractor: this._NAME,
+      };
+    };
+
+    if (!isAlbum || tracks.length === 1) {
+      const track = tracks[0];
+      if (!track) throw new ExtractorError("Bandcamp: no tracks found");
+      return buildTrackInfo(track, 0);
+    }
+
+    const albumTitle = tralbum.current?.title ?? "Album";
+    const entries = tracks
+      .filter((t) => t.has_audio !== false)
+      .map((t, i) => buildTrackInfo(t, i));
+
+    return {
+      id: String(tralbum.current?.id ?? "album"),
+      title: albumTitle,
+      uploader: artist,
+      thumbnails,
+      entries,
+      _type: "playlist",
+      playlist_count: entries.length,
+      webpage_url: url,
+      extractor: this._NAME,
+    };
+  }
+}

package/src/extractors/base.ts

@@ -0,0 +1,29 @@
+import { BaseExtractor } from "../core/types";
+import { GenericExtractor } from "./generic";
+
+export { BaseExtractor };
+
+const extractors: BaseExtractor[] = [];
+const genericExtractor = new GenericExtractor();
+
+export function registerExtractor(extractor: BaseExtractor): void {
+  extractors.push(extractor);
+}
+
+export function findExtractor(url: string): BaseExtractor | null {
+  for (const extractor of extractors) {
+    if (extractor.canHandle(url)) {
+      return extractor;
+    }
+  }
+
+  if (genericExtractor.canHandle(url)) {
+    return genericExtractor;
+  }
+
+  return null;
+}
+
+export function getExtractors(): readonly BaseExtractor[] {
+  return extractors;
+}

package/src/extractors/bilibili/bangumi.ts

@@ -0,0 +1,205 @@
+import { BaseExtractor, ExtractorError } from "../../core/types";
+import type { InfoDict, Format, Thumbnail } from "../../core/types";
+
+const VALID_URL = /https?:\/\/(?:www\.)?bilibili\.com\/bangumi\/play\/(ep(\d+)|ss(\d+))/;
+
+interface BangumiEpisode {
+  id: number;
+  ep_id?: number;
+  aid: number;
+  bvid: string;
+  cid: number;
+  title: string;
+  long_title?: string;
+  duration: number;
+  pub_time: number;
+  cover: string;
+  badge?: string;
+  index: number;
+  index_title?: string;
+}
+
+interface BangumiData {
+  code: number;
+  message: string;
+  result: {
+    season_id: number;
+    season_title: string;
+    cover: string;
+    evaluate?: string;
+    total: number;
+    media_id: number;
+    type_name: string;
+    episodes: BangumiEpisode[];
+    up_info?: { mid: number; uname: string };
+  };
+}
+
+interface PlayUrlData {
+  code: number;
+  message: string;
+  result: {
+    quality: number;
+    accept_quality: number[];
+    dash?: {
+      video: Array<{
+        id: number;
+        baseUrl: string;
+        bandwidth: number;
+        mimeType: string;
+        codecs: string;
+        width?: number;
+        height?: number;
+        frameRate?: string;
+      }>;
+      audio: Array<{
+        id: number;
+        baseUrl: string;
+        bandwidth: number;
+        mimeType: string;
+        codecs: string;
+      }>;
+    };
+    durl?: Array<{ url: string; size: number; order: number }>;
+  };
+}
+
+const QUALITY_MAP: Record<number, string> = {
+  127: "8K", 126: "Dolby Vision", 125: "HDR", 120: "4K",
+  116: "1080p60", 112: "1080p+", 80: "1080p", 64: "720p", 32: "480p", 16: "360p",
+};
+
+const BILIBILI_HEADERS = {
+  "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",
+  Referer: "https://www.bilibili.com",
+  Origin: "https://www.bilibili.com",
+};
+
+export class BilibiliBangumiExtractor extends BaseExtractor {
+  readonly _VALID_URL = VALID_URL;
+  readonly _NAME = "bilibili:bangumi";
+
+  protected async _real_extract(url: string): Promise<InfoDict> {
+    const match = VALID_URL.exec(url);
+    if (!match) throw new ExtractorError(`bilibili:bangumi: invalid URL: ${url}`);
+
+    const epId = match[2];
+    const ssId = match[3];
+
+    const apiUrl = epId
+      ? `https://api.bilibili.com/pgc/view/web/season?ep_id=${epId}`
+      : `https://api.bilibili.com/pgc/view/web/season?season_id=${ssId}`;
+
+    const resp = await fetch(apiUrl, { headers: BILIBILI_HEADERS });
+    if (!resp.ok) throw new ExtractorError(`bilibili:bangumi: API failed: ${resp.status}`);
+
+    const data = (await resp.json()) as BangumiData;
+    if (data.code !== 0) throw new ExtractorError(`bilibili:bangumi: ${data.message}`);
+
+    const season = data.result;
+
+    if (epId) {
+      const ep = season.episodes.find((e) => String(e.id) === epId || String(e.ep_id) === epId);
+      if (!ep) throw new ExtractorError(`bilibili:bangumi: episode ${epId} not found`);
+      return await this.extractEpisode(ep, season.season_title, url);
+    }
+
+    const entries: InfoDict[] = [];
+    for (const ep of season.episodes) {
+      entries.push({
+        id: `ep${ep.id}`,
+        title: `${season.season_title} - ${ep.long_title ?? ep.title}`,
+        thumbnail: ep.cover,
+        duration: ep.duration / 1000,
+        webpage_url: `https://www.bilibili.com/bangumi/play/ep${ep.id}`,
+        _type: "url",
+      });
+    }
+
+    const thumbnails: Thumbnail[] = [{ url: season.cover }];
+
+    return {
+      id: `ss${season.season_id}`,
+      title: season.season_title,
+      description: season.evaluate,
+      thumbnails,
+      entries,
+      playlist_count: season.total,
+      _type: "playlist",
+      webpage_url: url,
+    };
+  }
+
+  private async extractEpisode(
+    ep: BangumiEpisode,
+    seasonTitle: string,
+    url: string,
+  ): Promise<InfoDict> {
+    const playParams = new URLSearchParams({
+      ep_id: String(ep.id),
+      bvid: ep.bvid,
+      cid: String(ep.cid),
+      qn: "127",
+      fnval: "4048",
+      fnver: "0",
+      fourk: "1",
+    });
+
+    const playResp = await fetch(
+      `https://api.bilibili.com/pgc/player/web/playurl?${playParams}`,
+      { headers: BILIBILI_HEADERS },
+    );
+    if (!playResp.ok)
+      throw new ExtractorError(`bilibili:bangumi: playurl failed: ${playResp.status}`);
+
+    const playData = (await playResp.json()) as PlayUrlData;
+    if (playData.code !== 0)
+      throw new ExtractorError(`bilibili:bangumi: playurl: ${playData.message}`);
+
+    const formats: Format[] = [];
+
+    if (playData.result.dash) {
+      for (const vs of playData.result.dash.video) {
+        formats.push({
+          format_id: `dash-video-${vs.id}`,
+          url: vs.baseUrl,
+          ext: vs.mimeType.includes("mp4") ? "mp4" : "webm",
+          vcodec: vs.codecs,
+          acodec: "none",
+          width: vs.width,
+          height: vs.height,
+          fps: vs.frameRate ? parseFloat(vs.frameRate) : undefined,
+          tbr: Math.round(vs.bandwidth / 1000),
+          format_note: QUALITY_MAP[vs.id] ?? `qn${vs.id}`,
+          http_headers: BILIBILI_HEADERS,
+        });
+      }
+      for (const as_ of playData.result.dash.audio) {
+        formats.push({
+          format_id: `dash-audio-${as_.id}`,
+          url: as_.baseUrl,
+          ext: as_.mimeType.includes("mp4") ? "m4a" : "ogg",
+          vcodec: "none",
+          acodec: as_.codecs,
+          abr: Math.round(as_.bandwidth / 1000),
+          format_note: "audio",
+          http_headers: BILIBILI_HEADERS,
+        });
+      }
+    }
+
+    const uploadDate = new Date(ep.pub_time * 1000).toISOString().slice(0, 10).replace(/-/g, "");
+
+    return {
+      id: `ep${ep.id}`,
+      title: `${seasonTitle} - ${ep.long_title ?? ep.title}`,
+      thumbnail: ep.cover,
+      duration: ep.duration / 1000,
+      upload_date: uploadDate,
+      timestamp: ep.pub_time,
+      formats,
+      webpage_url: url,
+      _type: "video",
+    };
+  }
+}