npm - getraw - Versions diffs - 0.1.0 - Mend

getraw 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (105) hide show

package/.gitattributes +4 -0
package/CLAUDE.md +57 -0
package/README.md +166 -0
package/RESEARCH.md +109 -0
package/STATUS.md +23 -0
package/bun.lock +50 -0
package/bunfig.toml +3 -0
package/docs/plugin-guide.md +166 -0
package/docs/supported-sites.md +41 -0
package/package.json +30 -0
package/src/cli/index.ts +52 -0
package/src/cli/options.ts +97 -0
package/src/core/format-sorter.ts +208 -0
package/src/core/logger.ts +101 -0
package/src/core/orchestrator.ts +140 -0
package/src/core/output-template.ts +58 -0
package/src/core/types.ts +237 -0
package/src/downloaders/base.ts +25 -0
package/src/downloaders/dash.ts +287 -0
package/src/downloaders/fragment.ts +226 -0
package/src/downloaders/hls.ts +170 -0
package/src/downloaders/http.ts +260 -0
package/src/extractors/archive-org.ts +126 -0
package/src/extractors/bandcamp.ts +130 -0
package/src/extractors/base.ts +29 -0
package/src/extractors/bilibili/bangumi.ts +205 -0
package/src/extractors/bilibili/index.ts +233 -0
package/src/extractors/bilibili/wbi.ts +60 -0
package/src/extractors/coub.ts +137 -0
package/src/extractors/dailymotion.ts +99 -0
package/src/extractors/dropbox.ts +52 -0
package/src/extractors/generic.ts +118 -0
package/src/extractors/google-drive.ts +106 -0
package/src/extractors/imgur.ts +156 -0
package/src/extractors/instagram/index.ts +263 -0
package/src/extractors/instagram/reels.ts +166 -0
package/src/extractors/kick/clips.ts +91 -0
package/src/extractors/kick/index.ts +118 -0
package/src/extractors/kick/live.ts +89 -0
package/src/extractors/niconico/index.ts +209 -0
package/src/extractors/odysee.ts +126 -0
package/src/extractors/peertube.ts +143 -0
package/src/extractors/reddit/gallery.ts +124 -0
package/src/extractors/reddit/index.ts +203 -0
package/src/extractors/rumble.ts +127 -0
package/src/extractors/soundcloud/index.ts +161 -0
package/src/extractors/soundcloud/playlist.ts +129 -0
package/src/extractors/spotify.ts +97 -0
package/src/extractors/streamable.ts +121 -0
package/src/extractors/ted.ts +151 -0
package/src/extractors/tiktok/index.ts +207 -0
package/src/extractors/tiktok/user.ts +176 -0
package/src/extractors/twitch/clips.ts +125 -0
package/src/extractors/twitch/index.ts +136 -0
package/src/extractors/twitch/live.ts +132 -0
package/src/extractors/twitter/index.ts +140 -0
package/src/extractors/twitter/spaces.ts +200 -0
package/src/extractors/vimeo/index.ts +187 -0
package/src/extractors/youtube/captions.ts +111 -0
package/src/extractors/youtube/index.ts +252 -0
package/src/extractors/youtube/innertube.ts +364 -0
package/src/extractors/youtube/nsig.ts +105 -0
package/src/extractors/youtube/playlist.ts +227 -0
package/src/extractors/youtube/signature.ts +163 -0
package/src/networking/client.ts +311 -0
package/src/networking/cookies.ts +138 -0
package/src/networking/proxy.ts +132 -0
package/src/networking/tls.ts +67 -0
package/src/networking/user-agents.ts +88 -0
package/src/postprocessors/base.ts +44 -0
package/src/postprocessors/extract-audio.ts +98 -0
package/src/postprocessors/ffmpeg.ts +146 -0
package/src/postprocessors/merge.ts +102 -0
package/src/postprocessors/metadata.ts +73 -0
package/src/postprocessors/sponsorblock.ts +162 -0
package/src/postprocessors/subtitles.ts +285 -0
package/src/postprocessors/thumbnails.ts +194 -0
package/src/utils/sanitize.ts +36 -0
package/src/utils/traverse.ts +68 -0
package/tests/core/format-sorter.test.ts +96 -0
package/tests/core/output-template.test.ts +56 -0
package/tests/core/types.test.ts +79 -0
package/tests/unit/downloaders/dash.test.ts +57 -0
package/tests/unit/downloaders/hls.test.ts +120 -0
package/tests/unit/downloaders/http.test.ts +114 -0
package/tests/unit/extractors/bilibili.test.ts +83 -0
package/tests/unit/extractors/instagram.test.ts +273 -0
package/tests/unit/extractors/kick.test.ts +85 -0
package/tests/unit/extractors/misc.test.ts +942 -0
package/tests/unit/extractors/niconico.test.ts +61 -0
package/tests/unit/extractors/reddit.test.ts +222 -0
package/tests/unit/extractors/soundcloud.test.ts +299 -0
package/tests/unit/extractors/tiktok.test.ts +260 -0
package/tests/unit/extractors/twitch.test.ts +250 -0
package/tests/unit/extractors/twitter.test.ts +181 -0
package/tests/unit/extractors/vimeo.test.ts +253 -0
package/tests/unit/extractors/youtube.test.ts +259 -0
package/tests/unit/networking/client.test.ts +272 -0
package/tests/unit/networking/cookies.test.ts +256 -0
package/tests/unit/networking/proxy.test.ts +137 -0
package/tests/unit/postprocessors/extract-audio.test.ts +63 -0
package/tests/unit/postprocessors/merge.test.ts +61 -0
package/tests/unit/postprocessors/subtitles.test.ts +89 -0
package/tools/dashboard.ts +112 -0
package/tsconfig.json +17 -0

