@lmna22/aio-downloader 2.0.1 → 2.0.3

package/README.md

@@ -1,6 +1,6 @@
 # @lmna22/aio-downloader
 
-> All-in-one media downloader for YouTube, Instagram, TikTok, Pinterest, Pixiv, X/Twitter, and Lahelu.
+> All-in-one media downloader for YouTube, Instagram, TikTok, Pinterest, Pixiv, X (Twitter), Lahelu, Xiaohongshu (RedNote), and more.
 
 [![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)
@@ -21,6 +21,9 @@ Scrape and download videos, audio, and images from multiple platforms with a sin
 | **Pixiv** | — | — | ✅ (Original Resolution) | ✅ |
 | **X / Twitter** | ✅ (Best quality) | — | ✅ | — |
 | **Lahelu** | ✅ | — | ✅ | — |
+| **Xiaohongshu/RedNote** | ✅ | — | ✅ | — |
+| **Dailymotion** | ✅ | ✅ | ✅ | ✅ |
+| **Spotify** | — | ✅ (MP3, Opus, WAV) | — | — |
 
 - 🔗 **Auto-detect platform** from URL — just pass any supported link
 - 📦 **Programmatic API** — designed for Node.js applications, bots, and scripts
@@ -95,7 +98,77 @@ const { lmna } = require("@lmna22/aio-downloader");
 const result = await lmna.tiktok("https://www.tiktok.com/@user/video/1234567890");
 ```
 
-*(See the API Reference below for other platforms: Pinterest, Pixiv, Twitter, Lahelu)*
+### Xiaohongshu / RedNote
+
+```javascript
+const { lmna } = require("@lmna22/aio-downloader");
+
+const result = await lmna.xiaohongshu("https://www.xiaohongshu.com/explore/abc123");
+
+if (result.status) {
+    console.log(result.data.title);
+    console.log(result.data.author.nickname);
+    console.log(result.data.stats.likes);
+    console.log(result.data.stats.collects);
+    console.log(result.data.stats.comments);
+    console.log(result.data.media.url);
+
+    // Download the media
+    const { download } = require("@lmna22/aio-downloader");
+    await download(result.data.media.url, `./downloads/${result.data.fileName}`);
+}
+```
+
+### Dailymotion
+
+```javascript
+const { lmna } = require("@lmna22/aio-downloader");
+
+// Download video
+const result = await lmna.dailymotion("https://www.dailymotion.com/video/x8z3v2y");
+
+if (result.status) {
+    console.log(result.data.title);
+    console.log(result.data.author);
+    console.log(result.data.views);
+    console.log(result.data.url);
+}
+
+// Search videos
+const searchResult = await lmna.dailymotion("https://www.dailymotion.com/search/programming", { query: "programming", limit: 10 });
+
+if (searchResult.status) {
+    console.log(searchResult.data.videos);
+}
+```
+
+### Spotify
+
+```javascript
+const { lmna } = require("@lmna22/aio-downloader");
+
+// Get track metadata (returns search query, does not download)
+const result = await lmna.spotify("https://open.spotify.com/track/4cOdK2wGLETKBW3PvgPWqT");
+
+if (result.status) {
+    console.log(result.data.title);
+    console.log(result.data.artist);
+    console.log(result.data.cover);
+    console.log(result.data.searchQuery); // Use this to download with yt-dlp
+    
+    // Download using yt-dlp or similar tool
+    // Example: yt-dlp "ytsearch1:Never Gonna Give You Up audio" --extract-audio --audio-format mp3
+}
+
+// Supported formats: mp3, opus, wav
+const mp3Result = await lmna.spotify("https://open.spotify.com/track/abc123", { format: 'mp3' });
+const opusResult = await lmna.spotify("https://open.spotify.com/track/abc123", { format: 'opus' });
+const wavResult = await lmna.spotify("https://open.spotify.com/track/abc123", { format: 'wav' });
+```
+
+**Note:** Spotify scraper returns metadata and a search query. Use yt-dlp or similar tool to download the actual audio file using the provided searchQuery.
+
+*(See the API Reference below for other platforms: Pinterest, Pixiv, Twitter, Lahelu, Dailymotion)*
 
 ---
 
@@ -132,6 +205,12 @@ 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");
+await aioDownloader("https://www.xiaohongshu.com/explore/abc123");
+await aioDownloader("https://www.rednote.com/explore/abc123");
+await aioDownloader("https://xhslink.com/abc123");
+await aioDownloader("https://www.dailymotion.com/video/x8z3v2y");
+await aioDownloader("https://www.dailymotion.com/search/programming");
+await aioDownloader("https://open.spotify.com/track/4cOdK2wGLETKBW3PvgPWqT");
 
 // Force a specific platform
 await aioDownloader("https://example.com/video", { platform: "youtube", quality: 5 });
@@ -145,6 +224,12 @@ 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://xiaohongshu.com/explore/abc"); // "xiaohongshu"
+detectPlatform("https://rednote.com/explore/abc");   // "xiaohongshu"
+detectPlatform("https://xhslink.com/abc");           // "xiaohongshu"
+detectPlatform("https://dailymotion.com/video/x8z3v2y"); // "dailymotion"
+detectPlatform("https://dailymotion.com/search/music"); // "dailymotion"
+detectPlatform("https://open.spotify.com/track/abc123"); // "spotify"
 detectPlatform("https://unknown.com");               // null
 ```
 
@@ -167,6 +252,11 @@ await lmna.pinterest(url, options);
 await lmna.pixiv(url, options);
 await lmna.twitter(url);
 await lmna.lahelu(url);
+await lmna.xiaohongshu(url);
+await lmna.dailymotion(url, options);
+await lmna.spotify(url, options);
+
+// All return: { status, platform, data?, message? }
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lmna22/aio-downloader",
-    "version": "2.0.1",
+    "version": "2.0.3",
     "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": {
@@ -20,7 +20,10 @@
         "image",
         "media",
         "scraper",
-        "aio"
+        "aio",
+        "lahelu",
+        "dailymotion",
+        "xiaohongshu"
     ],
     "author": "",
     "license": "MIT",
@@ -37,18 +40,11 @@
         "axios-cookiejar-support": "^5.0.0",
         "cheerio": "^1.0.0",
         "ffmpeg-static": "^5.0.0",
+        "puppeteer": "^24.40.0",
         "qs": "^6.13.0",
         "tough-cookie": "^5.1.0",
         "youtube-dl-exec": "^3.1.4"
     },
