Histmy/play-dl-fix
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

SoundCloud work + prettier

Browse Source
This commit is contained in:
killer069 2021-09-17 14:36:32 +05:30
parent f9876ce5c5
commit 90b13629b4
21 changed files with 1615 additions and 1162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
.prettierrc Normal file
View File

@ -0,0 +1,9 @@
{
"printWidth": 120,
"tabWidth": 4,
"singleQuote": true,
"quoteProps": "consistent",
"semi": true,
"embeddedLanguageFormatting": "off",
"trailingComma": "none"
}

21
package-lock.json generated
View File

@ -9,7 +9,8 @@
"version": "0.9.9", "version": "0.9.9",
"license": "MIT", "license": "MIT",
"devDependencies": { "devDependencies": {
"@types/node": "^16.9.1" "@types/node": "^16.9.1",
"prettier": "^2.3.1"
}, },
"engines": { "engines": {
"node": ">=16.0.0" "node": ">=16.0.0"
@ -20,6 +21,18 @@
"resolved": "https://registry.npmjs.org/@types/node/-/node-16.9.1.tgz", "resolved": "https://registry.npmjs.org/@types/node/-/node-16.9.1.tgz",
"integrity": "sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g==", "integrity": "sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g==",
"dev": true "dev": true
},
"node_modules/prettier": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/prettier/-/prettier-2.4.1.tgz",
"integrity": "sha512-9fbDAXSBcc6Bs1mZrDYb3XKzDLm4EXXL9sC1LqKP5rZkT6KRr/rf9amVUcODVXgguK/isJz0d0hP72WeaKWsvA==",
"dev": true,
"bin": {
"prettier": "bin-prettier.js"
},
"engines": {
"node": ">=10.13.0"
}
} }
}, },
"dependencies": { "dependencies": {
@ -28,6 +41,12 @@
"resolved": "https://registry.npmjs.org/@types/node/-/node-16.9.1.tgz", "resolved": "https://registry.npmjs.org/@types/node/-/node-16.9.1.tgz",
"integrity": "sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g==", "integrity": "sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g==",
"dev": true "dev": true
},
"prettier": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/prettier/-/prettier-2.4.1.tgz",
"integrity": "sha512-9fbDAXSBcc6Bs1mZrDYb3XKzDLm4EXXL9sC1LqKP5rZkT6KRr/rf9amVUcODVXgguK/isJz0d0hP72WeaKWsvA==",
"dev": true
} }
} }
} }

7
package.json
View File

@ -10,7 +10,9 @@
}, },
"scripts": { "scripts": {
"build": "tsc", "build": "tsc",
"build:check": "tsc --noEmit --incremental false" "build:check": "tsc --noEmit --incremental false",
"pretty": "prettier --config .prettierrc \"play-dl/*.ts\" \"play-dl/*/*.ts\" \"play-dl/*/*/*.ts\" --write ",
"lint": "eslint . --ext .ts"
}, },
"repository": { "repository": {
"type": "git", "type": "git",
@ -39,6 +41,7 @@
"dist/*" "dist/*"
], ],
"devDependencies": { "devDependencies": {
"@types/node": "^16.9.1" "@types/node": "^16.9.1",
"prettier": "^2.3.1"
} }
} }

225
play-dl/SoundCloud/classes.ts Normal file
View File

@ -0,0 +1,225 @@
import { request, request_stream } from '../YouTube/utils/request';
import { PassThrough } from 'stream';
import { IncomingMessage } from 'http';
import { StreamType } from '../YouTube/stream';
interface SoundCloudUser {
name: string;
id: string;
url: string;
type: 'track' | 'playlist' | 'user';
verified: boolean;
description: string;
first_name: string;
full_name: string;
last_name: string;
thumbnail: string;
}
interface SoundCloudTrackDeprecated {
fetched: boolean;
id: number;
type: 'track';
}
interface SoundCloudTrackFormat {
url: string;
preset: string;
duration: number;
format: {
protocol: string;
mime_type: string;
};
quality: string;
}
export class SoundCloudTrack {
name: string;
id: number;
url: string;
fetched: boolean;
type: 'track' | 'playlist' | 'user';
durationInSec: number;
durationInMs: number;
formats: SoundCloudTrackFormat[];
publisher: {
name: string;
id: number;
artist: string;
contains_music: boolean;
writer_composer: string;
};
thumbanil: string;
user: SoundCloudUser;
constructor(data: any) {
this.name = data.title;
this.id = data.id;
this.url = data.uri;
this.fetched = true;
this.type = 'track';
this.durationInSec = Number(data.duration) / 1000;
this.durationInMs = Number(data.duration);
this.publisher = {
name: data.publisher_metadata.publisher,
id: data.publisher_metadata.id,
artist: data.publisher_metadata.artist,
contains_music: Boolean(data.publisher_metadata.contains_music) || false,
writer_composer: data.publisher_metadata.writer_composer
};
this.formats = data.media.transcodings;
this.user = {
name: data.user.username,
id: data.user.id,
type: 'user',
url: data.user.permalink_url,
verified: Boolean(data.user.verified) || false,
description: data.user.description,
first_name: data.user.first_name,
full_name: data.user.full_name,
last_name: data.user.last_name,
thumbnail: data.user.avatar_url
};
this.thumbanil = data.artwork_url;
}
}
export class SoundCloudPlaylist {
name: string;
id: number;
url: string;
type: 'track' | 'playlist' | 'user';
sub_type: string;
durationInSec: number;
durationInMs: number;
client_id: string;
user: SoundCloudUser;
tracks: SoundCloudTrack[] | SoundCloudTrackDeprecated[];
tracksCount: number;
constructor(data: any, client_id: string) {
this.name = data.title;
this.id = data.id;
this.url = data.uri;
this.client_id = client_id;
this.type = 'playlist';
this.sub_type = data.set_type;
this.durationInSec = Number(data.duration) / 1000;
this.durationInMs = Number(data.duration);
this.user = {
name: data.user.username,
id: data.user.id,
type: 'user',
url: data.user.permalink_url,
verified: Boolean(data.user.verified) || false,
description: data.user.description,
first_name: data.user.first_name,
full_name: data.user.full_name,
last_name: data.user.last_name,
thumbnail: data.user.avatar_url
};
this.tracksCount = data.track_count;
const tracks: any[] = [];
data.tracks.forEach((track: any) => {
if (track.title) {
tracks.push(new SoundCloudTrack(track));
} else
tracks.push({
id: track.id,
fetched: false,
type: 'track'
});
});
this.tracks = tracks;
}
async fetch() {
const work: any[] = [];
for (let i = 0; i < this.tracks.length; i++) {
if (!this.tracks[i].fetched) {
work.push(
new Promise(async (resolve, reject) => {
const num = i;
const data = await request(
`https://api-v2.soundcloud.com/tracks/${this.tracks[i].id}?client_id=${this.client_id}`
);
this.tracks[num] = new SoundCloudTrack(JSON.parse(data));
resolve('');
})
);
}
}
await Promise.allSettled(work);
}
}
export class Stream {
type: StreamType;
stream: PassThrough;
private url: string;
private playing_count: number;
private downloaded_time: number;
private request : IncomingMessage | null
private time: number[];
private segment_urls: string[];
constructor(url: string, type: StreamType = StreamType.Arbitrary, client_id: string) {
this.type = type;
this.url = url + client_id;
this.stream = new PassThrough({ highWaterMark: 10 * 1000 * 1000 });
this.playing_count = 0;
this.downloaded_time = 0;
this.request = null
this.time = [];
this.segment_urls = [];
this.stream.on('close', () => {
this.cleanup();
});
this.stream.on('pause', () => {
this.playing_count++;
});
this.start();
}
private async parser() {
const response = await request(this.url).catch((err: Error) => {
return err;
});
if (response instanceof Error) throw response;
const array = response.split('\n');
array.forEach((val) => {
if (val.startsWith('#EXTINF:')) {
this.time.push(parseFloat(val.replace('#EXTINF:', '')));
} else if (val.startsWith('https')) {
this.segment_urls.push(val);
}
});
return;
}
private async start() {
if (this.stream.destroyed) {
this.cleanup();
return;
}
await this.parser();
for await (const segment of this.segment_urls) {
await new Promise(async (resolve, reject) => {
const stream = await request_stream(segment).catch((err: Error) => err);
if (stream instanceof Error) {
this.stream.emit('error', stream);
reject(stream)
return;
}
this.request = stream
stream.pipe(this.stream, { end : false })
stream.on('end', () => {
resolve('');
});
stream.once('error', (err) => {
this.stream.emit('error', err);
});
});
}
}
private cleanup() {}
}

43
play-dl/SoundCloud/index.ts Normal file
View File

@ -0,0 +1,43 @@
import fs from 'fs';
import { request } from '../YouTube/utils/request';
import { SoundCloudPlaylist, SoundCloudTrack } from './classes';
let soundData: SoundDataOptions;
if (fs.existsSync('.data/soundcloud.data')) {
soundData = JSON.parse(fs.readFileSync('.data/soundcloud.data').toString());
}
interface SoundDataOptions {
client_id: string;
}
const pattern = /^(?:(https?):\/\/)?(?:(?:www|m)\.)?(soundcloud\.com|snd\.sc)\/(.*)$/;
export async function soundcloud(url: string): Promise<SoundCloudTrack | SoundCloudPlaylist> {
if (!soundData) throw new Error('SoundCloud Data is missing\nDid you forgot to do authorization ?');
if (!url.match(pattern)) throw new Error('This is not a SoundCloud URL');
const data = await request(
`https://api-v2.soundcloud.com/resolve?url=${url}&client_id=${soundData.client_id}`
).catch((err: Error) => err);
if (data instanceof Error) throw data;
const json_data = JSON.parse(data);
if (json_data.kind !== 'track' && json_data.kind !== 'playlist')
throw new Error('This url is out of scope for play-dl.');
if (json_data.kind === 'track') return new SoundCloudTrack(json_data);
else return new SoundCloudPlaylist(json_data, soundData.client_id);
}
export async function check_id(id: string) {
const response = await request(`https://api-v2.soundcloud.com/search?client_id=${id}&q=Rick+Roll&limit=0`).catch(
(err: Error) => {
return err;
}
);
if (response instanceof Error) return false;
else return true;
}

531
play-dl/Spotify/classes.ts
View File

