streamify-audio 2.2.13 → 2.3.0

package/src/discord/Stream.js

@@ -11,6 +11,50 @@ try {
 
 const { createAudioResource, StreamType } = voiceModule || {};
 
+class StreamURLCache {
+    constructor(defaultTTL = 1800000) {
+        this._cache = new Map();
+        this._defaultTTL = defaultTTL;
+        this._cleanupInterval = setInterval(() => this._cleanup(), 300000);
+        if (this._cleanupInterval.unref) this._cleanupInterval.unref();
+    }
+
+    get(key) {
+        const entry = this._cache.get(key);
+        if (!entry) return null;
+        if (Date.now() > entry.expiry) {
+            this._cache.delete(key);
+            return null;
+        }
+        return { url: entry.url, headers: entry.headers };
+    }
+
+    set(key, url, headers = null, ttl = this._defaultTTL) {
+        this._cache.set(key, {
+            url,
+            headers,
+            expiry: Date.now() + ttl
+        });
+    }
+
+    invalidate(key) {
+        this._cache.delete(key);
+    }
+
+    get size() {
+        return this._cache.size;
+    }
+
+    _cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this._cache) {
+            if (now > entry.expiry) this._cache.delete(key);
+        }
+    }
+}
+
+const urlCache = new StreamURLCache();
+
 class StreamController {
     constructor(track, filters, config) {
         this.track = track;
@@ -23,54 +67,120 @@ class StreamController {
         this.startTime = null;
         this.ytdlpError = '';
         this.ffmpegError = '';
-        
-        // Timing metrics
+
+        this._videoId = null;
+        this._directStreamUrl = null;
+        this._directStreamHeaders = null;
+        this._useDirectUrl = false;
+        this._prepared = false;
+        this._ffmpegSpawnTime = null;
+
         this.metrics = {
             metadata: 0,
+            urlExtract: 0,
             spawn: 0,
             firstByte: 0,
             total: 0
         };
     }
 
-    async create(seekPosition = 0) {
-        if (this.destroyed) {
-            throw new Error('Stream already destroyed');
-        }
-
-        if (this.resource) {
-            return this.resource;
-        }
+    async prepare() {
+        if (this.destroyed) throw new Error('Stream already destroyed');
 
         this.startTime = Date.now();
-        const startTimestamp = this.startTime;
         const source = this.track.source || 'youtube';
-
         let videoId = this.track._resolvedId || this.track.id;
 
-        // Skip metadata resolution if we already have it
         if (source === 'spotify' && !this.track._resolvedId) {
             log.info('STREAM', `Resolving Spotify track to YouTube: ${this.track.title}`);
             try {
                 const spotify = require('../providers/spotify');
                 videoId = await spotify.resolveToYouTube(this.track.id, this.config);
                 this.track._resolvedId = videoId;
-                this.metrics.metadata = Date.now() - startTimestamp;
+                this.metrics.metadata = Date.now() - this.startTime;
             } catch (error) {
-                log.error('STREAM', `Spotify resolution failed: ${error.message}`);
                 throw new Error(`Failed to resolve Spotify track: ${error.message}`);
             }
         } else {
-            this.metrics.metadata = 0; // Already resolved
+            this.metrics.metadata = 0;
         }
 
         if (!videoId || videoId === 'undefined') {
-            throw new Error(`Invalid track ID: ${videoId} (source: ${source}, title: ${this.track.title})`);
+            throw new Error(`Invalid track ID: ${videoId} (source: ${source})`);
+        }
+
+        this._videoId = videoId;
+        const isYouTube = source === 'youtube' || source === 'spotify';
+        const isLive = this.track.isLive === true || this.track.duration === 0;
+        const isLocal = source === 'local';
+
+        if (isLocal || isLive || !isYouTube) {
+            this._useDirectUrl = false;
+            this._prepared = true;
+            return;
+        }
+
+        const cacheKey = `${videoId}:${this.config.ytdlp.format}`;
+        const cached = urlCache.get(cacheKey);
+
+        if (cached) {
+            log.info('STREAM', `URL cache hit for ${videoId}`);
+            this._directStreamUrl = cached.url;
+            this._directStreamHeaders = cached.headers;
+            this._useDirectUrl = true;
+            this._prepared = true;
+            return;
+        }
+
+        const extractStart = Date.now();
+        const maxRetries = this.config.stream?.maxRetries || 2;
+
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const extractedUrl = await this._extractUrl(videoId, this.config, isYouTube);
+                this.metrics.urlExtract = Date.now() - extractStart;
+
+                const ttl = (this.config.stream?.urlCacheTTL || 1800) * 1000;
+                urlCache.set(cacheKey, extractedUrl, this.track._headers, ttl);
+
+                this._directStreamUrl = extractedUrl;
+                this._directStreamHeaders = this.track._headers;
+                this._useDirectUrl = true;
+                this._prepared = true;
+
+                log.info('STREAM', `URL extracted for ${videoId} (${this.metrics.urlExtract}ms, attempt ${attempt})`);
+                return;
+            } catch (error) {
+                log.warn('STREAM', `URL extraction attempt ${attempt}/${maxRetries} failed: ${error.message}`);
+                if (attempt === maxRetries) {
+                    log.warn('STREAM', `All extraction attempts failed for ${videoId}, falling back to pipe mode`);
+                    this._useDirectUrl = false;
+                    this._prepared = true;
+                    return;
+                }
+            }
+        }
+    }
+
+    async start(seekPosition = 0) {
+        if (this.destroyed) throw new Error('Stream already destroyed');
+        if (this.resource) return this.resource;
+
+        if (!this._prepared) {
+            await this.prepare();
         }
 
-        log.info('STREAM', `Creating stream for ${videoId} (${source})`);
-        
-        // Log Filter Chain Trace (No data impact)
+        if (!this.startTime) this.startTime = Date.now();
+        const startTimestamp = this.startTime;
+
+        const videoId = this._videoId || this.track._resolvedId || this.track.id;
+        const source = this.track.source || 'youtube';
+        const isLive = this.track.isLive === true || this.track.duration === 0;
+        const isLocal = source === 'local';
+        const isYouTube = source === 'youtube' || source === 'spotify';
+
+        log.info('STREAM', `Creating stream for ${videoId} (${source}, mode: ${this._useDirectUrl ? 'direct' : isLocal ? 'local' : 'pipe'})`);
+
         const filterNames = Object.keys(this.filters).filter(k => k !== 'start' && k !== '_trigger' && k !== 'volume');
         if (filterNames.length > 0) {
             const chain = filterNames.map(name => {
@@ -78,30 +188,14 @@ class StreamController {
                 let displayVal = typeof val === 'object' ? JSON.stringify(val) : val;
                 if (displayVal === true || displayVal === 'true') displayVal = 'ON';
                 return `[${name.toUpperCase()} (${displayVal})]`;
-            }).join(' ➔ ');
+            }).join(' > ');
             log.info('STREAM', `Filter Chain: ${chain}`);
         }
 
-        const isYouTube = source === 'youtube' || source === 'spotify';
-        const isLive = this.track.isLive === true || this.track.duration === 0;
-        const isLocal = source === 'local';
-
-        let ytdlp;
-        let ffmpegIn;
-
         const env = { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH };
-        const spawnStart = Date.now();
+        const bufferSize = this.config.stream?.bufferSize || '1M';
 
-        if (isLocal) {
-            // Skip yt-dlp for local files
-            ffmpegIn = 'pipe:0'; // We'll just pass the file path to ffmpeg -i
-            this.metrics.spawn = Date.now() - spawnStart;
-        } else if (this.track._directUrl && !isLive && seekPosition === 0) {
-            // OPTIMIZATION: Bypass yt-dlp if we already have a direct stream URL
-            ffmpegIn = this.track._directUrl;
-            log.info('STREAM', `Bypassing yt-dlp, using direct URL for ${videoId}`);
-            this.metrics.spawn = 0;
-        } else {
+        if (!this._useDirectUrl && !isLocal) {
             let url;
             if (source === 'soundcloud') {
                 url = this.track.uri || `https://api.soundcloud.com/tracks/${videoId}/stream`;
@@ -111,13 +205,7 @@ class StreamController {
                 url = `https://www.youtube.com/watch?v=${videoId}`;
             }
 
-            let formatString;
-            if (isLive) {
-                formatString = 'bestaudio*/best';
-            } else {
-                formatString = this.config.ytdlp.format;
-            }
-
+            const formatString = isLive ? 'bestaudio*/best' : this.config.ytdlp.format;
             const ytdlpArgs = [
                 '-f', formatString,
                 '--no-playlist',
@@ -125,7 +213,7 @@ class StreamController {
                 '--no-warnings',
                 '--no-cache-dir',
                 '--no-mtime',
-                '--buffer-size', '16K',
+                '--buffer-size', bufferSize,
                 '--quiet',
                 '--retries', '3',
                 '--fragment-retries', '3',
@@ -156,13 +244,11 @@ class StreamController {
             }
 
             this.ytdlp = spawn(this.config.ytdlpPath, ytdlpArgs, { env });
-            ffmpegIn = 'pipe:0';
         }
 
         const ffmpegFilters = { ...this.filters };
         const ffmpegArgs = buildFfmpegArgs(ffmpegFilters, this.config);
-        
-        // Input injection - only override if NOT using pipe:0 (buildFfmpegArgs already includes -i pipe:0)
+
         if (isLocal) {
             const filePath = this.track.absolutePath || videoId.replace('file://', '');
             const pipeIndex = ffmpegArgs.indexOf('pipe:0');
@@ -173,23 +259,29 @@ class StreamController {
                     ffmpegArgs.splice(pipeIndex - 1, 0, '-ss', seekSeconds);
                 }
             }
-        } else if (ffmpegIn !== 'pipe:0') {
-            // Direct URL - replace the pipe:0 input with the direct URL
+        } else if (this._useDirectUrl) {
             const pipeIndex = ffmpegArgs.indexOf('pipe:0');
             if (pipeIndex > 0) {
-                ffmpegArgs[pipeIndex] = ffmpegIn;
-                if (this.track._headers) {
-                    const headers = Object.entries(this.track._headers)
+                if (seekPosition > 0) {
+                    const seekSeconds = (seekPosition / 1000).toFixed(3);
+                    ffmpegArgs.splice(pipeIndex - 1, 0, '-ss', seekSeconds);
+                }
+
+                const newPipeIndex = ffmpegArgs.indexOf('pipe:0');
+                ffmpegArgs[newPipeIndex] = this._directStreamUrl;
+
+                if (this._directStreamHeaders) {
+                    const headers = Object.entries(this._directStreamHeaders)
                         .map(([k, v]) => `${k}: ${v}`)
                         .join('\r\n');
-                    ffmpegArgs.splice(pipeIndex - 1, 0, '-headers', headers);
+                    ffmpegArgs.splice(newPipeIndex - 1, 0, '-headers', headers);
                 }
             }
         }
-        // else: pipe:0 - buildFfmpegArgs already has -i pipe:0, nothing to change
 
+        this._ffmpegSpawnTime = Date.now();
         this.ffmpeg = spawn(this.config.ffmpegPath, ffmpegArgs, { env });
-        this.metrics.spawn = Date.now() - spawnStart;
+        this.metrics.spawn = Date.now() - this._ffmpegSpawnTime;
 
         if (this.ytdlp) {
             this.ffmpeg.stdin.on('error', (err) => {
@@ -212,8 +304,6 @@ class StreamController {
                 this.ytdlpError += msg;
                 if (msg.includes('ERROR:') && !msg.includes('Retrying') && !msg.includes('Broken pipe')) {
                     log.error('YTDLP', msg.trim());
-                } else if (!msg.includes('[download]') && !msg.includes('ETA') && !msg.includes('[youtube]') && !msg.includes('Retrying fragment') && !msg.includes('Got error')) {
-                    log.debug('YTDLP', msg.trim());
                 }
             });
 
@@ -236,7 +326,17 @@ class StreamController {
             }
         });
 
-        await this._waitForData(isLive);
+        try {
+            await this._waitForData();
+        } catch (error) {
+            if (this._useDirectUrl && (error.message.includes('timed out') || error.message.includes('403'))) {
+                const cacheKey = `${videoId}:${this.config.ytdlp.format}`;
+                urlCache.invalidate(cacheKey);
+                log.warn('STREAM', `Invalidated cached URL for ${videoId} after error`);
+            }
+            this.destroy();
+            throw error;
+        }
 
         if (this.destroyed || !this.ffmpeg) {
             throw new Error('Stream destroyed during initialization');
@@ -244,37 +344,104 @@ class StreamController {
 
         this.resource = createAudioResource(this.ffmpeg.stdout, {
             inputType: StreamType.OggOpus,
-            inlineVolume: true,
-            silencePaddingFrames: 10
+            inlineVolume: false,
+            silencePaddingFrames: 5
         });
 
         const elapsed = Date.now() - startTimestamp;
         this.metrics.total = elapsed;
-        
-        log.info('STREAM', `Ready ${elapsed}ms | Metrics: [Metadata: ${this.metrics.metadata}ms | Spawn: ${this.metrics.spawn}ms | FirstByte: ${this.metrics.firstByte}ms]`);
+
+        log.info('STREAM', `Ready ${elapsed}ms | Metrics: [Metadata: ${this.metrics.metadata}ms | URLExtract: ${this.metrics.urlExtract}ms | Spawn: ${this.metrics.spawn}ms | FirstByte: ${this.metrics.firstByte}ms]`);
 
         return this.resource;
     }
 
-    _waitForData(isLive = false) {
+    async create(seekPosition = 0) {
+        return this.start(seekPosition);
+    }
+
+    _extractUrl(videoId, config, isYouTube) {
+        return new Promise((resolve, reject) => {
+            const url = `https://www.youtube.com/watch?v=${videoId}`;
+            const args = [
+                '--get-url',
+                '-f', config.ytdlp.format,
+                '--no-playlist',
+                '--no-check-certificates',
+                '--no-warnings',
+                '--no-cache-dir',
+                url
+            ];
+
+            if (isYouTube) {
+                args.push('--extractor-args', 'youtube:player_client=web_creator');
+            }
+
+            if (config.cookiesPath) {
+                args.unshift('--cookies', config.cookiesPath);
+            }
+
+            if (config.sponsorblock?.enabled !== false && isYouTube) {
+                const categories = config.sponsorblock?.categories || ['sponsor', 'selfpromo'];
+                args.push('--sponsorblock-remove', categories.join(','));
+            }
+
+            const env = { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH };
+            const proc = spawn(config.ytdlpPath, args, { env });
+
+            let stdout = '';
+            let stderr = '';
+            const timeout = setTimeout(() => {
+                proc.kill('SIGKILL');
+                reject(new Error('URL extraction timed out'));
+            }, 15000);
+
+            proc.stdout.on('data', (data) => { stdout += data; });
+            proc.stderr.on('data', (data) => { stderr += data; });
+
+            proc.on('close', (code) => {
+                clearTimeout(timeout);
+                if (code !== 0) {
+                    return reject(new Error(`yt-dlp --get-url failed (code ${code}): ${stderr.slice(-200)}`));
+                }
+                const urls = stdout.trim().split('\n').filter(Boolean);
+                if (urls.length === 0) {
+                    return reject(new Error('yt-dlp returned no URLs'));
+                }
+                resolve(urls[0]);
+            });
+
+            proc.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`yt-dlp spawn failed: ${err.message}`));
+            });
+        });
+    }
+
+    _waitForData() {
         const ffmpeg = this.ffmpeg;
         const ytdlp = this.ytdlp;
+        const isLive = this.track.isLive === true || this.track.duration === 0;
+        const timeoutMs = isLive
+            ? (this.config.stream?.liveDataTimeout || 15000)
+            : (this.config.stream?.dataTimeout || 8000);
 
         return new Promise((resolve, reject) => {
             if (!ffmpeg) return resolve();
 
-            const timeoutMs = isLive ? 30000 : 15000;
+            let resolved = false;
+
             const timeout = setTimeout(() => {
-                log.warn('STREAM', `Timeout waiting for data, proceeding anyway`);
-                resolve();
+                if (resolved) return;
+                resolved = true;
+                if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
+                reject(new Error(`Stream timed out after ${timeoutMs}ms waiting for audio data`));
             }, timeoutMs);
 
-            let resolved = false;
-
             const onReadable = () => {
                 if (resolved) return;
                 resolved = true;
-                this.metrics.firstByte = Date.now() - (this.startTime + this.metrics.metadata + this.metrics.spawn);
+                this.metrics.firstByte = Date.now() - this._ffmpegSpawnTime;
                 clearTimeout(timeout);
                 if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
                 resolve();
@@ -284,19 +451,20 @@ class StreamController {
                 ffmpeg.stdout.on('readable', onReadable);
             }
 
-            ffmpeg.on('close', () => {
-                if (!resolved) {
-                    resolved = true;
-                    clearTimeout(timeout);
-                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
-
-                    if (this.destroyed) {
-                        return reject(new Error('Stream destroyed during initialization'));
-                    }
+            ffmpeg.on('close', (code) => {
+                if (resolved) return;
+                resolved = true;
+                clearTimeout(timeout);
+                if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
 
-                    const sourceErr = ytdlp ? `yt-dlp stderr: ${this.ytdlpError.slice(-200) || 'none'}` : `ffmpeg stderr: ${this.ffmpegError.slice(-200) || 'none'}`;
-                    reject(new Error(`ffmpeg closed before producing data. ${sourceErr}`));
+                if (this.destroyed) {
+                    return reject(new Error('Stream destroyed during initialization'));
                 }
+
+                const sourceErr = ytdlp
+                    ? `yt-dlp stderr: ${this.ytdlpError.slice(-200) || 'none'}`
+                    : `ffmpeg stderr: ${this.ffmpegError.slice(-200) || 'none'}`;
+                reject(new Error(`ffmpeg closed before producing data. ${sourceErr}`));
             });
 
             if (ytdlp) {
@@ -305,12 +473,10 @@ class StreamController {
                         resolved = true;
                         clearTimeout(timeout);
                         if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
-
                         if (this.destroyed) {
                             return reject(new Error('Stream destroyed during initialization'));
                         }
-
-                        reject(new Error(`yt-dlp failed with code ${code}`));
+                        reject(new Error(`yt-dlp failed with code ${code}: ${this.ytdlpError.slice(-200)}`));
                     }
                 });
             }
@@ -355,4 +521,4 @@ function createStream(track, filters, config) {
     return new StreamController(track, filters, config);
 }
 
-module.exports = { createStream, StreamController };
+module.exports = { createStream, StreamController, urlCache };

package/src/filters/ffmpeg.js

@@ -69,7 +69,7 @@ function buildEqualizer(bands) {
 function buildFfmpegArgs(filters = {}, config = {}) {
     filters = filters || {};
     const args = [
-        '-thread_queue_size', '512',
+        '-thread_queue_size', '4096',
         '-i', 'pipe:0',
         '-vn',
         '-sn'
@@ -260,8 +260,9 @@ function buildFfmpegArgs(filters = {}, config = {}) {
             '-acodec', 'libopus',
             '-b:a', bitrate,
             '-vbr', config.audio?.vbr !== false ? 'on' : 'off',
-            '-compression_level', (config.audio?.compressionLevel ?? 10).toString(),
-            '-application', config.audio?.application || 'audio',
+            '-compression_level', (config.audio?.compressionLevel ?? 5).toString(),
+            '-frame_duration', '20',
+            '-application', config.audio?.application || 'lowdelay',
             '-f', 'ogg'
         );
     } else if (format === 'mp3') {

package/youtube-cookies.txt

@@ -0,0 +1,26 @@
+# Netscape HTTP Cookie File
+# This file is generated by yt-dlp.  Do not edit.
+
+.youtube.com	TRUE	/	TRUE	1800398983	__Secure-YENID	12.YTE=UfQjguVvlx3WLiJJHSjg4nPS-N-5O3Xj8RZj-wlLmRdjAvaF3TRdMzSmyUmo82Z4P-tggpd89U5d3hMDN886ZuUZUzi5XdEFEmHjL0YrTPBwPhD6pZx5CJ-3bNb3Eb_7eZuq_YlqQb0OX6Hvu2yYtWfWZPq7dZUjnJarOqJB0UaWu4jlsn27LkAmA9ecZK7Tj0NXQsIiDMR_y8pHe-kOfQ9LhLBeMnUWvR7GXsSOo_NqyfHrNnu4W8YnBd45ZUQIhwQ91X7lhuTkbBj3hYNJsWv0G7yda1NfB8j-nh8ZkordnGPIyv5QlCTd745j2DiGeS1GSa2jP2bClx7SoQxTjQ
+.youtube.com	TRUE	/	FALSE	0	PREF	f6=40000000&tz=UTC&hl=en
+.youtube.com	TRUE	/	TRUE	1782082203	NID	527=aqYd85605VNHKMN7IAs-QcA6YfpJm6LGDAjKm929dxg81_ly4EHuc_A0jCgct9sjP-yDkNobeQPSES7fdZYHdzmlnHO_gGQ-oVCIbS3GQvSB89DCDEPB-toK2K62rr6iUVoTg3lcUG5xBhVXwoPPOD6VWWqegOp-IOhJhTb7Ijp_899mbKpj-4Elx8vNwUL0X-lJAe5Th-4Mxv9lDynXDH8axGjFhMHboeuTOHiIXRg10-4BoqyhAGFDhKNohiMwDc66EraGHim03-ZM
+.youtube.com	TRUE	/	TRUE	1800826170	__Secure-1PSIDTS	sidts-CjUB7I_69MoGgU9hYcmJtLk5dHx1d0LjE7gLaoN86V6V3M8eyIyUH6LOPPFj2llBVQAVsulbqRAA
+.youtube.com	TRUE	/	TRUE	1800826170	__Secure-3PSIDTS	sidts-CjUB7I_69MoGgU9hYcmJtLk5dHx1d0LjE7gLaoN86V6V3M8eyIyUH6LOPPFj2llBVQAVsulbqRAA
+.youtube.com	TRUE	/	FALSE	1803850170	HSID	Ab4swI6vjvKUnUkhu
+.youtube.com	TRUE	/	TRUE	1803850170	SSID	AaxSz8h17yLe-BmmX
+.youtube.com	TRUE	/	FALSE	1803850170	APISID	pQgk6uQUwAqRtThp/Ape45AAtgBDxnzVco
+.youtube.com	TRUE	/	TRUE	1803850170	SAPISID	y_RgVkrBXATC2XrL/Avlu8CWS6dwZ7LTEg
+.youtube.com	TRUE	/	TRUE	1803850170	__Secure-1PAPISID	y_RgVkrBXATC2XrL/Avlu8CWS6dwZ7LTEg
+.youtube.com	TRUE	/	TRUE	1803850170	__Secure-3PAPISID	y_RgVkrBXATC2XrL/Avlu8CWS6dwZ7LTEg
+.youtube.com	TRUE	/	FALSE	1803850170	SID	g.a0006AhyolP4RoeyrQXcHsFnRGkuVLVIZ9QQsgpwFaXGd822GTtb98Ev6KQIph7SQPbMD4aekgACgYKAaMSARMSFQHGX2MijLBjWKdOhQm5VmUkh9wlRhoVAUF8yKqE_WWJQO8PgiZpXVV1MiB30076
+.youtube.com	TRUE	/	TRUE	1803850170	__Secure-1PSID	g.a0006AhyolP4RoeyrQXcHsFnRGkuVLVIZ9QQsgpwFaXGd822GTtb9khH10B1YSjuMht-R8LNjAACgYKAQ8SARMSFQHGX2MiWX5D8_L5MAZK1TLabPQMghoVAUF8yKoFUiQLoi8zHLuskryhcx1P0076
+.youtube.com	TRUE	/	TRUE	1803850170	__Secure-3PSID	g.a0006AhyolP4RoeyrQXcHsFnRGkuVLVIZ9QQsgpwFaXGd822GTtbc5VtVrqvDy9fWzO4vguctgACgYKAUkSARMSFQHGX2MinKYgh3CtvTW5E5T8SwXiERoVAUF8yKqzIJTS4ajNX5uO8nh3r0j10076
+.youtube.com	TRUE	/	TRUE	1803850170	LOGIN_INFO	AFmmF2swRQIgH6IrdLYFOhW8xu4opIUHTGxAf33LzI5EXw6pdoqsh_gCIQCxYHQL4VZEyb3nE-rhXM6VU2ua99G4AhzKl4JJlzZBEQ:QUQ3MjNmeFpJOS1rVDgtM2I4cm50Z3M4NUplLTlSbXV4OFl4MTM5eUtHX3FEcVNmT2ltVFlSWmpQdlR2QTVqR29mZlUtTVh4OEhkOGw4Rkd5d2tQZm52NXJmQzdrMFJPVk5uYTFLNFFMZWlGelJhRVk1TkVaMm9Uby0xWlcwR3ozYkwwY2lWT21pV2dpU0lsWW5saFhMektISWxwUkRUcXl3
+.youtube.com	TRUE	/	FALSE	1803305074	SIDCC	AKEyXzW6XAqY9tNhDWlFzlv-TcDtmpxQxQjOpTwkeLq7ddP20Ecx5ttbRGa7K7WKJVXYBIsbGTE
+.youtube.com	TRUE	/	TRUE	1803305074	__Secure-1PSIDCC	AKEyXzVdeiA5hPJOoWk_iVZXhBC3-3D4ZAlHjwkIdtnQ-y_iHxOeAdYucag2Dv-EMebAtINo-Q
+.youtube.com	TRUE	/	TRUE	1803305074	__Secure-3PSIDCC	AKEyXzX9LV_1LP1Z1T6SCow5CKbPxteZg-XPIOt3o2Uu6OlsIn6Z2S3gRZBgUTHpaiRcVbPYbg
+.youtube.com	TRUE	/	TRUE	1787290794	__Secure-YNID	16.YT=uhIB3j65_j5F-nN_AIVu93J6J4tqe4fviGdBQuGk0X5EW7VRESfm4qMadhbgM04D7x1YyYRXKI0UIHJjiRMWqsP5PmT_qrHoTUSn4MOLA-FPeX09ELODYdpGvps9F6B3EFC2jC4MXYiWVY6KGZRiEoYBh_KWkh4Suwgn38LgfqN0E4Xv3YAzCB390qeKtLVkaqlQDUIvhnqGBPrObW-DzawPn00gHQph8VM2Zrklq_BzRYVaZHKHs2WkKlHqLljxwOiNXcsLrIkLqGsCgKR_onVOnlWN2gd0zojNv0VyuwYgfB9GBOLzweTnTWBZmp9IPWRA39DH4zMFerdTND-Yfg
+.youtube.com	TRUE	/	TRUE	0	YSC	-LHUdUOZvC4
+.youtube.com	TRUE	/	TRUE	1787321074	VISITOR_INFO1_LIVE	AuEVGsoJz2Y
+.youtube.com	TRUE	/	TRUE	1787321074	VISITOR_PRIVACY_METADATA	CgJVUxIEGgAgVQ%3D%3D
+.youtube.com	TRUE	/	TRUE	1787290794	__Secure-ROLLOUT_TOKEN	CIbdoKq8kOipXhC__cjij6WSAxiZi8-rseySAw%3D%3D