-    "peerDependencies": {
-        "puppeteer": ">=20.0.0"
-    },
-    "peerDependenciesMeta": {
-        "puppeteer": {
-            "optional": true
-        }
-    },
     "engines": {
         "node": ">=14.0.0"
     }

package/src/index.js

@@ -5,6 +5,9 @@ const pinterestDownloader = require("./lib/pinterest");
 const pixivDownloader = require("./lib/pixiv");
 const twitterDownloader = require("./lib/twitter");
 const laheluDownloader = require("./lib/lahelu");
+const xiaohongshuDownloader = require("./lib/xiaohongshu");
+const dailymotionDownloader = require("./lib/dailymotion");
+const spotifyDownloader = require("./lib/spotify");
 const download = require("./download");
 
 const PLATFORM_PATTERNS = [
@@ -15,6 +18,9 @@ const PLATFORM_PATTERNS = [
     { 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) },
+    { name: "xiaohongshu", test: (url) => /xiaohongshu\.com|rednote\.com|xhslink\.com/i.test(url) },
+    { name: "dailymotion", test: (url) => /dailymotion\.com\//i.test(url) },
+    { name: "spotify", test: (url) => /open\.spotify\.com\//i.test(url) },
 ];
 
 function detectPlatform(url) {
@@ -32,6 +38,9 @@ const scrapers = {
     pixiv: (url, options) => pixivDownloader(url, options),
     twitter: (url) => twitterDownloader(url),
     lahelu: (url) => laheluDownloader(url),
+    xiaohongshu: (url) => xiaohongshuDownloader(url),
+    dailymotion: (url, options) => dailymotionDownloader(url, options),
+    spotify: (url, options) => spotifyDownloader(url, options),
 };
 
 async function aioDownloader(url, options = {}) {
@@ -39,7 +48,7 @@ async function aioDownloader(url, options = {}) {
 
     if (!platform) {
         throw new Error(
-            `Unsupported or unrecognized URL: ${url}. Supported platforms: YouTube, Instagram, TikTok, Pinterest, Pixiv, X/Twitter.`
+            `Unsupported or unrecognized URL: ${url}. Supported platforms: YouTube, Instagram, TikTok, Pinterest, Pixiv, X/Twitter, Dailymotion, Spotify.`
         );
     }
 
@@ -60,6 +69,9 @@ const lmna = {
     pixiv: (url, options) => pixivDownloader(url, options),
     twitter: (url) => twitterDownloader(url),
     lahelu: (url) => laheluDownloader(url),
+    xiaohongshu: (url) => xiaohongshuDownloader(url),
+    dailymotion: (url, options) => dailymotionDownloader(url, options),
+    spotify: (url, options) => spotifyDownloader(url, options),
 };
 
 module.exports = {

package/src/lib/dailymotion.js

@@ -0,0 +1,278 @@
+const puppeteer = require('puppeteer');
+
+function extractVideoId(url) {
+    const patterns = [
+        /dailymotion\.com\/video\/([a-zA-Z0-9]+)/,
+        /dai\.ly\/([a-zA-Z0-9]+)/,
+        /dailymotion\.com\/embed\/video\/([a-zA-Z0-9]+)/,
+    ];
+
+    for (const pattern of patterns) {
+        const match = url.match(pattern);
+        if (match) return match[1];
+    }
+    return null;
+}
+
+async function fetchDailymotionData(url) {
+    const videoId = extractVideoId(url);
+    if (!videoId) {
+        throw new Error('Invalid Dailymotion URL');
+    }
+
+    let browser;
+    try {
+        browser = await puppeteer.launch({
+            headless: 'new',
+            args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-gpu']
+        });
+
+        const page = await browser.newPage();
+        await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
+
+        let videoData = null;
+        let masterM3U8Url = null;
+        let masterM3U8Content = null;
+
+        page.on('response', async (response) => {
+            const resUrl = response.url();
+
+            if (resUrl.includes('geo.dailymotion.com') && resUrl.includes('/video/') && resUrl.includes('.json') && !resUrl.includes('fields=')) {
+                try {
+                    const data = await response.json();
+                    if (data && data.id === videoId) {
+                        videoData = data;
+                    }
+                } catch (e) { }
+            }
+
+            if (resUrl.includes('cdndirector.dailymotion.com') && resUrl.includes('.m3u8') && !resUrl.includes('cookie_sync') && !resUrl.includes('af=')) {
+                try {
+                    const text = await response.text();
+                    if (text.includes('#EXTM3U') && text.includes('#EXT-X-STREAM-INF')) {
+                        masterM3U8Url = resUrl;
+                        masterM3U8Content = text;
+                    }
+                } catch (e) { }
+            }
+
+            if (resUrl.includes('graphql-eu-west-1.api.dailymotion.com') && resUrl.includes('video')) {
+                try {
+                    const data = await response.json();
+                    if (data && data.data && data.data.video && data.data.video.xid === videoId) {
+                        const v = data.data.video;
+                        videoData = {
+                            id: v.xid || v.id,
+                            title: v.title,
+                            description: v.description,
+                            duration: v.duration,
+                            author: v.author,
+                            thumbnails: {
+                                '360': v.thumbnailx360,
+                                '480': v.thumbnailx480,
+                                '720': v.thumbnailx720
+                            },
+                            created_time: v.createdAt ? Math.floor(new Date(v.createdAt).getTime() / 1000) : null,
+                            views_total: v.views,
+                            likes_total: v.likes
+                        };
+                    }
+                } catch (e) { }
+            }
+        });
+
+        await page.goto(url, {
+            waitUntil: 'networkidle0',
+            timeout: 30000
+        });
+
+        await new Promise(r => setTimeout(r, 5000));
+
+        if (!videoData) {
+            videoData = await page.evaluate((id) => {
+                const content = document.documentElement.outerHTML;
+
+                const jsonPattern = new RegExp('{"id":"[^"]*' + id + '[^}]*"title":"[^"]+"[^}]*}', 'g');
+                const matches = content.match(jsonPattern);
+
+                if (matches && matches.length > 0) {
+                    for (const match of matches) {
+                        try {
+                            const data = JSON.parse(match);
+                            if (data.id === id && data.title) {
+                                return {
+                                    id: data.id,
+                                    title: data.title,
+                                    description: data.description || '',
+                                    duration: data.duration || 0,
+                                    author: data.author || '',
+                                    thumbnails: data.thumbnails || {},
+                                    created_time: data.created_time,
+                                    views_total: data.views_total,
+                                    likes_total: data.likes_total
+                                };
+                            }
+                        } catch (e) { }
+                    }
+                }
+                return null;
+            }, videoId);
+        }
+
+        if (!videoData) {
+            throw new Error('Failed to fetch video metadata');
+        }
+
+        if (!masterM3U8Content || !masterM3U8Content.includes('#EXT-X-STREAM-INF')) {
+            throw new Error('No video stream found');
+        }
+
+        await browser.close();
+
+        const lines = masterM3U8Content.split('\n');
+        const streams = [];
+        let currentBandwidth = 0;
+        let currentResolution = '';
+        let currentName = '';
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (line.startsWith('#EXT-X-STREAM-INF:')) {
+                const bwMatch = line.match(/BANDWIDTH=(\d+)/);
+                const resMatch = line.match(/RESOLUTION=(\d+x\d+)/);
+                const nameMatch = line.match(/NAME="([^"]+)"/);
+
+                currentBandwidth = bwMatch ? parseInt(bwMatch[1]) : 0;
+                currentResolution = resMatch ? resMatch[1] : '';
+                currentName = nameMatch ? nameMatch[1] : '';
+            } else if (line && !line.startsWith('#') && (line.includes('.m3u8') || line.includes('dmcdn'))) {
+                if (currentResolution) {
+                    const [width, height] = currentResolution.split('x').map(Number);
+                    const fullUrl = line.startsWith('http') ? line : masterM3U8Url.substring(0, masterM3U8Url.lastIndexOf('/') + 1) + line;
+                    streams.push({
+                        quality: currentName ? `${currentName}p` : `${height}p`,
+                        height: height,
+                        width: width,
+                        bandwidth: currentBandwidth,
+                        name: currentName,
+                        fps: null,
+                        formatId: currentResolution,
+                        type: 'MP4',
+                        url: fullUrl,
+                    });
+                }
+                currentResolution = '';
+            }
+        }
+
+        if (streams.length === 0) {
+            throw new Error('No video qualities found in manifest');
+        }
+
+        streams.sort((a, b) => a.height - b.height);
+
+        streams.push({
+            quality: 'Audio Only',
+            height: 0,
+            width: 0,
+            bandwidth: streams[0].bandwidth,
+            name: 'Audio',
+            fps: null,
+            formatId: 'audio',
+            type: 'MP3',
+            url: streams[0].url,
+        });
+
+        const metadata = {
+            id: videoData.id || videoId,
+            title: videoData.title || 'Unknown',
+            description: videoData.description || '',
+            duration: videoData.duration || 0,
+            views: parseInt(videoData.views_total) || 0,
+            likes: parseInt(videoData.likes_total) || 0,
+            owner: {
+                screenname: videoData.owner?.screenname || videoData.author || '',
+                username: videoData.owner?.username || '',
+                id: videoData.owner?.id || '',
+            },
+            thumbnail: videoData.thumbnails?.['720'] || videoData.thumbnails?.['480'] || videoData.thumbnails?.['360'] || '',
+            uploadDate: videoData.created_time ? new Date(videoData.created_time * 1000).toISOString() : '',
+        };
+
+        return {
+            metadata,
+            streams,
+            info: videoData,
+        };
+    } catch (err) {
+        if (browser) await browser.close().catch(() => { });
+        throw err;
+    }
+}
+
+async function dailymotionDownloader(url) {
+    if (typeof url !== 'string' || (!url.includes('dailymotion.com') && !url.includes('dai.ly'))) {
+        return {
+            status: false,
+            platform: "dailymotion",
+            message: 'Invalid Dailymotion URL'
+        };
+    }
+
+    try {
+        const data = await fetchDailymotionData(url);
+
+        if (!data || !data.metadata || !data.streams || data.streams.length === 0) {
+            return {
+                status: false,
+                platform: "dailymotion",
+                message: 'Failed to get video data'
+            };
+        }
+
+        const { metadata, streams } = data;
+
+        const videoUrls = streams
+            .filter(s => s.quality !== 'Audio Only')
+            .map(s => s.url);
+
+        const audioUrl = streams.find(s => s.quality === 'Audio Only')?.url;
+
+        const qualities = streams
+            .filter(s => s.quality !== 'Audio Only')
+            .map(s => ({
+                quality: s.quality,
+                resolution: `${s.width}x${s.height}`,
+                bandwidth: s.bandwidth,
+                url: s.url
+            }));
+
+        return {
+            status: true,
+            platform: "dailymotion",
+            data: {
+                id: metadata.id,
+                title: metadata.title,
+                description: metadata.description,
+                duration: metadata.duration,
+                views: metadata.views,
+                likes: metadata.likes,
+                author: metadata.owner?.screenname || metadata.owner?.username,
+                thumbnail: metadata.thumbnail,
+                uploadDate: metadata.uploadDate,
+                url: videoUrls.length > 0 ? videoUrls : [audioUrl],
+                audio: audioUrl || null,
+                qualities: qualities,
+                isVideo: true
+            }
+        };
+    } catch (error) {
+        return {
+            status: false,
+            platform: "dailymotion",
+            message: error.message
+        };
+    }
+}
+
+module.exports = dailymotionDownloader;

package/src/lib/spotify.js

@@ -0,0 +1,89 @@
+const axios = require('axios');
+const youtubedl = require('youtube-dl-exec');
+
+async function getSpotifyTrackInfo(url) {
+    try {
+        const trackId = url.split('track/')[1]?.split('?')[0] || url.split('track/')[1]?.split('/')[0];
+
+        if (!trackId) {
+            throw new Error('Invalid Spotify track URL');
+        }
+
+        const { data } = await axios.get(`https://open.spotify.com/oembed?url=${encodeURIComponent(url)}`, {
+            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'
+            }
+        });
+
+        let title = data.title || 'Unknown Title';
+        let cover = data.thumbnail_url || '';
+
+        const searchQuery = title;
+
+        return {
+            id: trackId,
+            title: title.replace(/\s*-\s*(Original Audio|Spotify|Audio|Official Video|Lyrics)$/i, '').trim(),
+            artist: 'Spotify Track',
+            cover: cover,
+            url: url,
+            searchQuery: searchQuery
+        };
+    } catch (e) {
+        throw new Error('Failed to fetch Spotify metadata: ' + e.message);
+    }
+}
+
+async function spotifyDownloader(url, options = {}) {
+    const { format = 'mp3' } = options;
+
+    if (typeof url !== 'string' || !url.includes('spotify.com/')) {
+        return {
+            status: false,
+            platform: 'spotify',
+            message: 'Invalid Spotify URL. Only track links are supported.'
+        };
+    }
+
+    try {
+        const trackMetadata = await getSpotifyTrackInfo(url);
+
+        // search on youtube for the track
+        let videoUrl = null;
+        try {
+            const searchResult = await youtubedl(`ytsearch1:${trackMetadata.searchQuery}`, {
+                dumpSingleJson: true,
+                noCheckCertificates: true,
+                noWarnings: true,
+            });
+            videoUrl = searchResult.entries?.[0]?.webpage_url || null;
+        } catch (err) {
+            console.error('Spotify YouTube Search Error:', err.message);
+        }
+
+        return {
+            status: true,
+            platform: 'spotify',
+            data: {
+                id: trackMetadata.id,
+                title: trackMetadata.title,
+                artist: trackMetadata.artist,
+                cover: trackMetadata.cover,
+                url: trackMetadata.url,
+                videoUrl: videoUrl, // This will be used by test.js to auto-download
+                searchQuery: trackMetadata.searchQuery,
+                format: format,
+                isAudio: true,
+                message: videoUrl ? 'Successfully found a matching video on YouTube' : 'Could not find a matching video on YouTube'
+            }
+        };
+
+    } catch (err) {
+        return {
+            status: false,
+            platform: 'spotify',
+            message: err.message
+        };
+    }
+}
+
+module.exports = spotifyDownloader;

package/src/lib/xiaohongshu.js

@@ -0,0 +1,288 @@
+const axios = require("axios");
+const path = require("path");
+const { sanitizeFileName, getExtFromUrl } = require("../utils");
+
+let puppeteer;
+try {
+    puppeteer = require("puppeteer");
+} catch (err) { }
+
+function isXiaohongshuUrl(url) {
+    try {
+        const u = new URL(url);
+        return u.hostname.includes("xiaohongshu.com") || 
+               u.hostname.includes("rednote.com") || 
+               u.hostname.includes("xhslink.com");
+    } catch {
+        return false;
+    }
+}
+
+function parseNoteId(url) {
+    const patterns = [
+        /xiaohongshu\.com\/(?:explore|discovery\/item)\/([a-f0-9]+)/i,
+        /rednote\.com\/(?:explore|discovery\/item)\/([a-f0-9]+)/i,
+        /xhslink\.com\/([a-zA-Z0-9]+)/i,
+    ];
+
+    for (const pattern of patterns) {
+        const match = url.match(pattern);
+        if (match) return match[1];
+    }
+    return null;
+}
+
+function buildPostUrl(noteIdOrUrl) {
+    if (noteIdOrUrl.startsWith("http")) return noteIdOrUrl;
+    return `https://www.xiaohongshu.com/explore/${noteIdOrUrl}`;
+}
+
+async function resolveShortLink(url) {
+    if (!url.includes("xhslink.com")) return url;
+
+    try {
+        const res = await axios.head(url, {
+            maxRedirects: 5,
+            headers: {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+            },
+        });
+        return res.request.res.responseUrl || url;
+    } catch (e) {
+        if (e.response && e.response.headers && e.response.headers.location) {
+            return e.response.headers.location;
+        }
+    }
+    return url;
+}
+
+async function fetchXiaohongshuData(url) {
+    if (!puppeteer) {
+        throw new Error("Puppeteer is required for Xiaohongshu downloads. Install it with: npm install puppeteer");
+    }
+
+    let browser = null;
+    try {
+        browser = await puppeteer.launch({
+            headless: "new",
+            args: [
+                "--disable-blink-features=AutomationControlled",
+                "--disable-web-security",
+                "--disable-features=IsolateOrigins,site-per-process",
+                "--window-size=1920,1080",
+                "--no-sandbox",
+                "--disable-setuid-sandbox",
+            ],
+        });
+
+        const page = await browser.newPage();
+        await page.setViewport({ width: 1920, height: 1080 });
+
+        await page.setUserAgent(
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36"
+        );
+
+        await page.evaluateOnNewDocument(() => {
+            Object.defineProperty(navigator, "webdriver", { get: () => undefined });
+            Object.defineProperty(navigator, "plugins", { get: () => [1, 2, 3, 4, 5] });
+            window.chrome = { runtime: {} };
+        });
+
+        page.setDefaultTimeout(30000);
+
+        let finalUrl = await resolveShortLink(url);
+
+        await page.goto(finalUrl, {
+            waitUntil: "networkidle2",
+            timeout: 30000,
+        });
+
+        await page.waitForFunction(
+            () => window.__INITIAL_STATE__ !== undefined,
+            { timeout: 15000 }
+        );
+
+        await new Promise((r) => setTimeout(r, 1500));
+
+        const postData = await page.evaluate(() => {
+            const state = window.__INITIAL_STATE__;
+            if (!state) return null;
+
+            const noteMap = state?.note?.noteDetailMap || {};
+            const firstKey = Object.keys(noteMap)[0];
+            const noteWrapper = noteMap[firstKey];
+            const note = noteWrapper?.note || noteWrapper;
+
+            if (!note) return null;
+
+            return {
+                id: note.noteId || note.id || firstKey || "",
+                title: note.title || "",
+                desc: note.desc || "",
+                type: note.type || "normal",
+                author: {
+                    nickname: note.user?.nickname || "",
+                    userId: note.user?.userId || "",
+                    avatar: note.user?.image || note.user?.avatar || "",
+                },
+                images: (note.imageList || []).map((img) => ({
+                    url: img.urlDefault || img.url || "",
+                    livePhoto: img.livePhoto || img.stream?.h264?.[0]?.masterUrl || "",
+                    width: img.width || 0,
+                    height: img.height || 0,
+                })),
+                video: note.video ? {
+                    url: note.video.media?.stream?.h264?.[0]?.masterUrl ||
+                         note.video.media?.stream?.h265?.[0]?.masterUrl ||
+                         note.video.url || "",
+                    backupUrl: note.video.media?.stream?.h264?.[0]?.backupUrls?.[0] ||
+                               note.video.media?.stream?.h265?.[0]?.backupUrls?.[0] || "",
+                    duration: note.video.duration || 0,
+                    width: note.video.width || note.video.media?.stream?.h264?.[0]?.width || 0,
+                    height: note.video.height || note.video.media?.stream?.h264?.[0]?.height || 0,
+                    cover: note.video.image?.firstFrameFileid || note.video.thumbnail || "",
+                } : null,
+                cover: note.cover?.urlDefault || note.cover?.url || "",
+                stats: {
+                    likes: note.interactInfo?.likedCount || "0",
+                    collects: note.interactInfo?.collectedCount || "0",
+                    comments: note.interactInfo?.commentCount || "0",
+                    shares: note.interactInfo?.shareCount || "0",
+                },
+                tags: (note.tagList || []).map((tag) => tag.name || "").filter(Boolean),
+                publishedAt: note.time || "",
+                ipLocation: note.ipLocation || "",
+            };
+        });
+
+        await browser.close();
+        browser = null;
+
+        if (!postData) {
+            return null;
+        }
+
+        const medias = [];
+
+        if (postData.video && postData.video.url) {
+            medias.push({
+                type: "video",
+                format: "mp4",
+                desc: `Video ${postData.video.width}x${postData.video.height}` +
+                      (postData.video.duration ? ` (${Math.round(postData.video.duration)}s)` : ""),
+                url: postData.video.url,
+                backupUrl: postData.video.backupUrl || "",
+            });
+        }
+
+        if (postData.images && postData.images.length > 0) {
+            postData.images.forEach((img, i) => {
+                if (img.url) {
+                    medias.push({
+                        type: "image",
+                        format: "jpg",
+                        desc: `Image ${i + 1}` + (img.width && img.height ? ` (${img.width}x${img.height})` : ""),
+                        url: img.url.startsWith("http") ? img.url : `https://sns-img-bd.xhscdn.com/${img.url}`,
+                    });
+                }
+                if (img.livePhoto) {
+                    medias.push({
+                        type: "video",
+                        format: "mp4",
+                        desc: `Live Photo ${i + 1}`,
+                        url: img.livePhoto,
+                    });
+                }
+            });
+        }
+
+        return {
+            ...postData,
+            medias,
+        };
+    } catch (err) {
+        if (browser) {
+            try { await browser.close(); } catch (_) { }
+        }
+        throw err;
+    }
+}
+
+async function xiaohongshuDownloader(url) {
+    try {
+        if (!isXiaohongshuUrl(url)) {
+            return {
+                status: false,
+                platform: "xiaohongshu",
+                message: "Invalid Xiaohongshu URL. Make sure it's a valid post URL.",
+            };
+        }
+
+        const noteId = parseNoteId(url);
+        if (!noteId && !url.includes("xhslink.com")) {
+            return {
+                status: false,
+                platform: "xiaohongshu",
+                message: "Could not extract note ID from URL.",
+            };
+        }
+
+        const postUrl = buildPostUrl(url);
+        const data = await fetchXiaohongshuData(postUrl);
+
+        if (!data || !data.medias || data.medias.length === 0) {
+            return {
+                status: false,
+                platform: "xiaohongshu",
+                message: "No media found in this post. The post may be private or deleted.",
+            };
+        }
+
+        const selected = data.medias[0];
+        const ext = selected.format.startsWith(".") ? selected.format : "." + selected.format;
+        const safeTitle = sanitizeFileName(data.id || noteId || "xhs");
+        const fileName = `xhs_${safeTitle}_${selected.type}${ext}`;
+
+        return {
+            status: true,
+            platform: "xiaohongshu",
+            data: {
+                id: data.id || noteId,
+                title: data.title || "Untitled",
+                description: data.desc || "",
+                author: {
+                    nickname: data.author?.nickname || "Unknown",
+                    userId: data.author?.userId || "",
+                    avatar: data.author?.avatar || "",
+                },
+                type: data.type,
+                stats: {
+                    likes: data.stats?.likes || "0",
+                    collects: data.stats?.collects || "0",
+                    comments: data.stats?.comments || "0",
+                    shares: data.stats?.shares || "0",
+                },
+                tags: data.tags || [],
+                publishedAt: data.publishedAt,
+                ipLocation: data.ipLocation,
+                media: {
+                    type: selected.type,
+                    format: selected.format,
+                    url: selected.url,
+                    backupUrl: selected.backupUrl || "",
+                    desc: selected.desc,
+                },
+                allMedias: data.medias,
+                fileName: fileName,
+            },
+        };
+    } catch (error) {
+        return {
+            status: false,
+            platform: "xiaohongshu",
+            message: error.message || "An unexpected error occurred",
+        };
+    }
+}
+
+module.exports = xiaohongshuDownloader;