@ -1,315 +1,328 @@
import { request } from "../YouTube/utils/request"; import { request } from '../YouTube/utils/request';
import { SpotifyDataOptions } from "."; import { SpotifyDataOptions } from '.';
interface SpotifyTrackAlbum {
interface SpotifyTrackAlbum{ name: string;
name : string; url: string;
url : string; id: string;
id : string; release_date: string;
release_date : string; release_date_precision: string;
release_date_precision : string; total_tracks: number;
total_tracks : number;
} }
interface SpotifyArtists{ interface SpotifyArtists {
name : string; name: string;
url : string; url: string;
id : string; id: string;
} }
interface SpotifyThumbnail{ interface SpotifyThumbnail {
height : number; height: number;
width : number width: number;
url : string url: string;
} }
interface SpotifyCopyright{ interface SpotifyCopyright {
text : string; text: string;
type : string; type: string;
} }
export class SpotifyVideo{ export class SpotifyVideo {
name : string; name: string;
type : "track" | "playlist" | "album" type: 'track' | 'playlist' | 'album';
id : string; id: string;
url : string; url: string;
explicit : boolean; explicit: boolean;
durationInSec : number; durationInSec: number;
durationInMs : number; durationInMs: number;
artists : SpotifyArtists[] artists: SpotifyArtists[];
album : SpotifyTrackAlbum album: SpotifyTrackAlbum;
thumbnail : SpotifyThumbnail thumbnail: SpotifyThumbnail;
constructor(data : any){ constructor(data: any) {
this.name = data.name this.name = data.name;
this.id = data.id this.id = data.id;
this.type = "track" this.type = 'track';
this.url = data.external_urls.spotify this.url = data.external_urls.spotify;
this.explicit = data.explicit this.explicit = data.explicit;
this.durationInMs = data.duration_ms this.durationInMs = data.duration_ms;
this.durationInSec = Math.round(this.durationInMs/1000) this.durationInSec = Math.round(this.durationInMs / 1000);
let artists : SpotifyArtists[] = [] const artists: SpotifyArtists[] = [];
data.artists.forEach((v : any) => { data.artists.forEach((v: any) => {
artists.push({ artists.push({
name : v.name, name: v.name,
id : v.id, id: v.id,
url : v.external_urls.spotify url: v.external_urls.spotify
}) });
}) });
this.artists = artists this.artists = artists;
this.album = { this.album = {
name : data.album.name, name: data.album.name,
url : data.external_urls.spotify, url: data.external_urls.spotify,
id : data.album.id, id: data.album.id,
release_date : data.album.release_date, release_date: data.album.release_date,
release_date_precision : data.album.release_date_precision, release_date_precision: data.album.release_date_precision,
total_tracks : data.album.total_tracks total_tracks: data.album.total_tracks
} };
this.thumbnail = data.album.images[0] this.thumbnail = data.album.images[0];
} }
toJSON(){ toJSON() {
return { return {
name : this.name, name: this.name,
id : this.id, id: this.id,
type : this.type, type: this.type,
url : this.url, url: this.url,
explicit : this.explicit, explicit: this.explicit,
durationInMs : this.durationInMs, durationInMs: this.durationInMs,
durationInSec : this.durationInSec, durationInSec: this.durationInSec,
artists : this.artists, artists: this.artists,
album : this.album, album: this.album,
thumbnail : this.thumbnail thumbnail: this.thumbnail
} };
} }
} }
export class SpotifyPlaylist{ export class SpotifyPlaylist {
name : string; name: string;
type : "track" | "playlist" | "album" type: 'track' | 'playlist' | 'album';
collaborative : boolean; collaborative: boolean;
description : string; description: string;
url : string; url: string;
id : string; id: string;
thumbnail : SpotifyThumbnail; thumbnail: SpotifyThumbnail;
owner : SpotifyArtists; owner: SpotifyArtists;
tracksCount : number; tracksCount: number;
private spotifyData : SpotifyDataOptions; private spotifyData: SpotifyDataOptions;
private fetched_tracks : Map<string, SpotifyVideo[]> private fetched_tracks: Map<string, SpotifyVideo[]>;
constructor(data : any, spotifyData : SpotifyDataOptions){ constructor(data: any, spotifyData: SpotifyDataOptions) {
this.name = data.name this.name = data.name;
this.type = "playlist" this.type = 'playlist';
this.collaborative = data.collaborative this.collaborative = data.collaborative;
this.description = data.description this.description = data.description;
this.url = data.external_urls.spotify this.url = data.external_urls.spotify;
this.id = data.id this.id = data.id;
this.thumbnail = data.images[0] this.thumbnail = data.images[0];
this.owner = { this.owner = {
name : data.owner.display_name, name: data.owner.display_name,
url : data.owner.external_urls.spotify, url: data.owner.external_urls.spotify,
id : data.owner.id id: data.owner.id
} };
this.tracksCount = Number(data.tracks.total) this.tracksCount = Number(data.tracks.total);
let videos: SpotifyVideo[] = [] const videos: SpotifyVideo[] = [];
data.tracks.items.forEach((v : any) => { data.tracks.items.forEach((v: any) => {
videos.push(new SpotifyVideo(v.track)) videos.push(new SpotifyVideo(v.track));
}) });
this.fetched_tracks = new Map() this.fetched_tracks = new Map();
this.fetched_tracks.set('1', videos) this.fetched_tracks.set('1', videos);
this.spotifyData = spotifyData this.spotifyData = spotifyData;
} }
async fetch(){ async fetch() {
let fetching : number; let fetching: number;
if(this.tracksCount > 1000) fetching = 1000 if (this.tracksCount > 1000) fetching = 1000;
else fetching = this.tracksCount else fetching = this.tracksCount;
if(fetching <= 100) return if (fetching <= 100) return;
let work = [] const work = [];
for(let i = 2; i <= Math.ceil(fetching/100); i++){ for (let i = 2; i <= Math.ceil(fetching / 100); i++) {
work.push(new Promise(async (resolve, reject) => { work.push(
let response = await request(`https://api.spotify.com/v1/playlists/${this.id}/tracks?offset=${(i-1)*100}&limit=100&market=${this.spotifyData.market}`, { new Promise(async (resolve, reject) => {
headers : { const response = await request(
"Authorization" : `${this.spotifyData.token_type} ${this.spotifyData.access_token}` `https://api.spotify.com/v1/playlists/${this.id}/tracks?offset=${
} (i - 1) * 100
}).catch((err) => reject(`Response Error : \n${err}`)) }&limit=100&market=${this.spotifyData.market}`,
let videos: SpotifyVideo[] = [] {
if(typeof response !== 'string') return headers: {
let json_data = JSON.parse(response) Authorization: `${this.spotifyData.token_type} ${this.spotifyData.access_token}`
json_data.items.forEach((v : any) => { }
videos.push(new SpotifyVideo(v.track)) }
).catch((err) => reject(`Response Error : \n${err}`));
const videos: SpotifyVideo[] = [];
if (typeof response !== 'string') return;
const json_data = JSON.parse(response);
json_data.items.forEach((v: any) => {
videos.push(new SpotifyVideo(v.track));
});
this.fetched_tracks.set(`${i}`, videos);
resolve('Success');
}) })
this.fetched_tracks.set(`${i}`, videos) );
resolve('Success')
}))
} }
await Promise.allSettled(work) await Promise.allSettled(work);
return this return this;
} }
page(num : number){ page(num: number) {
if(!num) throw new Error('Page number is not provided') if (!num) throw new Error('Page number is not provided');
if(!this.fetched_tracks.has(`${num}`)) throw new Error('Given Page number is invalid') if (!this.fetched_tracks.has(`${num}`)) throw new Error('Given Page number is invalid');
return this.fetched_tracks.get(`${num}`) return this.fetched_tracks.get(`${num}`);
} }
get total_pages(){ get total_pages() {
return this.fetched_tracks.size return this.fetched_tracks.size;
} }
get total_tracks(){ get total_tracks() {
let page_number: number = this.total_pages const page_number: number = this.total_pages;
return (page_number - 1) * 100 + (this.fetched_tracks.get(`page${page_number}`) as SpotifyVideo[]).length return (page_number - 1) * 100 + (this.fetched_tracks.get(`page${page_number}`) as SpotifyVideo[]).length;
} }
toJSON(){ toJSON() {
return { return {
name : this.name, name: this.name,
type : this.type, type: this.type,
collaborative : this.collaborative, collaborative: this.collaborative,
description : this.description, description: this.description,
url : this.url, url: this.url,
id : this.id, id: this.id,
thumbnail : this.thumbnail, thumbnail: this.thumbnail,
owner : this.owner, owner: this.owner
} };
} }
} }
export class SpotifyAlbum{ export class SpotifyAlbum {
name : string name: string;
type : "track" | "playlist" | "album" type: 'track' | 'playlist' | 'album';
url : string url: string;
id : string; id: string;
thumbnail : SpotifyThumbnail thumbnail: SpotifyThumbnail;
artists : SpotifyArtists[] artists: SpotifyArtists[];
copyrights : SpotifyCopyright[] copyrights: SpotifyCopyright[];
release_date : string; release_date: string;
release_date_precision : string; release_date_precision: string;
trackCount : number trackCount: number;
private spotifyData : SpotifyDataOptions; private spotifyData: SpotifyDataOptions;
private fetched_tracks : Map<string, SpotifyTracks[]> private fetched_tracks: Map<string, SpotifyTracks[]>;
constructor(data : any, spotifyData : SpotifyDataOptions){ constructor(data: any, spotifyData: SpotifyDataOptions) {
this.name = data.name this.name = data.name;
this.type = "album" this.type = 'album';
this.id = data.id this.id = data.id;
this.url = data.external_urls.spotify this.url = data.external_urls.spotify;
this.thumbnail = data.images[0] this.thumbnail = data.images[0];
let artists : SpotifyArtists[] = [] const artists: SpotifyArtists[] = [];
data.artists.forEach((v : any) => { data.artists.forEach((v: any) => {
artists.push({ artists.push({
name : v.name, name: v.name,
id : v.id, id: v.id,
url : v.external_urls.spotify url: v.external_urls.spotify
}) });
}) });
this.artists = artists this.artists = artists;
this.copyrights = data.copyrights this.copyrights = data.copyrights;
this.release_date = data.release_date this.release_date = data.release_date;
this.release_date_precision = data.release_date_precision this.release_date_precision = data.release_date_precision;
this.trackCount = data.total_tracks this.trackCount = data.total_tracks;
let videos: SpotifyTracks[] = [] const videos: SpotifyTracks[] = [];
data.tracks.items.forEach((v : any) => { data.tracks.items.forEach((v: any) => {
videos.push(new SpotifyTracks(v)) videos.push(new SpotifyTracks(v));
}) });
this.fetched_tracks = new Map() this.fetched_tracks = new Map();
this.fetched_tracks.set('1', videos) this.fetched_tracks.set('1', videos);
this.spotifyData = spotifyData this.spotifyData = spotifyData;
} }
async fetch(){ async fetch() {
let fetching : number; let fetching: number;
if(this.trackCount > 500) fetching = 500 if (this.trackCount > 500) fetching = 500;
else fetching = this.trackCount else fetching = this.trackCount;
if(fetching <= 50) return if (fetching <= 50) return;
let work = [] const work = [];
for(let i = 2; i <= Math.ceil(fetching/50); i++){ for (let i = 2; i <= Math.ceil(fetching / 50); i++) {
work.push(new Promise(async (resolve, reject) => { work.push(
let response = await request(`https://api.spotify.com/v1/albums/${this.id}/tracks?offset=${(i-1)*50}&limit=50&market=${this.spotifyData.market}`, { new Promise(async (resolve, reject) => {
headers : { const response = await request(
"Authorization" : `${this.spotifyData.token_type} ${this.spotifyData.access_token}` `https://api.spotify.com/v1/albums/${this.id}/tracks?offset=${(i - 1) * 50}&limit=50&market=${
} this.spotifyData.market
}).catch((err) => reject(`Response Error : \n${err}`)) }`,
let videos: SpotifyTracks[] = [] {
if(typeof response !== 'string') return headers: {
let json_data = JSON.parse(response) Authorization: `${this.spotifyData.token_type} ${this.spotifyData.access_token}`
json_data.items.forEach((v : any) => { }
videos.push(new SpotifyTracks(v)) }
).catch((err) => reject(`Response Error : \n${err}`));
const videos: SpotifyTracks[] = [];
if (typeof response !== 'string') return;
const json_data = JSON.parse(response);
json_data.items.forEach((v: any) => {
videos.push(new SpotifyTracks(v));
});
this.fetched_tracks.set(`${i}`, videos);
resolve('Success');
}) })
this.fetched_tracks.set(`${i}`, videos) );
resolve('Success')
}))
} }
await Promise.allSettled(work) await Promise.allSettled(work);
return this return this;
} }
page(num : number){ page(num: number) {
if(!num) throw new Error('Page number is not provided') if (!num) throw new Error('Page number is not provided');
if(!this.fetched_tracks.has(`${num}`)) throw new Error('Given Page number is invalid') if (!this.fetched_tracks.has(`${num}`)) throw new Error('Given Page number is invalid');
return this.fetched_tracks.get(`${num}`) return this.fetched_tracks.get(`${num}`);
} }
get total_pages(){ get total_pages() {
return this.fetched_tracks.size return this.fetched_tracks.size;
} }
get total_tracks(){ get total_tracks() {
let page_number: number = this.total_pages const page_number: number = this.total_pages;
return (page_number - 1) * 100 + (this.fetched_tracks.get(`page${page_number}`) as SpotifyVideo[]).length return (page_number - 1) * 100 + (this.fetched_tracks.get(`page${page_number}`) as SpotifyVideo[]).length;
} }
toJSON(){ toJSON() {
return { return {
name : this.name, name: this.name,
type : this.type, type: this.type,
url : this.url, url: this.url,
thumbnail : this.thumbnail, thumbnail: this.thumbnail,
artists : this.artists, artists: this.artists,
copyrights : this.copyrights, copyrights: this.copyrights,
release_date : this.release_date, release_date: this.release_date,
release_date_precision : this.release_date_precision, release_date_precision: this.release_date_precision,
total_tracks : this.total_tracks, total_tracks: this.total_tracks
} };
} }
} }
class SpotifyTracks{ class SpotifyTracks {
name : string; name: string;
type : "track" | "playlist" | "album" type: 'track' | 'playlist' | 'album';
id : string; id: string;
url : string; url: string;
explicit : boolean; explicit: boolean;
durationInSec : number; durationInSec: number;
durationInMs : number; durationInMs: number;
artists : SpotifyArtists[] artists: SpotifyArtists[];
constructor(data : any){ constructor(data: any) {
this.name = data.name this.name = data.name;
this.id = data.id this.id = data.id;
this.type = "track" this.type = 'track';
this.url = data.external_urls.spotify this.url = data.external_urls.spotify;
this.explicit = data.explicit this.explicit = data.explicit;
this.durationInMs = data.duration_ms this.durationInMs = data.duration_ms;
this.durationInSec = Math.round(this.durationInMs/1000) this.durationInSec = Math.round(this.durationInMs / 1000);
let artists : SpotifyArtists[] = [] const artists: SpotifyArtists[] = [];
data.artists.forEach((v : any) => { data.artists.forEach((v: any) => {
artists.push({ artists.push({
name : v.name, name: v.name,
id : v.id, id: v.id,
url : v.external_urls.spotify url: v.external_urls.spotify
}) });
}) });
this.artists = artists this.artists = artists;
} }
toJSON(){ toJSON() {
return { return {
name : this.name, name: this.name,
id : this.id, id: this.id,
type : this.type, type: this.type,
url : this.url, url: this.url,
explicit : this.explicit, explicit: this.explicit,
durationInMs : this.durationInMs, durationInMs: this.durationInMs,
durationInSec : this.durationInSec, durationInSec: this.durationInSec,
artists : this.artists, artists: this.artists
} };
} }
} }

265
play-dl/Spotify/index.ts
View File

@ -1,171 +1,134 @@
import { request } from "../YouTube/utils/request"; import { request } from '../YouTube/utils/request';
import { SpotifyAlbum, SpotifyPlaylist, SpotifyVideo } from "./classes" import { SpotifyAlbum, SpotifyPlaylist, SpotifyVideo } from './classes';
import readline from 'readline' import fs from 'fs';
import fs from 'fs'
var spotifyData : SpotifyDataOptions; let spotifyData: SpotifyDataOptions;
if(fs.existsSync('.data/spotify.data')){ if (fs.existsSync('.data/spotify.data')) {
spotifyData = JSON.parse(fs.readFileSync('.data/spotify.data').toString()) spotifyData = JSON.parse(fs.readFileSync('.data/spotify.data').toString());
} }
export interface SpotifyDataOptions{ export interface SpotifyDataOptions {
client_id : string; client_id: string;
client_secret : string; client_secret: string;
redirect_url : string; redirect_url: string;
authorization_code? :string; authorization_code?: string;
access_token? : string; access_token?: string;
refresh_token? : string; refresh_token?: string;
token_type? : string; token_type?: string;
expires_in? : number; expires_in?: number;
expiry? : number; expiry?: number;
market? : string; market?: string;
} }
const pattern = /^((https:)?\/\/)?open.spotify.com\/(track|album|playlist)\// const pattern = /^((https:)?\/\/)?open.spotify.com\/(track|album|playlist)\//;
export async function spotify(url : string): Promise<SpotifyAlbum | SpotifyPlaylist | SpotifyVideo>{ export async function spotify(url: string): Promise<SpotifyAlbum | SpotifyPlaylist | SpotifyVideo> {
if(!spotifyData) throw new Error('Spotify Data is missing\nDid you forgot to do authorization ?') if (!spotifyData) throw new Error('Spotify Data is missing\nDid you forgot to do authorization ?');
if(!url.match(pattern)) throw new Error('This is not a Spotify URL') if (!url.match(pattern)) throw new Error('This is not a Spotify URL');
if(url.indexOf('track/') !== -1){ if (url.indexOf('track/') !== -1) {
let trackID = url.split('track/')[1].split('&')[0].split('?')[0] const trackID = url.split('track/')[1].split('&')[0].split('?')[0];
let response = await request(`https://api.spotify.com/v1/tracks/${trackID}?market=${spotifyData.market}`, { const response = await request(`https://api.spotify.com/v1/tracks/${trackID}?market=${spotifyData.market}`, {
headers : { headers: {
"Authorization" : `${spotifyData.token_type} ${spotifyData.access_token}` Authorization: `${spotifyData.token_type} ${spotifyData.access_token}`
} }
}).catch((err) => {return 0}) }).catch((err: Error) => {
if(typeof response !== 'number') return new SpotifyVideo(JSON.parse(response)) return err;
else throw new Error('Failed to get spotify Track Data') });
} if (response instanceof Error) throw response;
else if(url.indexOf('album/') !== -1){ return new SpotifyVideo(JSON.parse(response));
let albumID = url.split('album/')[1].split('&')[0].split('?')[0] } else if (url.indexOf('album/') !== -1) {
let response = await request(`https://api.spotify.com/v1/albums/${albumID}?market=${spotifyData.market}`, { const albumID = url.split('album/')[1].split('&')[0].split('?')[0];
headers : { const response = await request(`https://api.spotify.com/v1/albums/${albumID}?market=${spotifyData.market}`, {
"Authorization" : `${spotifyData.token_type} ${spotifyData.access_token}` headers: {
Authorization: `${spotifyData.token_type} ${spotifyData.access_token}`
} }
}).catch((err) => {return 0}) }).catch((err: Error) => {
if(typeof response !== 'number') return new SpotifyAlbum(JSON.parse(response), spotifyData) return err;
else throw new Error('Failed to get spotify Album Data') });
} if (response instanceof Error) throw response;
else if(url.indexOf('playlist/') !== -1){ return new SpotifyAlbum(JSON.parse(response), spotifyData);
let playlistID = url.split('playlist/')[1].split('&')[0].split('?')[0] } else if (url.indexOf('playlist/') !== -1) {
let response = await request(`https://api.spotify.com/v1/playlists/${playlistID}?market=${spotifyData.market}`, { const playlistID = url.split('playlist/')[1].split('&')[0].split('?')[0];
headers : { const response = await request(
"Authorization" : `${spotifyData.token_type} ${spotifyData.access_token}` `https://api.spotify.com/v1/playlists/${playlistID}?market=${spotifyData.market}`,
{
headers: {
Authorization: `${spotifyData.token_type} ${spotifyData.access_token}`
}
} }
}).catch((err) => {return 0}) ).catch((err: Error) => {
if(typeof response !== 'number') return new SpotifyPlaylist(JSON.parse(response), spotifyData) return err;
else throw new Error('Failed to get spotify Playlist Data') });
} if (response instanceof Error) throw response;
else throw new Error('URL is out of scope for play-dl.') return new SpotifyPlaylist(JSON.parse(response), spotifyData);
} else throw new Error('URL is out of scope for play-dl.');
} }
export function sp_validate(url : string): "track" | "playlist" | "album" | boolean{ export function sp_validate(url: string): 'track' | 'playlist' | 'album' | boolean {
if(!url.match(pattern)) return false if (!url.match(pattern)) return false;
if(url.indexOf('track/') !== -1){ if (url.indexOf('track/') !== -1) {
return "track" return 'track';
} } else if (url.indexOf('album/') !== -1) {
else if(url.indexOf('album/') !== -1){ return 'album';
return "album" } else if (url.indexOf('playlist/') !== -1) {
} return 'playlist';
else if(url.indexOf('playlist/') !== -1){ } else return false;
return "playlist"
}
else return false
} }
export function Authorization(){ export async function SpotifyAuthorize(data: SpotifyDataOptions): Promise<boolean> {
let ask = readline.createInterface({ const response = await request(`https://accounts.spotify.com/api/token`, {
input : process.stdin, headers: {
output : process.stdout 'Authorization': `Basic ${Buffer.from(`${data.client_id}:${data.client_secret}`).toString('base64')}`,
}) 'Content-Type': 'application/x-www-form-urlencoded'
let client_id : string, client_secret : string, redirect_url : string, market : string;
ask.question('Client ID : ', (id) => {
client_id = id
ask.question('Client Secret : ', (secret) => {
client_secret = secret
ask.question('Redirect URL : ', (url) => {
redirect_url = url
console.log('\nMarket Selection URL : \nhttps://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements \n')
ask.question('Market : ', (mar) => {
if(mar.length === 2) market = mar
else {
console.log('Invalid Market, Selecting IN as market')
market = 'IN'
}
console.log('\nNow Go to your browser and Paste this url. Authroize it and paste the redirected url here. \n')
console.log(`https://accounts.spotify.com/authorize?client_id=${client_id}&response_type=code&redirect_uri=${encodeURI(redirect_url)} \n`)
ask.question('Redirected URL : ',async (url) => {
if (!fs.existsSync('.data')) fs.mkdirSync('.data')
spotifyData = {
client_id,
client_secret,
redirect_url,
authorization_code : url.split('code=')[1],
market
}
let check = await SpotifyAuthorize(spotifyData)
if(check === false) throw new Error('Failed to get access Token.')
ask.close()
})
})
})
})
})
}
async function SpotifyAuthorize(data : SpotifyDataOptions): Promise<boolean>{
let response = await request(`https://accounts.spotify.com/api/token`, {
headers : {
"Authorization" : `Basic ${Buffer.from(`${data.client_id}:${data.client_secret}`).toString('base64')}`,
"Content-Type" : "application/x-www-form-urlencoded"
}, },
body : `grant_type=authorization_code&code=${data.authorization_code}&redirect_uri=${encodeURI(data.redirect_url)}`, body: `grant_type=authorization_code&code=${data.authorization_code}&redirect_uri=${encodeURI(
method : "POST" data.redirect_url
}).catch(() => { )}`,
return 0 method: 'POST'
}) }).catch((err: Error) => {
return err;
if(typeof response === 'number') return false });
let resp_json = JSON.parse(response) if (response instanceof Error) throw response;
const resp_json = JSON.parse(response);
spotifyData = { spotifyData = {
client_id : data.client_id, client_id: data.client_id,
client_secret : data.client_secret, client_secret: data.client_secret,
redirect_url : data.redirect_url, redirect_url: data.redirect_url,
access_token : resp_json.access_token, access_token: resp_json.access_token,
refresh_token : resp_json.refresh_token, refresh_token: resp_json.refresh_token,
expires_in : Number(resp_json.expires_in), expires_in: Number(resp_json.expires_in),
expiry : Date.now() + ((resp_json.expires_in - 1) * 1000), expiry: Date.now() + (resp_json.expires_in - 1) * 1000,
token_type : resp_json.token_type, token_type: resp_json.token_type,
market : data.market market: data.market
} };
fs.writeFileSync('.data/spotify.data', JSON.stringify(spotifyData, undefined, 4)) fs.writeFileSync('.data/spotify.data', JSON.stringify(spotifyData, undefined, 4));
return true return true;
} }
export function is_expired(){ export function is_expired() {
if(Date.now() >= (spotifyData.expiry as number)) return true if (Date.now() >= (spotifyData.expiry as number)) return true;
else return false else return false;
} }
export async function RefreshToken(): Promise<true | false>{ export async function refreshToken(): Promise<true | false> {
let response = await request(`https://accounts.spotify.com/api/token`, { const response = await request(`https://accounts.spotify.com/api/token`, {
headers : { headers: {
"Authorization" : `Basic ${Buffer.from(`${spotifyData.client_id}:${spotifyData.client_secret}`).toString('base64')}`, 'Authorization': `Basic ${Buffer.from(`${spotifyData.client_id}:${spotifyData.client_secret}`).toString(
"Content-Type" : "application/x-www-form-urlencoded" 'base64'
)}`,
'Content-Type': 'application/x-www-form-urlencoded'
}, },
body : `grant_type=refresh_token&refresh_token=${spotifyData.refresh_token}`, body: `grant_type=refresh_token&refresh_token=${spotifyData.refresh_token}`,
method : "POST" method: 'POST'
}).catch(() => { }).catch((err: Error) => {
return 0 return err;
}) });
if (response instanceof Error) throw response;
if(typeof response === 'number') return false const resp_json = JSON.parse(response);
let resp_json = JSON.parse(response) spotifyData.access_token = resp_json.access_token;
spotifyData.access_token = resp_json.access_token spotifyData.expires_in = Number(resp_json.expires_in);
spotifyData.expires_in = Number(resp_json.expires_in) spotifyData.expiry = Date.now() + (resp_json.expires_in - 1) * 1000;
spotifyData.expiry = Date.now() + ((resp_json.expires_in - 1) * 1000) spotifyData.token_type = resp_json.token_type;
spotifyData.token_type = resp_json.token_type fs.writeFileSync('.data/spotify.data', JSON.stringify(spotifyData, undefined, 4));
fs.writeFileSync('.data/spotify.data', JSON.stringify(spotifyData, undefined, 4)) return true;
return true }
}

14
play-dl/YouTube/classes/Channel.ts
View File

@ -34,19 +34,19 @@ export class Channel {
* @param {object} options Icon options * @param {object} options Icon options
* @param {number} [options.size=0] Icon size. **Default is 0** * @param {number} [options.size=0] Icon size. **Default is 0**
*/ */
iconURL(options = { size: 0 }): string | undefined{ iconURL(options = { size: 0 }): string | undefined {
if (typeof options.size !== "number" || options.size < 0) throw new Error("invalid icon size"); if (typeof options.size !== 'number' || options.size < 0) throw new Error('invalid icon size');
if (!this.icon?.url) return undefined; if (!this.icon?.url) return undefined;
const def = this.icon.url.split("=s")[1].split("-c")[0]; const def = this.icon.url.split('=s')[1].split('-c')[0];
return this.icon.url.replace(`=s${def}-c`, `=s${options.size}-c`); return this.icon.url.replace(`=s${def}-c`, `=s${options.size}-c`);
} }
get type(): "channel" { get type(): 'channel' {
return "channel"; return 'channel';
} }
toString(): string { toString(): string {
return this.name || ""; return this.name || '';
} }
toJSON() { toJSON() {
@ -60,4 +60,4 @@ export class Channel {
subscribers: this.subscribers subscribers: this.subscribers
}; };
} }
} }

347
play-dl/YouTube/classes/LiveStream.ts
View File

@ -1,222 +1,235 @@
import { PassThrough } from 'stream' import { PassThrough } from 'stream';
import { IncomingMessage } from 'http'; import { IncomingMessage } from 'http';
import { StreamType } from '../stream'; import { StreamType } from '../stream';
import { request, request_stream } from '../utils/request'; import { request, request_stream } from '../utils/request';
import { video_info } from '..'; import { video_info } from '..';
export interface FormatInterface{ export interface FormatInterface {
url : string; url: string;
targetDurationSec : number; targetDurationSec: number;
maxDvrDurationSec : number maxDvrDurationSec: number;
} }
export class LiveStreaming{ export class LiveStreaming {
type : StreamType type: StreamType;
stream : PassThrough stream: PassThrough;
private base_url : string private base_url: string;
private url : string private url: string;
private interval : number private interval: number;
private packet_count : number private packet_count: number;
private timer : NodeJS.Timer | null private timer: NodeJS.Timer | null;
private video_url : string private video_url: string;
private dash_timer : NodeJS.Timer | null private dash_timer: NodeJS.Timer | null;
private segments_urls : string[] private segments_urls: string[];
private request : IncomingMessage | null private request: IncomingMessage | null;
constructor(dash_url : string, target_interval : number, video_url : string){ constructor(dash_url: string, target_interval: number, video_url: string) {
this.type = StreamType.Arbitrary this.type = StreamType.Arbitrary;
this.url = dash_url this.url = dash_url;
this.base_url = '' this.base_url = '';
this.stream = new PassThrough({ highWaterMark : 10 * 1000 * 1000 }) this.stream = new PassThrough({ highWaterMark: 10 * 1000 * 1000 });
this.segments_urls = [] this.segments_urls = [];
this.packet_count = 0 this.packet_count = 0;
this.request = null this.request = null;
this.timer = null this.timer = null;
this.video_url = video_url this.video_url = video_url;
this.interval = target_interval * 1000 || 0 this.interval = target_interval * 1000 || 0;
this.dash_timer = setTimeout(() => { this.dash_timer = setTimeout(() => {
this.dash_updater() this.dash_updater();
}, 1800000) }, 1800000);
this.stream.on('close', () => { this.stream.on('close', () => {
this.cleanup() this.cleanup();
}); });
this.start() this.start();
} }
private async dash_updater(){ private async dash_updater() {
let info = await video_info(this.video_url) const info = await video_info(this.video_url);
if(info.LiveStreamData.isLive === true && info.LiveStreamData.hlsManifestUrl !== null && info.video_details.durationInSec === '0'){ if (
this.url = info.LiveStreamData.dashManifestUrl info.LiveStreamData.isLive === true &&
info.LiveStreamData.hlsManifestUrl !== null &&
info.video_details.durationInSec === '0'
) {
this.url = info.LiveStreamData.dashManifestUrl;
} }
this.dash_timer = setTimeout(() => { this.dash_timer = setTimeout(() => {
this.dash_updater() this.dash_updater();
}, 1800000) }, 1800000);
} }
private async dash_getter(){ private async dash_getter() {
let response = await request(this.url) const response = await request(this.url);
let audioFormat = response.split('<AdaptationSet id="0"')[1].split('</AdaptationSet>')[0].split('</Representation>') const audioFormat = response
if(audioFormat[audioFormat.length - 1] === '') audioFormat.pop() .split('<AdaptationSet id="0"')[1]
this.base_url = audioFormat[audioFormat.length - 1].split('<BaseURL>')[1].split('</BaseURL>')[0] .split('</AdaptationSet>')[0]
let list = audioFormat[audioFormat.length - 1].split('<SegmentList>')[1].split('</SegmentList>')[0] .split('</Representation>');
this.segments_urls = list.replace(new RegExp('<SegmentURL media="', 'g'), '').split('"/>') if (audioFormat[audioFormat.length - 1] === '') audioFormat.pop();
if(this.segments_urls[this.segments_urls.length - 1] === '') this.segments_urls.pop() this.base_url = audioFormat[audioFormat.length - 1].split('<BaseURL>')[1].split('</BaseURL>')[0];
const list = audioFormat[audioFormat.length - 1].split('<SegmentList>')[1].split('</SegmentList>')[0];
this.segments_urls = list.replace(new RegExp('<SegmentURL media="', 'g'), '').split('"/>');
if (this.segments_urls[this.segments_urls.length - 1] === '') this.segments_urls.pop();
} }
private cleanup(){ private cleanup() {
clearTimeout(this.timer as NodeJS.Timer) clearTimeout(this.timer as NodeJS.Timer);
clearTimeout(this.dash_timer as NodeJS.Timer) clearTimeout(this.dash_timer as NodeJS.Timer);
this.request?.unpipe(this.stream) this.request?.unpipe(this.stream);
this.request?.destroy() this.request?.destroy();
this.dash_timer = null this.dash_timer = null;
this.video_url = '' this.video_url = '';
this.request = null this.request = null;
this.timer = null this.timer = null;
this.url = '' this.url = '';
this.base_url = '' this.base_url = '';
this.segments_urls = [] this.segments_urls = [];
this.packet_count = 0 this.packet_count = 0;
this.interval = 0 this.interval = 0;
} }
private async start(){ private async start() {
if(this.stream.destroyed){ if (this.stream.destroyed) {
this.cleanup() this.cleanup();
return return;
} }
await this.dash_getter() await this.dash_getter();
if(this.segments_urls.length > 3) this.segments_urls.splice(0, this.segments_urls.length - 3) if (this.segments_urls.length > 3) this.segments_urls.splice(0, this.segments_urls.length - 3);
if(this.packet_count === 0) this.packet_count = Number(this.segments_urls[0].split('sq/')[1].split('/')[0]) if (this.packet_count === 0) this.packet_count = Number(this.segments_urls[0].split('sq/')[1].split('/')[0]);
for await (let segment of this.segments_urls){ for await (const segment of this.segments_urls) {
if(Number(segment.split('sq/')[1].split('/')[0]) !== this.packet_count){ if (Number(segment.split('sq/')[1].split('/')[0]) !== this.packet_count) {
continue continue;
} }
await new Promise(async(resolve, reject) => { await new Promise(async (resolve, reject) => {
let stream = await request_stream(this.base_url + segment).catch((err: Error) => err) const stream = await request_stream(this.base_url + segment).catch((err: Error) => err);
if(stream instanceof Error){ if (stream instanceof Error) {
this.stream.emit('error', stream) this.stream.emit('error', stream);
return return;
} }
this.request = stream this.request = stream;
stream.pipe(this.stream, { end : false }) stream.pipe(this.stream, { end: false });
stream.on('end', () => { stream.on('end', () => {
this.packet_count++ this.packet_count++;
resolve('') resolve('');
}) });
stream.once('error', (err) => { stream.once('error', (err) => {
this.stream.emit('error', err) this.stream.emit('error', err);
}) });
}) });
} }
this.timer = setTimeout(() => { this.timer = setTimeout(() => {
this.start() this.start();
}, this.interval) }, this.interval);
} }
} }
export class Stream { export class Stream {
type : StreamType type: StreamType;
stream : PassThrough stream: PassThrough;
private url : string private url: string;
private bytes_count : number; private bytes_count: number;
private per_sec_bytes : number; private per_sec_bytes: number;
private content_length : number; private content_length: number;
private video_url : string; private video_url: string;
private timer : NodeJS.Timer | null; private timer: NodeJS.Timer | null;
private cookie : string; private cookie: string;
private data_ended : boolean; private data_ended: boolean;
private playing_count : number; private playing_count: number;
private request : IncomingMessage | null private request: IncomingMessage | null;
constructor(url : string, type : StreamType, duration : number, contentLength : number, video_url : string, cookie : string){ constructor(
this.url = url url: string,
this.type = type type: StreamType,
this.stream = new PassThrough({ highWaterMark : 10 * 1000 * 1000 }) duration: number,
this.bytes_count = 0 contentLength: number,
this.video_url = video_url video_url: string,
this.cookie = cookie cookie: string
) {
this.url = url;
this.type = type;
this.stream = new PassThrough({ highWaterMark: 10 * 1000 * 1000 });
this.bytes_count = 0;
this.video_url = video_url;
this.cookie = cookie;
this.timer = setInterval(() => { this.timer = setInterval(() => {
this.retry() this.retry();
}, 7200 * 1000) }, 7200 * 1000);
this.per_sec_bytes = Math.ceil(contentLength / duration) this.per_sec_bytes = Math.ceil(contentLength / duration);
this.content_length = contentLength this.content_length = contentLength;
this.request = null this.request = null;
this.data_ended = false this.data_ended = false;
this.playing_count = 0 this.playing_count = 0;
this.stream.on('close', () => { this.stream.on('close', () => {
this.cleanup() this.cleanup();
}) });
this.stream.on('pause', () => { this.stream.on('pause', () => {
this.playing_count++; this.playing_count++;
if(this.data_ended){ if (this.data_ended) {
this.bytes_count = 0 this.bytes_count = 0;
this.per_sec_bytes = 0 this.per_sec_bytes = 0;
this.cleanup() this.cleanup();
this.stream.removeAllListeners('pause') this.stream.removeAllListeners('pause');
} else if (this.playing_count === 280) {
this.playing_count = 0;
this.loop();
} }
else if(this.playing_count === 280){ });
this.playing_count = 0 this.loop();
this.loop()
}
})
this.loop()
} }
private async retry(){ private async retry() {
let info = await video_info(this.video_url, this.cookie) const info = await video_info(this.video_url, this.cookie);
this.url = info.format[info.format.length - 1].url this.url = info.format[info.format.length - 1].url;
} }
private cleanup(){ private cleanup() {
clearInterval(this.timer as NodeJS.Timer) clearInterval(this.timer as NodeJS.Timer);
this.request?.unpipe(this.stream) this.request?.unpipe(this.stream);
this.request?.destroy() this.request?.destroy();
this.timer = null this.timer = null;
this.request = null this.request = null;
this.url = '' this.url = '';
} }
private async loop(){ private async loop() {
if(this.stream.destroyed){ if (this.stream.destroyed) {
this.cleanup() this.cleanup();
return return;
} }
let end : number = this.bytes_count + this.per_sec_bytes * 300; const end: number = this.bytes_count + this.per_sec_bytes * 300;
let stream = await request_stream(this.url, { const stream = await request_stream(this.url, {
headers : { headers: {
"range" : `bytes=${this.bytes_count}-${end >= this.content_length ? '' : end}` range: `bytes=${this.bytes_count}-${end >= this.content_length ? '' : end}`
} }
}).catch((err: Error) => err) }).catch((err: Error) => err);
if(stream instanceof Error){ if (stream instanceof Error) {
this.stream.emit('error', stream) this.stream.emit('error', stream);
this.data_ended = true this.data_ended = true;
this.bytes_count = 0 this.bytes_count = 0;
this.per_sec_bytes = 0 this.per_sec_bytes = 0;
this.cleanup() this.cleanup();
return return;
} }
if(Number(stream.statusCode) >= 400){ if (Number(stream.statusCode) >= 400) {
this.cleanup() this.cleanup();
await this.retry() await this.retry();
this.loop() this.loop();
if(!this.timer){ if (!this.timer) {
this.timer = setInterval(() => { this.timer = setInterval(() => {
this.retry() this.retry();
}, 7200 * 1000) }, 7200 * 1000);
} }
return return;
} }
this.request = stream this.request = stream;
stream.pipe(this.stream, { end : false }) stream.pipe(this.stream, { end: false });
stream.once('error', (err) => { stream.once('error', (err) => {
this.stream.emit('error', err) this.stream.emit('error', err);
}) });
stream.on('data', (chunk: any) => { stream.on('data', (chunk: any) => {
this.bytes_count += chunk.length this.bytes_count += chunk.length;
}) });
stream.on('end', () => { stream.on('end', () => {
if(end >= this.content_length) this.data_ended = true if (end >= this.content_length) this.data_ended = true;
}) });
} }
} }

111
play-dl/YouTube/classes/Playlist.ts
View File

@ -1,11 +1,11 @@
import { getPlaylistVideos, getContinuationToken } from "../utils/extractor"; import { getPlaylistVideos, getContinuationToken } from '../utils/extractor';
import { request } from "../utils/request"; import { request } from '../utils/request';
import { Thumbnail } from "./Thumbnail"; import { Thumbnail } from './Thumbnail';
import { Channel } from "./Channel"; import { Channel } from './Channel';
import { Video } from "./Video"; import { Video } from './Video';
const BASE_API = "https://www.youtube.com/youtubei/v1/browse?key="; const BASE_API = 'https://www.youtube.com/youtubei/v1/browse?key=';
export class PlayList{ export class PlayList {
id?: string; id?: string;
title?: string; title?: string;
videoCount?: number; videoCount?: number;
@ -16,19 +16,23 @@ export class PlayList{
channel?: Channel; channel?: Channel;
thumbnail?: Thumbnail; thumbnail?: Thumbnail;
private videos?: []; private videos?: [];
private fetched_videos : Map<string, Video[]> private fetched_videos: Map<string, Video[]>;
private _continuation: { api?: string; token?: string; clientVersion?: string } = {}; private _continuation: {
private __count : number api?: string;
token?: string;
clientVersion?: string;
} = {};
private __count: number;
constructor(data : any, searchResult : Boolean = false){ constructor(data: any, searchResult = false) {
if (!data) throw new Error(`Cannot instantiate the ${this.constructor.name} class without data!`); if (!data) throw new Error(`Cannot instantiate the ${this.constructor.name} class without data!`);
this.__count = 0 this.__count = 0;
this.fetched_videos = new Map() this.fetched_videos = new Map();
if(searchResult) this.__patchSearch(data) if (searchResult) this.__patchSearch(data);
else this.__patch(data) else this.__patch(data);
} }
private __patch(data:any){ private __patch(data: any) {
this.id = data.id || undefined; this.id = data.id || undefined;
this.url = data.url || undefined; this.url = data.url || undefined;
this.title = data.title || undefined; this.title = data.title || undefined;
@ -39,14 +43,14 @@ export class PlayList{
this.channel = data.author || undefined; this.channel = data.author || undefined;
this.thumbnail = data.thumbnail || undefined; this.thumbnail = data.thumbnail || undefined;
this.videos = data.videos || []; this.videos = data.videos || [];
this.__count ++ this.__count++;
this.fetched_videos.set(`page${this.__count}`, this.videos as Video[]) this.fetched_videos.set(`page${this.__count}`, this.videos as Video[]);
this._continuation.api = data.continuation?.api ?? undefined; this._continuation.api = data.continuation?.api ?? undefined;
this._continuation.token = data.continuation?.token ?? undefined; this._continuation.token = data.continuation?.token ?? undefined;
this._continuation.clientVersion = data.continuation?.clientVersion ?? "<important data>"; this._continuation.clientVersion = data.continuation?.clientVersion ?? '<important data>';
} }
private __patchSearch(data: any){ private __patchSearch(data: any) {
this.id = data.id || undefined; this.id = data.id || undefined;
this.url = this.id ? `https://www.youtube.com/playlist?list=${this.id}` : undefined; this.url = this.id ? `https://www.youtube.com/playlist?list=${this.id}` : undefined;
this.title = data.title || undefined; this.title = data.title || undefined;
@ -59,19 +63,19 @@ export class PlayList{
this.views = 0; this.views = 0;
} }
async next(limit: number = Infinity): Promise<Video[]> { async next(limit = Infinity): Promise<Video[]> {
if (!this._continuation || !this._continuation.token) return []; if (!this._continuation || !this._continuation.token) return [];
let nextPage = await request(`${BASE_API}${this._continuation.api}`, { const nextPage = await request(`${BASE_API}${this._continuation.api}`, {
method: "POST", method: 'POST',
body: JSON.stringify({ body: JSON.stringify({
continuation: this._continuation.token, continuation: this._continuation.token,
context: { context: {
client: { client: {
utcOffsetMinutes: 0, utcOffsetMinutes: 0,
gl: "US", gl: 'US',
hl: "en", hl: 'en',
clientName: "WEB", clientName: 'WEB',
clientVersion: this._continuation.clientVersion clientVersion: this._continuation.clientVersion
}, },
user: {}, user: {},
@ -79,24 +83,25 @@ export class PlayList{
} }
}) })
}); });
let contents = JSON.parse(nextPage)?.onResponseReceivedActions[0]?.appendContinuationItemsAction?.continuationItems
if(!contents) return []
let playlist_videos = getPlaylistVideos(contents, limit) const contents =
this.fetched_videos.set(`page${this.__count}`, playlist_videos) JSON.parse(nextPage)?.onResponseReceivedActions[0]?.appendContinuationItemsAction?.continuationItems;
this._continuation.token = getContinuationToken(contents) if (!contents) return [];
return playlist_videos
const playlist_videos = getPlaylistVideos(contents, limit);
this.fetched_videos.set(`page${this.__count}`, playlist_videos);
this._continuation.token = getContinuationToken(contents);
return playlist_videos;
} }
async fetch(max: number = Infinity) { async fetch(max = Infinity) {
let continuation = this._continuation.token; const continuation = this._continuation.token;
if (!continuation) return this; if (!continuation) return this;
if (max < 1) max = Infinity; if (max < 1) max = Infinity;
while (typeof this._continuation.token === "string" && this._continuation.token.length) { while (typeof this._continuation.token === 'string' && this._continuation.token.length) {
if (this.videos?.length as number >= max) break; if ((this.videos?.length as number) >= max) break;
this.__count++ this.__count++;
const res = await this.next(); const res = await this.next();
if (!res.length) break; if (!res.length) break;
} }
@ -104,23 +109,23 @@ export class PlayList{
return this; return this;
} }
get type(): "playlist" { get type(): 'playlist' {
return "playlist"; return 'playlist';
} }
page(number : number): Video[]{ page(number: number): Video[] {
if(!number) throw new Error('Page number is not provided') if (!number) throw new Error('Page number is not provided');
if(!this.fetched_videos.has(`page${number}`)) throw new Error('Given Page number is invalid') if (!this.fetched_videos.has(`page${number}`)) throw new Error('Given Page number is invalid');
return this.fetched_videos.get(`page${number}`) as Video[] return this.fetched_videos.get(`page${number}`) as Video[];
} }
get total_pages(){ get total_pages() {
return this.fetched_videos.size return this.fetched_videos.size;
} }
get total_videos(){ get total_videos() {
let page_number: number = this.total_pages const page_number: number = this.total_pages;
return (page_number - 1) * 100 + (this.fetched_videos.get(`page${page_number}`) as Video[]).length return (page_number - 1) * 100 + (this.fetched_videos.get(`page${page_number}`) as Video[]).length;
} }
toJSON() { toJSON() {
@ -129,12 +134,12 @@ export class PlayList{
title: this.title, title: this.title,
thumbnail: this.thumbnail, thumbnail: this.thumbnail,
channel: { channel: {
name : this.channel?.name, name: this.channel?.name,
id : this.channel?.id, id: this.channel?.id,
icon : this.channel?.iconURL() icon: this.channel?.iconURL()
}, },
url: this.url, url: this.url,
videos: this.videos videos: this.videos
}; };
} }
} }

17
play-dl/YouTube/classes/Thumbnail.ts
View File

@ -1,4 +1,4 @@
type ThumbnailType = "default" | "hqdefault" | "mqdefault" | "sddefault" | "maxresdefault" | "ultrares"; type ThumbnailType = 'default' | 'hqdefault' | 'mqdefault' | 'sddefault' | 'maxresdefault' | 'ultrares';
export class Thumbnail { export class Thumbnail {
id?: string; id?: string;
@ -21,20 +21,21 @@ export class Thumbnail {
this.url = data.url || undefined; this.url = data.url || undefined;
} }
displayThumbnailURL(thumbnailType: ThumbnailType = "maxresdefault"): string { displayThumbnailURL(thumbnailType: ThumbnailType = 'maxresdefault'): string {
if (!["default", "hqdefault", "mqdefault", "sddefault", "maxresdefault", "ultrares"].includes(thumbnailType)) throw new Error(`Invalid thumbnail type "${thumbnailType}"!`); if (!['default', 'hqdefault', 'mqdefault', 'sddefault', 'maxresdefault', 'ultrares'].includes(thumbnailType))
if (thumbnailType === "ultrares") return this.url as string; throw new Error(`Invalid thumbnail type "${thumbnailType}"!`);
if (thumbnailType === 'ultrares') return this.url as string;
return `https://i3.ytimg.com/vi/${this.id}/${thumbnailType}.jpg`; return `https://i3.ytimg.com/vi/${this.id}/${thumbnailType}.jpg`;
} }
defaultThumbnailURL(id: "0" | "1" | "2" | "3" | "4"): string { defaultThumbnailURL(id: '0' | '1' | '2' | '3' | '4'): string {
if (!id) id = "0"; if (!id) id = '0';
if (!["0", "1", "2", "3", "4"].includes(id)) throw new Error(`Invalid thumbnail id "${id}"!`); if (!['0', '1', '2', '3', '4'].includes(id)) throw new Error(`Invalid thumbnail id "${id}"!`);
return `https://i3.ytimg.com/vi/${this.id}/${id}.jpg`; return `https://i3.ytimg.com/vi/${this.id}/${id}.jpg`;
} }
toString(): string { toString(): string {
return this.url ? `${this.url}` : ""; return this.url ? `${this.url}` : '';
} }
toJSON() { toJSON() {

44
play-dl/YouTube/classes/Video.ts
View File

@ -1,9 +1,9 @@
import { Channel } from "./Channel"; import { Channel } from './Channel';
import { Thumbnail } from "./Thumbnail"; import { Thumbnail } from './Thumbnail';
interface VideoOptions { interface VideoOptions {
id?: string; id?: string;
url? : string; url?: string;
title?: string; title?: string;
description?: string; description?: string;
durationRaw: string; durationRaw: string;
@ -12,21 +12,21 @@ interface VideoOptions {
views: number; views: number;
thumbnail?: { thumbnail?: {
id: string | undefined; id: string | undefined;
width: number | undefined ; width: number | undefined;
height: number | undefined; height: number | undefined;
url: string | undefined; url: string | undefined;
}; };
channel?: { channel?: {
name : string, name: string;
id : string, id: string;
icon : string icon: string;
}; };
videos?: Video[]; videos?: Video[];
type : string; type: string;
ratings : { ratings: {
likes: number; likes: number;
dislikes: number; dislikes: number;
} };
live: boolean; live: boolean;
private: boolean; private: boolean;
tags: string[]; tags: string[];
@ -34,7 +34,7 @@ interface VideoOptions {
export class Video { export class Video {
id?: string; id?: string;
url? : string; url?: string;
title?: string; title?: string;
description?: string; description?: string;
durationRaw: string; durationRaw: string;
@ -50,35 +50,35 @@ export class Video {
private: boolean; private: boolean;
tags: string[]; tags: string[];
constructor(data : any){ constructor(data: any) {
if(!data) throw new Error(`Can not initiate ${this.constructor.name} without data`) if (!data) throw new Error(`Can not initiate ${this.constructor.name} without data`);
this.id = data.id || undefined; this.id = data.id || undefined;
this.url = `https://www.youtube.com/watch?v=${this.id}` this.url = `https://www.youtube.com/watch?v=${this.id}`;
this.title = data.title || undefined; this.title = data.title || undefined;
this.description = data.description || undefined; this.description = data.description || undefined;
this.durationRaw = data.duration_raw || "0:00"; this.durationRaw = data.duration_raw || '0:00';
this.durationInSec = (data.duration < 0 ? 0 : data.duration) || 0; this.durationInSec = (data.duration < 0 ? 0 : data.duration) || 0;
this.uploadedAt = data.uploadedAt || undefined; this.uploadedAt = data.uploadedAt || undefined;
this.views = parseInt(data.views) || 0; this.views = parseInt(data.views) || 0;
this.thumbnail = data.thumbnail || {}; this.thumbnail = data.thumbnail || {};
this.channel = data.channel || {}; this.channel = data.channel || {};
this.likes = data.ratings?.likes as number || 0; this.likes = (data.ratings?.likes as number) || 0;
this.dislikes = data.ratings?.dislikes || 0; this.dislikes = data.ratings?.dislikes || 0;
this.live = !!data.live; this.live = !!data.live;
this.private = !!data.private; this.private = !!data.private;
this.tags = data.tags || []; this.tags = data.tags || [];
} }
get type(): "video" { get type(): 'video' {
return "video"; return 'video';
} }
get toString(): string { get toString(): string {
return this.url || ""; return this.url || '';
} }
get toJSON(): VideoOptions{ get toJSON(): VideoOptions {
return { return {
id: this.id, id: this.id,
url: this.url, url: this.url,
@ -104,4 +104,4 @@ export class Video {
private: this.private private: this.private
}; };
} }
} }

6
play-dl/YouTube/index.ts
View File

@ -1,3 +1,3 @@
export { search } from './search' export { search } from './search';
export { stream, stream_from_info } from './stream' export { stream, stream_from_info } from './stream';
export * from './utils' export * from './utils';

52
play-dl/YouTube/search.ts
View File

@ -1,36 +1,38 @@
import { request } from "./utils/request"; import { request } from './utils/request';
import { ParseSearchInterface, ParseSearchResult } from "./utils/parser"; import { ParseSearchInterface, ParseSearchResult } from './utils/parser';
import { Video } from "./classes/Video"; import { Video } from './classes/Video';
import { Channel } from "./classes/Channel"; import { Channel } from './classes/Channel';
import { PlayList } from "./classes/Playlist"; import { PlayList } from './classes/Playlist';
enum SearchType { enum SearchType {
Video = 'EgIQAQ%253D%253D', Video = 'EgIQAQ%253D%253D',
PlayList = 'EgIQAw%253D%253D', PlayList = 'EgIQAw%253D%253D',
Channel = 'EgIQAg%253D%253D', Channel = 'EgIQAg%253D%253D'
} }
export async function search(search :string, options : ParseSearchInterface = {}): Promise<(Video | Channel | PlayList)[]> { export async function search(
let url = 'https://www.youtube.com/results?search_query=' + search.replaceAll(' ', '+') search: string,
options.type ??= "video" options: ParseSearchInterface = {}
if(!url.match('&sp=')){ ): Promise<(Video | Channel | PlayList)[]> {
url += '&sp=' let url = 'https://www.youtube.com/results?search_query=' + search.replaceAll(' ', '+');
switch(options?.type){ options.type ??= 'video';
if (!url.match('&sp=')) {
url += '&sp=';
switch (options?.type) {
case 'channel': case 'channel':
url += SearchType.Channel url += SearchType.Channel;
break break;
case 'playlist': case 'playlist':
url += SearchType.PlayList url += SearchType.PlayList;
break break;
case 'video': case 'video':
url += SearchType.Video url += SearchType.Video;
break break;
} }
} }
let body = await request(url, { const body = await request(url, {
headers : {'accept-language' : 'en-US,en-IN;q=0.9,en;q=0.8,hi;q=0.7'} headers: { 'accept-language': 'en-US,en-IN;q=0.9,en;q=0.8,hi;q=0.7' }
}) });
let data = ParseSearchResult(body, options) const data = ParseSearchResult(body, options);
return data return data;
} }

166
play-dl/YouTube/stream.ts
View File

@ -1,97 +1,123 @@
import { video_info } from "." import { video_info } from '.';
import { LiveStreaming, Stream } from "./classes/LiveStream" import { LiveStreaming, Stream } from './classes/LiveStream';
export enum StreamType{ export enum StreamType {
Arbitrary = 'arbitrary', Arbitrary = 'arbitrary',
Raw = 'raw', Raw = 'raw',
OggOpus = 'ogg/opus', OggOpus = 'ogg/opus',
WebmOpus = 'webm/opus', WebmOpus = 'webm/opus',
Opus = 'opus', Opus = 'opus'
} }
interface InfoData{ interface InfoData {
LiveStreamData : { LiveStreamData: {
isLive : boolean isLive: boolean;
dashManifestUrl : string dashManifestUrl: string;
hlsManifestUrl : string hlsManifestUrl: string;
} };
html5player : string html5player: string;
format : any[] format: any[];
video_details : any video_details: any;
} }
function parseAudioFormats(formats : any[]){ function parseAudioFormats(formats: any[]) {
let result: any[] = [] const result: any[] = [];
formats.forEach((format) => { formats.forEach((format) => {
let type = format.mimeType as string const type = format.mimeType as string;
if(type.startsWith('audio')){ if (type.startsWith('audio')) {
format.codec = type.split('codecs="')[1].split('"')[0] format.codec = type.split('codecs="')[1].split('"')[0];
format.container = type.split('audio/')[1].split(';')[0] format.container = type.split('audio/')[1].split(';')[0];
result.push(format) result.push(format);
} }
}) });
return result return result;
} }
export async function stream(url : string, cookie? : string): Promise<Stream | LiveStreaming>{ export async function stream(url: string, cookie?: string): Promise<Stream | LiveStreaming> {
let info = await video_info(url, cookie) const info = await video_info(url, cookie);
let final: any[] = []; const final: any[] = [];
let type : StreamType; let type: StreamType;
if(info.LiveStreamData.isLive === true && info.LiveStreamData.hlsManifestUrl !== null && info.video_details.durationInSec === '0') { if (
return new LiveStreaming(info.LiveStreamData.dashManifestUrl, info.format[info.format.length - 1].targetDurationSec, info.video_details.url) info.LiveStreamData.isLive === true &&
info.LiveStreamData.hlsManifestUrl !== null &&
info.video_details.durationInSec === '0'
) {
return new LiveStreaming(
info.LiveStreamData.dashManifestUrl,
info.format[info.format.length - 1].targetDurationSec,
info.video_details.url
);
} }
let audioFormat = parseAudioFormats(info.format) const audioFormat = parseAudioFormats(info.format);
let opusFormats = filterFormat(audioFormat, "opus") const opusFormats = filterFormat(audioFormat, 'opus');
if(opusFormats.length === 0){ if (opusFormats.length === 0) {
type = StreamType.Arbitrary type = StreamType.Arbitrary;
if(audioFormat.length === 0){ if (audioFormat.length === 0) {
final.push(info.format[info.format.length - 1]) final.push(info.format[info.format.length - 1]);
} } else {
else{ final.push(audioFormat[audioFormat.length - 1]);
final.push(audioFormat[audioFormat.length - 1]) }
} } else {
type = StreamType.WebmOpus;
final.push(opusFormats[opusFormats.length - 1]);
} }
else{
type = StreamType.WebmOpus return new Stream(
final.push(opusFormats[opusFormats.length - 1]) final[0].url,
} type,
info.video_details.durationInSec,
return new Stream(final[0].url, type, info.video_details.durationInSec, Number(final[0].contentLength), info.video_details.url, cookie as string) Number(final[0].contentLength),
info.video_details.url,
cookie as string
);
} }
export async function stream_from_info(info : InfoData, cookie? : string): Promise<Stream | LiveStreaming>{ export async function stream_from_info(info: InfoData, cookie?: string): Promise<Stream | LiveStreaming> {
let final: any[] = []; const final: any[] = [];
let type : StreamType; let type: StreamType;
if(info.LiveStreamData.isLive === true && info.LiveStreamData.hlsManifestUrl !== null && info.video_details.durationInSec === '0') { if (
return new LiveStreaming(info.LiveStreamData.dashManifestUrl, info.format[info.format.length - 1].targetDurationSec, info.video_details.url) info.LiveStreamData.isLive === true &&
info.LiveStreamData.hlsManifestUrl !== null &&
info.video_details.durationInSec === '0'
) {
return new LiveStreaming(
info.LiveStreamData.dashManifestUrl,
info.format[info.format.length - 1].targetDurationSec,
info.video_details.url
);
} }
let audioFormat = parseAudioFormats(info.format) const audioFormat = parseAudioFormats(info.format);
let opusFormats = filterFormat(audioFormat, "opus") const opusFormats = filterFormat(audioFormat, 'opus');
if(opusFormats.length === 0){ if (opusFormats.length === 0) {
type = StreamType.Arbitrary type = StreamType.Arbitrary;
if(audioFormat.length === 0){ if (audioFormat.length === 0) {
final.push(info.format[info.format.length - 1]) final.push(info.format[info.format.length - 1]);
} } else {
else{ final.push(audioFormat[audioFormat.length - 1]);
final.push(audioFormat[audioFormat.length - 1]) }
} } else {
type = StreamType.WebmOpus;
final.push(opusFormats[opusFormats.length - 1]);
} }
else{
type = StreamType.WebmOpus return new Stream(
final.push(opusFormats[opusFormats.length - 1]) final[0].url,
} type,
info.video_details.durationInSec,
return new Stream(final[0].url, type, info.video_details.durationInSec, Number(final[0].contentLength), info.video_details.url, cookie as string) Number(final[0].contentLength),
info.video_details.url,
cookie as string
);
} }
function filterFormat(formats : any[], codec : string){ function filterFormat(formats: any[], codec: string) {
let result: any[] = [] const result: any[] = [];
formats.forEach((format) => { formats.forEach((format) => {
if(format.codec === codec) result.push(format) if (format.codec === codec) result.push(format);
}) });
return result return result;
} }

261
play-dl/YouTube/utils/cipher.ts
View File

@ -1,13 +1,13 @@
import { URL } from 'url' import { URL } from 'url';
import { request } from './request' import { request } from './request';
import querystring from 'querystring' import querystring from 'querystring';
interface formatOptions { interface formatOptions {
url? : string; url?: string;
sp? : string; sp?: string;
signatureCipher? : string; signatureCipher?: string;
cipher?: string; cipher?: string;
s? : string; s?: string;
} }
const var_js = '[a-zA-Z_\\$][a-zA-Z_0-9]*'; const var_js = '[a-zA-Z_\\$][a-zA-Z_0-9]*';
const singlequote_js = `'[^'\\\\]*(:?\\\\[\\s\\S][^'\\\\]*)*'`; const singlequote_js = `'[^'\\\\]*(:?\\\\[\\s\\S][^'\\\\]*)*'`;
@ -16,159 +16,140 @@ const quote_js = `(?:${singlequote_js}|${duoblequote_js})`;
const key_js = `(?:${var_js}|${quote_js})`; const key_js = `(?:${var_js}|${quote_js})`;
const prop_js = `(?:\\.${var_js}|\\[${quote_js}\\])`; const prop_js = `(?:\\.${var_js}|\\[${quote_js}\\])`;
const empty_js = `(?:''|"")`; const empty_js = `(?:''|"")`;
const reverse_function = ':function\\(a\\)\\{' + const reverse_function = ':function\\(a\\)\\{' + '(?:return )?a\\.reverse\\(\\)' + '\\}';
'(?:return )?a\\.reverse\\(\\)' + const slice_function = ':function\\(a,b\\)\\{' + 'return a\\.slice\\(b\\)' + '\\}';
'\\}'; const splice_function = ':function\\(a,b\\)\\{' + 'a\\.splice\\(0,b\\)' + '\\}';
const slice_function = ':function\\(a,b\\)\\{' + const swap_function =
'return a\\.slice\\(b\\)' + ':function\\(a,b\\)\\{' +
'\\}'; 'var c=a\\[0\\];a\\[0\\]=a\\[b(?:%a\\.length)?\\];a\\[b(?:%a\\.length)?\\]=c(?:;return a)?' +
const splice_function = ':function\\(a,b\\)\\{' + '\\}';
'a\\.splice\\(0,b\\)' +
'\\}';
const swap_function = ':function\\(a,b\\)\\{' +
'var c=a\\[0\\];a\\[0\\]=a\\[b(?:%a\\.length)?\\];a\\[b(?:%a\\.length)?\\]=c(?:;return a)?' +
'\\}';
const obj_regexp = new RegExp( const obj_regexp = new RegExp(
`var (${var_js})=\\{((?:(?:${ `var (${var_js})=\\{((?:(?:${key_js}${reverse_function}|${key_js}${slice_function}|${key_js}${splice_function}|${key_js}${swap_function}),?\\r?\\n?)+)\\};`
key_js}${reverse_function}|${ );
key_js}${slice_function}|${ const function_regexp = new RegExp(
key_js}${splice_function}|${ `${
key_js}${swap_function `function(?: ${var_js})?\\(a\\)\\{` + `a=a\\.split\\(${empty_js}\\);\\s*` + `((?:(?:a=)?${var_js}`
}),?\\r?\\n?)+)\\};`) }${prop_js}\\(a,\\d+\\);)+)` +
const function_regexp = new RegExp(`${`function(?: ${var_js})?\\(a\\)\\{` + `return a\\.join\\(${empty_js}\\)` +
`a=a\\.split\\(${empty_js}\\);\\s*` + `\\}`
`((?:(?:a=)?${var_js}`}${ );
prop_js
}\\(a,\\d+\\);)+)` +
`return a\\.join\\(${empty_js}\\)` +
`\\}`);
const reverse_regexp = new RegExp(`(?:^|,)(${key_js})${reverse_function}`, 'm'); const reverse_regexp = new RegExp(`(?:^|,)(${key_js})${reverse_function}`, 'm');
const slice_regexp = new RegExp(`(?:^|,)(${key_js})${slice_function}`, 'm'); const slice_regexp = new RegExp(`(?:^|,)(${key_js})${slice_function}`, 'm');
const splice_regexp = new RegExp(`(?:^|,)(${key_js})${splice_function}`, 'm'); const splice_regexp = new RegExp(`(?:^|,)(${key_js})${splice_function}`, 'm');
const swap_regexp = new RegExp(`(?:^|,)(${key_js})${swap_function}`, 'm'); const swap_regexp = new RegExp(`(?:^|,)(${key_js})${swap_function}`, 'm');
export function js_tokens( body:string ) { export function js_tokens(body: string) {
let function_action = function_regexp.exec(body) const function_action = function_regexp.exec(body);
let object_action = obj_regexp.exec(body) const object_action = obj_regexp.exec(body);
if(!function_action || !object_action) return null if (!function_action || !object_action) return null;
let object = object_action[1].replace(/\$/g, '\\$') const object = object_action[1].replace(/\$/g, '\\$');
let object_body = object_action[2].replace(/\$/g, '\\$') const object_body = object_action[2].replace(/\$/g, '\\$');
let function_body = function_action[1].replace(/\$/g, '\\$') const function_body = function_action[1].replace(/\$/g, '\\$');
let result = reverse_regexp.exec(object_body); let result = reverse_regexp.exec(object_body);
const reverseKey = result && result[1] const reverseKey = result && result[1].replace(/\$/g, '\\$').replace(/\$|^'|^"|'$|"$/g, '');
.replace(/\$/g, '\\$')
.replace(/\$|^'|^"|'$|"$/g, '');
result = slice_regexp.exec(object_body)
const sliceKey = result && result[1]
.replace(/\$/g, '\\$')
.replace(/\$|^'|^"|'$|"$/g, '');
result = splice_regexp.exec(object_body); result = slice_regexp.exec(object_body);
const spliceKey = result && result[1] const sliceKey = result && result[1].replace(/\$/g, '\\$').replace(/\$|^'|^"|'$|"$/g, '');
.replace(/\$/g, '\\$')
.replace(/\$|^'|^"|'$|"$/g, '');
result = swap_regexp.exec(object_body); result = splice_regexp.exec(object_body);
const swapKey = result && result[1] const spliceKey = result && result[1].replace(/\$/g, '\\$').replace(/\$|^'|^"|'$|"$/g, '');
.replace(/\$/g, '\\$')
.replace(/\$|^'|^"|'$|"$/g, '');
const keys = `(${[reverseKey, sliceKey, spliceKey, swapKey].join('|')})`; result = swap_regexp.exec(object_body);
const myreg = `(?:a=)?${object const swapKey = result && result[1].replace(/\$/g, '\\$').replace(/\$|^'|^"|'$|"$/g, '');
}(?:\\.${keys}|\\['${keys}'\\]|\\["${keys}"\\])` +
`\\(a,(\\d+)\\)`; const keys = `(${[reverseKey, sliceKey, spliceKey, swapKey].join('|')})`;
const tokenizeRegexp = new RegExp(myreg, 'g'); const myreg = `(?:a=)?${object}(?:\\.${keys}|\\['${keys}'\\]|\\["${keys}"\\])` + `\\(a,(\\d+)\\)`;
const tokens = []; const tokenizeRegexp = new RegExp(myreg, 'g');
while((result = tokenizeRegexp.exec(function_body)) !== null){ const tokens = [];
let key = result[1] || result[2] || result[3]; while ((result = tokenizeRegexp.exec(function_body)) !== null) {
switch (key) { const key = result[1] || result[2] || result[3];
case swapKey: switch (key) {
tokens.push(`sw${result[4]}`); case swapKey:
break; tokens.push(`sw${result[4]}`);
case reverseKey: break;
tokens.push('rv'); case reverseKey:
break; tokens.push('rv');
case sliceKey: break;
tokens.push(`sl${result[4]}`); case sliceKey:
break; tokens.push(`sl${result[4]}`);
case spliceKey: break;
tokens.push(`sp${result[4]}`); case spliceKey:
break; tokens.push(`sp${result[4]}`);
break;
}
} }
} return tokens;
return tokens
} }
function deciper_signature(tokens : string[], signature :string){ function deciper_signature(tokens: string[], signature: string) {
let sig = signature.split('') let sig = signature.split('');
let len = tokens.length const len = tokens.length;
for(let i = 0; i < len; i++ ){ for (let i = 0; i < len; i++) {
let token = tokens[i], pos; let token = tokens[i],
switch(token.slice(0,2)){ pos;
case 'sw': switch (token.slice(0, 2)) {
pos = parseInt(token.slice(2)) case 'sw':
sig = swappositions(sig, pos) pos = parseInt(token.slice(2));
break sig = swappositions(sig, pos);
case 'rv': break;
sig = sig.reverse() case 'rv':
break sig = sig.reverse();
case 'sl': break;
pos = parseInt(token.slice(2)) case 'sl':
sig = sig.slice(pos) pos = parseInt(token.slice(2));
break sig = sig.slice(pos);
case 'sp': break;
pos = parseInt(token.slice(2)) case 'sp':
sig.splice(0, pos) pos = parseInt(token.slice(2));
break sig.splice(0, pos);
break;
}
} }
} return sig.join('');
return sig.join('')
} }
function swappositions(array: string[], position: number) {
function swappositions(array : string[], position : number){ const first = array[0];
let first = array[0] array[0] = array[position];
array[0] = array[position] array[position] = first;
array[position] = first return array;
return array
} }
function download_url(format: formatOptions, sig : string){ function download_url(format: formatOptions, sig: string) {
let decoded_url; let decoded_url;
if(!format.url) return; if (!format.url) return;
decoded_url = format.url decoded_url = format.url;
decoded_url = decodeURIComponent(decoded_url) decoded_url = decodeURIComponent(decoded_url);
let parsed_url = new URL(decoded_url) const parsed_url = new URL(decoded_url);
parsed_url.searchParams.set('ratebypass', 'yes'); parsed_url.searchParams.set('ratebypass', 'yes');
if(sig){ if (sig) {
parsed_url.searchParams.set(format.sp || 'signature', sig) parsed_url.searchParams.set(format.sp || 'signature', sig);
} }
format.url = parsed_url.toString(); format.url = parsed_url.toString();
} }
export async function format_decipher(formats: formatOptions[], html5player : string){ export async function format_decipher(formats: formatOptions[], html5player: string) {
let body = await request(html5player) const body = await request(html5player);
let tokens = js_tokens(body) const tokens = js_tokens(body);
formats.forEach((format) => { formats.forEach((format) => {
let cipher = format.signatureCipher || format.cipher; const cipher = format.signatureCipher || format.cipher;
if(cipher){ if (cipher) {
Object.assign(format, querystring.parse(cipher)) Object.assign(format, querystring.parse(cipher));
delete format.signatureCipher; delete format.signatureCipher;
delete format.cipher; delete format.cipher;
} }
let sig; let sig;
if(tokens && format.s){ if (tokens && format.s) {
sig = deciper_signature(tokens, format.s) sig = deciper_signature(tokens, format.s);
download_url(format, sig) download_url(format, sig);
delete format.s delete format.s;
delete format.sp delete format.sp;
} }
}); });
return formats return formats;
} }

329
play-dl/YouTube/utils/extractor.ts
View File

@ -1,166 +1,187 @@
import { request } from './request' import { request } from './request';
import { format_decipher, js_tokens } from './cipher' import { format_decipher, js_tokens } from './cipher';
import { Video } from '../classes/Video' import { Video } from '../classes/Video';
import { PlayList } from '../classes/Playlist' import { PlayList } from '../classes/Playlist';
const DEFAULT_API_KEY = "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8"; const DEFAULT_API_KEY = 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8';
const video_pattern = /^((?:https?:)?\/\/)?(?:(?:www|m)\.)?((?:youtube\.com|youtu.be))(\/(?:[\w\-]+\?v=|embed\/|v\/)?)([\w\-]+)(\S+)?$/; const video_pattern =
const playlist_pattern = /^((?:https?:)?\/\/)?(?:(?:www|m)\.)?(youtube\.com)\/(?:(playlist|watch))(.*)?((\?|\&)list=)/ /^((?:https?:)?\/\/)?(?:(?:www|m)\.)?((?:youtube\.com|youtu.be))(\/(?:[\w\-]+\?v=|embed\/|v\/)?)([\w\-]+)(\S+)?$/;
const playlist_pattern = /^((?:https?:)?\/\/)?(?:(?:www|m)\.)?(youtube\.com)\/(?:(playlist|watch))(.*)?((\?|\&)list=)/;
export function yt_validate(url : string): "playlist" | "video" | boolean { export function yt_validate(url: string): 'playlist' | 'video' | boolean {
if(url.indexOf('list=') === -1){ if (url.indexOf('list=') === -1) {
if(!url.match(video_pattern)) return false if (!url.match(video_pattern)) return false;
else return "video" else return 'video';
} } else {
else { if (!url.match(playlist_pattern)) return false;
if(!url.match(playlist_pattern)) return false const Playlist_id = url.split('list=')[1].split('&')[0];
let Playlist_id = url.split('list=')[1].split('&')[0] if (Playlist_id.length !== 34 || !Playlist_id.startsWith('PL')) {
if(Playlist_id.length !== 34 || !Playlist_id.startsWith('PL')){ return false;
return false
} }
return "playlist" return 'playlist';
} }
} }
export function extractID(url : string): string{ export function extractID(url: string): string {
if(url.startsWith('https')){ if (url.startsWith('https')) {
if(url.indexOf('list=') === -1){ if (url.indexOf('list=') === -1) {
let video_id : string; let video_id: string;
if(url.includes('youtu.be/')) video_id = url.split('youtu.be/')[1].split('/')[0] if (url.includes('youtu.be/')) video_id = url.split('youtu.be/')[1].split('/')[0];
else if(url.includes('youtube.com/embed/')) video_id = url.split('youtube.com/embed/')[1].split('/')[0] else if (url.includes('youtube.com/embed/')) video_id = url.split('youtube.com/embed/')[1].split('/')[0];
else video_id = url.split('watch?v=')[1].split('&')[0]; else video_id = url.split('watch?v=')[1].split('&')[0];
return video_id return video_id;
} else {
return url.split('list=')[1].split('&')[0];
} }
else{ } else return url;
return url.split('list=')[1].split('&')[0]
}
}
else return url
} }
export async function video_basic_info(url : string, cookie? : string){ export async function video_basic_info(url: string, cookie?: string) {
let video_id : string; let video_id: string;
if(url.startsWith('https')) { if (url.startsWith('https')) {
if(yt_validate(url) !== 'video') throw new Error('This is not a YouTube Watch URL') if (yt_validate(url) !== 'video') throw new Error('This is not a YouTube Watch URL');
video_id = extractID(url) video_id = extractID(url);
} } else video_id = url;
else video_id = url const new_url = `https://www.youtube.com/watch?v=${video_id}`;
let new_url = `https://www.youtube.com/watch?v=${video_id}` const body = await request(new_url, {
let body = await request(new_url, { headers: cookie
headers : (cookie) ? { 'cookie' : cookie, 'accept-language' : 'en-US,en-IN;q=0.9,en;q=0.8,hi;q=0.7' } : {'accept-language' : 'en-US,en-IN;q=0.9,en;q=0.8,hi;q=0.7'} ? {
}) 'cookie': cookie,
let player_response = JSON.parse(body.split("var ytInitialPlayerResponse = ")[1].split("}};")[0] + '}}') 'accept-language': 'en-US,en-IN;q=0.9,en;q=0.8,hi;q=0.7'
let initial_response = JSON.parse(body.split("var ytInitialData = ")[1].split("}};")[0] + '}}') }
let badge = initial_response.contents.twoColumnWatchNextResults.results.results.contents[1]?.videoSecondaryInfoRenderer?.owner?.videoOwnerRenderer?.badges && initial_response.contents.twoColumnWatchNextResults.results.results.contents[1]?.videoSecondaryInfoRenderer?.owner?.videoOwnerRenderer?.badges[0] : { 'accept-language': 'en-US,en-IN;q=0.9,en;q=0.8,hi;q=0.7' }
if(player_response.playabilityStatus.status !== 'OK') throw new Error(`While getting info from url\n${player_response.playabilityStatus.errorScreen.playerErrorMessageRenderer?.reason.simpleText ?? player_response.playabilityStatus.errorScreen.playerKavRenderer?.reason.simpleText}`) });
let html5player = `https://www.youtube.com${body.split('"jsUrl":"')[1].split('"')[0]}` const player_response = JSON.parse(body.split('var ytInitialPlayerResponse = ')[1].split('}};')[0] + '}}');
let format = [] const initial_response = JSON.parse(body.split('var ytInitialData = ')[1].split('}};')[0] + '}}');
let vid = player_response.videoDetails const badge =
let microformat = player_response.microformat.playerMicroformatRenderer initial_response.contents.twoColumnWatchNextResults.results.results.contents[1]?.videoSecondaryInfoRenderer
let video_details = { ?.owner?.videoOwnerRenderer?.badges &&
id : vid.videoId, initial_response.contents.twoColumnWatchNextResults.results.results.contents[1]?.videoSecondaryInfoRenderer
url : `https://www.youtube.com/watch?v=${vid.videoId}`, ?.owner?.videoOwnerRenderer?.badges[0];
title : vid.title, if (player_response.playabilityStatus.status !== 'OK')
description : vid.shortDescription, throw new Error(
durationInSec : vid.lengthSeconds, `While getting info from url\n${
durationRaw : parseSeconds(vid.lengthSeconds), player_response.playabilityStatus.errorScreen.playerErrorMessageRenderer?.reason.simpleText ??
uploadedDate : microformat.publishDate, player_response.playabilityStatus.errorScreen.playerKavRenderer?.reason.simpleText
thumbnail : vid.thumbnail.thumbnails[vid.thumbnail.thumbnails.length - 1], }`
channel : { );
name : vid.author, const html5player = `https://www.youtube.com${body.split('"jsUrl":"')[1].split('"')[0]}`;
id : vid.channelId, const format = [];
url : `https://www.youtube.com/channel/${vid.channelId}`, const vid = player_response.videoDetails;
verified : Boolean(badge?.metadataBadgeRenderer?.style?.toLowerCase().includes('verified')) const microformat = player_response.microformat.playerMicroformatRenderer;
}, const video_details = {
views : vid.viewCount, id: vid.videoId,
tags : vid.keywords, url: `https://www.youtube.com/watch?v=${vid.videoId}`,
averageRating : vid.averageRating, title: vid.title,
live : vid.isLiveContent, description: vid.shortDescription,
private : vid.isPrivate durationInSec: vid.lengthSeconds,
} durationRaw: parseSeconds(vid.lengthSeconds),
if(!video_details.live) format.push(player_response.streamingData.formats[0]) uploadedDate: microformat.publishDate,
format.push(...player_response.streamingData.adaptiveFormats) thumbnail: vid.thumbnail.thumbnails[vid.thumbnail.thumbnails.length - 1],
let LiveStreamData = { channel: {
isLive : video_details.live, name: vid.author,
dashManifestUrl : player_response.streamingData?.dashManifestUrl ?? null, id: vid.channelId,
hlsManifestUrl : player_response.streamingData?.hlsManifestUrl ?? null url: `https://www.youtube.com/channel/${vid.channelId}`,
} verified: Boolean(badge?.metadataBadgeRenderer?.style?.toLowerCase().includes('verified'))
return { },
LiveStreamData, views: vid.viewCount,
html5player, tags: vid.keywords,
format, averageRating: vid.averageRating,
video_details live: vid.isLiveContent,
} private: vid.isPrivate
};
if (!video_details.live) format.push(player_response.streamingData.formats[0]);
format.push(...player_response.streamingData.adaptiveFormats);
const LiveStreamData = {
isLive: video_details.live,
dashManifestUrl: player_response.streamingData?.dashManifestUrl ?? null,
hlsManifestUrl: player_response.streamingData?.hlsManifestUrl ?? null
};
return {
LiveStreamData,
html5player,
format,
video_details
};
} }
function parseSeconds(seconds : number): string { function parseSeconds(seconds: number): string {
let d = Number(seconds); const d = Number(seconds);
var h = Math.floor(d / 3600); const h = Math.floor(d / 3600);
var m = Math.floor(d % 3600 / 60); const m = Math.floor((d % 3600) / 60);
var s = Math.floor(d % 3600 % 60); const s = Math.floor((d % 3600) % 60);
var hDisplay = h > 0 ? (h < 10 ? `0${h}` : h) + ':' : ""; const hDisplay = h > 0 ? (h < 10 ? `0${h}` : h) + ':' : '';
var mDisplay = m > 0 ? (m < 10 ? `0${m}` : m) + ':' : "00:"; const mDisplay = m > 0 ? (m < 10 ? `0${m}` : m) + ':' : '00:';
var sDisplay = s > 0 ? (s < 10 ? `0${s}` : s) : "00"; const sDisplay = s > 0 ? (s < 10 ? `0${s}` : s) : '00';
return hDisplay + mDisplay + sDisplay; return hDisplay + mDisplay + sDisplay;
} }
export async function video_info(url : string, cookie? : string) { export async function video_info(url: string, cookie?: string) {
let data = await video_basic_info(url, cookie) const data = await video_basic_info(url, cookie);
if(data.LiveStreamData.isLive === true && data.LiveStreamData.hlsManifestUrl !== null){ if (data.LiveStreamData.isLive === true && data.LiveStreamData.hlsManifestUrl !== null) {
return data return data;
} } else if (data.format[0].signatureCipher || data.format[0].cipher) {
else if(data.format[0].signatureCipher || data.format[0].cipher){ data.format = await format_decipher(data.format, data.html5player);
data.format = await format_decipher(data.format, data.html5player) return data;
return data } else {
} return data;
else {
return data
} }
} }
export async function playlist_info(url : string, parseIncomplete : boolean = false) { export async function playlist_info(url: string, parseIncomplete = false) {
if (!url || typeof url !== "string") throw new Error(`Expected playlist url, received ${typeof url}!`); if (!url || typeof url !== 'string') throw new Error(`Expected playlist url, received ${typeof url}!`);
let Playlist_id : string let Playlist_id: string;
if(url.startsWith('https')){ if (url.startsWith('https')) {
if(yt_validate(url) !== 'playlist') throw new Error('This is not a Playlist URL') if (yt_validate(url) !== 'playlist') throw new Error('This is not a Playlist URL');
Playlist_id = extractID(url) Playlist_id = extractID(url);
} } else Playlist_id = url;
else Playlist_id = url const new_url = `https://www.youtube.com/playlist?list=${Playlist_id}`;
let new_url = `https://www.youtube.com/playlist?list=${Playlist_id}`
const body = await request(new_url, {
let body = await request(new_url, { headers: { 'accept-language': 'en-US,en-IN;q=0.9,en;q=0.8,hi;q=0.7' }
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]);
let response = JSON.parse(body.split("var ytInitialData = ")[1].split(";</script>")[0]) if (response.alerts) {
if(response.alerts){ if (response.alerts[0].alertWithButtonRenderer?.type === 'INFO') {
if(response.alerts[0].alertWithButtonRenderer?.type === 'INFO') { if (!parseIncomplete)
if(!parseIncomplete) throw new Error(`While parsing playlist url\n${response.alerts[0].alertWithButtonRenderer.text.simpleText}`) throw new Error(
} `While parsing playlist url\n${response.alerts[0].alertWithButtonRenderer.text.simpleText}`
else if(response.alerts[0].alertRenderer?.type === 'ERROR') throw new Error(`While parsing playlist url\n${response.alerts[0].alertRenderer.text.runs[0].text}`) );
else throw new Error('While parsing playlist url\nUnknown Playlist Error') } else if (response.alerts[0].alertRenderer?.type === 'ERROR')
throw new Error(`While parsing playlist url\n${response.alerts[0].alertRenderer.text.runs[0].text}`);
else throw new Error('While parsing playlist url\nUnknown Playlist Error');
} }
let rawJSON = `${body.split('{"playlistVideoListRenderer":{"contents":')[1].split('}],"playlistId"')[0]}}]`; const rawJSON = `${body.split('{"playlistVideoListRenderer":{"contents":')[1].split('}],"playlistId"')[0]}}]`;
let parsed = JSON.parse(rawJSON); const parsed = JSON.parse(rawJSON);
let playlistDetails = JSON.parse(body.split('{"playlistSidebarRenderer":')[1].split("}};</script>")[0]).items; const playlistDetails = JSON.parse(body.split('{"playlistSidebarRenderer":')[1].split('}};</script>')[0]).items;
let API_KEY = body.split('INNERTUBE_API_KEY":"')[1]?.split('"')[0] ?? body.split('innertubeApiKey":"')[1]?.split('"')[0] ?? DEFAULT_API_KEY; const API_KEY =
let videos = getPlaylistVideos(parsed, 100); body.split('INNERTUBE_API_KEY":"')[1]?.split('"')[0] ??
body.split('innertubeApiKey":"')[1]?.split('"')[0] ??
DEFAULT_API_KEY;
const videos = getPlaylistVideos(parsed, 100);
let data = playlistDetails[0].playlistSidebarPrimaryInfoRenderer; const data = playlistDetails[0].playlistSidebarPrimaryInfoRenderer;
if (!data.title.runs || !data.title.runs.length) return undefined; if (!data.title.runs || !data.title.runs.length) return undefined;
let author = playlistDetails[1]?.playlistSidebarSecondaryInfoRenderer.videoOwner; const author = playlistDetails[1]?.playlistSidebarSecondaryInfoRenderer.videoOwner;
let views = data.stats.length === 3 ? data.stats[1].simpleText.replace(/[^0-9]/g, "") : 0; const views = data.stats.length === 3 ? data.stats[1].simpleText.replace(/[^0-9]/g, '') : 0;
let lastUpdate = data.stats.find((x: any) => "runs" in x && x["runs"].find((y: any) => y.text.toLowerCase().includes("last update")))?.runs.pop()?.text ?? null; const lastUpdate =
let videosCount = data.stats[0].runs[0].text.replace(/[^0-9]/g, "") || 0; data.stats
.find((x: any) => 'runs' in x && x['runs'].find((y: any) => y.text.toLowerCase().includes('last update')))
?.runs.pop()?.text ?? null;
const videosCount = data.stats[0].runs[0].text.replace(/[^0-9]/g, '') || 0;
let res = new PlayList({ const res = new PlayList({
continuation: { continuation: {
api: API_KEY, api: API_KEY,
token: getContinuationToken(parsed), token: getContinuationToken(parsed),
clientVersion: body.split('"INNERTUBE_CONTEXT_CLIENT_VERSION":"')[1]?.split('"')[0] ?? body.split('"innertube_context_client_version":"')[1]?.split('"')[0] ?? "<some version>" clientVersion:
body.split('"INNERTUBE_CONTEXT_CLIENT_VERSION":"')[1]?.split('"')[0] ??
body.split('"innertube_context_client_version":"')[1]?.split('"')[0] ??
'<some version>'
}, },
id: data.title.runs[0].navigationEndpoint.watchEndpoint.playlistId, id: data.title.runs[0].navigationEndpoint.watchEndpoint.playlistId,
title: data.title.runs[0].text, title: data.title.runs[0].text,
@ -174,16 +195,27 @@ export async function playlist_info(url : string, parseIncomplete : boolean = fa
? { ? {
name: author.videoOwnerRenderer.title.runs[0].text, name: author.videoOwnerRenderer.title.runs[0].text,
id: author.videoOwnerRenderer.title.runs[0].navigationEndpoint.browseEndpoint.browseId, id: author.videoOwnerRenderer.title.runs[0].navigationEndpoint.browseEndpoint.browseId,
url: `https://www.youtube.com${author.videoOwnerRenderer.navigationEndpoint.commandMetadata.webCommandMetadata.url || author.videoOwnerRenderer.navigationEndpoint.browseEndpoint.canonicalBaseUrl}`, url: `https://www.youtube.com${
icon: author.videoOwnerRenderer.thumbnail.thumbnails.length ? author.videoOwnerRenderer.thumbnail.thumbnails[author.videoOwnerRenderer.thumbnail.thumbnails.length - 1].url : null author.videoOwnerRenderer.navigationEndpoint.commandMetadata.webCommandMetadata.url ||
author.videoOwnerRenderer.navigationEndpoint.browseEndpoint.canonicalBaseUrl
}`,
icon: author.videoOwnerRenderer.thumbnail.thumbnails.length
? author.videoOwnerRenderer.thumbnail.thumbnails[
author.videoOwnerRenderer.thumbnail.thumbnails.length - 1
].url
: null
} }
: {}, : {},
thumbnail: data.thumbnailRenderer.playlistVideoThumbnailRenderer?.thumbnail.thumbnails.length ? data.thumbnailRenderer.playlistVideoThumbnailRenderer.thumbnail.thumbnails[data.thumbnailRenderer.playlistVideoThumbnailRenderer.thumbnail.thumbnails.length - 1].url : null thumbnail: data.thumbnailRenderer.playlistVideoThumbnailRenderer?.thumbnail.thumbnails.length
? data.thumbnailRenderer.playlistVideoThumbnailRenderer.thumbnail.thumbnails[
data.thumbnailRenderer.playlistVideoThumbnailRenderer.thumbnail.thumbnails.length - 1
].url
: null
}); });
return res; return res;
} }
export function getPlaylistVideos(data:any, limit : number = Infinity) : Video[] { export function getPlaylistVideos(data: any, limit = Infinity): Video[] {
const videos = []; const videos = [];
for (let i = 0; i < data.length; i++) { for (let i = 0; i < data.length; i++) {
@ -196,7 +228,7 @@ export function getPlaylistVideos(data:any, limit : number = Infinity) : Video[]
id: info.videoId, id: info.videoId,
index: parseInt(info.index?.simpleText) || 0, index: parseInt(info.index?.simpleText) || 0,
duration: parseDuration(info.lengthText?.simpleText) || 0, duration: parseDuration(info.lengthText?.simpleText) || 0,
duration_raw: info.lengthText?.simpleText ?? "0:00", duration_raw: info.lengthText?.simpleText ?? '0:00',
thumbnail: { thumbnail: {
id: info.videoId, id: info.videoId,
url: info.thumbnail.thumbnails[info.thumbnail.thumbnails.length - 1].url, url: info.thumbnail.thumbnails[info.thumbnail.thumbnails.length - 1].url,
@ -207,18 +239,21 @@ export function getPlaylistVideos(data:any, limit : number = Infinity) : Video[]
channel: { channel: {
id: info.shortBylineText.runs[0].navigationEndpoint.browseEndpoint.browseId || undefined, id: info.shortBylineText.runs[0].navigationEndpoint.browseEndpoint.browseId || undefined,
name: info.shortBylineText.runs[0].text || undefined, name: info.shortBylineText.runs[0].text || undefined,
url: `https://www.youtube.com${info.shortBylineText.runs[0].navigationEndpoint.browseEndpoint.canonicalBaseUrl || info.shortBylineText.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url}`, url: `https://www.youtube.com${
info.shortBylineText.runs[0].navigationEndpoint.browseEndpoint.canonicalBaseUrl ||
info.shortBylineText.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url
}`,
icon: undefined icon: undefined
} }
}) })
); );
} }
return videos return videos;
} }
function parseDuration(duration: string): number { function parseDuration(duration: string): number {
duration ??= "0:00"; duration ??= '0:00';
const args = duration.split(":"); const args = duration.split(':');
let dur = 0; let dur = 0;
switch (args.length) { switch (args.length) {
@ -235,8 +270,8 @@ function parseDuration(duration: string): number {
return dur; return dur;
} }
export function getContinuationToken(data: any): string {
export function getContinuationToken(data:any): string { const continuationToken = data.find((x: any) => Object.keys(x)[0] === 'continuationItemRenderer')
const continuationToken = data.find((x: any) => Object.keys(x)[0] === "continuationItemRenderer")?.continuationItemRenderer.continuationEndpoint?.continuationCommand?.token; ?.continuationItemRenderer.continuationEndpoint?.continuationCommand?.token;
return continuationToken; return continuationToken;
} }

2
play-dl/YouTube/utils/index.ts
View File

@ -1 +1 @@
export { video_basic_info, video_info, playlist_info, yt_validate, extractID } from './extractor' export { video_basic_info, video_info, playlist_info, yt_validate, extractID } from './extractor';

122
play-dl/YouTube/utils/parser.ts
View File

@ -1,50 +1,51 @@
import { Video } from "../classes/Video"; import { Video } from '../classes/Video';
import { PlayList } from "../classes/Playlist"; import { PlayList } from '../classes/Playlist';
import { Channel } from "../classes/Channel"; import { Channel } from '../classes/Channel';
export interface ParseSearchInterface { export interface ParseSearchInterface {
type?: "video" | "playlist" | "channel" ; type?: 'video' | 'playlist' | 'channel';
limit?: number; limit?: number;
} }
export interface thumbnail{ export interface thumbnail {
width: string; width: string;
height : string; height: string;
url : string url: string;
} }
export function ParseSearchResult(html : string, options? : ParseSearchInterface): (Video | PlayList | Channel)[] { export function ParseSearchResult(html: string, options?: ParseSearchInterface): (Video | PlayList | Channel)[] {
if(!html) throw new Error('Can\'t parse Search result without data') if (!html) throw new Error("Can't parse Search result without data");
if (!options) options = { type: "video", limit: 0 }; if (!options) options = { type: 'video', limit: 0 };
if (!options.type) options.type = "video"; if (!options.type) options.type = 'video';
let data = html.split("var ytInitialData = ")[1].split("}};")[0] + '}}'; const data = html.split('var ytInitialData = ')[1].split('}};')[0] + '}}';
let json_data = JSON.parse(data) const json_data = JSON.parse(data);
let results = [] const results = [];
let details = json_data.contents.twoColumnSearchResultsRenderer.primaryContents.sectionListRenderer.contents[0].itemSectionRenderer.contents const details =
for(let i = 0; i < details.length; i++){ json_data.contents.twoColumnSearchResultsRenderer.primaryContents.sectionListRenderer.contents[0]
if (typeof options.limit === "number" && options.limit > 0 && results.length >= options.limit) break; .itemSectionRenderer.contents;
if (options.type === "video") { for (let i = 0; i < details.length; i++) {
if (typeof options.limit === 'number' && options.limit > 0 && results.length >= options.limit) break;
if (options.type === 'video') {
const parsed = parseVideo(details[i]); const parsed = parseVideo(details[i]);
if (!parsed) continue; if (!parsed) continue;
results.push(parsed) results.push(parsed);
} else if (options.type === "channel") { } else if (options.type === 'channel') {
const parsed = parseChannel(details[i]); const parsed = parseChannel(details[i]);
if (!parsed) continue; if (!parsed) continue;
results.push(parsed) results.push(parsed);
} else if (options.type === "playlist") { } else if (options.type === 'playlist') {
const parsed = parsePlaylist(details[i]); const parsed = parsePlaylist(details[i]);
if (!parsed) continue; if (!parsed) continue;
results.push(parsed) results.push(parsed);
} }
} }
return results return results;
} }
function parseDuration(duration: string): number { function parseDuration(duration: string): number {
duration ??= "0:00"; duration ??= '0:00';
const args = duration.split(":"); const args = duration.split(':');
let dur = 0; let dur = 0;
switch (args.length) { switch (args.length) {
@ -64,18 +65,27 @@ function parseDuration(duration: string): number {
export function parseChannel(data?: any): Channel | void { export function parseChannel(data?: any): Channel | void {
if (!data || !data.channelRenderer) return; if (!data || !data.channelRenderer) return;
const badge = data.channelRenderer.ownerBadges && data.channelRenderer.ownerBadges[0]; const badge = data.channelRenderer.ownerBadges && data.channelRenderer.ownerBadges[0];
let url = `https://www.youtube.com${data.channelRenderer.navigationEndpoint.browseEndpoint.canonicalBaseUrl || data.channelRenderer.navigationEndpoint.commandMetadata.webCommandMetadata.url}`; const url = `https://www.youtube.com${
let res = new Channel({ data.channelRenderer.navigationEndpoint.browseEndpoint.canonicalBaseUrl ||
data.channelRenderer.navigationEndpoint.commandMetadata.webCommandMetadata.url
}`;
const res = new Channel({
id: data.channelRenderer.channelId, id: data.channelRenderer.channelId,
name: data.channelRenderer.title.simpleText, name: data.channelRenderer.title.simpleText,
icon: { icon: {
url : data.channelRenderer.thumbnail.thumbnails[data.channelRenderer.thumbnail.thumbnails.length - 1].url.replace('//', 'https://'), url: data.channelRenderer.thumbnail.thumbnails[
width : data.channelRenderer.thumbnail.thumbnails[data.channelRenderer.thumbnail.thumbnails.length - 1].width, data.channelRenderer.thumbnail.thumbnails.length - 1
height: data.channelRenderer.thumbnail.thumbnails[data.channelRenderer.thumbnail.thumbnails.length - 1].height ].url.replace('//', 'https://'),
width: data.channelRenderer.thumbnail.thumbnails[data.channelRenderer.thumbnail.thumbnails.length - 1]
.width,
height: data.channelRenderer.thumbnail.thumbnails[data.channelRenderer.thumbnail.thumbnails.length - 1]
.height
}, },
url: url, url: url,
verified: Boolean(badge?.metadataBadgeRenderer?.style?.toLowerCase().includes("verified")), verified: Boolean(badge?.metadataBadgeRenderer?.style?.toLowerCase().includes('verified')),
subscribers: (data.channelRenderer.subscriberCountText?.simpleText) ? data.channelRenderer.subscriberCountText.simpleText : '0 subscribers' subscribers: data.channelRenderer.subscriberCountText?.simpleText
? data.channelRenderer.subscriberCountText.simpleText
: '0 subscribers'
}); });
return res; return res;
@ -85,34 +95,42 @@ export function parseVideo(data?: any): Video | void {
if (!data || !data.videoRenderer) return; if (!data || !data.videoRenderer) return;
const badge = data.videoRenderer.ownerBadges && data.videoRenderer.ownerBadges[0]; const badge = data.videoRenderer.ownerBadges && data.videoRenderer.ownerBadges[0];
let res = new Video({ const res = new Video({
id: data.videoRenderer.videoId, id: data.videoRenderer.videoId,
url: `https://www.youtube.com/watch?v=${data.videoRenderer.videoId}`, url: `https://www.youtube.com/watch?v=${data.videoRenderer.videoId}`,
title: data.videoRenderer.title.runs[0].text, title: data.videoRenderer.title.runs[0].text,
description: data.videoRenderer.descriptionSnippet && data.videoRenderer.descriptionSnippet.runs[0] ? data.videoRenderer.descriptionSnippet.runs[0].text : "", description:
data.videoRenderer.descriptionSnippet && data.videoRenderer.descriptionSnippet.runs[0]
? data.videoRenderer.descriptionSnippet.runs[0].text
: '',
duration: data.videoRenderer.lengthText ? parseDuration(data.videoRenderer.lengthText.simpleText) : 0, duration: data.videoRenderer.lengthText ? parseDuration(data.videoRenderer.lengthText.simpleText) : 0,
duration_raw: data.videoRenderer.lengthText ? data.videoRenderer.lengthText.simpleText : null, duration_raw: data.videoRenderer.lengthText ? data.videoRenderer.lengthText.simpleText : null,
thumbnail: data.videoRenderer.thumbnail.thumbnails[data.videoRenderer.thumbnail.thumbnails.length - 1], thumbnail: data.videoRenderer.thumbnail.thumbnails[data.videoRenderer.thumbnail.thumbnails.length - 1],
channel: { channel: {
id: data.videoRenderer.ownerText.runs[0].navigationEndpoint.browseEndpoint.browseId || null, id: data.videoRenderer.ownerText.runs[0].navigationEndpoint.browseEndpoint.browseId || null,
name: data.videoRenderer.ownerText.runs[0].text || null, name: data.videoRenderer.ownerText.runs[0].text || null,
url: `https://www.youtube.com${data.videoRenderer.ownerText.runs[0].navigationEndpoint.browseEndpoint.canonicalBaseUrl || data.videoRenderer.ownerText.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url}`, url: `https://www.youtube.com${
data.videoRenderer.ownerText.runs[0].navigationEndpoint.browseEndpoint.canonicalBaseUrl ||
data.videoRenderer.ownerText.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url
}`,
icon: { icon: {
url: data.videoRenderer.channelThumbnailSupportedRenderers.channelThumbnailWithLinkRenderer.thumbnail.thumbnails[0].url, url: data.videoRenderer.channelThumbnailSupportedRenderers.channelThumbnailWithLinkRenderer.thumbnail
width: data.videoRenderer.channelThumbnailSupportedRenderers.channelThumbnailWithLinkRenderer.thumbnail.thumbnails[0].width, .thumbnails[0].url,
height: data.videoRenderer.channelThumbnailSupportedRenderers.channelThumbnailWithLinkRenderer.thumbnail.thumbnails[0].height width: data.videoRenderer.channelThumbnailSupportedRenderers.channelThumbnailWithLinkRenderer.thumbnail
.thumbnails[0].width,
height: data.videoRenderer.channelThumbnailSupportedRenderers.channelThumbnailWithLinkRenderer.thumbnail
.thumbnails[0].height
}, },
verified: Boolean(badge?.metadataBadgeRenderer?.style?.toLowerCase().includes("verified")) verified: Boolean(badge?.metadataBadgeRenderer?.style?.toLowerCase().includes('verified'))
}, },
uploadedAt: data.videoRenderer.publishedTimeText?.simpleText ?? null, uploadedAt: data.videoRenderer.publishedTimeText?.simpleText ?? null,
views: data.videoRenderer.viewCountText?.simpleText?.replace(/[^0-9]/g, "") ?? 0, views: data.videoRenderer.viewCountText?.simpleText?.replace(/[^0-9]/g, '') ?? 0,
live : data.videoRenderer.lengthText ? false : true, live: data.videoRenderer.lengthText ? false : true
}); });
return res; return res;
} }
export function parsePlaylist(data?: any): PlayList | void { export function parsePlaylist(data?: any): PlayList | void {
if (!data.playlistRenderer) return; if (!data.playlistRenderer) return;
@ -122,19 +140,25 @@ export function parsePlaylist(data?: any): PlayList | void {
title: data.playlistRenderer.title.simpleText, title: data.playlistRenderer.title.simpleText,
thumbnail: { thumbnail: {
id: data.playlistRenderer.playlistId, id: data.playlistRenderer.playlistId,
url: data.playlistRenderer.thumbnails[0].thumbnails[data.playlistRenderer.thumbnails[0].thumbnails.length - 1].url, url: data.playlistRenderer.thumbnails[0].thumbnails[
height: data.playlistRenderer.thumbnails[0].thumbnails[data.playlistRenderer.thumbnails[0].thumbnails.length - 1].height, data.playlistRenderer.thumbnails[0].thumbnails.length - 1
width: data.playlistRenderer.thumbnails[0].thumbnails[data.playlistRenderer.thumbnails[0].thumbnails.length - 1].width ].url,
height: data.playlistRenderer.thumbnails[0].thumbnails[
data.playlistRenderer.thumbnails[0].thumbnails.length - 1
].height,
width: data.playlistRenderer.thumbnails[0].thumbnails[
data.playlistRenderer.thumbnails[0].thumbnails.length - 1
].width
}, },
channel: { channel: {
id: data.playlistRenderer.shortBylineText.runs[0].navigationEndpoint.browseEndpoint.browseId, id: data.playlistRenderer.shortBylineText.runs[0].navigationEndpoint.browseEndpoint.browseId,
name: data.playlistRenderer.shortBylineText.runs[0].text, name: data.playlistRenderer.shortBylineText.runs[0].text,
url: `https://www.youtube.com${data.playlistRenderer.shortBylineText.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url}` url: `https://www.youtube.com${data.playlistRenderer.shortBylineText.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url}`
}, },
videos: parseInt(data.playlistRenderer.videoCount.replace(/[^0-9]/g, "")) videos: parseInt(data.playlistRenderer.videoCount.replace(/[^0-9]/g, ''))
}, },
true true
); );
return res; return res;
} }

85
play-dl/YouTube/utils/request.ts
View File

@ -1,56 +1,61 @@
import https, { RequestOptions } from 'https' import https, { RequestOptions } from 'https';
import { IncomingMessage } from 'http' import { IncomingMessage } from 'http';
import { URL } from 'url' import { URL } from 'url';
interface RequestOpts extends RequestOptions{ interface RequestOpts extends RequestOptions {
body? : string; body?: string;
method? : "GET" | "POST" method?: 'GET' | 'POST';
} }
function https_getter(req_url : string, options : RequestOpts = {}): Promise<IncomingMessage>{ function https_getter(req_url: string, options: RequestOpts = {}): Promise<IncomingMessage> {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
let s = new URL(req_url) const s = new URL(req_url);
options.method ??= "GET" options.method ??= 'GET';
let req_options : RequestOptions = { const req_options: RequestOptions = {
host : s.hostname, host: s.hostname,
path : s.pathname + s.search, path: s.pathname + s.search,
headers : options.headers ?? {}, headers: options.headers ?? {},
method : options.method method: options.method
} };
let req = https.request(req_options, resolve) const req = https.request(req_options, resolve);
req.on('error', (err) => { req.on('error', (err) => {
reject(err) reject(err);
}) });
if(options.method === "POST") req.write(options.body) if (options.method === 'POST') req.write(options.body);
req.end() req.end();
}) });
} }
export async function request(url : string, options? : RequestOpts): Promise<string>{ export async function request(url: string, options?: RequestOpts): Promise<string> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
let data = '' let data = '';
let res = await https_getter(url, options).catch((err: Error) => err) let res = await https_getter(url, options).catch((err: Error) => err);
if(res instanceof Error) {reject(res); return} if (res instanceof Error) {
if(Number(res.statusCode) >= 300 && Number(res.statusCode) < 400){ reject(res);
res = await https_getter(res.headers.location as string , options) return;
} }
else if(Number(res.statusCode) > 400){ if (Number(res.statusCode) >= 300 && Number(res.statusCode) < 400) {
reject(new Error(`Got ${res.statusCode} from the request`)) res = await https_getter(res.headers.location as string, options);
} else if (Number(res.statusCode) > 400) {
reject(new Error(`Got ${res.statusCode} from the request`));
} }
res.setEncoding('utf-8') res.setEncoding('utf-8');
res.on('data', (c) => data+=c) res.on('data', (c) => (data += c));
res.on('end', () => resolve(data)) res.on('end', () => resolve(data));
}) });
} }
export async function request_stream(url : string, options? : RequestOpts): Promise<IncomingMessage>{ export async function request_stream(url: string, options?: RequestOpts): Promise<IncomingMessage> {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
let res = await https_getter(url, options).catch((err: Error) => err) let res = await https_getter(url, options).catch((err: Error) => err);
if(res instanceof Error) {reject(res); return} if (res instanceof Error) {
if(Number(res.statusCode) >= 300 && Number(res.statusCode) < 400){ reject(res);
res = await https_getter(res.headers.location as string, options) return;
} }
resolve(res) if (Number(res.statusCode) >= 300 && Number(res.statusCode) < 400) {
}) res = await https_getter(res.headers.location as string, options);
}
resolve(res);
});
} }

120
play-dl/index.ts
View File

@ -1,22 +1,108 @@
export { playlist_info, video_basic_info, video_info, search, stream, stream_from_info, yt_validate, extractID } from "./YouTube"; import readline from 'readline';
export { spotify, sp_validate, Authorization, RefreshToken, is_expired } from './Spotify' export {
playlist_info,
video_basic_info,
video_info,
search,
stream,
stream_from_info,
yt_validate,
extractID
} from './YouTube';
import { sp_validate, yt_validate } from "."; export { spotify, sp_validate, refreshToken, is_expired } from './Spotify';
export function validate(url : string): string | boolean{ export { soundcloud } from './SoundCloud';
if(url.indexOf('spotify') !== -1){
let check = sp_validate(url) import { sp_validate, yt_validate } from '.';
if(check){ import { SpotifyAuthorize } from './Spotify';
return "sp_" + check import fs from 'fs';
} import { check_id } from './SoundCloud';
else return check
export function validate(url: string): string | boolean {
if (url.indexOf('spotify') !== -1) {
const check = sp_validate(url);
if (check) {
return 'sp_' + check;
} else return check;
} else {
const check = yt_validate(url);
if (check) {
return 'yt_' + check;
} else return check;
} }
else{ }
let check = yt_validate(url)
if(check){ export function authorization() {
return "yt_" + check const ask = readline.createInterface({
input: process.stdin,
output: process.stdout
});
ask.question('SoundCloud/ Spotify (so/sp) : ', (msg) => {
if (msg.toLowerCase().startsWith('sp')) {
let client_id: string, client_secret: string, redirect_url: string, market: string;
ask.question('Client ID : ', (id) => {
client_id = id;
ask.question('Client Secret : ', (secret) => {
client_secret = secret;
ask.question('Redirect URL : ', (url) => {
redirect_url = url;
console.log(
'\nMarket Selection URL : \nhttps://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements \n'
);
ask.question('Market : ', (mar) => {
if (mar.length === 2) market = mar;
else {
console.log('Invalid Market, Selecting IN as market');
market = 'IN';
}
console.log(
'\nNow Go to your browser and Paste this url. Authroize it and paste the redirected url here. \n'
);
console.log(
`https://accounts.spotify.com/authorize?client_id=${client_id}&response_type=code&redirect_uri=${encodeURI(
redirect_url
)} \n`
);
ask.question('Redirected URL : ', async (url) => {
if (!fs.existsSync('.data')) fs.mkdirSync('.data');
const spotifyData = {
client_id,
client_secret,
redirect_url,
authorization_code: url.split('code=')[1],
market
};
const check = await SpotifyAuthorize(spotifyData);
if (check === false) throw new Error('Failed to get access Token.');
ask.close();
});
});
});
});
});
} else if (msg.toLowerCase().startsWith('so')) {
let client_id: string;
ask.question('Client ID : ', async (id) => {
client_id = id;
if (!client_id) {
console.log("You didn't provided Client ID. Try again");
ask.close();
return;
}
if (!fs.existsSync('.data')) fs.mkdirSync('.data');
console.log('Checking Client ID...................');
if (await check_id(client_id)) {
console.log('Congratulations! Client ID is correct');
fs.writeFileSync('.data/soundcloud.data', JSON.stringify({ client_id }, undefined, 4));
} else console.log('Client ID is incorrect. Try to run this again with correct client ID.');
ask.close();
});
} else {
console.log('Invalid Option, Please Try again');
ask.close();
} }
else return check });
} }
}