pretty codes and LiveStream issues fixed 100%

play-dl/YouTube/utils/extractor.ts

@@ -3,14 +3,14 @@ import { format_decipher } from './cipher';
 import { YouTubeVideo } from '../classes/Video';
 import { YouTubePlayList } from '../classes/Playlist';
 
-interface InfoOptions{
-    cookie? : string;
-    proxy? : Proxy[]
+interface InfoOptions {
+    cookie?: string;
+    proxy?: Proxy[];
 }
 
 interface PlaylistOptions {
-    incomplete? : boolean;
-    proxy? : Proxy[]
+    incomplete?: boolean;
+    proxy?: Proxy[];
 }
 
 const DEFAULT_API_KEY = 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8';
@@ -54,7 +54,7 @@ export async function video_basic_info(url: string, options: InfoOptions = {}) {
     } else video_id = url;
     const new_url = `https://www.youtube.com/watch?v=${video_id}`;
     const body = await request(new_url, {
-        proxies : options.proxy ?? [],
+        proxies: options.proxy ?? [],
         headers: options.cookie
             ? {
                   'cookie': options.cookie,
@@ -148,7 +148,7 @@ export async function video_info(url: string, options: InfoOptions = {}) {
     }
 }
 
-export async function playlist_info(url: string, options : PlaylistOptions = {}) {
+export async function playlist_info(url: string, options: PlaylistOptions = {}) {
     if (!url || typeof url !== 'string') throw new Error(`Expected playlist url, received ${typeof url}!`);
     let Playlist_id: string;
     if (url.startsWith('https')) {
@@ -158,7 +158,7 @@ export async function playlist_info(url: string, options : PlaylistOptions = {})
     const new_url = `https://www.youtube.com/playlist?list=${Playlist_id}`;
 
     const body = await request(new_url, {
-        proxies : options.proxy ?? [],
+        proxies: options.proxy ?? [],
         headers: { 'accept-language': 'en-US,en-IN;q=0.9,en;q=0.8,hi;q=0.7' }
     });
     const response = JSON.parse(body.split('var ytInitialData = ')[1].split(';</script>')[0]);

play-dl/YouTube/utils/request.ts

@@ -1,29 +1,29 @@
 import https, { RequestOptions } from 'https';
 import tls from 'tls';
-import http , { ClientRequest, IncomingMessage } from 'http';
+import http, { ClientRequest, IncomingMessage } from 'http';
 import { URL } from 'url';
 
-export type Proxy = ProxyOpts | string
+export type Proxy = ProxyOpts | string;
 
 interface ProxyOpts {
-    host : string,
-    port : number,
-    authentication? : {
-        username : string;
-        password : string;
-    }
+    host: string;
+    port: number;
+    authentication?: {
+        username: string;
+        password: string;
+    };
 }
 
 interface ProxyOutput {
-    statusCode : number;
-    head : string;
-    body : string;
+    statusCode: number;
+    head: string;
+    body: string;
 }
 
 interface RequestOpts extends RequestOptions {
     body?: string;
     method?: 'GET' | 'POST';
-    proxies? : Proxy[]
+    proxies?: Proxy[];
 }
 
 function https_getter(req_url: string, options: RequestOpts = {}): Promise<IncomingMessage> {
@@ -46,86 +46,91 @@ function https_getter(req_url: string, options: RequestOpts = {}): Promise<Incom
     });
 }
 
-function randomIntFromInterval(min : number, max: number) : number {
-    let x = Math.floor(Math.random() * (max - min + 1) + min)
-    if(x === 0) return 0
-    else return x - 1
-  }
+function randomIntFromInterval(min: number, max: number): number {
+    let x = Math.floor(Math.random() * (max - min + 1) + min);
+    if (x === 0) return 0;
+    else return x - 1;
+}
 
-async function proxy_getter(req_url : string, req_proxy : Proxy[]): Promise<ProxyOutput>{
+async function proxy_getter(req_url: string, req_proxy: Proxy[]): Promise<ProxyOutput> {
     return new Promise((resolve, reject) => {
-        const proxy : string | ProxyOpts = req_proxy[randomIntFromInterval(0, req_proxy.length)]
-        const parsed_url = new URL(req_url)
-        let opts : ProxyOpts
-        if(typeof proxy === 'string'){
-            const parsed = new URL(proxy)
+        const proxy: string | ProxyOpts = req_proxy[randomIntFromInterval(0, req_proxy.length)];
+        const parsed_url = new URL(req_url);
+        let opts: ProxyOpts;
+        if (typeof proxy === 'string') {
+            const parsed = new URL(proxy);
             opts = {
-                host : parsed.hostname,
-                port : Number(parsed.port),
-                authentication : {
-                    username : parsed.username,
-                    password : parsed.password
+                host: parsed.hostname,
+                port: Number(parsed.port),
+                authentication: {
+                    username: parsed.username,
+                    password: parsed.password
                 }
-            }
-        }
-        else opts = proxy
-        let req : ClientRequest
-        if(opts.authentication?.username.length === 0){
+            };
+        } else opts = proxy;
+        let req: ClientRequest;
+        if (opts.authentication?.username.length === 0) {
             req = http.request({
                 host: opts.host,
                 port: opts.port,
                 method: 'CONNECT',
-                path: `${parsed_url.host}:443`,
+                path: `${parsed_url.host}:443`
             });
-        }
-        else {
+        } else {
             req = http.request({
                 host: opts.host,
                 port: opts.port,
                 method: 'CONNECT',
                 path: `${parsed_url.host}:443`,
-                headers : {
-                    "Proxy-Authorization" : `Basic ${Buffer.from(`${opts.authentication?.username}:${opts.authentication?.password}`).toString('base64')}`
+                headers: {
+                    'Proxy-Authorization': `Basic ${Buffer.from(
+                        `${opts.authentication?.username}:${opts.authentication?.password}`
+                    ).toString('base64')}`
                 }
             });
         }
 
         req.on('connect', function (res, socket, head) {
-            console.log('Connected')
-            const tlsConnection = tls.connect({
-                host : parsed_url.hostname,
-                port : 443,
-                socket : socket,
-                rejectUnauthorized : false
-            }, function() {
-                tlsConnection.write(`GET ${parsed_url.pathname}${parsed_url.search} HTTP/1.1\r\n`
-                + `Host : ${parsed_url.hostname}\r\n`
-                + 'Connection: close\r\n'
-				+ '\r\n')
-            })
+            console.log('Connected');
+            const tlsConnection = tls.connect(
+                {
+                    host: parsed_url.hostname,
+                    port: 443,
+                    socket: socket,
+                    rejectUnauthorized: false
+                },
+                function () {
+                    tlsConnection.write(
+                        `GET ${parsed_url.pathname}${parsed_url.search} HTTP/1.1\r\n` +
+                            `Host : ${parsed_url.hostname}\r\n` +
+                            'Connection: close\r\n' +
+                            '\r\n'
+                    );
+                }
+            );
 
-            tlsConnection.setEncoding('utf-8')
-            let data = ''
-            tlsConnection.once('error', (e) => reject(e))
-            tlsConnection.on('data', (c) => data+=c)
+            tlsConnection.setEncoding('utf-8');
+            let data = '';
+            tlsConnection.once('error', (e) => reject(e));
+            tlsConnection.on('data', (c) => (data += c));
             tlsConnection.on('end', () => {
-                const y = data.split('\r\n\r\n')
-                const head = y.shift() as string
+                const y = data.split('\r\n\r\n');
+                const head = y.shift() as string;
                 resolve({
-                    statusCode : Number(head.split('\n')[0].split(' ')[1]),
-                    head : head,
-                    body : y.join('\n')
-                })
-            })
-        })
-        req.on('error', (e : Error) => reject(e))
-        req.end()
-    })
+                    statusCode: Number(head.split('\n')[0].split(' ')[1]),
+                    head: head,
+                    body: y.join('\n')
+                });
+            });
+        });
+        req.on('error', (e: Error) => reject(e));
+        req.end();
+    });
 }
 
 export async function request(url: string, options?: RequestOpts): Promise<string> {
     return new Promise(async (resolve, reject) => {
-        if(!options?.proxies){
+        if (!options?.proxies) {
             let data = '';
             let res = await https_getter(url, options).catch((err: Error) => err);
             if (res instanceof Error) {
@@ -140,19 +145,18 @@ export async function request(url: string, options?: RequestOpts): Promise<strin
             res.setEncoding('utf-8');
             res.on('data', (c) => (data += c));
             res.on('end', () => resolve(data));
-        }
-        else {
-            let res = await proxy_getter(url, options.proxies).catch((e : Error) => e)
+        } else {
+            let res = await proxy_getter(url, options.proxies).catch((e: Error) => e);
             if (res instanceof Error) {
                 reject(res);
                 return;
             }
-            if(res.statusCode >= 300 && res.statusCode < 400){
-                res = await proxy_getter(res.head.split('Location: ')[1].split('\n')[0], options.proxies)
-            } else if (res.statusCode > 400){
-                reject(new Error(`GOT ${res.statusCode} from proxy request`))
+            if (res.statusCode >= 300 && res.statusCode < 400) {
+                res = await proxy_getter(res.head.split('Location: ')[1].split('\n')[0], options.proxies);
+            } else if (res.statusCode > 400) {
+                reject(new Error(`GOT ${res.statusCode} from proxy request`));
             }
-            resolve(res.body)
+            resolve(res.body);
         }
     });
 }