package/tests/unit/extractors/tiktok.test.ts ADDED Viewed

@@ -0,0 +1,260 @@
+import { describe, test, expect, mock } from "bun:test";
+import { TikTokExtractor } from "../../../src/extractors/tiktok/index";
+import { TikTokUserExtractor } from "../../../src/extractors/tiktok/user";
+import { ExtractorError } from "../../../src/core/types";
+const MOCK_ITEM_STRUCT = {
+  id: "7123456789012345678",
+  desc: "Cool video #fyp #trending",
+  createTime: 1700000000,
+  author: {
+    uniqueId: "coolcreator",
+    nickname: "Cool Creator",
+    id: "123456789",
+    avatarThumb: "https://p16-sign.tiktokcdn-us.com/avatar.jpg",
+  },
+  music: {
+    title: "Original Sound",
+    authorName: "coolcreator",
+    id: "987654321",
+  },
+  video: {
+    playAddr: "https://v19.tiktok.com/play/video.mp4",
+    downloadAddr: "https://v19.tiktok.com/download/video.mp4",
+    width: 1080,
+    height: 1920,
+    duration: 15,
+    bitrate: 2000000,
+    format: "mp4",
+    codecType: "h264",
+    cover: "https://p16.tiktok.com/cover.jpg",
+    dynamicCover: "https://p16.tiktok.com/dynamic_cover.webp",
+    originCover: "https://p16.tiktok.com/origin_cover.jpg",
+  },
+  stats: {
+    diggCount: 50000,
+    shareCount: 1000,
+    commentCount: 500,
+    playCount: 1000000,
+  },
+  textExtra: [{ hashtagName: "fyp" }, { hashtagName: "trending" }],
+};
+const MOCK_REHYDRATION_JSON = JSON.stringify({
+  __DEFAULT_SCOPE__: {
+    "webapp.video-detail": {
+      itemInfo: {
+        itemStruct: MOCK_ITEM_STRUCT,
+      },
+    },
+  },
+});
+const MOCK_HTML = `<!DOCTYPE html>
+<html>
+<head><title>TikTok</title></head>
+<body>
+<script id="__UNIVERSAL_DATA_FOR_REHYDRATION__" type="application/json">${MOCK_REHYDRATION_JSON}</script>
+</body>
+</html>`;
+describe("TikTokExtractor", () => {
+  const extractor = new TikTokExtractor();
+  test("canHandle matches tiktok.com video URLs", () => {
+    expect(extractor.canHandle("https://www.tiktok.com/@user/video/7123456789012345678")).toBe(true);
+    expect(extractor.canHandle("https://tiktok.com/@creator.name/video/1234567890123456789")).toBe(true);
+  });
+  test("canHandle matches vm.tiktok.com short URLs", () => {
+    expect(extractor.canHandle("https://vm.tiktok.com/ZMeABCDEF/")).toBe(true);
+    expect(extractor.canHandle("https://vm.tiktok.com/ABC123/")).toBe(true);
+  });
+  test("canHandle rejects non-tiktok URLs", () => {
+    expect(extractor.canHandle("https://tiktok.com/@user")).toBe(false);
+    expect(extractor.canHandle("https://youtube.com/watch?v=abc")).toBe(false);
+  });
+  test("_NAME is tiktok", () => {
+    expect(extractor._NAME).toBe("tiktok");
+  });
+  test("extract returns correct info from rehydration data", async () => {
+    const originalFetch = global.fetch;
+    global.fetch = mock(() =>
+      Promise.resolve({
+        ok: true,
+        url: "https://www.tiktok.com/@coolcreator/video/7123456789012345678",
+        text: () => Promise.resolve(MOCK_HTML),
+      } as Response),
+    );
+    try {
+      const info = await extractor.extract(
+        "https://www.tiktok.com/@coolcreator/video/7123456789012345678",
+      );
+      expect(info.id).toBe("7123456789012345678");
+      expect(info.title).toBe("Cool video #fyp #trending");
+      expect(info.description).toBe("Cool video #fyp #trending");
+      expect(info.uploader).toBe("Cool Creator");
+      expect(info.uploader_id).toBe("coolcreator");
+      expect(info.uploader_url).toBe("https://www.tiktok.com/@coolcreator");
+      expect(info.duration).toBe(15);
+      expect(info.view_count).toBe(1000000);
+      expect(info.like_count).toBe(50000);
+      expect(info.comment_count).toBe(500);
+      expect(info.tags).toEqual(["fyp", "trending"]);
+      expect(info.extractor).toBe("tiktok");
+      expect(info.formats).toBeDefined();
+      expect(info.formats!.length).toBeGreaterThanOrEqual(1);
+      const downloadFormat = info.formats!.find((f) => f.format_id === "download");
+      expect(downloadFormat).toBeDefined();
+      expect(downloadFormat!.url).toBe("https://v19.tiktok.com/download/video.mp4");
+      expect(downloadFormat!.width).toBe(1080);
+      expect(downloadFormat!.height).toBe(1920);
+      expect(info.thumbnails).toBeDefined();
+      expect(info.thumbnails!.length).toBeGreaterThan(0);
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+  test("extract throws ExtractorError when rehydration data is missing", async () => {
+    const originalFetch = global.fetch;
+    global.fetch = mock(() =>
+      Promise.resolve({
+        ok: true,
+        url: "https://www.tiktok.com/@user/video/1234567890",
+        text: () => Promise.resolve("<html><body>No data here</body></html>"),
+      } as Response),
+    );
+    try {
+      await expect(
+        extractor.extract("https://www.tiktok.com/@user/video/1234567890"),
+      ).rejects.toThrow(ExtractorError);
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+  test("extract throws ExtractorError on page fetch failure", async () => {
+    const originalFetch = global.fetch;
+    global.fetch = mock(() =>
+      Promise.resolve({
+        ok: false,
+        status: 404,
+        statusText: "Not Found",
+        url: "https://www.tiktok.com/@user/video/1234567890",
+      } as Response),
+    );
+    try {
+      await expect(
+        extractor.extract("https://www.tiktok.com/@user/video/1234567890"),
+      ).rejects.toThrow(ExtractorError);
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+});
+describe("TikTokUserExtractor", () => {
+  const extractor = new TikTokUserExtractor();
+  test("canHandle matches tiktok.com user profile URLs", () => {
+    expect(extractor.canHandle("https://www.tiktok.com/@coolcreator")).toBe(true);
+    expect(extractor.canHandle("https://tiktok.com/@creator.name")).toBe(true);
+    expect(extractor.canHandle("https://www.tiktok.com/@user123/")).toBe(true);
+  });
+  test("canHandle rejects video and other URLs", () => {
+    expect(
+      extractor.canHandle("https://www.tiktok.com/@user/video/123456789"),
+    ).toBe(false);
+    expect(extractor.canHandle("https://youtube.com/@channel")).toBe(false);
+  });
+  test("_NAME is tiktok:user", () => {
+    expect(extractor._NAME).toBe("tiktok:user");
+  });
+  test("extract returns playlist InfoDict", async () => {
+    const mockUserRehydration = JSON.stringify({
+      __DEFAULT_SCOPE__: {
+        "webapp.user-detail": {
+          userInfo: {
+            user: {
+              id: "123456789",
+              uniqueId: "coolcreator",
+              nickname: "Cool Creator",
+              signature: "Creating cool content",
+            },
+            stats: { videoCount: 2 },
+          },
+        },
+      },
+    });
+    const mockUserHtml = `<!DOCTYPE html>
+<html>
+<body>
+<script id="__UNIVERSAL_DATA_FOR_REHYDRATION__" type="application/json">${mockUserRehydration}</script>
+</body>
+</html>`;
+    const mockVideoList = {
+      itemList: [
+        {
+          id: "1111111111",
+          desc: "First video",
+          createTime: 1700000000,
+          video: { cover: "https://p16.tiktok.com/cover1.jpg" },
+        },
+        {
+          id: "2222222222",
+          desc: "Second video",
+          createTime: 1700000100,
+          video: { cover: "https://p16.tiktok.com/cover2.jpg" },
+        },
+      ],
+      hasMore: false,
+      maxCursor: 2,
+    };
+    const originalFetch = global.fetch;
+    let callCount = 0;
+    global.fetch = mock(() => {
+      callCount++;
+      if (callCount === 1) {
+        return Promise.resolve({
+          ok: true,
+          text: () => Promise.resolve(mockUserHtml),
+        } as Response);
+      }
+      return Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(mockVideoList),
+      } as Response);
+    });
+    try {
+      const info = await extractor.extract("https://www.tiktok.com/@coolcreator");
+      expect(info._type).toBe("playlist");
+      expect(info.id).toBe("123456789");
+      expect(info.uploader_id).toBe("coolcreator");
+      expect(info.entries).toBeDefined();
+      expect(info.entries!.length).toBe(2);
+      expect(info.entries![0].id).toBe("1111111111");
+      expect(info.entries![1].id).toBe("2222222222");
+      expect(info.playlist_count).toBe(2);
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+});

package/tests/unit/extractors/twitch.test.ts ADDED Viewed

@@ -0,0 +1,250 @@
+import { describe, test, expect, mock } from "bun:test";
+import { TwitchVODExtractor } from "../../../src/extractors/twitch/index";
+import { TwitchClipExtractor } from "../../../src/extractors/twitch/clips";
+import { TwitchLiveExtractor } from "../../../src/extractors/twitch/live";
+import { ExtractorError } from "../../../src/core/types";
+const vodExtractor = new TwitchVODExtractor();
+const clipExtractor = new TwitchClipExtractor();
+const liveExtractor = new TwitchLiveExtractor();
+describe("TwitchVODExtractor", () => {
+  test("canHandle matches VOD URL", () => {
+    expect(vodExtractor.canHandle("https://www.twitch.tv/videos/1234567890")).toBe(true);
+  });
+  test("canHandle rejects clip URL", () => {
+    expect(vodExtractor.canHandle("https://www.twitch.tv/streamer/clip/ClipSlug")).toBe(false);
+  });
+  test("canHandle rejects live URL", () => {
+    expect(vodExtractor.canHandle("https://www.twitch.tv/streamer")).toBe(false);
+  });
+  test("_NAME is twitch:vod", () => {
+    expect(vodExtractor._NAME).toBe("twitch:vod");
+  });
+  test("extract returns HLS format with access token", async () => {
+    const originalFetch = globalThis.fetch;
+    const mockTokenResponse = {
+      data: { videoPlaybackAccessToken: { value: "token123", signature: "sig456" } },
+    };
+    const mockMetaResponse = {
+      data: {
+        video: {
+          id: "1234567890",
+          title: "Epic Stream VOD",
+          description: "A great stream",
+          lengthSeconds: 7200,
+          viewCount: 50000,
+          publishedAt: "2024-01-15T20:00:00Z",
+          owner: { displayName: "Streamer", login: "streamer", id: "12345" },
+          previewThumbnailURL: "https://vod-secure.twitch.tv/thumbnail.jpg",
+        },
+      },
+    };
+    let callCount = 0;
+    globalThis.fetch = mock(() => {
+      callCount++;
+      const response = callCount === 1 ? mockTokenResponse : mockMetaResponse;
+      return Promise.resolve(
+        new Response(JSON.stringify(response), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        })
+      );
+    });
+    const info = await vodExtractor.extract("https://www.twitch.tv/videos/1234567890");
+    expect(info.id).toBe("1234567890");
+    expect(info.title).toBe("Epic Stream VOD");
+    expect(info.duration).toBe(7200);
+    expect(info.uploader).toBe("Streamer");
+    expect(info.formats).toBeDefined();
+    expect(info.formats!.length).toBeGreaterThan(0);
+    const hlsFormat = info.formats!.find((f) => f.protocol === "m3u8");
+    expect(hlsFormat).toBeDefined();
+    expect(hlsFormat!.url).toContain("usher.twitchapps.com");
+    expect(hlsFormat!.url).toContain("sig456");
+    expect(hlsFormat!.url).toContain("token123");
+    globalThis.fetch = originalFetch;
+  });
+  test("extract throws ExtractorError on GQL failure", async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(null, { status: 401 }))
+    );
+    await expect(
+      vodExtractor.extract("https://www.twitch.tv/videos/9999999999")
+    ).rejects.toThrow(ExtractorError);
+    globalThis.fetch = originalFetch;
+  });
+});
+describe("TwitchClipExtractor", () => {
+  test("canHandle matches clip URL with channel", () => {
+    expect(
+      clipExtractor.canHandle("https://www.twitch.tv/streamer/clip/AwesomeClip")
+    ).toBe(true);
+  });
+  test("canHandle matches clips.twitch.tv URL", () => {
+    expect(clipExtractor.canHandle("https://clips.twitch.tv/AwesomeClip")).toBe(true);
+  });
+  test("canHandle rejects VOD URL", () => {
+    expect(clipExtractor.canHandle("https://www.twitch.tv/videos/123456")).toBe(false);
+  });
+  test("_NAME is twitch:clip", () => {
+    expect(clipExtractor._NAME).toBe("twitch:clip");
+  });
+  test("extract returns clip formats with quality variants", async () => {
+    const originalFetch = globalThis.fetch;
+    const mockResponse = {
+      data: {
+        clip: {
+          id: "clip123",
+          slug: "AwesomeClip",
+          title: "Amazing Play",
+          durationSeconds: 30,
+          viewCount: 10000,
+          createdAt: "2024-01-10T15:30:00Z",
+          broadcaster: { displayName: "Streamer", login: "streamer", id: "12345" },
+          thumbnailURL: "https://clips-media-assets2.twitch.tv/thumb.jpg",
+          playbackAccessToken: { value: "cliptoken", signature: "clipsig" },
+          videoQualities: [
+            { quality: "1080", frameRate: 60, sourceURL: "https://clips-media.twitch.tv/clip-1080.mp4" },
+            { quality: "720", frameRate: 30, sourceURL: "https://clips-media.twitch.tv/clip-720.mp4" },
+            { quality: "480", frameRate: 30, sourceURL: "https://clips-media.twitch.tv/clip-480.mp4" },
+          ],
+        },
+      },
+    };
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(JSON.stringify(mockResponse), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        })
+      )
+    );
+    const info = await clipExtractor.extract("https://clips.twitch.tv/AwesomeClip");
+    expect(info.id).toBe("clip123");
+    expect(info.title).toBe("Amazing Play");
+    expect(info.duration).toBe(30);
+    expect(info.formats).toBeDefined();
+    expect(info.formats!.length).toBe(3);
+    const highestQuality = info.formats!.find((f) => f.format_id === "clip-1080");
+    expect(highestQuality).toBeDefined();
+    expect(highestQuality!.height).toBe(1080);
+    expect(highestQuality!.url).toContain("clipsig");
+    globalThis.fetch = originalFetch;
+  });
+});
+describe("TwitchLiveExtractor", () => {
+  test("canHandle matches live channel URL", () => {
+    expect(liveExtractor.canHandle("https://www.twitch.tv/streamer")).toBe(true);
+    expect(liveExtractor.canHandle("https://twitch.tv/streamer")).toBe(true);
+  });
+  test("canHandle rejects VOD URL", () => {
+    expect(liveExtractor.canHandle("https://www.twitch.tv/videos/123456")).toBe(false);
+  });
+  test("_NAME is twitch:live", () => {
+    expect(liveExtractor._NAME).toBe("twitch:live");
+  });
+  test("extract returns HLS live stream URL", async () => {
+    const originalFetch = globalThis.fetch;
+    const mockTokenResponse = {
+      data: { streamPlaybackAccessToken: { value: "livetoken", signature: "livesig" } },
+    };
+    const mockStreamResponse = {
+      data: {
+        user: {
+          stream: {
+            id: "stream123",
+            title: "Playing Games Live",
+            viewersCount: 5000,
+            previewImageURL: "https://static-cdn.jtvnw.net/previews-ttv/thumb.jpg",
+            broadcaster: { displayName: "Streamer", login: "streamer", id: "12345" },
+            game: { name: "Minecraft" },
+          },
+        },
+      },
+    };
+    let callCount = 0;
+    globalThis.fetch = mock(() => {
+      callCount++;
+      const response = callCount === 1 ? mockTokenResponse : mockStreamResponse;
+      return Promise.resolve(
+        new Response(JSON.stringify(response), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        })
+      );
+    });
+    const info = await liveExtractor.extract("https://www.twitch.tv/streamer");
+    expect(info.id).toBe("streamer");
+    expect(info.title).toBe("Playing Games Live");
+    expect(info.live_status).toBe("is_live");
+    expect(info.view_count).toBe(5000);
+    expect(info.formats).toBeDefined();
+    const liveFormat = info.formats!.find((f) => f.protocol === "m3u8");
+    expect(liveFormat).toBeDefined();
+    expect(liveFormat!.url).toContain("usher.twitchapps.com");
+    expect(liveFormat!.url).toContain("livesig");
+    globalThis.fetch = originalFetch;
+  });
+  test("extract throws when no access token returned", async () => {
+    const originalFetch = globalThis.fetch;
+    const mockTokenResponse = { data: { streamPlaybackAccessToken: null } };
+    const mockStreamResponse = { data: { user: null } };
+    let callCount = 0;
+    globalThis.fetch = mock(() => {
+      callCount++;
+      const response = callCount === 1 ? mockTokenResponse : mockStreamResponse;
+      return Promise.resolve(
+        new Response(JSON.stringify(response), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        })
+      );
+    });
+    await expect(
+      liveExtractor.extract("https://www.twitch.tv/offlinechannel")
+    ).rejects.toThrow(ExtractorError);
+    globalThis.fetch = originalFetch;
+  });
+});

package/tests/unit/extractors/twitter.test.ts ADDED Viewed

@@ -0,0 +1,181 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test";
+import { TwitterExtractor } from "../../../src/extractors/twitter/index";
+import { TwitterSpacesExtractor } from "../../../src/extractors/twitter/spaces";
+import { ExtractorError } from "../../../src/core/types";
+describe("TwitterExtractor", () => {
+  const extractor = new TwitterExtractor();
+  test("canHandle matches twitter.com status URLs", () => {
+    expect(extractor.canHandle("https://twitter.com/user/status/1234567890")).toBe(true);
+    expect(extractor.canHandle("https://www.twitter.com/user/status/1234567890")).toBe(true);
+  });
+  test("canHandle matches x.com status URLs", () => {
+    expect(extractor.canHandle("https://x.com/user/status/9876543210")).toBe(true);
+    expect(extractor.canHandle("https://www.x.com/elonmusk/status/9876543210")).toBe(true);
+  });
+  test("canHandle rejects non-tweet URLs", () => {
+    expect(extractor.canHandle("https://twitter.com/user")).toBe(false);
+    expect(extractor.canHandle("https://youtube.com/watch?v=abc")).toBe(false);
+    expect(extractor.canHandle("https://x.com/i/spaces/abc123")).toBe(false);
+  });
+  test("_NAME is twitter", () => {
+    expect(extractor._NAME).toBe("twitter");
+  });
+  test("extract sets extractor metadata", async () => {
+    const mockTweetData = {
+      id_str: "1234567890",
+      full_text: "Test tweet with video",
+      user: { name: "Test User", screen_name: "testuser", id_str: "999" },
+      created_at: "Mon Jan 01 12:00:00 +0000 2024",
+      favorite_count: 100,
+      views: { count: "5000" },
+      mediaDetails: [
+        {
+          type: "video",
+          media_url_https: "https://pbs.twimg.com/ext_tw_video_thumb/1234567890/pu/img/thumb.jpg",
+          original_info: { width: 1280, height: 720 },
+          video_info: {
+            duration_millis: 30000,
+            variants: [
+              {
+                content_type: "video/mp4",
+                url: "https://video.twimg.com/ext_tw_video/1234567890/pu/vid/1280x720/video.mp4",
+                bitrate: 2176000,
+              },
+              {
+                content_type: "video/mp4",
+                url: "https://video.twimg.com/ext_tw_video/1234567890/pu/vid/640x360/video.mp4",
+                bitrate: 832000,
+              },
+              {
+                content_type: "application/x-mpegURL",
+                url: "https://video.twimg.com/ext_tw_video/1234567890/pu/pl/playlist.m3u8",
+              },
+            ],
+          },
+        },
+      ],
+    };
+    const originalFetch = global.fetch;
+    global.fetch = mock(() =>
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(mockTweetData),
+      } as Response),
+    );
+    try {
+      const info = await extractor.extract("https://twitter.com/testuser/status/1234567890");
+      expect(info.id).toBe("1234567890");
+      expect(info.title).toBe("Test tweet with video");
+      expect(info.uploader).toBe("Test User");
+      expect(info.uploader_id).toBe("testuser");
+      expect(info.view_count).toBe(5000);
+      expect(info.like_count).toBe(100);
+      expect(info.duration).toBe(30);
+      expect(info.extractor).toBe("twitter");
+      expect(info.extractor_key).toBe("TwitterExtractor");
+      expect(info.formats).toBeDefined();
+      expect(info.formats!.length).toBeGreaterThan(0);
+      const mp4Formats = info.formats!.filter((f) => f.ext === "mp4" && !f.protocol);
+      expect(mp4Formats.length).toBe(2);
+      const highestBitrate = mp4Formats[0];
+      expect(highestBitrate.tbr).toBe(2176);
+      const hlsFormat = info.formats!.find((f) => f.protocol === "m3u8");
+      expect(hlsFormat).toBeDefined();
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+  test("extract throws ExtractorError when API returns no data", async () => {
+    const originalFetch = global.fetch;
+    global.fetch = mock(() =>
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({}),
+      } as Response),
+    );
+    try {
+      await expect(
+        extractor.extract("https://twitter.com/user/status/1234567890"),
+      ).rejects.toThrow(ExtractorError);
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+  test("extract throws ExtractorError on API failure", async () => {
+    const originalFetch = global.fetch;
+    global.fetch = mock(() =>
+      Promise.resolve({
+        ok: false,
+        status: 403,
+        statusText: "Forbidden",
+      } as Response),
+    );
+    try {
+      await expect(
+        extractor.extract("https://twitter.com/user/status/1234567890"),
+      ).rejects.toThrow(ExtractorError);
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+  test("extract handles tweet without video", async () => {
+    const mockTweetData = {
+      id_str: "9999999999",
+      full_text: "Tweet without video",
+      user: { name: "User", screen_name: "user", id_str: "1" },
+      created_at: "Mon Jan 01 12:00:00 +0000 2024",
+    };
+    const originalFetch = global.fetch;
+    global.fetch = mock(() =>
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(mockTweetData),
+      } as Response),
+    );
+    try {
+      const info = await extractor.extract("https://twitter.com/user/status/9999999999");
+      expect(info.id).toBe("9999999999");
+      expect(info.formats).toEqual([]);
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+});
+describe("TwitterSpacesExtractor", () => {
+  const extractor = new TwitterSpacesExtractor();
+  test("canHandle matches Twitter Spaces URLs", () => {
+    expect(extractor.canHandle("https://twitter.com/i/spaces/1YqKDqPQjnkKV")).toBe(true);
+    expect(extractor.canHandle("https://x.com/i/spaces/1YqKDqPQjnkKV")).toBe(true);
+    expect(extractor.canHandle("https://www.twitter.com/i/spaces/abc123XYZ")).toBe(true);
+  });
+  test("canHandle rejects non-spaces URLs", () => {
+    expect(extractor.canHandle("https://twitter.com/user/status/123")).toBe(false);
+    expect(extractor.canHandle("https://twitter.com/user")).toBe(false);
+  });
+  test("_NAME is twitter:spaces", () => {
+    expect(extractor._NAME).toBe("twitter:spaces");
+  });
+});