@lmna22/aio-downloader 1.0.3 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # @lmna22/aio-downloader
 
-> All-in-one media downloader for YouTube, Instagram, TikTok, Pinterest, Pixiv, and X/Twitter.
+> All-in-one media downloader for YouTube, Instagram, TikTok, Pinterest, Pixiv, X/Twitter, and Lahelu.
 
 [![npm version](https://img.shields.io/npm/v/@lmna22/aio-downloader.svg)](https://www.npmjs.com/package/@lmna22/aio-downloader)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -16,17 +16,18 @@ Scrape and download videos, audio, and images from multiple platforms with a sin
 |---|---|---|---|---|
 | **YouTube** | ✅ (Multiple qualities) | ✅ (MP3) | — | — |
 | **Instagram** | ✅ | — | ✅ | — |
-| **TikTok** | ✅ (Buffer) | ✅ | — | — |
+| **TikTok** | ✅ (Buffer) | ✅ | ✅ (Photo/Slides) | — |
 | **Pinterest** | — | — | ✅ | ✅ |
 | **Pixiv** | — | — | ✅ (Original Resolution) | ✅ |
 | **X / Twitter** | ✅ (Best quality) | — | ✅ | — |
+| **Lahelu** | ✅ | — | ✅ | — |
 
 - 🔗 **Auto-detect platform** from URL — just pass any supported link
 - 📦 **Programmatic API** — designed for Node.js applications, bots, and scripts
 - 📥 **Built-in download helper** with progress callback
 - 🔍 **Search support** for Pinterest and Pixiv (pass keywords instead of URLs)
 - 🚫 **No API keys** — all data is scraped from public sources
-- 🔄 **Multi-method fallback** — Instagram uses 4 different methods for maximum reliability
+- 🔄 **Multi-method fallback** — Instagram uses 4 methods, TikTok uses 2 methods for maximum reliability
 - 🎬 **YouTube quality selection** — choose from 144p to 2160p, or audio-only MP3
 
 ---
@@ -50,11 +51,15 @@ npm install puppeteer
 ## 🚀 Quick Start
 
 ```javascript
-const { aioDownloader } = require("@lmna22/aio-downloader");
+const { lmna, aioDownloader } = require("@lmna22/aio-downloader");
 
-// Auto-detects the platform from the URL
-const result = await aioDownloader("https://www.youtube.com/watch?v=dQw4w9WgXcQ", { quality: 5 });
+// Using the lmna namespace (recommended)
+const result = await lmna.youtube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 5);
 console.log(result);
+
+// Or auto-detect platform from URL
+const result2 = await aioDownloader("https://www.instagram.com/p/ABC123/");
+console.log(result2);
 ```
 
 ---
@@ -64,7 +69,7 @@ console.log(result);
 ### YouTube
 
 ```javascript
-const { youtubeDownloader, youtubePlaylistDownloader } = require("@lmna22/aio-downloader");
+const { lmna } = require("@lmna22/aio-downloader");
 
 // Quality options:
 // 1 = 144p, 2 = 360p, 3 = 480p, 4 = 720p,
@@ -72,7 +77,7 @@ const { youtubeDownloader, youtubePlaylistDownloader } = require("@lmna22/aio-do
 // 8 = Audio only (MP3), 9 = Get bitrate list
 
 // Download a video in 1080p
-const result = await youtubeDownloader("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 5);
+const result = await lmna.youtube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 5);
 
 if (result.status) {
     console.log(result.data.title);      // "Rick Astley - Never Gonna Give You Up"
@@ -87,14 +92,14 @@ if (result.status) {
 }
 
 // Download audio only
-const audio = await youtubeDownloader("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 8);
+const audio = await lmna.youtube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 8);
 
 // Get available audio bitrates
-const bitrates = await youtubeDownloader("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 9);
+const bitrates = await lmna.youtube("https://www.youtube.com/watch?v=dQw4w9WgXcQ", 9);
 console.log(bitrates.data.bitrateList);
 
 // Download entire playlist
-const playlist = await youtubePlaylistDownloader(
+const playlist = await lmna.youtubePlaylist(
     "https://www.youtube.com/playlist?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf",
     5, // quality
     "./my-playlist" // output folder
@@ -104,9 +109,9 @@ const playlist = await youtubePlaylistDownloader(
 ### Instagram
 
 ```javascript
-const { instagramDownloader } = require("@lmna22/aio-downloader");
+const { lmna } = require("@lmna22/aio-downloader");
 
-const result = await instagramDownloader("https://www.instagram.com/p/ABC123/");
+const result = await lmna.instagram("https://www.instagram.com/p/ABC123/");
 
 if (result.status) {
     console.log(result.data.url);        // Array of download URLs
@@ -127,9 +132,9 @@ if (result.status) {
 ### TikTok
 
 ```javascript
-const { tiktokDownloader } = require("@lmna22/aio-downloader");
+const { lmna } = require("@lmna22/aio-downloader");
 
-const result = await tiktokDownloader("https://www.tiktok.com/@user/video/1234567890");
+const result = await lmna.tiktok("https://www.tiktok.com/@user/video/1234567890");
 
 if (result.status) {
     const data = result.data;
@@ -150,19 +155,24 @@ if (result.status) {
         const fs = require("fs");
         fs.writeFileSync("tiktok_video.mp4", data.videoBuffer);
     }
+
+    // For photo/slide posts
+    if (data.images) {
+        console.log(data.images); // Array of image URLs
+    }
 }
 ```
 
 ### Pinterest
 
 ```javascript
-const { pinterestDownloader } = require("@lmna22/aio-downloader");
+const { lmna } = require("@lmna22/aio-downloader");
 
 // From a direct pin URL
-const data = await pinterestDownloader("https://www.pinterest.com/pin/123456789/");
+const data = await lmna.pinterest("https://www.pinterest.com/pin/123456789/");
 
 // Or search by keyword
-const searchResults = await pinterestDownloader("aesthetic wallpaper", { limit: 20 });
+const searchResults = await lmna.pinterest("aesthetic wallpaper", { limit: 20 });
 
 console.log(data.results);
 // [
@@ -179,13 +189,13 @@ console.log(data.results);
 ### Pixiv
 
 ```javascript
-const { pixivDownloader } = require("@lmna22/aio-downloader");
+const { lmna } = require("@lmna22/aio-downloader");
 
 // From an artwork URL
-const data = await pixivDownloader("https://www.pixiv.net/artworks/12345678");
+const data = await lmna.pixiv("https://www.pixiv.net/artworks/12345678");
 
 // Or search by tag/keyword
-const searchResults = await pixivDownloader("landscape", { limit: 5 });
+const searchResults = await lmna.pixiv("landscape", { limit: 5 });
 
 console.log(data.results);
 // [
@@ -202,15 +212,15 @@ console.log(data.results);
 // ]
 
 // Skip enrichment for faster results (no original resolution images)
-const fast = await pixivDownloader("landscape", { limit: 10, enrich: false });
+const fast = await lmna.pixiv("landscape", { limit: 10, enrich: false });
 ```
 
 ### X / Twitter
 
 ```javascript
-const { twitterDownloader } = require("@lmna22/aio-downloader");
+const { lmna } = require("@lmna22/aio-downloader");
 
-const result = await twitterDownloader("https://x.com/user/status/1234567890");
+const result = await lmna.twitter("https://x.com/user/status/1234567890");
 
 if (result.status) {
     console.log(result.data.author);          // "username"
@@ -237,6 +247,33 @@ if (result.status) {
 }
 ```
 
+### Lahelu
+
+```javascript
+const { lmna } = require("@lmna22/aio-downloader");
+
+const result = await lmna.lahelu("https://lahelu.com/post/abc123");
+
+if (result.status) {
+    const data = result.data;
+
+    console.log(data.title);           // Post title
+    console.log(data.author);          // Username
+    console.log(data.createdAt);       // Creation date
+    console.log(data.stats.views);     // View count
+    console.log(data.stats.likes);     // Like count
+    console.log(data.stats.comments);  // Comment count
+    console.log(data.media.type);      // "video" or "image"
+    console.log(data.media.format);    // File format (mp4, jpg, etc.)
+    console.log(data.media.url);       // Direct download URL
+    console.log(data.fileName);        // Suggested filename
+
+    // Download the media
+    const { download } = require("@lmna22/aio-downloader");
+    await download(data.media.url, `./downloads/${data.fileName}`);
+}
+```
+
 ---
 
 ## 📥 Download Helper
@@ -271,6 +308,7 @@ await aioDownloader("https://www.tiktok.com/@user/video/123");
 await aioDownloader("https://www.pinterest.com/pin/456/");
 await aioDownloader("https://www.pixiv.net/artworks/789");
 await aioDownloader("https://x.com/user/status/101112");
+await aioDownloader("https://lahelu.com/post/abc123");
 
 // Force a specific platform
 await aioDownloader("https://example.com/video", { platform: "youtube", quality: 5 });
@@ -280,8 +318,10 @@ detectPlatform("https://youtube.com/watch?v=abc");  // "youtube"
 detectPlatform("https://instagram.com/p/xyz");       // "instagram"
 detectPlatform("https://tiktok.com/@user/video/1");  // "tiktok"
 detectPlatform("https://pinterest.com/pin/123");     // "pinterest"
+detectPlatform("https://pin.it/abc123");             // "pinterest"
 detectPlatform("https://pixiv.net/artworks/456");    // "pixiv"
 detectPlatform("https://x.com/user/status/789");     // "twitter"
+detectPlatform("https://lahelu.com/post/abc");       // "lahelu"
 detectPlatform("https://unknown.com");               // null
 ```
 
@@ -289,6 +329,23 @@ detectPlatform("https://unknown.com");               // null
 
 ## 📚 API Reference
 
+### `lmna` Namespace (Recommended)
+
+```javascript
+const { lmna } = require("@lmna22/aio-downloader");
+
+await lmna.youtube(url, quality);
+await lmna.youtubePlaylist(url, quality, folderPath);
+await lmna.instagram(url);
+await lmna.tiktok(url);
+await lmna.pinterest(input, options);
+await lmna.pixiv(input, options);
+await lmna.twitter(url);
+await lmna.lahelu(url);
+```
+
+---
+
 ### `aioDownloader(url, options?)`
 
 Auto-detect platform and scrape media data.
@@ -301,42 +358,42 @@ Auto-detect platform and scrape media data.
 
 ---
 
-### `youtubeDownloader(url, quality)`
+### `lmna.youtube(url, quality)`
 
 | Parameter | Type | Description |
 |---|---|---|
 | `url` | `string` | YouTube video URL |
 | `quality` | `number` | 1=144p, 2=360p, 3=480p, 4=720p, 5=1080p, 6=1440p, 7=2160p, 8=MP3, 9=bitrate list |
 
-**Returns:** `{ creator, status, data: { title, result (Buffer), size, quality, desc, views, likes, channel, uploadDate, thumb, type } }`
+**Returns:** `{ status, platform, data: { title, result (Buffer), size, quality, desc, views, likes, channel, uploadDate, thumb, type } }`
 
 ---
 
-### `youtubePlaylistDownloader(url, quality, folderPath?)`
+### `lmna.youtubePlaylist(url, quality, folderPath?)`
 
 Downloads all videos from a YouTube playlist.
 
-**Returns:** `{ creator, status, data: { title, resultPath[], metadata[] } }`
+**Returns:** `{ status, platform, data: { title, resultPath[], metadata[] } }`
 
 ---
 
-### `instagramDownloader(url)`
+### `lmna.instagram(url)`
 
 Uses 4 fallback methods for maximum reliability.
 
-**Returns:** `{ creator, status, data: { url[], caption, username, like, comment, isVideo } }`
+**Returns:** `{ status, platform, data: { url[], caption, username, like, comment, isVideo } }`
 
 ---
 
-### `tiktokDownloader(url)`
+### `lmna.tiktok(url)`
 
-Returns video as a Buffer (no watermark).
+Returns video as a Buffer (no watermark). Uses direct scraping with tikwm.com API fallback.
 
-**Returns:** `{ creator, status, data: { videoId, description, videoUrl, videoBuffer (Buffer), videoInfo, author, music, stats, locationCreated } }`
+**Returns:** `{ status, platform, data: { videoId, description, videoUrl, videoBuffer (Buffer), videoInfo, author, music, stats, locationCreated, images? } }`
 
 ---
 
-### `pinterestDownloader(input, options?)`
+### `lmna.pinterest(input, options?)`
 
 | Parameter | Type | Description |
 |---|---|---|
@@ -347,7 +404,7 @@ Returns video as a Buffer (no watermark).
 
 ---
 
-### `pixivDownloader(input, options?)`
+### `lmna.pixiv(input, options?)`
 
 | Parameter | Type | Description |
 |---|---|---|
@@ -359,11 +416,19 @@ Returns video as a Buffer (no watermark).
 
 ---
 
-### `twitterDownloader(url)`
+### `lmna.twitter(url)`
 
 Extracts best quality video/image/gif from tweets via Twitter GraphQL API.
 
-**Returns:** `{ creator, status, data: { author, like, view, retweet, description, sensitiveContent, result: [{ type, url, thumb? }] } }`
+**Returns:** `{ status, platform, data: { author, like, view, retweet, description, sensitiveContent, result: [{ type, url, thumb? }] } }`
+
+---
+
+### `lmna.lahelu(url)`
+
+Scrapes video or image from Lahelu posts.
+
+**Returns:** `{ status, platform, data: { postId, title, author, createdAt, stats: { views, likes, comments }, media: { type, format, url, desc }, fileName } }`
 
 ---
 
@@ -385,18 +450,34 @@ Helper to download any file to disk.
 
 ### `detectPlatform(url)`
 
-**Returns:** `"youtube"` | `"instagram"` | `"tiktok"` | `"pinterest"` | `"pixiv"` | `"twitter"` | `null`
+**Returns:** `"youtube"` | `"instagram"` | `"tiktok"` | `"pinterest"` | `"pixiv"` | `"twitter"` | `"lahelu"` | `null`
+
+---
+
+## 🔄 Migration from v1.0.x
+
+If you're upgrading from the old API, the legacy named exports still work:
+
+```javascript
+// Old way (still works)
+const { tiktokDownloader } = require("@lmna22/aio-downloader");
+await tiktokDownloader(url);
+
+// New way (recommended)
+const { lmna } = require("@lmna22/aio-downloader");
+await lmna.tiktok(url);
+```
 
 ---
 
 ## ⚠️ Error Handling
 
-All functions return `{ status: false, message: "..." }` on failure:
+All functions return `{ status: false, platform: "...", message: "..." }` on failure:
 
 ```javascript
-const { youtubeDownloader } = require("@lmna22/aio-downloader");
+const { lmna } = require("@lmna22/aio-downloader");
 
-const result = await youtubeDownloader("https://www.youtube.com/watch?v=invalid", 5);
+const result = await lmna.youtube("https://www.youtube.com/watch?v=invalid", 5);
 if (!result.status) {
     console.error("Failed:", result.message);
 }

package/package.json

@@ -1,10 +1,10 @@
 {
     "name": "@lmna22/aio-downloader",
-    "version": "1.0.3",
+    "version": "2.0.0",
     "description": "All-in-one media downloader for YouTube, Instagram, TikTok, Pinterest, Pixiv, and X/Twitter. Scrape and download videos, audio, and images from multiple platforms with a single library.",
     "main": "src/index.js",
     "scripts": {
-        "test": "node -e \"const aio = require('./src/index.js'); console.log('Exports:', Object.keys(aio)); console.log('Platform detection:', aio.detectPlatform('https://youtube.com/watch?v=test'));\""
+        "test": "node -e \"const { lmna, detectPlatform } = require('./src/index.js'); console.log('lmna methods:', Object.keys(lmna)); console.log('Platform detection:', detectPlatform('https://youtube.com/watch?v=test'));\""
     },
     "keywords": [
         "downloader",

package/src/index.js

@@ -4,15 +4,17 @@ const tiktokDownloader = require("./lib/tiktok");
 const pinterestDownloader = require("./lib/pinterest");
 const pixivDownloader = require("./lib/pixiv");
 const twitterDownloader = require("./lib/twitter");
+const laheluDownloader = require("./lib/lahelu");
 const download = require("./download");
 
 const PLATFORM_PATTERNS = [
     { name: "youtube", test: (url) => /(?:youtube\.com\/watch|youtu\.be\/|youtube\.com\/shorts|youtube\.com\/playlist)/i.test(url) },
     { name: "instagram", test: (url) => /instagram\.com\//i.test(url) },
     { name: "tiktok", test: (url) => /tiktok\.com\//i.test(url) },
-    { name: "pinterest", test: (url) => /pinterest\./i.test(url) },
+    { name: "pinterest", test: (url) => /(?:pinterest\.|pin\.it\/)/i.test(url) },
     { name: "pixiv", test: (url) => /pixiv\.net\//i.test(url) },
     { name: "twitter", test: (url) => /(?:twitter\.com\/|x\.com\/)/i.test(url) },
+    { name: "lahelu", test: (url) => /lahelu\.com\/post\//i.test(url) },
 ];
 
 function detectPlatform(url) {
@@ -29,6 +31,7 @@ const scrapers = {
     pinterest: (url, options) => pinterestDownloader(url, options),
     pixiv: (url, options) => pixivDownloader(url, options),
     twitter: (url) => twitterDownloader(url),
+    lahelu: (url) => laheluDownloader(url),
 };
 
 async function aioDownloader(url, options = {}) {
@@ -48,10 +51,23 @@ async function aioDownloader(url, options = {}) {
     return scraper(url, options);
 }
 
+const lmna = {
+    youtube: (url, quality) => youtubeDownloader(url, quality),
+    youtubePlaylist: (url, quality, folder) => youtubePlaylistDownloader(url, quality, folder),
+    instagram: (url) => instagramDownloader(url),
+    tiktok: (url) => tiktokDownloader(url),
+    pinterest: (url, options) => pinterestDownloader(url, options),
+    pixiv: (url, options) => pixivDownloader(url, options),
+    twitter: (url) => twitterDownloader(url),
+    lahelu: (url) => laheluDownloader(url),
+};
+
 module.exports = {
+    lmna,
     aioDownloader,
     detectPlatform,
     download,
+    // Legacy named exports (backward compatible)
     youtubeDownloader,
     youtubePlaylistDownloader,
     instagramDownloader,
@@ -59,4 +75,5 @@ module.exports = {
     pinterestDownloader,
     pixivDownloader,
     twitterDownloader,
+    laheluDownloader,
 };

package/src/lib/lahelu.js

@@ -0,0 +1,170 @@
+const axios = require("axios");
+const { DEFAULT_UA, sanitizeFileName, getExtFromUrl, formatNumber } = require("../utils");
+
+function isLaheluUrl(url) {
+    try {
+        const u = new URL(url);
+        return u.hostname.includes("lahelu.com") && u.pathname.includes("/post/");
+    } catch {
+        return false;
+    }
+}
+
+function extractPostId(url) {
+    try {
+        const urlObj = new URL(url);
+        const paths = urlObj.pathname.split("/").filter(p => p);
+        if (paths.length >= 2 && paths[0] === "post" && paths[1]) {
+            return paths[1];
+        }
+    } catch {
+        const match = url.match(/lahelu\.com\/post\/([a-zA-Z0-9_-]+)/);
+        if (match) return match[1];
+    }
+    return null;
+}
+
+async function fetchLaheluData(postId) {
+    for (let page = 1; page <= 10; page++) {
+        const apiUrl = `https://lahelu.com/api/post/get-posts?feed=1&page=${page}`;
+
+        const res = await axios.get(apiUrl, {
+            headers: {
+                "User-Agent": DEFAULT_UA,
+                "Referer": "https://lahelu.com/",
+            },
+            timeout: 15000,
+        });
+
+        if (res.data && res.data.postInfos && Array.isArray(res.data.postInfos)) {
+            const post = res.data.postInfos.find(p => p.postId === postId || p.postID === postId);
+            if (post) return post;
+            if (!res.data.hasMore) break;
+        }
+    }
+    return null;
+}
+
+function normalizeMedia(post) {
+    const CACHE_URL = "https://cache.lahelu.com/";
+    const medias = [];
+
+    if (post.mediaType === "video" || post.type === "video") {
+        const videoUrl = post.media?.startsWith("http") ? post.media : CACHE_URL + post.media;
+        medias.push({
+            type: "video",
+            format: "mp4",
+            url: videoUrl,
+            desc: "Video",
+        });
+    } else if (post.mediaType === "image" || post.type === "image") {
+        const imageUrl = post.media?.startsWith("http") ? post.media : CACHE_URL + post.media;
+        medias.push({
+            type: "image",
+            format: getExtFromUrl(imageUrl, ".jpg"),
+            url: imageUrl,
+            desc: "Image",
+        });
+    }
+
+    if (post.content && Array.isArray(post.content) && post.content.length > 0) {
+        const firstItem = post.content[0];
+        const mediaUrl = firstItem.value?.startsWith("http") ? firstItem.value : CACHE_URL + firstItem.value;
+        const isVideo = firstItem.type === "video" || (firstItem.value && firstItem.value.match(/\.(mp4|webm|mov)(\?.*)?$/i));
+        const mediaType = isVideo ? "video" : "image";
+        const format = mediaType === "video" ? "mp4" : getExtFromUrl(mediaUrl, ".jpg");
+
+        medias.push({
+            type: mediaType,
+            format: format,
+            url: mediaUrl,
+            desc: mediaType === "video" ? "Video" : "Image",
+        });
+    }
+
+    return medias;
+}
+
+async function laheluDownloader(url) {
+    try {
+        if (!isLaheluUrl(url)) {
+            return {
+                status: false,
+                platform: "lahelu",
+                message: "Invalid Lahelu URL. Make sure it's a valid post URL.",
+            };
+        }
+
+        const postId = extractPostId(url);
+        if (!postId) {
+            return {
+                status: false,
+                platform: "lahelu",
+                message: "Could not extract post ID from URL.",
+            };
+        }
+
+        const post = await fetchLaheluData(postId);
+
+        if (!post) {
+            return {
+                status: false,
+                platform: "lahelu",
+                message: "Post not found. The post may have been deleted or is private.",
+            };
+        }
+
+        const medias = normalizeMedia(post);
+
+        if (medias.length === 0) {
+            return {
+                status: false,
+                platform: "lahelu",
+                message: "No media found in this post.",
+            };
+        }
+
+        const title = post.title || "Untitled";
+        const author = post.userUsername || post.userInfo?.username || "Unknown";
+        const createdAt = post.createTime ? new Date(post.createTime * 1000).toLocaleDateString("en-US") : "-";
+        const views = parseInt(post.totalViews || 0, 10);
+        const likes = parseInt(post.totalUpvotes || 0, 10);
+        const comments = parseInt(post.totalComments || 0, 10);
+
+        const selected = medias[0];
+        const ext = selected.format.startsWith(".") ? selected.format : "." + selected.format;
+        const safeTitle = sanitizeFileName(postId);
+        const fileName = `${safeTitle}_${selected.type}${ext}`;
+
+        return {
+            status: true,
+            platform: "lahelu",
+            data: {
+                postId: post.postId || post.postID || postId,
+                title: title,
+                author: author,
+                createdAt: createdAt,
+                stats: {
+                    views: views,
+                    likes: likes,
+                    comments: comments,
+                },
+                media: {
+                    type: selected.type,
+                    format: selected.format,
+                    url: selected.url,
+                    desc: selected.desc,
+                },
+                fileName: fileName,
+            },
+        };
+    } catch (error) {
+        return {
+            status: false,
+            platform: "lahelu",
+            message: error.message || "An unexpected error occurred",
+        };
+    }
+}
+
+module.exports = laheluDownloader;

package/src/lib/tiktok.js

@@ -7,17 +7,88 @@ try {
     wrapper = require('axios-cookiejar-support').wrapper;
 } catch (err) { }
 
-async function tiktokDownloader(url) {
+function extractVideoId(url) {
+    const match = url.match(/\/(?:video|photo)\/(\d+)/);
+    return match ? match[1] : null;
+}
+
+async function tiktokViaTikwm(url) {
+    const res = await axios.post('https://www.tikwm.com/api/',
+        new URLSearchParams({ url, count: 12, cursor: 0, web: 1, hd: 1 }).toString(),
+        {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36',
+            },
+            timeout: 15000,
+        }
+    );
+
+    const apiData = res.data;
+    if (!apiData || apiData.code !== 0 || !apiData.data) {
+        throw new Error('tikwm API returned an error or empty data.');
+    }
+
+    const d = apiData.data;
+    const isImages = d.images && d.images.length > 0;
+
+    const importantData = {
+        videoId: d.id,
+        description: d.title,
+        createTime: d.create_time,
+        videoUrl: isImages ? null : (d.hdplay || d.play),
+        videoInfo: {
+            size: d.size || null,
+            duration: d.duration,
+            width: d.width || null,
+            height: d.height || null,
+            definition: d.hd_size ? 'hd' : 'sd',
+            coverUrl: d.cover || d.origin_cover,
+            subtitles: []
+        },
+        author: {
+            id: d.author?.id,
+            uniqueId: d.author?.unique_id,
+            nickname: d.author?.nickname,
+            avatarThumb: d.author?.avatar
+        },
+        music: {
+            id: d.music_info?.id,
+            title: d.music_info?.title,
+            authorName: d.music_info?.author,
+            playUrl: d.music_info?.play || d.music,
+            isOriginal: d.music_info?.original
+        },
+        stats: {
+            likes: d.digg_count,
+            shares: d.share_count,
+            comments: d.comment_count,
+            plays: d.play_count,
+            collects: d.collect_count,
+            reposts: null
+        },
+        locationCreated: null,
+        videoBuffer: null,
+    };
+
+    if (isImages) {
+        importantData.images = d.images;
+        importantData.videoInfo.type = 'images';
+    }
+
+    return {
+        status: true,
+        platform: "tiktok",
+        data: importantData
+    };
+}
+
+async function tiktokViaDirect(url) {
     if (!CookieJar || !wrapper) {
-        return {
-            status: false,
-            platform: "tiktok",
-            message: 'tough-cookie and axios-cookiejar-support are required for TikTok downloads. Install them with: npm install tough-cookie axios-cookiejar-support'
-        };
+        throw new Error('Direct scraping requires tough-cookie and axios-cookiejar-support.');
     }
 
     const jar = new CookieJar();
-
     const apiClient = axios.create({
         jar: jar,
         withCredentials: true,
@@ -27,93 +98,142 @@ async function tiktokDownloader(url) {
     });
     wrapper(apiClient);
 
-    try {
-        const htmlResponse = await apiClient.get(url);
-        const html = htmlResponse.data;
-
-        const $ = cheerio.load(html);
-        const scriptContent = $('#__UNIVERSAL_DATA_FOR_REHYDRATION__').html();
-        if (!scriptContent) throw new Error('Script tag #__UNIVERSAL_DATA_FOR_REHYDRATION__ not found.');
-        const jsonData = JSON.parse(scriptContent);
-        const itemStruct = jsonData?.__DEFAULT_SCOPE__?.["webapp.video-detail"]?.itemInfo?.itemStruct;
-        if (!itemStruct) throw new Error('itemStruct not found within the JSON data.');
-
-        const videoUrlToDownload = itemStruct.video?.downloadAddr || itemStruct.video?.playAddr;
-        const videoId = itemStruct.id;
-
-        const importantData = {
-            videoId: videoId,
-            description: itemStruct.desc,
-            createTime: itemStruct.createTime,
-            videoUrl: videoUrlToDownload,
-            videoInfo: {
-                size: null,
-                duration: itemStruct.video?.duration,
-                width: itemStruct.video?.width,
-                height: itemStruct.video?.height,
-                definition: itemStruct.video?.definition,
-                coverUrl: itemStruct.video?.cover,
-                subtitles: itemStruct.video?.subtitleInfos?.map(sub => ({
-                    language: sub.LanguageCodeName, url: sub.Url, format: sub.Format, source: sub.Source
-                })) || []
-            },
-            author: {
-                id: itemStruct.author?.id,
-                uniqueId: itemStruct.author?.uniqueId,
-                nickname: itemStruct.author?.nickname,
-                avatarThumb: itemStruct.author?.avatarThumb
-            },
-            music: {
-                id: itemStruct.music?.id,
-                title: itemStruct.music?.title,
-                authorName: itemStruct.music?.authorName,
-                playUrl: itemStruct.music?.playUrl,
-                isOriginal: itemStruct.music?.original
-            },
-            stats: {
-                likes: itemStruct.statsV2?.diggCount ?? itemStruct.stats?.diggCount,
-                shares: itemStruct.statsV2?.shareCount ?? itemStruct.stats?.shareCount,
-                comments: itemStruct.statsV2?.commentCount ?? itemStruct.stats?.commentCount,
-                plays: itemStruct.statsV2?.playCount ?? itemStruct.stats?.playCount,
-                collects: itemStruct.statsV2?.collectCount ?? itemStruct.stats?.collectCount,
-                reposts: itemStruct.statsV2?.repostCount
-            },
-            locationCreated: itemStruct.locationCreated,
-            videoBuffer: null
-        };
+    const htmlResponse = await apiClient.get(url);
+    const html = htmlResponse.data;
+    const $ = cheerio.load(html);
+    let itemStruct = null;
+
+    // Approach 1: __UNIVERSAL_DATA_FOR_REHYDRATION__
+    const universalData = $('#__UNIVERSAL_DATA_FOR_REHYDRATION__').html();
+    if (universalData) {
+        try {
+            const jsonData = JSON.parse(universalData);
+            itemStruct = jsonData?.__DEFAULT_SCOPE__?.["webapp.video-detail"]?.itemInfo?.itemStruct;
+        } catch { }
+    }
+
+    // Approach 2: __NEXT_DATA__
+    if (!itemStruct) {
+        const nextData = $('#__NEXT_DATA__').html();
+        if (nextData) {
+            try {
+                const jsonData = JSON.parse(nextData);
+                itemStruct = jsonData?.props?.pageProps?.itemInfo?.itemStruct;
+            } catch { }
+        }
+    }
 
-        if (videoUrlToDownload) {
+    // Approach 3: SIGI_STATE script
+    if (!itemStruct) {
+        const sigiScript = $('script').filter((_, el) => {
+            const text = $(el).html() || '';
+            return text.includes('SIGI_STATE') || text.includes('"ItemModule"');
+        }).html();
+        if (sigiScript) {
             try {
-                const videoResponse = await apiClient.get(videoUrlToDownload, {
-                    responseType: 'arraybuffer',
-                    headers: {
-                        'Referer': url,
-                        'Range': 'bytes=0-'
+                const match = sigiScript.match(/window\['SIGI_STATE'\]\s*=\s*(\{.+?\});/s)
+                    || sigiScript.match(/SIGI_STATE\s*=\s*(\{.+?\});/s);
+                if (match) {
+                    const sigiData = JSON.parse(match[1]);
+                    const itemModule = sigiData?.ItemModule;
+                    if (itemModule) {
+                        const firstKey = Object.keys(itemModule)[0];
+                        if (firstKey) itemStruct = itemModule[firstKey];
                     }
-                });
+                }
+            } catch { }
+        }
+    }
+
+    if (!itemStruct) throw new Error('Direct scraping failed.');
+
+    const videoUrlToDownload = itemStruct.video?.downloadAddr || itemStruct.video?.playAddr;
+    const videoId = itemStruct.id;
 
-                if (videoResponse.status === 200 || videoResponse.status === 206) {
-                    importantData.videoBuffer = Buffer.from(videoResponse.data);
-                    importantData.videoInfo.size = videoResponse.data.length;
+    const importantData = {
+        videoId: videoId,
+        description: itemStruct.desc,
+        createTime: itemStruct.createTime,
+        videoUrl: videoUrlToDownload,
+        videoInfo: {
+            size: null,
+            duration: itemStruct.video?.duration,
+            width: itemStruct.video?.width,
+            height: itemStruct.video?.height,
+            definition: itemStruct.video?.definition,
+            coverUrl: itemStruct.video?.cover,
+            subtitles: itemStruct.video?.subtitleInfos?.map(sub => ({
+                language: sub.LanguageCodeName, url: sub.Url, format: sub.Format, source: sub.Source
+            })) || []
+        },
+        author: {
+            id: itemStruct.author?.id,
+            uniqueId: itemStruct.author?.uniqueId,
+            nickname: itemStruct.author?.nickname,
+            avatarThumb: itemStruct.author?.avatarThumb
+        },
+        music: {
+            id: itemStruct.music?.id,
+            title: itemStruct.music?.title,
+            authorName: itemStruct.music?.authorName,
+            playUrl: itemStruct.music?.playUrl,
+            isOriginal: itemStruct.music?.original
+        },
+        stats: {
+            likes: itemStruct.statsV2?.diggCount ?? itemStruct.stats?.diggCount,
+            shares: itemStruct.statsV2?.shareCount ?? itemStruct.stats?.shareCount,
+            comments: itemStruct.statsV2?.commentCount ?? itemStruct.stats?.commentCount,
+            plays: itemStruct.statsV2?.playCount ?? itemStruct.stats?.playCount,
+            collects: itemStruct.statsV2?.collectCount ?? itemStruct.stats?.collectCount,
+            reposts: itemStruct.statsV2?.repostCount
+        },
+        locationCreated: itemStruct.locationCreated,
+        videoBuffer: null
+    };
+
+    if (videoUrlToDownload) {
+        try {
+            const videoResponse = await apiClient.get(videoUrlToDownload, {
+                responseType: 'arraybuffer',
+                headers: {
+                    'Referer': url,
+                    'Range': 'bytes=0-'
                 }
-            } catch (videoError) {
-                console.error(`Error downloading video: ${videoError.message}`);
+            });
+
+            if (videoResponse.status === 200 || videoResponse.status === 206) {
+                importantData.videoBuffer = Buffer.from(videoResponse.data);
+                importantData.videoInfo.size = videoResponse.data.length;
             }
+        } catch (videoError) {
+            // Video download failed, but metadata is still available
         }
+    }
 
-        return {
-            status: true,
-            platform: "tiktok",
-            data: importantData
-        };
+    return {
+        status: true,
+        platform: "tiktok",
+        data: importantData
+    };
+}
+
+async function tiktokDownloader(url) {
+    // Try direct scraping first
+    try {
+        return await tiktokViaDirect(url);
+    } catch { }
 
+    // Fallback: tikwm.com API
+    try {
+        return await tiktokViaTikwm(url);
     } catch (error) {
         return {
             status: false,
             platform: "tiktok",
-            message: error.message || 'An unexpected error occurred'
+            message: error.message || 'All TikTok scraping methods failed.'
         };
     }
 }
 
 module.exports = tiktokDownloader;
+

package/src/lib/twitter.js

@@ -59,14 +59,31 @@ async function getTokens(tweetUrl) {
     }
 
     const { data: redirectPageData } = await axios.get(tweetUrl, { headers: DEFAULT_HEADERS });
-    const mainJsUrlMatch = redirectPageData.match(/https:\/\/abs.twimg.com\/responsive-web\/client-web-legacy\/main\.[^\.]+\.js/);
 
-    if (!mainJsUrlMatch) {
-        throw new Error('Failed to find main JS URL.');
+    // Try multiple patterns for the main JS bundle URL
+    const mainJsPatterns = [
+        /https:\/\/abs\.twimg\.com\/responsive-web\/client-web-legacy\/main\.[^\.]+\.js/,
+        /https:\/\/abs\.twimg\.com\/responsive-web\/client-web\/main\.[^\.]+\.js/,
+        /https:\/\/abs\.twimg\.com\/responsive-web\/[^\/]+\/main\.[^"'\s]+\.js/,
+    ];
+
+    let bearerToken = null;
+
+    for (const pattern of mainJsPatterns) {
+        const match = redirectPageData.match(pattern);
+        if (match) {
+            try {
+                bearerToken = await extractBearerToken(match[0]);
+                break;
+            } catch { }
+        }
+    }
+
+    // Fallback: use the well-known public guest bearer token
+    if (!bearerToken) {
+        bearerToken = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
     }
 
-    const mainJsUrl = mainJsUrlMatch[0];
-    const bearerToken = await extractBearerToken(mainJsUrl);
     const guestToken = await getGuestToken(redirectPageData);
     const tokens = { bearer: bearerToken, guest: guestToken };
     tokenCache.set(tweetUrl, tokens);

package/src/lib/youtube.js

@@ -33,6 +33,7 @@ async function youtubeDownloader(link, qualityIndex) {
     if (!youtubedl) {
         return {
             status: false,
+            platform: "youtube",
             message: `youtube-dl-exec not found, can't download video`,
         };
     }