├── .DS_Store
├── .gitignore
├── README.md
├── output
    ├── Authenticator.d.ts
    ├── Authenticator.js
    ├── IYoutube.d.ts
    ├── IYoutube.js
    ├── WrappedHTTPClient.d.ts
    ├── WrappedHTTPClient.js
    ├── adapters
    │   ├── NodeFSStorageAdapter.d.ts
    │   ├── NodeFSStorageAdapter.js
    │   ├── NodeFetchClientAdapter.d.ts
    │   └── NodeFetchClientAdapter.js
    ├── constants.d.ts
    ├── constants.js
    ├── fetchers
    │   ├── CommentContinuatedList.d.ts
    │   ├── CommentContinuatedList.js
    │   ├── CommentSectionContinuatedList.d.ts
    │   ├── CommentSectionContinuatedList.js
    │   ├── CommentThreadRepliesContinuatedList.d.ts
    │   ├── CommentThreadRepliesContinuatedList.js
    │   ├── ContinuatedList.d.ts
    │   ├── ContinuatedList.js
    │   ├── Explorer.d.ts
    │   ├── Explorer.js
    │   ├── PlaylistContinuatedList.d.ts
    │   ├── PlaylistContinuatedList.js
    │   ├── SearchContinuatedList.d.ts
    │   ├── SearchContinuatedList.js
    │   ├── SubscriptionFeedContinuatedList.d.ts
    │   ├── SubscriptionFeedContinuatedList.js
    │   ├── User.d.ts
    │   ├── User.js
    │   ├── helpers.d.ts
    │   └── helpers.js
    ├── formatsChipher.d.ts
    ├── formatsChipher.js
    ├── interfaces
    │   ├── Badge.d.ts
    │   ├── Badge.js
    │   ├── Badge.ts
    │   ├── CaptionTrack.d.ts
    │   ├── CaptionTrack.js
    │   ├── Channel.d.ts
    │   ├── Channel.js
    │   ├── ChannelBadge.d.ts
    │   ├── ChannelBadge.js
    │   ├── ChannelLink.d.ts
    │   ├── ChannelLink.js
    │   ├── Comment.d.ts
    │   ├── Comment.js
    │   ├── CommentThread.d.ts
    │   ├── CommentThread.js
    │   ├── Format.d.ts
    │   ├── Format.js
    │   ├── HTTPClient.d.ts
    │   ├── HTTPClient.js
    │   ├── List.d.ts
    │   ├── List.js
    │   ├── Playlist.d.ts
    │   ├── Playlist.js
    │   ├── SearchProposal.d.ts
    │   ├── SearchProposal.js
    │   ├── SponsorBlockSegment.d.ts
    │   ├── SponsorBlockSegment.js
    │   ├── StorageAdapter.d.ts
    │   ├── StorageAdapter.js
    │   ├── Thumbnail.d.ts
    │   ├── Thumbnail.js
    │   ├── Video.d.ts
    │   └── Video.js
    ├── main.d.ts
    ├── main.js
    ├── nodeDefault.d.ts
    ├── nodeDefault.js
    ├── nodeInst.d.ts
    └── nodeInst.js
├── package-lock.json
├── package.json
├── src
    ├── Authenticator.ts
    ├── IYoutube.ts
    ├── WrappedHTTPClient.ts
    ├── adapters
    │   ├── NodeFSStorageAdapter.ts
    │   └── NodeFetchClientAdapter.ts
    ├── constants.ts
    ├── fetchers
    │   ├── CommentSectionContinuatedList.ts
    │   ├── CommentThreadRepliesContinuatedList.ts
    │   ├── ContinuatedList.ts
    │   ├── Explorer.ts
    │   ├── PlaylistContinuatedList.ts
    │   ├── SearchContinuatedList.ts
    │   ├── SubscriptionFeedContinuatedList.ts
    │   ├── User.ts
    │   └── helpers.ts
    ├── formatsChipher.ts
    ├── interfaces
    │   ├── Badge.ts
    │   ├── CaptionTrack.ts
    │   ├── Channel.ts
    │   ├── ChannelBadge.ts
    │   ├── ChannelLink.ts
    │   ├── Comment.ts
    │   ├── CommentThread.ts
    │   ├── Format.ts
    │   ├── HTTPClient.ts
    │   ├── List.ts
    │   ├── Playlist.ts
    │   ├── SearchProposal.ts
    │   ├── SponsorBlockSegment.ts
    │   ├── StorageAdapter.ts
    │   ├── Thumbnail.ts
    │   └── Video.ts
    ├── main.ts
    └── nodeDefault.ts
├── test
    └── test.js
├── todo.md
└── tsconfig.json


/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ToBiDi0410/IYoutube/0cfb13dfd4fc8cce3e5501869cc1509319d994b0/.DS_Store


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | *tokens.json
3 | datastorage
4 | testIgnored.js


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <h1 align="center">IYoutube</h1>
 2 | 
 3 | <p align=center>
 4 |   <i>
 5 |     The ultimate dirty API Client for the internal YouTube API (Innertube API) with a big and growing coverage of actions and endpoints
 6 |   </i>
 7 | <p>
 8 | 
 9 | #### Features
10 | - Video information and statistics fetching
11 | - Playlist information and videos
12 | - Search functions (with type filters)
13 | - Like & subscriptions API coverage (videos, channels, playlists)
14 | - Comment API coverage (partial, only for videos)
15 | - Simple User Authentication using OAuth2 (allows Private Videos) <b>*1</b>
16 | - Built on one of the latest versions
17 | - Typescript types (for most things)
18 | - Support for a wide variety of plattforms, due to optional adapter support for HTTP fetching and storage access
19 | 
20 | <b>*1 This does not require an API Key. It uses extracted keys from the YouTube TV App.</b>
21 | 
22 | #### Usage
23 | 
24 | ###### Please look at the Basic [Example](./test/test.js)
25 | 
26 | #### To-Do
27 | I will do my best to keep up the work on this project, any pull requests or contributions in any way (e.g feature suggestions) are welcome.  
28 | 
29 | [Current Todo List](./todo.md)
30 | 
31 | <b>This API was originally designed for [IonicTube](https://github.com/ToBiDi0410/IonicTube) (an alternative YT App)</b>
32 | #### Credits
33 | - @pytube for the authentication method: https://github.com/pytube/pytube
34 | - @ytdl-org for the consent confirmation: https://github.com/ytdl-org/youtube-dl/
35 | - @Microsoft with Visual Studio Code for development: https://code.visualstudio.com/
36 | - @Google for their API and Chrome Dev Tools to analyse it :)
37 | - @TeamNewPipe for the signature code (from: https://github.com/TeamNewPipe/NewPipeExtractor)
38 | - @Anarios for the Return-YT-Dislike API (https://github.com/Anarios/return-youtube-dislike)
39 | - @Ajayyy for the Sponsorblock API (https://sponsor.ajay.app/)
40 | 
41 | #### Disclaimers
42 | - This project is not affiliated or linked to Google/YouTube in any way
43 | - This project does not contain any unofficial source code
44 | - This project is created for educational use only!
45 | - All mentioned brands and trademarks (e.g "Google" & "YouTube") are the property of their lawful owners
46 | 


--------------------------------------------------------------------------------
/output/Authenticator.d.ts:
--------------------------------------------------------------------------------
 1 | import { HTTPClient } from "./interfaces/HTTPClient";
 2 | import { StorageAdapter } from "./interfaces/StorageAdapter";
 3 | export declare class Authenticator {
 4 |     httpClient: HTTPClient;
 5 |     storageAdapter: StorageAdapter;
 6 |     token: any;
 7 |     constructor(httpclient: HTTPClient, storage: StorageAdapter);
 8 |     init(): Promise<void>;
 9 |     requiresLogin(): boolean;
10 |     getNewLoginCode(): Promise<{
11 |         userCode: any;
12 |         deviceCode: any;
13 |         userUrl: any;
14 |         expiresIn: any;
15 |         interval: number;
16 |     }>;
17 |     loadTokensWithDeviceCode(deviceCode: string): Promise<void>;
18 |     getToken(): Promise<any>;
19 |     getAuthorizationHeader(): Promise<string>;
20 | }
21 | 


--------------------------------------------------------------------------------
/output/Authenticator.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
  3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  4 |     return new (P || (P = Promise))(function (resolve, reject) {
  5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
  9 |     });
 10 | };
 11 | Object.defineProperty(exports, "__esModule", { value: true });
 12 | exports.Authenticator = void 0;
 13 | const constants_1 = require("./constants");
 14 | const HTTPClient_1 = require("./interfaces/HTTPClient");
 15 | const CLIENT_ID = "861556708454-d6dlm3lh05idd8npek18k6be8ba3oc68.apps.googleusercontent.com";
 16 | const CLIENT_SECRET = "SboVhoG9s0rNafixCSGGKXAT";
 17 | class Authenticator {
 18 |     constructor(httpclient, storage) {
 19 |         this.token = {
 20 |             access: "NULL",
 21 |             refresh: "NULL",
 22 |             type: "NULL",
 23 |             expireDate: new Date()
 24 |         };
 25 |         this.httpClient = httpclient;
 26 |         this.storageAdapter = storage;
 27 |     }
 28 |     init() {
 29 |         return __awaiter(this, void 0, void 0, function* () {
 30 |             if (constants_1.DEBUG)
 31 |                 console.log(constants_1.CONSOLE_COLORS.fg.cyan + "[AUTHENTICATOR] Initializing Authenticator...", constants_1.CONSOLE_COLORS.reset);
 32 |             if ((yield this.storageAdapter.exists(TOKEN_FILE))) {
 33 |                 if (constants_1.DEBUG)
 34 |                     console.log(constants_1.CONSOLE_COLORS.fg.magenta + "[AUTHENTICATOR] Found Token File in Storage, reading it...", constants_1.CONSOLE_COLORS.reset);
 35 |                 var str = yield this.storageAdapter.get(TOKEN_FILE);
 36 |                 if (str) {
 37 |                     this.token = JSON.parse(str);
 38 |                     if (constants_1.DEBUG)
 39 |                         console.log(constants_1.CONSOLE_COLORS.bright + constants_1.CONSOLE_COLORS.fg.green + "[AUTHENTICATOR] Now using Token from Storage (expires: " + new Date(this.token.expireDate).toLocaleString() + ")", constants_1.CONSOLE_COLORS.reset);
 40 |                 }
 41 |             }
 42 |         });
 43 |     }
 44 |     requiresLogin() {
 45 |         return Object.values(this.token).includes("NULL");
 46 |     }
 47 |     getNewLoginCode() {
 48 |         return __awaiter(this, void 0, void 0, function* () {
 49 |             const res = yield this.httpClient.request({
 50 |                 url: "https://oauth2.googleapis.com/device/code",
 51 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
 52 |                 data: JSON.stringify({
 53 |                     client_id: CLIENT_ID,
 54 |                     scope: "https://www.googleapis.com/auth/youtube"
 55 |                 }),
 56 |                 headers: {
 57 |                     "content-type": "text/plain;charset=UTF-8",
 58 |                     "user-agent": constants_1.DEFAULT_USER_AGENT
 59 |                 }
 60 |             });
 61 |             if (res.status != 200)
 62 |                 throw new Error("Failed to get new Google Login Code");
 63 |             const resJSON = JSON.parse(res.data);
 64 |             if (constants_1.DEBUG)
 65 |                 console.log(constants_1.CONSOLE_COLORS.bright + constants_1.CONSOLE_COLORS.fg.yellow + "[AUTHENTICATOR] Started Authentication Method: Device Code", constants_1.CONSOLE_COLORS.reset);
 66 |             return { userCode: resJSON.user_code, deviceCode: resJSON.device_code, userUrl: resJSON.verification_url, expiresIn: resJSON.expires_in, interval: 5 };
 67 |         });
 68 |     }
 69 |     loadTokensWithDeviceCode(deviceCode) {
 70 |         return __awaiter(this, void 0, void 0, function* () {
 71 |             var res;
 72 |             while (!res || !res.refresh_token) {
 73 |                 try {
 74 |                     res = yield this.httpClient.request({
 75 |                         method: HTTPClient_1.HTTPRequestMethod.POST,
 76 |                         url: "https://oauth2.googleapis.com/token",
 77 |                         data: JSON.stringify({
 78 |                             client_id: CLIENT_ID,
 79 |                             client_secret: CLIENT_SECRET,
 80 |                             device_code: deviceCode,
 81 |                             grant_type: "urn:ietf:params:oauth:grant-type:device_code"
 82 |                         }),
 83 |                         headers: {
 84 |                             "content-type": "text/plain;charset=UTF-8",
 85 |                             "user-agent": constants_1.DEFAULT_USER_AGENT
 86 |                         }
 87 |                     });
 88 |                     res = JSON.parse(res.data);
 89 |                     yield new Promise(resolve => setTimeout(resolve, 5000));
 90 |                 }
 91 |                 catch (err) {
 92 |                     if (constants_1.DEBUG)
 93 |                         console.log("[AUTHENTICATOR] Failed to recieve Token with Code:\n", err);
 94 |                 }
 95 |             }
 96 |             this.token = { type: null, access: null, refresh: res.refresh_token, expireDate: null };
 97 |             if (constants_1.DEBUG)
 98 |                 console.log(constants_1.CONSOLE_COLORS.bright + constants_1.CONSOLE_COLORS.fg.yellow + "[AUTHENTICATOR] Authentication Method successfull: Device Code", constants_1.CONSOLE_COLORS.reset);
 99 |             yield this.getToken();
100 |         });
101 |     }
102 |     getToken() {
103 |         return __awaiter(this, void 0, void 0, function* () {
104 |             if (this.token.access == null || (Date.now() - this.token.expireDate) > 0) {
105 |                 let res = yield this.httpClient.request({
106 |                     method: HTTPClient_1.HTTPRequestMethod.POST,
107 |                     url: "https://oauth2.googleapis.com/token",
108 |                     data: JSON.stringify({
109 |                         client_id: CLIENT_ID,
110 |                         client_secret: CLIENT_SECRET,
111 |                         grant_type: "refresh_token",
112 |                         refresh_token: this.token.refresh
113 |                     }),
114 |                     headers: {
115 |                         "content-type": "text/plain;charset=UTF-8",
116 |                         "user-agent": constants_1.DEFAULT_USER_AGENT
117 |                     }
118 |                 });
119 |                 res = JSON.parse(res.data);
120 |                 this.token = { type: res.token_type, access: res.access_token, refresh: this.token.refresh, expireDate: (new Date().getTime() + 1000 * res.expires_in) };
121 |                 if (constants_1.DEBUG)
122 |                     console.log(constants_1.CONSOLE_COLORS.bright + constants_1.CONSOLE_COLORS.fg.green + "[AUTHENTICATOR] Refreshed the Access Token using the refresh Token", constants_1.CONSOLE_COLORS.reset);
123 |                 yield this.storageAdapter.set(TOKEN_FILE, JSON.stringify(Object.assign({}, this.token)));
124 |                 if (constants_1.DEBUG)
125 |                     console.log(constants_1.CONSOLE_COLORS.bright + constants_1.CONSOLE_COLORS.fg.yellow + "[AUTHENTICATOR] Current Token written to Storage", constants_1.CONSOLE_COLORS.reset);
126 |             }
127 |             return this.token;
128 |         });
129 |     }
130 |     getAuthorizationHeader() {
131 |         return __awaiter(this, void 0, void 0, function* () {
132 |             var currentToken = yield this.getToken();
133 |             return currentToken.type + " " + currentToken.access;
134 |         });
135 |     }
136 | }
137 | exports.Authenticator = Authenticator;
138 | const TOKEN_FILE = "IYoutubeTokens.json";
139 | 


--------------------------------------------------------------------------------
/output/IYoutube.d.ts:
--------------------------------------------------------------------------------
 1 | import { Authenticator } from "./Authenticator";
 2 | import { HTTPClient } from "./interfaces/HTTPClient";
 3 | import { StorageAdapter } from "./interfaces/StorageAdapter";
 4 | import { WrappedHTTPClient } from "./WrappedHTTPClient";
 5 | import { SearchType } from "./fetchers/SearchContinuatedList";
 6 | import { Explorer } from "./fetchers/Explorer";
 7 | import { ContinuatedList } from "./fetchers/ContinuatedList";
 8 | import { User } from "./fetchers/User";
 9 | import { Playlist } from "./interfaces/Playlist";
10 | import { Channel, SearchProposal, Video } from "./main";
11 | export default class IYoutube {
12 |     rawHttpClient: HTTPClient;
13 |     wrappedHttpClient: WrappedHTTPClient;
14 |     storageAdapter: StorageAdapter;
15 |     authenticator: Authenticator;
16 |     explorer: Explorer;
17 |     user: User;
18 |     constructor(httpClient: HTTPClient, storageAdapater: StorageAdapter);
19 |     init(): Promise<void>;
20 |     search(term: string, type: SearchType): Promise<ContinuatedList>;
21 |     searchProposals(term: string): Promise<Array<SearchProposal>>;
22 |     getPlaylist(playlistId: string): Promise<Playlist>;
23 |     getChannel(channelId: string): Promise<Channel>;
24 |     getVideo(videoId: string): Promise<Video>;
25 |     getWhatToWatch(): ContinuatedList;
26 |     getExplorer(): Explorer;
27 |     getUser(): User;
28 |     getCookies(): string;
29 |     throwErrorIfNotReady(): void;
30 | }
31 | 


--------------------------------------------------------------------------------
/output/IYoutube.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
  3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  4 |     return new (P || (P = Promise))(function (resolve, reject) {
  5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
  9 |     });
 10 | };
 11 | Object.defineProperty(exports, "__esModule", { value: true });
 12 | const Authenticator_1 = require("./Authenticator");
 13 | const HTTPClient_1 = require("./interfaces/HTTPClient");
 14 | const WrappedHTTPClient_1 = require("./WrappedHTTPClient");
 15 | const SearchContinuatedList_1 = require("./fetchers/SearchContinuatedList");
 16 | const Explorer_1 = require("./fetchers/Explorer");
 17 | const ContinuatedList_1 = require("./fetchers/ContinuatedList");
 18 | const User_1 = require("./fetchers/User");
 19 | const Playlist_1 = require("./interfaces/Playlist");
 20 | const constants_1 = require("./constants");
 21 | const main_1 = require("./main");
 22 | const helpers_1 = require("./fetchers/helpers");
 23 | class IYoutube {
 24 |     constructor(httpClient, storageAdapater) {
 25 |         this.rawHttpClient = httpClient;
 26 |         this.wrappedHttpClient = new WrappedHTTPClient_1.WrappedHTTPClient(this.rawHttpClient);
 27 |         this.storageAdapter = storageAdapater;
 28 |         this.authenticator = new Authenticator_1.Authenticator(this.rawHttpClient, this.storageAdapter);
 29 |         this.wrappedHttpClient.authorizationHeaderCallback = () => { return this.authenticator.getAuthorizationHeader(); };
 30 |         this.explorer = new Explorer_1.Explorer(this.wrappedHttpClient, this);
 31 |         this.user = new User_1.User(this.wrappedHttpClient, this);
 32 |     }
 33 |     init() {
 34 |         return __awaiter(this, void 0, void 0, function* () {
 35 |             if (constants_1.DEBUG)
 36 |                 console.log("");
 37 |             yield this.authenticator.init();
 38 |         });
 39 |     }
 40 |     search(term, type) {
 41 |         return __awaiter(this, void 0, void 0, function* () {
 42 |             this.throwErrorIfNotReady();
 43 |             var list = new SearchContinuatedList_1.SearchConitinuatedList(term, type, this.wrappedHttpClient);
 44 |             return list;
 45 |         });
 46 |     }
 47 |     searchProposals(term) {
 48 |         return __awaiter(this, void 0, void 0, function* () {
 49 |             this.throwErrorIfNotReady();
 50 |             const url = new URL(constants_1.ENDPOINT_SEARCH_SUGGEST);
 51 |             url.searchParams.set("client", "youtube");
 52 |             url.searchParams.set("gs_ri", "youtube");
 53 |             url.searchParams.set("ds", "yt");
 54 |             url.searchParams.set("q", term);
 55 |             const result = yield this.rawHttpClient.request({
 56 |                 url: url.toString(),
 57 |                 method: HTTPClient_1.HTTPRequestMethod.GET,
 58 |             });
 59 |             const resultJSONText = result.data.split("(")[1].split(")")[0];
 60 |             const resultsJSON = yield JSON.parse(resultJSONText)[1];
 61 |             const finalResults = resultsJSON.map((a) => ({ text: a[0] }));
 62 |             return finalResults;
 63 |         });
 64 |     }
 65 |     getPlaylist(playlistId) {
 66 |         return __awaiter(this, void 0, void 0, function* () {
 67 |             this.throwErrorIfNotReady();
 68 |             var pl = new Playlist_1.Playlist(this.wrappedHttpClient);
 69 |             pl.playlistId = playlistId;
 70 |             yield pl.loadAll();
 71 |             return pl;
 72 |         });
 73 |     }
 74 |     getChannel(channelId) {
 75 |         return __awaiter(this, void 0, void 0, function* () {
 76 |             this.throwErrorIfNotReady();
 77 |             var ch = new main_1.Channel(this.wrappedHttpClient);
 78 |             ch.channelId = channelId;
 79 |             yield ch.loadAll();
 80 |             return ch;
 81 |         });
 82 |     }
 83 |     getVideo(videoId) {
 84 |         return __awaiter(this, void 0, void 0, function* () {
 85 |             this.throwErrorIfNotReady();
 86 |             var v = new main_1.Video(this.wrappedHttpClient);
 87 |             v.videoId = videoId;
 88 |             yield v.loadAll();
 89 |             return v;
 90 |         });
 91 |     }
 92 |     getWhatToWatch() {
 93 |         return new ContinuatedList_1.ContinuatedList({
 94 |             url: constants_1.ENDPOINT_BROWSE,
 95 |             method: HTTPClient_1.HTTPRequestMethod.POST,
 96 |             data: {
 97 |                 browseId: "FEwhat_to_watch"
 98 |             }
 99 |         }, (data) => {
100 |             const renderers = helpers_1.default.recursiveSearchForKey("richItemRenderer", data);
101 |             let contents = helpers_1.default.recursiveSearchForKey("content", renderers);
102 |             contents = contents.flat(1);
103 |             return contents;
104 |         }, this.wrappedHttpClient, true);
105 |     }
106 |     getExplorer() {
107 |         return this.explorer;
108 |     }
109 |     getUser() {
110 |         return this.user;
111 |     }
112 |     getCookies() {
113 |         return this.wrappedHttpClient.cookieString;
114 |     }
115 |     throwErrorIfNotReady() {
116 |         if (!this.storageAdapter)
117 |             throw new Error("The provided Storage Adapter was invalid");
118 |         if (!this.rawHttpClient)
119 |             throw new Error("The provided HTTP Client was invalid");
120 |         if (this.authenticator.requiresLogin())
121 |             throw new Error("This Instance of IYoutube is not authenticated");
122 |     }
123 | }
124 | exports.default = IYoutube;
125 | 


--------------------------------------------------------------------------------
/output/WrappedHTTPClient.d.ts:
--------------------------------------------------------------------------------
 1 | import { HTTPClient, HTTPMap, HTTPRequestOptions } from "./interfaces/HTTPClient";
 2 | export declare class WrappedHTTPClient {
 3 |     client: HTTPClient;
 4 |     headers: HTTPMap;
 5 |     authorizationHeaderCallback?: Function;
 6 |     cookieString: string;
 7 |     constructor(client: HTTPClient);
 8 |     request(options: HTTPRequestOptions): Promise<import("./interfaces/HTTPClient").HTTPResponse>;
 9 | }
10 | 


--------------------------------------------------------------------------------
/output/WrappedHTTPClient.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.WrappedHTTPClient = void 0;
13 | const constants_1 = require("./constants");
14 | class WrappedHTTPClient {
15 |     constructor(client) {
16 |         this.cookieString = "";
17 |         this.client = client;
18 |         this.headers = new Object();
19 |     }
20 |     request(options) {
21 |         return __awaiter(this, void 0, void 0, function* () {
22 |             if (!options.params)
23 |                 options.params = new Object();
24 |             if (!options.headers)
25 |                 options.headers = new Object();
26 |             options.headers["x-youtube-client-version"] = constants_1.DEFAULT_CLIENT_VERSION;
27 |             options.headers["x-youtube-client-name"] = constants_1.DEFAULT_CLIENT_NAME;
28 |             options.headers["user-agent"] = constants_1.DEFAULT_USER_AGENT;
29 |             options.headers["cookie"] = this.cookieString;
30 |             options.headers = Object.assign(Object.assign({}, options.headers), this.headers);
31 |             if (this.authorizationHeaderCallback)
32 |                 options.headers["Authorization"] = yield this.authorizationHeaderCallback();
33 |             else
34 |                 options.params["key"] = constants_1.DEFAULT_API_KEY;
35 |             const finalURL = new URL(options.url);
36 |             if (options.params)
37 |                 for (const [key, value] of Object.entries(options.params))
38 |                     finalURL.searchParams.set(key, value.toString());
39 |             options.url = finalURL.toString();
40 |             if (typeof options.data == 'object')
41 |                 options.data.context = Object.assign(Object.assign({}, constants_1.DEFAULT_CONTEXT), options.data.context);
42 |             if (typeof options.data != 'string') {
43 |                 options.data = JSON.stringify(options.data);
44 |                 options.headers["Content-Type"] = "application/json";
45 |             }
46 |             if (constants_1.DEBUG)
47 |                 console.log(constants_1.CONSOLE_COLORS.fg.cyan + "[WHTTPCLIENT] Requesting Data from Endpoint: " + options.url.toString(), constants_1.CONSOLE_COLORS.reset);
48 |             var res = yield this.client.request(options);
49 |             if (constants_1.DEBUG)
50 |                 console.log(constants_1.CONSOLE_COLORS.fg.cyan + "[WHTTPCLIENT] Got respone with Code: " + res.status, constants_1.CONSOLE_COLORS.reset);
51 |             if (res.headers["set-cookie"]) {
52 |                 var newCookies = parseCookies(res.headers["set-cookie"]);
53 |                 if (constants_1.DEBUG)
54 |                     console.log(constants_1.CONSOLE_COLORS.fg.magenta + "[WHTTPCLIENT] Recieved new Cookies: " + Object.keys(newCookies).join(", "), constants_1.CONSOLE_COLORS.reset);
55 |                 if (newCookies["CONSENT"]) {
56 |                     newCookies["CONSENT"] = "YES+cb.20210328-17-p0.en+FX+" + newCookies["CONSENT"].split("+")[1];
57 |                     if (constants_1.DEBUG)
58 |                         console.log(constants_1.CONSOLE_COLORS.bright + constants_1.CONSOLE_COLORS.fg.green + "[WHTTPCLIENT] Accepted Consent and modified Cookie: " + newCookies["CONSENT"], constants_1.CONSOLE_COLORS.reset);
59 |                 }
60 |                 this.cookieString = joinCookies(newCookies, this.cookieString);
61 |             }
62 |             if (res.data.includes("STATE_TAG_BROWSE_INSTRUCTION_MARK_AS_DIRTY"))
63 |                 if (constants_1.DEBUG)
64 |                     console.warn(constants_1.CONSOLE_COLORS.fg.yellow + "[WHTTPCLIENT] Youtube detected this as a dirty client!", constants_1.CONSOLE_COLORS.reset);
65 |             return res;
66 |         });
67 |     }
68 | }
69 | exports.WrappedHTTPClient = WrappedHTTPClient;
70 | var ignoreCookieData = ["expires", "path", "domain", "priority"];
71 | function parseCookies(str) {
72 |     const pairs = str.split(";");
73 |     let pairArrays = pairs.map(v => v.split("="));
74 |     pairArrays.forEach((obj) => obj[0] = obj[0].replaceAll(" ", ""));
75 |     pairArrays = pairArrays.filter((obj) => { return obj[0].length > 0 && !ignoreCookieData.includes(obj[0]); });
76 |     const pairsObject = new Object();
77 |     for (const pairArray of pairArrays) {
78 |         pairsObject[pairArray[0]] = pairArray[1];
79 |     }
80 |     return pairsObject;
81 | }
82 | function serializeCookies(obj) {
83 |     let cookieString = "";
84 |     for (const [key, value] of Object.entries(obj)) {
85 |         if (key != null && key.length > 0) {
86 |             const partString = (key + "=" + (value ? value : '') + "; ");
87 |             cookieString += partString;
88 |         }
89 |     }
90 |     cookieString = cookieString.trimEnd();
91 |     return cookieString;
92 | }
93 | function joinCookies(str1, str2) {
94 |     const resObj = Object.assign(Object.assign({}, (typeof str1 == 'string' ? parseCookies(str1) : str1)), (typeof str2 == 'string' ? parseCookies(str2) : str2));
95 |     const resString = serializeCookies(resObj);
96 |     return resString;
97 | }
98 | 


--------------------------------------------------------------------------------
/output/adapters/NodeFSStorageAdapter.d.ts:
--------------------------------------------------------------------------------
1 | import { StorageAdapter } from "../interfaces/StorageAdapter";
2 | export declare class NodeFSStorageAdapater implements StorageAdapter {
3 |     basePath: string;
4 |     constructor(basePath: string);
5 |     set(paths: string, value: string): Promise<boolean>;
6 |     get(paths: string): Promise<string>;
7 |     exists(paths: string): Promise<boolean>;
8 | }
9 | 


--------------------------------------------------------------------------------
/output/adapters/NodeFSStorageAdapter.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.NodeFSStorageAdapater = void 0;
13 | const fs = require("fs");
14 | const path = require("path");
15 | class NodeFSStorageAdapater {
16 |     constructor(basePath) {
17 |         this.basePath = basePath;
18 |         fs.mkdirSync(basePath, { recursive: true });
19 |     }
20 |     set(paths, value) {
21 |         return __awaiter(this, void 0, void 0, function* () {
22 |             try {
23 |                 fs.writeFileSync(path.join(this.basePath, paths), value, { encoding: 'utf-8' });
24 |                 return true;
25 |             }
26 |             catch (err) {
27 |                 return false;
28 |             }
29 |         });
30 |     }
31 |     get(paths) {
32 |         return __awaiter(this, void 0, void 0, function* () {
33 |             return fs.readFileSync(path.join(this.basePath, paths), { encoding: 'utf-8' }).toString();
34 |         });
35 |     }
36 |     exists(paths) {
37 |         return __awaiter(this, void 0, void 0, function* () {
38 |             return fs.existsSync(path.join(this.basePath, paths));
39 |         });
40 |     }
41 | }
42 | exports.NodeFSStorageAdapater = NodeFSStorageAdapater;
43 | 


--------------------------------------------------------------------------------
/output/adapters/NodeFetchClientAdapter.d.ts:
--------------------------------------------------------------------------------
1 | import { HTTPClient, HTTPRequestOptions } from "../interfaces/HTTPClient";
2 | export declare class NodeFetchClientAdapter implements HTTPClient {
3 |     request(options: HTTPRequestOptions): Promise<{
4 |         status: any;
5 |         data: any;
6 |         headers: any;
7 |     }>;
8 | }
9 | 


--------------------------------------------------------------------------------
/output/adapters/NodeFetchClientAdapter.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.NodeFetchClientAdapter = void 0;
13 | const fetch = require("node-fetch");
14 | class NodeFetchClientAdapter {
15 |     request(options) {
16 |         return __awaiter(this, void 0, void 0, function* () {
17 |             var res = yield fetch(options.url, {
18 |                 headers: options.headers,
19 |                 method: options.method,
20 |                 body: options.data,
21 |             });
22 |             const refactoredHeaders = new Object();
23 |             for (var pair of res.headers.entries()) {
24 |                 refactoredHeaders[pair[0]] = pair[1];
25 |             }
26 |             return {
27 |                 status: res.status,
28 |                 data: yield res.text(),
29 |                 headers: refactoredHeaders
30 |             };
31 |         });
32 |     }
33 | }
34 | exports.NodeFetchClientAdapter = NodeFetchClientAdapter;
35 | 


--------------------------------------------------------------------------------
/output/constants.d.ts:
--------------------------------------------------------------------------------
 1 | export declare const DEBUG = false;
 2 | export declare const DEFAULT_API_KEY = "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8";
 3 | export declare const DEFAULT_CLIENT_VERSION = "2.20220406.09.00";
 4 | export declare const DEFAULT_CLIENT_NAME = "1";
 5 | export declare const DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.75 Safari/537.36";
 6 | export declare const DEFAULT_CONTEXT: {
 7 |     client: {
 8 |         clientName: string;
 9 |         clientVersion: string;
10 |         hl: string;
11 |         gl: string;
12 |         userAgent: string;
13 |         utcOffsetMinutes: string;
14 |     };
15 |     request: {
16 |         useSsl: string;
17 |         internalExperimentFlags: never[];
18 |         consistencyTokenJars: never[];
19 |     };
20 | };
21 | export declare const CONSOLE_COLORS: {
22 |     reset: string;
23 |     bright: string;
24 |     dim: string;
25 |     underscore: string;
26 |     blink: string;
27 |     reverse: string;
28 |     hidden: string;
29 |     fg: {
30 |         black: string;
31 |         red: string;
32 |         green: string;
33 |         yellow: string;
34 |         blue: string;
35 |         magenta: string;
36 |         cyan: string;
37 |         white: string;
38 |         crimson: string;
39 |     };
40 |     bg: {
41 |         black: string;
42 |         red: string;
43 |         green: string;
44 |         yellow: string;
45 |         blue: string;
46 |         magenta: string;
47 |         cyan: string;
48 |         white: string;
49 |         crimson: string;
50 |     };
51 | };
52 | export declare const ENDPOINT_BROWSE = "https://www.youtube.com/youtubei/v1/browse";
53 | export declare const ENDPOINT_SEARCH = "https://www.youtube.com/youtubei/v1/search";
54 | export declare const ENDPOINT_LIKE = "https://www.youtube.com/youtubei/v1/like/like";
55 | export declare const ENDPOINT_DISLIKE = "https://www.youtube.com/youtubei/v1/like/dislike";
56 | export declare const ENDPOINT_REMOVELIKE = "https://www.youtube.com/youtubei/v1/like/removelike";
57 | export declare const ENDPOINT_SUBSCRIBE = "https://www.youtube.com/youtubei/v1/subscription/subscribe";
58 | export declare const ENDPOINT_UNSUBSCRIBE = "https://www.youtube.com/youtubei/v1/subscription/unsubscribe";
59 | export declare const ENDPOINT_ADDTOPLAYLIST = "https://www.youtube.com/youtubei/v1/playlist/get_add_to_playlist";
60 | export declare const ENDPOINT_NEXT = "https://www.youtube.com/youtubei/v1/next";
61 | export declare const ENDPOINT_COMMENT_ACTION = "https://www.youtube.com/youtubei/v1/comment/perform_comment_action";
62 | export declare const ENDPOINT_PLAYER = "https://www.youtube.com/youtubei/v1/player";
63 | export declare const ENDPOINT_COMMENT_CREATE = "https://www.youtube.com/youtubei/v1/comment/create_comment";
64 | export declare const ENDPOINT_SEARCH_SUGGEST = "https://clients1.google.com/complete/search";
65 | export declare const ENDPOINT_WATCHPAGE = "https://www.youtube.com/watch";
66 | export declare const ENDPOINT_RATING = "https://returnyoutubedislikeapi.com/Votes";
67 | export declare const ENDPOINT_SPONSORBLOCK_SKIPSEGMENTS = "https://sponsor.ajay.app/api/skipSegments";
68 | export declare const ERROR_DATA_INVALID_FORMAT: Error;
69 | 


--------------------------------------------------------------------------------
/output/constants.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | exports.ERROR_DATA_INVALID_FORMAT = exports.ENDPOINT_SPONSORBLOCK_SKIPSEGMENTS = exports.ENDPOINT_RATING = exports.ENDPOINT_WATCHPAGE = exports.ENDPOINT_SEARCH_SUGGEST = exports.ENDPOINT_COMMENT_CREATE = exports.ENDPOINT_PLAYER = exports.ENDPOINT_COMMENT_ACTION = exports.ENDPOINT_NEXT = exports.ENDPOINT_ADDTOPLAYLIST = exports.ENDPOINT_UNSUBSCRIBE = exports.ENDPOINT_SUBSCRIBE = exports.ENDPOINT_REMOVELIKE = exports.ENDPOINT_DISLIKE = exports.ENDPOINT_LIKE = exports.ENDPOINT_SEARCH = exports.ENDPOINT_BROWSE = exports.CONSOLE_COLORS = exports.DEFAULT_CONTEXT = exports.DEFAULT_USER_AGENT = exports.DEFAULT_CLIENT_NAME = exports.DEFAULT_CLIENT_VERSION = exports.DEFAULT_API_KEY = exports.DEBUG = void 0;
 4 | exports.DEBUG = false;
 5 | exports.DEFAULT_API_KEY = "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8";
 6 | exports.DEFAULT_CLIENT_VERSION = "2.20220406.09.00";
 7 | exports.DEFAULT_CLIENT_NAME = "1";
 8 | exports.DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.75 Safari/537.36";
 9 | exports.DEFAULT_CONTEXT = {
10 |     client: {
11 |         clientName: "WEB",
12 |         clientVersion: exports.DEFAULT_CLIENT_VERSION,
13 |         hl: "en",
14 |         gl: "DE",
15 |         userAgent: exports.DEFAULT_USER_AGENT,
16 |         utcOffsetMinutes: "0"
17 |     },
18 |     request: {
19 |         useSsl: "true",
20 |         internalExperimentFlags: [],
21 |         consistencyTokenJars: [],
22 |     }
23 | };
24 | exports.CONSOLE_COLORS = {
25 |     reset: "\x1b[0m",
26 |     bright: "\x1b[1m",
27 |     dim: "\x1b[2m",
28 |     underscore: "\x1b[4m",
29 |     blink: "\x1b[5m",
30 |     reverse: "\x1b[7m",
31 |     hidden: "\x1b[8m",
32 |     fg: {
33 |         black: "\x1b[30m",
34 |         red: "\x1b[31m",
35 |         green: "\x1b[32m",
36 |         yellow: "\x1b[33m",
37 |         blue: "\x1b[34m",
38 |         magenta: "\x1b[35m",
39 |         cyan: "\x1b[36m",
40 |         white: "\x1b[37m",
41 |         crimson: "\x1b[38m"
42 |     },
43 |     bg: {
44 |         black: "\x1b[40m",
45 |         red: "\x1b[41m",
46 |         green: "\x1b[42m",
47 |         yellow: "\x1b[43m",
48 |         blue: "\x1b[44m",
49 |         magenta: "\x1b[45m",
50 |         cyan: "\x1b[46m",
51 |         white: "\x1b[47m",
52 |         crimson: "\x1b[48m"
53 |     }
54 | };
55 | exports.ENDPOINT_BROWSE = "https://www.youtube.com/youtubei/v1/browse";
56 | exports.ENDPOINT_SEARCH = "https://www.youtube.com/youtubei/v1/search";
57 | exports.ENDPOINT_LIKE = "https://www.youtube.com/youtubei/v1/like/like";
58 | exports.ENDPOINT_DISLIKE = "https://www.youtube.com/youtubei/v1/like/dislike";
59 | exports.ENDPOINT_REMOVELIKE = "https://www.youtube.com/youtubei/v1/like/removelike";
60 | exports.ENDPOINT_SUBSCRIBE = "https://www.youtube.com/youtubei/v1/subscription/subscribe";
61 | exports.ENDPOINT_UNSUBSCRIBE = "https://www.youtube.com/youtubei/v1/subscription/unsubscribe";
62 | exports.ENDPOINT_ADDTOPLAYLIST = "https://www.youtube.com/youtubei/v1/playlist/get_add_to_playlist";
63 | exports.ENDPOINT_NEXT = "https://www.youtube.com/youtubei/v1/next";
64 | exports.ENDPOINT_COMMENT_ACTION = "https://www.youtube.com/youtubei/v1/comment/perform_comment_action";
65 | exports.ENDPOINT_PLAYER = "https://www.youtube.com/youtubei/v1/player";
66 | exports.ENDPOINT_COMMENT_CREATE = "https://www.youtube.com/youtubei/v1/comment/create_comment";
67 | exports.ENDPOINT_SEARCH_SUGGEST = "https://clients1.google.com/complete/search";
68 | exports.ENDPOINT_WATCHPAGE = "https://www.youtube.com/watch";
69 | exports.ENDPOINT_RATING = "https://returnyoutubedislikeapi.com/Votes";
70 | exports.ENDPOINT_SPONSORBLOCK_SKIPSEGMENTS = "https://sponsor.ajay.app/api/skipSegments";
71 | exports.ERROR_DATA_INVALID_FORMAT = new Error("The Data recieved from the Google API seems to have an invalid format. It might be that Google updated their APIs and this Method no longer Works");
72 | 


--------------------------------------------------------------------------------
/output/fetchers/CommentContinuatedList.d.ts:
--------------------------------------------------------------------------------
1 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
2 | import { ContinuatedList } from "./ContinuatedList";
3 | export declare class CommentContinuatedList extends ContinuatedList {
4 |     constructor(videoId: string, httpclient: WrappedHTTPClient);
5 | }
6 | 


--------------------------------------------------------------------------------
/output/fetchers/CommentContinuatedList.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.CommentContinuatedList = void 0;
13 | const constants_1 = require("../constants");
14 | const HTTPClient_1 = require("../interfaces/HTTPClient");
15 | const ContinuatedList_1 = require("./ContinuatedList");
16 | const helpers_1 = require("./helpers");
17 | class CommentContinuatedList extends ContinuatedList_1.ContinuatedList {
18 |     constructor(videoId, httpclient) {
19 |         super({
20 |             url: constants_1.ENDPOINT_NEXT,
21 |             method: HTTPClient_1.HTTPRequestMethod.POST,
22 |             data: {
23 |                 autonavState: "STATE_ON",
24 |                 captionsRequested: true,
25 |                 contentCheckOK: false,
26 |                 params: "OALAAQHCAwtPUEhMX09MVzNkUQ%3D%3D",
27 |                 racyCheckOk: false,
28 |                 videoId: videoId,
29 |             }
30 |         }, function (resJSON) {
31 |             return __awaiter(this, void 0, void 0, function* () {
32 |                 const itemSectionRenderers = helpers_1.default.recursiveSearchForKey("itemSectionRenderer", resJSON);
33 |                 const commentSectionRenderer = itemSectionRenderers.find((a) => a.targetId == 'comments-section');
34 |                 if (commentSectionRenderer)
35 |                     return [];
36 |                 const continuationItems = helpers_1.default.recursiveSearchForKey("continuationItems", resJSON)[1];
37 |                 return continuationItems;
38 |             });
39 |         }, httpclient, false);
40 |     }
41 | }
42 | exports.CommentContinuatedList = CommentContinuatedList;
43 | 


--------------------------------------------------------------------------------
/output/fetchers/CommentSectionContinuatedList.d.ts:
--------------------------------------------------------------------------------
1 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
2 | import { ContinuatedList } from "./ContinuatedList";
3 | export declare class CommentSectionContinuatedList extends ContinuatedList {
4 |     constructor(initialContinuationToken: string, httpclient: WrappedHTTPClient);
5 | }
6 | 


--------------------------------------------------------------------------------
/output/fetchers/CommentSectionContinuatedList.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.CommentSectionContinuatedList = void 0;
13 | const constants_1 = require("../constants");
14 | const HTTPClient_1 = require("../interfaces/HTTPClient");
15 | const ContinuatedList_1 = require("./ContinuatedList");
16 | const helpers_1 = require("./helpers");
17 | class CommentSectionContinuatedList extends ContinuatedList_1.ContinuatedList {
18 |     constructor(initialContinuationToken, httpclient) {
19 |         super({
20 |             url: constants_1.ENDPOINT_NEXT,
21 |             method: HTTPClient_1.HTTPRequestMethod.POST,
22 |         }, function (resJSON) {
23 |             return __awaiter(this, void 0, void 0, function* () {
24 |                 const continuationItems = helpers_1.default.recursiveSearchForKey("continuationItems", resJSON)[1];
25 |                 return continuationItems;
26 |             });
27 |         }, httpclient, false);
28 |         this.continuationToken = initialContinuationToken;
29 |     }
30 | }
31 | exports.CommentSectionContinuatedList = CommentSectionContinuatedList;
32 | 


--------------------------------------------------------------------------------
/output/fetchers/CommentThreadRepliesContinuatedList.d.ts:
--------------------------------------------------------------------------------
1 | import { ContinuatedList, WrappedHTTPClient } from "../main";
2 | export declare class CommentThreadRepliesContinuatedList extends ContinuatedList {
3 |     constructor(initialContinuationToken: string, httpclient: WrappedHTTPClient);
4 | }
5 | 


--------------------------------------------------------------------------------
/output/fetchers/CommentThreadRepliesContinuatedList.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.CommentThreadRepliesContinuatedList = void 0;
13 | const constants_1 = require("../constants");
14 | const HTTPClient_1 = require("../interfaces/HTTPClient");
15 | const main_1 = require("../main");
16 | const helpers_1 = require("./helpers");
17 | class CommentThreadRepliesContinuatedList extends main_1.ContinuatedList {
18 |     constructor(initialContinuationToken, httpclient) {
19 |         super({
20 |             url: constants_1.ENDPOINT_NEXT,
21 |             method: HTTPClient_1.HTTPRequestMethod.POST,
22 |         }, function (resJSON) {
23 |             return __awaiter(this, void 0, void 0, function* () {
24 |                 const continuationItems = helpers_1.default.recursiveSearchForKey("continuationItems", resJSON)[0];
25 |                 return continuationItems;
26 |             });
27 |         }, httpclient, false);
28 |         this.continuationToken = initialContinuationToken;
29 |     }
30 | }
31 | exports.CommentThreadRepliesContinuatedList = CommentThreadRepliesContinuatedList;
32 | 


--------------------------------------------------------------------------------
/output/fetchers/ContinuatedList.d.ts:
--------------------------------------------------------------------------------
 1 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 2 | import { HTTPRequestOptions } from "../interfaces/HTTPClient";
 3 | import { List } from "../interfaces/List";
 4 | export declare class ContinuatedList extends List {
 5 |     endReached: boolean;
 6 |     requestOptions: HTTPRequestOptions;
 7 |     httpclient: WrappedHTTPClient;
 8 |     dataprocessor: Function;
 9 |     continuationToken: string;
10 |     onlyContinuation: boolean;
11 |     constructor(requestOptions: HTTPRequestOptions, dataprocessor: Function, httpclient: WrappedHTTPClient, onlyContinuation?: boolean);
12 |     loadFurhter(): Promise<any>;
13 | }
14 | 


--------------------------------------------------------------------------------
/output/fetchers/ContinuatedList.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.ContinuatedList = void 0;
13 | const helpers_1 = require("./helpers");
14 | const List_1 = require("../interfaces/List");
15 | class ContinuatedList extends List_1.List {
16 |     constructor(requestOptions, dataprocessor, httpclient, onlyContinuation) {
17 |         super();
18 |         this.endReached = false;
19 |         this.continuationToken = "";
20 |         this.onlyContinuation = false;
21 |         this.requestOptions = requestOptions;
22 |         this.httpclient = httpclient;
23 |         this.dataprocessor = dataprocessor;
24 |         if (this.onlyContinuation)
25 |             this.onlyContinuation = onlyContinuation;
26 |     }
27 |     loadFurhter() {
28 |         return __awaiter(this, void 0, void 0, function* () {
29 |             if (this.endReached)
30 |                 return [];
31 |             var joinedData = this.requestOptions.data;
32 |             if (!joinedData)
33 |                 joinedData = {};
34 |             if (this.continuationToken != "") {
35 |                 joinedData.continuation = this.continuationToken;
36 |                 if (this.onlyContinuation)
37 |                     joinedData = {
38 |                         continuation: this.continuationToken
39 |                     };
40 |             }
41 |             var res = yield this.httpclient.request({
42 |                 method: this.requestOptions.method,
43 |                 url: this.requestOptions.url,
44 |                 data: joinedData,
45 |                 headers: this.requestOptions.headers ? this.requestOptions.headers : {},
46 |                 params: this.requestOptions.params ? this.requestOptions.params : {},
47 |             });
48 |             const resJSON = yield JSON.parse(res.data);
49 |             const continuationCommand = helpers_1.default.recursiveSearchForKey("continuationCommand", resJSON)[0];
50 |             if (continuationCommand)
51 |                 this.continuationToken = continuationCommand.token;
52 |             else
53 |                 this.endReached = true;
54 |             let items = yield this.dataprocessor(resJSON);
55 |             items = helpers_1.default.processRendererItems(items, this.httpclient);
56 |             this.results = this.results.concat(items);
57 |             return items;
58 |         });
59 |     }
60 | }
61 | exports.ContinuatedList = ContinuatedList;
62 | 


--------------------------------------------------------------------------------
/output/fetchers/Explorer.d.ts:
--------------------------------------------------------------------------------
 1 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 2 | import { Video } from "../interfaces/Video";
 3 | import IYoutube from "../IYoutube";
 4 | export declare class Explorer {
 5 |     httpclient: WrappedHTTPClient;
 6 |     client: IYoutube;
 7 |     constructor(httpclient: WrappedHTTPClient, client: IYoutube);
 8 |     getPopularVideos(): Promise<Array<Video>>;
 9 |     getTrendsNow(): Promise<Array<Video>>;
10 | }
11 | 


--------------------------------------------------------------------------------
/output/fetchers/Explorer.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.Explorer = void 0;
13 | const HTTPClient_1 = require("../interfaces/HTTPClient");
14 | const helpers_1 = require("./helpers");
15 | const constants_1 = require("../constants");
16 | class Explorer {
17 |     constructor(httpclient, client) {
18 |         this.httpclient = httpclient;
19 |         this.client = client;
20 |     }
21 |     getPopularVideos() {
22 |         return __awaiter(this, void 0, void 0, function* () {
23 |             this.client.throwErrorIfNotReady();
24 |             const res = yield this.httpclient.request({
25 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
26 |                 url: constants_1.ENDPOINT_BROWSE,
27 |                 params: {
28 |                     prettyPrint: false
29 |                 },
30 |                 data: {
31 |                     browseId: "FEexplore"
32 |                 }
33 |             });
34 |             const resJSON = yield JSON.parse(res.data);
35 |             const popularShelf = helpers_1.default.recursiveSearchForKey("expandedShelfContentsRenderer", resJSON)[0];
36 |             let items = popularShelf.items;
37 |             items = helpers_1.default.processRendererItems(items, this.httpclient);
38 |             return items;
39 |         });
40 |     }
41 |     getTrendsNow() {
42 |         return __awaiter(this, void 0, void 0, function* () {
43 |             this.client.throwErrorIfNotReady();
44 |             const res = yield this.httpclient.request({
45 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
46 |                 url: constants_1.ENDPOINT_BROWSE,
47 |                 params: {
48 |                     prettyPrint: false
49 |                 },
50 |                 data: {
51 |                     browseId: "FEtrending",
52 |                     params: "6gQJRkVleHBsb3Jl"
53 |                 }
54 |             });
55 |             const resJSON = yield JSON.parse(res.data);
56 |             const categorieShelfs = helpers_1.default.recursiveSearchForKey("tabs", resJSON)[0];
57 |             const requestedShelf = categorieShelfs.find((a) => { return a.tabRenderer.title == "Now"; });
58 |             const sectionListRenderer = helpers_1.default.recursiveSearchForKey("expandedShelfContentsRenderer", requestedShelf);
59 |             let items = sectionListRenderer.map((a) => (a.items));
60 |             items = [...items[0], ...items[1]];
61 |             items = helpers_1.default.processRendererItems(items, this.httpclient);
62 |             return items;
63 |         });
64 |     }
65 | }
66 | exports.Explorer = Explorer;
67 | 


--------------------------------------------------------------------------------
/output/fetchers/PlaylistContinuatedList.d.ts:
--------------------------------------------------------------------------------
1 | import { WrappedHTTPClient } from "../main";
2 | import { ContinuatedList } from "./ContinuatedList";
3 | export declare class PlaylistContinuatedList extends ContinuatedList {
4 |     constructor(playlistId: string, httpclient: WrappedHTTPClient);
5 | }
6 | 


--------------------------------------------------------------------------------
/output/fetchers/PlaylistContinuatedList.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.PlaylistContinuatedList = void 0;
13 | const HTTPClient_1 = require("../interfaces/HTTPClient");
14 | const helpers_1 = require("./helpers");
15 | const constants_1 = require("../constants");
16 | const ContinuatedList_1 = require("./ContinuatedList");
17 | class PlaylistContinuatedList extends ContinuatedList_1.ContinuatedList {
18 |     constructor(playlistId, httpclient) {
19 |         super({
20 |             url: constants_1.ENDPOINT_BROWSE,
21 |             method: HTTPClient_1.HTTPRequestMethod.POST,
22 |             data: {
23 |                 browseId: "VL" + playlistId
24 |             }
25 |         }, function (resJSON) {
26 |             return __awaiter(this, void 0, void 0, function* () {
27 |                 const continuationItemsContainer = helpers_1.default.recursiveSearchForKey("continuationItems", resJSON)[0];
28 |                 if (continuationItemsContainer) {
29 |                     return continuationItemsContainer;
30 |                 }
31 |                 else {
32 |                     let itemSectionRenderer = helpers_1.default.recursiveSearchForKey("playlistVideoListRenderer", resJSON)[0];
33 |                     const items = helpers_1.default.recursiveSearchForKey("contents", itemSectionRenderer)[0];
34 |                     return items;
35 |                 }
36 |             });
37 |         }, httpclient, true);
38 |     }
39 | }
40 | exports.PlaylistContinuatedList = PlaylistContinuatedList;
41 | 


--------------------------------------------------------------------------------
/output/fetchers/SearchContinuatedList.d.ts:
--------------------------------------------------------------------------------
 1 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 2 | import { ContinuatedList } from "./ContinuatedList";
 3 | export declare class SearchConitinuatedList extends ContinuatedList {
 4 |     constructor(term: string, searchType: SearchType, httpclient: WrappedHTTPClient);
 5 | }
 6 | export declare enum SearchType {
 7 |     VIDEO = "EgIQAQ%3D%3D",
 8 |     CHANNEL = "EgIQAg%3D%3D",
 9 |     PLAYLIST = "EgIQAw%3D%3D",
10 |     MOVIE = "EgIQBA%3D%3D",
11 |     ANY = ""
12 | }
13 | 


--------------------------------------------------------------------------------
/output/fetchers/SearchContinuatedList.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.SearchType = exports.SearchConitinuatedList = void 0;
13 | const HTTPClient_1 = require("../interfaces/HTTPClient");
14 | const helpers_1 = require("./helpers");
15 | const ContinuatedList_1 = require("./ContinuatedList");
16 | const constants_1 = require("../constants");
17 | class SearchConitinuatedList extends ContinuatedList_1.ContinuatedList {
18 |     constructor(term, searchType, httpclient) {
19 |         super({
20 |             url: constants_1.ENDPOINT_SEARCH,
21 |             method: HTTPClient_1.HTTPRequestMethod.POST,
22 |             data: {
23 |                 query: term,
24 |                 params: searchType
25 |             }
26 |         }, function (resJSON) {
27 |             return __awaiter(this, void 0, void 0, function* () {
28 |                 let itemSectionRenderer = helpers_1.default.recursiveSearchForKey("itemSectionRenderer", resJSON);
29 |                 if (itemSectionRenderer.length > 0)
30 |                     itemSectionRenderer = itemSectionRenderer[itemSectionRenderer.length - 1];
31 |                 else
32 |                     itemSectionRenderer = itemSectionRenderer[0];
33 |                 const items = helpers_1.default.recursiveSearchForKey("contents", itemSectionRenderer)[0];
34 |                 return items;
35 |             });
36 |         }, httpclient);
37 |     }
38 | }
39 | exports.SearchConitinuatedList = SearchConitinuatedList;
40 | var SearchType;
41 | (function (SearchType) {
42 |     SearchType["VIDEO"] = "EgIQAQ%3D%3D";
43 |     SearchType["CHANNEL"] = "EgIQAg%3D%3D";
44 |     SearchType["PLAYLIST"] = "EgIQAw%3D%3D";
45 |     SearchType["MOVIE"] = "EgIQBA%3D%3D";
46 |     SearchType["ANY"] = "";
47 | })(SearchType = exports.SearchType || (exports.SearchType = {}));
48 | 


--------------------------------------------------------------------------------
/output/fetchers/SubscriptionFeedContinuatedList.d.ts:
--------------------------------------------------------------------------------
1 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
2 | import { ContinuatedList } from "./ContinuatedList";
3 | export declare class SubscriptionFeedContinuatedList extends ContinuatedList {
4 |     constructor(httpclient: WrappedHTTPClient);
5 | }
6 | 


--------------------------------------------------------------------------------
/output/fetchers/SubscriptionFeedContinuatedList.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.SubscriptionFeedContinuatedList = void 0;
13 | const HTTPClient_1 = require("../interfaces/HTTPClient");
14 | const helpers_1 = require("./helpers");
15 | const ContinuatedList_1 = require("./ContinuatedList");
16 | const constants_1 = require("../constants");
17 | class SubscriptionFeedContinuatedList extends ContinuatedList_1.ContinuatedList {
18 |     constructor(httpclient) {
19 |         super({
20 |             url: constants_1.ENDPOINT_BROWSE,
21 |             method: HTTPClient_1.HTTPRequestMethod.POST,
22 |             data: {
23 |                 browseId: "FEsubscriptions"
24 |             },
25 |             params: {
26 |                 prettyPrint: false
27 |             }
28 |         }, function (resJSON) {
29 |             return __awaiter(this, void 0, void 0, function* () {
30 |                 let itemSectionRenderer = helpers_1.default.recursiveSearchForKey("itemSectionRenderer", resJSON);
31 |                 if (itemSectionRenderer.length > 0)
32 |                     itemSectionRenderer = itemSectionRenderer[itemSectionRenderer.length - 1];
33 |                 else
34 |                     itemSectionRenderer = itemSectionRenderer[0];
35 |                 const gridRenderers = helpers_1.default.recursiveSearchForKey("gridRenderer", resJSON);
36 |                 let items = gridRenderers.map((a) => (a.items));
37 |                 items = items.flat(1);
38 |                 return items;
39 |             });
40 |         }, httpclient);
41 |     }
42 | }
43 | exports.SubscriptionFeedContinuatedList = SubscriptionFeedContinuatedList;
44 | 


--------------------------------------------------------------------------------
/output/fetchers/User.d.ts:
--------------------------------------------------------------------------------
 1 | import { List } from "../main";
 2 | import { ContinuatedList } from "./ContinuatedList";
 3 | import { Playlist } from "../interfaces/Playlist";
 4 | import IYoutube from "../IYoutube";
 5 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 6 | export declare class User {
 7 |     httpclient: WrappedHTTPClient;
 8 |     client: IYoutube;
 9 |     constructor(httpclient: WrappedHTTPClient, client: IYoutube);
10 |     getPlaylists(): Promise<List>;
11 |     getEditablePlaylists(): Promise<List>;
12 |     getWatchLaterPlaylist(): Promise<Playlist>;
13 |     getLikedPlaylist(): Promise<Playlist>;
14 |     getSubscriptions(): Promise<List>;
15 |     getSubscriptionFeed(): ContinuatedList;
16 | }
17 | 


--------------------------------------------------------------------------------
/output/fetchers/User.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
  3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  4 |     return new (P || (P = Promise))(function (resolve, reject) {
  5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
  9 |     });
 10 | };
 11 | Object.defineProperty(exports, "__esModule", { value: true });
 12 | exports.User = void 0;
 13 | const main_1 = require("../main");
 14 | const HTTPClient_1 = require("../interfaces/HTTPClient");
 15 | const Playlist_1 = require("../interfaces/Playlist");
 16 | const helpers_1 = require("./helpers");
 17 | const SubscriptionFeedContinuatedList_1 = require("./SubscriptionFeedContinuatedList");
 18 | const constants_1 = require("../constants");
 19 | class User {
 20 |     constructor(httpclient, client) {
 21 |         this.httpclient = httpclient;
 22 |         this.client = client;
 23 |     }
 24 |     getPlaylists() {
 25 |         return __awaiter(this, void 0, void 0, function* () {
 26 |             this.client.throwErrorIfNotReady();
 27 |             const res = yield this.httpclient.request({
 28 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
 29 |                 url: constants_1.ENDPOINT_BROWSE,
 30 |                 params: { prettyPrint: false },
 31 |                 data: {
 32 |                     browseId: "FElibrary"
 33 |                 }
 34 |             });
 35 |             const resJSON = yield JSON.parse(res.data);
 36 |             const itemSectionRenderers = helpers_1.default.recursiveSearchForKey("itemSectionRenderer", resJSON);
 37 |             const playlistItemSectionRenderer = itemSectionRenderers.find((a) => {
 38 |                 const title = helpers_1.default.recursiveSearchForKey("text", helpers_1.default.recursiveSearchForKey("shelfRenderer", a)[0].title).join("");
 39 |                 return title.toLowerCase().includes("playlists");
 40 |             });
 41 |             if (!playlistItemSectionRenderer)
 42 |                 throw constants_1.ERROR_DATA_INVALID_FORMAT;
 43 |             let items = helpers_1.default.recursiveSearchForKey("items", playlistItemSectionRenderer)[0];
 44 |             items = helpers_1.default.processRendererItems(items, this.httpclient);
 45 |             return new main_1.List(items);
 46 |         });
 47 |     }
 48 |     getEditablePlaylists() {
 49 |         return __awaiter(this, void 0, void 0, function* () {
 50 |             this.client.throwErrorIfNotReady();
 51 |             const res = yield this.httpclient.request({
 52 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
 53 |                 url: constants_1.ENDPOINT_ADDTOPLAYLIST,
 54 |                 params: { prettyPrint: false },
 55 |                 data: {
 56 |                     videoIds: ["p2_nQCVPJV8"],
 57 |                     excludeWatchLater: true
 58 |                 }
 59 |             });
 60 |             const resJSON = yield JSON.parse(res.data);
 61 |             let playlists = helpers_1.default.recursiveSearchForKey("playlists", resJSON)[0];
 62 |             playlists = playlists.map((a) => {
 63 |                 var playlist = new Playlist_1.Playlist(this.httpclient);
 64 |                 playlist.fromPlaylistAddToOptionRenderer(a.playlistAddToOptionRenderer);
 65 |                 return playlist;
 66 |             });
 67 |             return new main_1.List(playlists);
 68 |         });
 69 |     }
 70 |     getWatchLaterPlaylist() {
 71 |         return __awaiter(this, void 0, void 0, function* () {
 72 |             return yield this.client.getPlaylist("WL");
 73 |         });
 74 |     }
 75 |     getLikedPlaylist() {
 76 |         return __awaiter(this, void 0, void 0, function* () {
 77 |             return yield this.client.getPlaylist("LL");
 78 |         });
 79 |     }
 80 |     getSubscriptions() {
 81 |         return __awaiter(this, void 0, void 0, function* () {
 82 |             this.client.throwErrorIfNotReady();
 83 |             const res = yield this.httpclient.request({
 84 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
 85 |                 url: constants_1.ENDPOINT_BROWSE,
 86 |                 params: { prettyPrint: false },
 87 |                 data: { browseId: "FEchannels" }
 88 |             });
 89 |             const resJSON = yield JSON.parse(res.data);
 90 |             const expandedShelfContentsRenderer = helpers_1.default.recursiveSearchForKey("expandedShelfContentsRenderer", resJSON)[0];
 91 |             let items = expandedShelfContentsRenderer.items;
 92 |             items = helpers_1.default.processRendererItems(items, this.httpclient);
 93 |             return new main_1.List(items);
 94 |         });
 95 |     }
 96 |     getSubscriptionFeed() {
 97 |         this.client.throwErrorIfNotReady();
 98 |         return new SubscriptionFeedContinuatedList_1.SubscriptionFeedContinuatedList(this.httpclient);
 99 |     }
100 | }
101 | exports.User = User;
102 | 


--------------------------------------------------------------------------------
/output/fetchers/helpers.d.ts:
--------------------------------------------------------------------------------
 1 | import { Channel } from "../interfaces/Channel";
 2 | import { Playlist } from "../interfaces/Playlist";
 3 | import { Video } from "../interfaces/Video";
 4 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 5 | import { Comment, CommentThread } from "../main";
 6 | declare function recursiveSearchForPair(searchKey: string, obj: any): any[];
 7 | declare function recursiveSearchForKey(searchKey: string, obj: any): any[];
 8 | declare function getNumberFromText(str: string): number;
 9 | declare function replaceAll(search: string, value: string, source: string): string;
10 | declare function processRendererItems(arr: Array<any>, httpclient: WrappedHTTPClient): (Video | Channel | Playlist | Comment | CommentThread | undefined)[];
11 | declare function getVideoDefaultThumbnail(videoId: string): {
12 |     url: string;
13 |     height: number;
14 |     width: number;
15 | };
16 | declare function getIndexBefore(str: string, index: number, source: string): number;
17 | declare function getIndexAfter(str: string, index: number, source: string): number;
18 | declare const _default: {
19 |     recursiveSearchForPair: typeof recursiveSearchForPair;
20 |     recursiveSearchForKey: typeof recursiveSearchForKey;
21 |     getNumberFromText: typeof getNumberFromText;
22 |     processRendererItems: typeof processRendererItems;
23 |     getVideoDefaultThumbnail: typeof getVideoDefaultThumbnail;
24 |     replaceAll: typeof replaceAll;
25 |     getIndexAfter: typeof getIndexAfter;
26 |     getIndexBefore: typeof getIndexBefore;
27 | };
28 | export default _default;
29 | 


--------------------------------------------------------------------------------
/output/fetchers/helpers.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | Object.defineProperty(exports, "__esModule", { value: true });
  3 | const Channel_1 = require("../interfaces/Channel");
  4 | const Playlist_1 = require("../interfaces/Playlist");
  5 | const Video_1 = require("../interfaces/Video");
  6 | const constants_1 = require("../constants");
  7 | const main_1 = require("../main");
  8 | function recursiveSearchForPair(searchKey, obj) {
  9 |     if (typeof obj != 'object')
 10 |         return [];
 11 |     let results = new Array();
 12 |     for (const [key, value] of Object.entries(obj)) {
 13 |         if (key == searchKey)
 14 |             results.push({ key: key, value: value });
 15 |         results = results.concat(recursiveSearchForPair(searchKey, value));
 16 |     }
 17 |     return results;
 18 | }
 19 | function recursiveSearchForKey(searchKey, obj) {
 20 |     if (typeof obj != 'object')
 21 |         return [];
 22 |     let results = new Array();
 23 |     for (const [key, value] of Object.entries(obj)) {
 24 |         if (key == searchKey)
 25 |             results.push(value);
 26 |         results = results.concat(recursiveSearchForKey(searchKey, value));
 27 |     }
 28 |     return results;
 29 | }
 30 | function getNumberFromText(str) {
 31 |     if (str == "No views")
 32 |         return 0;
 33 |     str = str.split(" ")[0];
 34 |     var number = 0.0;
 35 |     if (str.endsWith("M")) {
 36 |         number = parseFloat(replaceAll("M", "", str));
 37 |         number = number * 1000000;
 38 |     }
 39 |     else if (str.endsWith("K")) {
 40 |         number = parseFloat(replaceAll("K", "", str));
 41 |         number = number * 1000;
 42 |     }
 43 |     else {
 44 |         str = replaceAll(".", "", str);
 45 |         str = replaceAll(",", "", str);
 46 |         number = parseInt(str);
 47 |     }
 48 |     return number;
 49 | }
 50 | function replaceAll(search, value, source) {
 51 |     return source.replace(new RegExp(escapeRegExp(search), 'g'), value);
 52 | }
 53 | function processRendererItems(arr, httpclient) {
 54 |     let processedList = arr.map((elem) => {
 55 |         if (elem.videoRenderer) {
 56 |             var video = new Video_1.Video(httpclient);
 57 |             video.fromVideoRenderer(elem.videoRenderer);
 58 |             return video;
 59 |         }
 60 |         else if (elem.gridVideoRenderer) {
 61 |             var video = new Video_1.Video(httpclient);
 62 |             video.fromGridRenderer(elem.gridVideoRenderer);
 63 |             return video;
 64 |         }
 65 |         else if (elem.playlistVideoRenderer) {
 66 |             var video = new Video_1.Video(httpclient);
 67 |             video.fromPlaylistVideoRenderer(elem.playlistVideoRenderer);
 68 |             return video;
 69 |         }
 70 |         else if (elem.channelRenderer) {
 71 |             var channel = new Channel_1.Channel(httpclient);
 72 |             channel.fromChannelRenderer(elem.channelRenderer);
 73 |             return channel;
 74 |         }
 75 |         else if (elem.gridChannelRenderer) {
 76 |             var channel = new Channel_1.Channel(httpclient);
 77 |             channel.fromGridChannelRenderer(elem.gridChannelRenderer);
 78 |             return channel;
 79 |         }
 80 |         else if (elem.commentThreadRenderer) {
 81 |             var commentThread = new main_1.CommentThread(httpclient);
 82 |             commentThread.fromCommentThreadRenderer(elem.commentThreadRenderer);
 83 |             return commentThread;
 84 |         }
 85 |         else if (elem.commentRenderer) {
 86 |             var comment = new main_1.Comment(httpclient);
 87 |             comment.fromCommentRenderer(elem.commentRenderer);
 88 |             return comment;
 89 |         }
 90 |         else if (elem.playlistRenderer) {
 91 |             var playlist = new Playlist_1.Playlist(httpclient);
 92 |             playlist.fromPlaylistRenderer(elem.playlistRenderer);
 93 |             return playlist;
 94 |         }
 95 |         else if (elem.gridPlaylistRenderer) {
 96 |             var playlist = new Playlist_1.Playlist(httpclient);
 97 |             playlist.fromGridPlaylistRenderer(elem.gridPlaylistRenderer);
 98 |             return playlist;
 99 |         }
100 |         else if (elem.continuationItemRenderer || elem.shelfRenderer) {
101 |             return undefined;
102 |         }
103 |         else {
104 |             console.warn(constants_1.CONSOLE_COLORS.fg.yellow + "[IYOUTUBE] Failed to Process Item with Type(s): " + Object.keys(elem), constants_1.CONSOLE_COLORS.reset);
105 |             return undefined;
106 |         }
107 |     });
108 |     processedList = processedList.filter((a) => { return a != undefined; });
109 |     return processedList;
110 | }
111 | function getVideoDefaultThumbnail(videoId) {
112 |     return {
113 |         url: "https://i.ytimg.com/vi/" + videoId + "/maxresdefault.jpg",
114 |         height: 1,
115 |         width: 1
116 |     };
117 | }
118 | function getIndexBefore(str, index, source) {
119 |     var before = source.substring(0, index);
120 |     return before.lastIndexOf(str);
121 | }
122 | function getIndexAfter(str, index, source) {
123 |     var after = source.substring(index, source.length);
124 |     return index + after.indexOf(str);
125 | }
126 | function escapeRegExp(string) {
127 |     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
128 | }
129 | exports.default = {
130 |     recursiveSearchForPair,
131 |     recursiveSearchForKey,
132 |     getNumberFromText,
133 |     processRendererItems,
134 |     getVideoDefaultThumbnail,
135 |     replaceAll,
136 |     getIndexAfter,
137 |     getIndexBefore
138 | };
139 | 


--------------------------------------------------------------------------------
/output/formatsChipher.d.ts:
--------------------------------------------------------------------------------
1 | import { WrappedHTTPClient } from "./WrappedHTTPClient";
2 | export declare function decipher(formats: Array<any>, playerURL: string, httpClient: WrappedHTTPClient): Promise<any[]>;
3 | 


--------------------------------------------------------------------------------
/output/formatsChipher.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.decipher = void 0;
13 | const helpers_1 = require("./fetchers/helpers");
14 | const HTTPClient_1 = require("./interfaces/HTTPClient");
15 | const REGEXES = [
16 |     new RegExp("(?:\\b|[^a-zA-Z0-9$])([a-zA-Z0-9$]{2,})\\s*=\\s*function\\(\\s*a\\s*\\)" + "\\s*\\{\\s*a\\s*=\\s*a\\.split\\(\\s*\"\"\\s*\\)"),
17 |     new RegExp("\\bm=([a-zA-Z0-9$]{2,})\\(decodeURIComponent\\(h\\.s\\)\\)"),
18 |     new RegExp("\\bc&&\\(c=([a-zA-Z0-9$]{2,})\\(decodeURIComponent\\(c\\)\\)"),
19 |     new RegExp("([\\w$]+)\\s*=\\s*function\\((\\w+)\\)\\{\\s*\\2=\\s*\\2\\.split\\(\"\"\\)\\s*;"),
20 |     new RegExp("\\b([\\w$]{2,})\\s*=\\s*function\\((\\w+)\\)\\{\\s*\\2=\\s*\\2\\.split\\(\"\"\\)\\s*;"),
21 |     new RegExp("\\bc\\s*&&\\s*d\\.set\\([^,]+\\s*,\\s*(:encodeURIComponent\\s*\\()([a-zA-Z0-9$]+)\\(")
22 | ];
23 | function decipher(formats, playerURL, httpClient) {
24 |     return __awaiter(this, void 0, void 0, function* () {
25 |         const playerResults = yield httpClient.request({
26 |             method: HTTPClient_1.HTTPRequestMethod.GET,
27 |             url: playerURL
28 |         });
29 |         const playerJS = playerResults.data;
30 |         let deobfuscateFunctionName = "";
31 |         for (const reg of REGEXES) {
32 |             deobfuscateFunctionName = matchGroup1(reg, playerJS);
33 |             if (deobfuscateFunctionName) {
34 |                 break;
35 |             }
36 |         }
37 |         const functionPattern = new RegExp("(" + deobfuscateFunctionName.replace("$", "\\$") + "=function\\([a-zA-Z0-9_]+\\)\\{.+?\\})");
38 |         const deobfuscateFunction = "var " + matchGroup1(functionPattern, playerJS) + ";";
39 |         const helperObjectName = matchGroup1(new RegExp(";([A-Za-z0-9_\\$]{2})\\...\\("), deobfuscateFunction);
40 |         const helperPattern = new RegExp("(var " + helperObjectName + "=\\{.+?\\}\\};)");
41 |         const helperObject = matchGroup1(helperPattern, helpers_1.default.replaceAll("\n", "", playerJS));
42 |         const finalFunc = eval(`(function getDecipherFunction() {
43 |     ` + helperObject + `
44 |     ` + deobfuscateFunction + `
45 | 
46 |     return (val) => ` + deobfuscateFunctionName + `;
47 |   })()`)();
48 |         for (const format of formats) {
49 |             if (format.signatureCipher) {
50 |                 const signatureParams = parseQuery(format.signatureCipher);
51 |                 const resolvedSignature = finalFunc(signatureParams.s);
52 |                 const finalURL = new URL(signatureParams.url);
53 |                 finalURL.searchParams.set(signatureParams.sp, resolvedSignature);
54 |                 format.url = finalURL.toString();
55 |             }
56 |         }
57 |         return formats;
58 |     });
59 | }
60 | exports.decipher = decipher;
61 | function matchGroup1(regex, str) {
62 |     const res = regex.exec(str);
63 |     if (!res)
64 |         return "";
65 |     return res[1];
66 | }
67 | function parseQuery(queryString) {
68 |     var query = {};
69 |     var pairs = (queryString[0] === '?' ? queryString.substr(1) : queryString).split('&');
70 |     for (var i = 0; i < pairs.length; i++) {
71 |         var pair = pairs[i].split('=');
72 |         query[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1] || '');
73 |     }
74 |     return query;
75 | }
76 | 


--------------------------------------------------------------------------------
/output/interfaces/Badge.d.ts:
--------------------------------------------------------------------------------
1 | export interface Badge {
2 |     name: string;
3 |     icon: string;
4 |     style?: string;
5 | }
6 | 


--------------------------------------------------------------------------------
/output/interfaces/Badge.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | 


--------------------------------------------------------------------------------
/output/interfaces/Badge.ts:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ToBiDi0410/IYoutube/0cfb13dfd4fc8cce3e5501869cc1509319d994b0/output/interfaces/Badge.ts


--------------------------------------------------------------------------------
/output/interfaces/CaptionTrack.d.ts:
--------------------------------------------------------------------------------
1 | export interface CaptionTrack {
2 |     baseUrl: string;
3 |     translateable: boolean;
4 |     languageCode: string;
5 |     name: string;
6 | }
7 | 


--------------------------------------------------------------------------------
/output/interfaces/CaptionTrack.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | 


--------------------------------------------------------------------------------
/output/interfaces/Channel.d.ts:
--------------------------------------------------------------------------------
 1 | import { ContinuatedList, Thumbnail, Badge, Video, WrappedHTTPClient } from "../main";
 2 | import { ChannelLink } from "./ChannelLink";
 3 | export declare class Channel {
 4 |     #private;
 5 |     channelId?: string;
 6 |     title?: string;
 7 |     description?: string;
 8 |     shortDescription?: string;
 9 |     badges?: Array<Badge>;
10 |     thumbnails?: Array<Thumbnail>;
11 |     banners?: Array<Thumbnail>;
12 |     mobileBanners?: Array<Thumbnail>;
13 |     tvBanners?: Array<Thumbnail>;
14 |     videoCount?: number;
15 |     subscribed?: boolean;
16 |     subscriberCount?: number;
17 |     country?: string;
18 |     viewCount?: number;
19 |     joinDate?: Date;
20 |     channelLinks?: Array<ChannelLink>;
21 |     otherChannels?: Array<Channel>;
22 |     featuredVideo?: Video;
23 |     httpclient: WrappedHTTPClient;
24 |     constructor(httpclient: WrappedHTTPClient);
25 |     fromVideoRenderer(obj: any): void;
26 |     fromChannelRenderer(obj: any): void;
27 |     fromGridVideoRenderer(obj: any): void;
28 |     fromPlaylistRenderer(obj: any): void;
29 |     fromVideoOwnerRenderer(obj: any): void;
30 |     fromPlaylistVideoRendererBylineText(obj: any): void;
31 |     fromGridChannelRenderer(obj: any): void;
32 |     fromCommentRenderer(obj: any): void;
33 |     fromPlayerMicroRenderer(obj: any): void;
34 |     loadAll(): Promise<void>;
35 |     loadDetailsFromOverviewPage(): Promise<void>;
36 |     loadDetailsFromAboutPage(): Promise<void>;
37 |     loadDetailsFromChannelsPages(): Promise<void>;
38 |     getUploadList(): ContinuatedList;
39 |     subscribe(): Promise<boolean>;
40 |     unsubscribe(): Promise<boolean>;
41 | }
42 | 


--------------------------------------------------------------------------------
/output/interfaces/ChannelBadge.d.ts:
--------------------------------------------------------------------------------
1 | export interface ChannelBadge {
2 |     name: string;
3 |     icon: string;
4 | }
5 | 


--------------------------------------------------------------------------------
/output/interfaces/ChannelBadge.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | 


--------------------------------------------------------------------------------
/output/interfaces/ChannelLink.d.ts:
--------------------------------------------------------------------------------
1 | import { Thumbnail } from "../main";
2 | export interface ChannelLink {
3 |     url: string;
4 |     title: string;
5 |     thumbnails?: Array<Thumbnail>;
6 | }
7 | 


--------------------------------------------------------------------------------
/output/interfaces/ChannelLink.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | 


--------------------------------------------------------------------------------
/output/interfaces/Comment.d.ts:
--------------------------------------------------------------------------------
 1 | import { Channel, WrappedHTTPClient } from "../main";
 2 | export declare class Comment {
 3 |     httpclient: WrappedHTTPClient;
 4 |     commentId?: string;
 5 |     text?: string;
 6 |     author?: Channel;
 7 |     authorIsChannelOwner?: boolean;
 8 |     likeCount?: number;
 9 |     hasLiked?: boolean;
10 |     publishedText?: string;
11 |     likeActionToken?: string;
12 |     dislikeActionToken?: string;
13 |     removeLikeActionToken?: string;
14 |     removeDislikeActionToken?: string;
15 |     canPerformLikeActions?: boolean;
16 |     constructor(httpclient: WrappedHTTPClient);
17 |     fromCommentRenderer(obj: any): void;
18 |     like(): Promise<boolean>;
19 |     dislike(): Promise<boolean>;
20 |     removeLike(): Promise<boolean>;
21 | }
22 | 


--------------------------------------------------------------------------------
/output/interfaces/Comment.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
  3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  4 |     return new (P || (P = Promise))(function (resolve, reject) {
  5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
  9 |     });
 10 | };
 11 | Object.defineProperty(exports, "__esModule", { value: true });
 12 | exports.Comment = void 0;
 13 | const main_1 = require("../main");
 14 | const helpers_1 = require("../fetchers/helpers");
 15 | const HTTPClient_1 = require("./HTTPClient");
 16 | const constants_1 = require("../constants");
 17 | class Comment {
 18 |     constructor(httpclient) {
 19 |         this.httpclient = httpclient;
 20 |     }
 21 |     fromCommentRenderer(obj) {
 22 |         this.commentId = helpers_1.default.recursiveSearchForKey("commentId", obj)[0];
 23 |         const contentContainer = helpers_1.default.recursiveSearchForKey("contentText", obj)[0];
 24 |         if (contentContainer)
 25 |             this.text = helpers_1.default.recursiveSearchForKey("text", contentContainer).join("");
 26 |         this.author = new main_1.Channel(this.httpclient);
 27 |         this.author.fromCommentRenderer(obj);
 28 |         this.authorIsChannelOwner = helpers_1.default.recursiveSearchForKey("authorIsChannelOwner", obj)[0];
 29 |         const likeCountContainer = helpers_1.default.recursiveSearchForKey("voteCount", obj)[0];
 30 |         if (likeCountContainer)
 31 |             this.likeCount = helpers_1.default.getNumberFromText(helpers_1.default.recursiveSearchForKey("simpleText", likeCountContainer).join(""));
 32 |         this.hasLiked = helpers_1.default.recursiveSearchForKey("isLiked", obj)[0];
 33 |         const publishedTimeTextContainer = helpers_1.default.recursiveSearchForKey("publishedTimeText", obj)[0];
 34 |         if (publishedTimeTextContainer) {
 35 |             this.publishedText = helpers_1.default.recursiveSearchForKey("text", publishedTimeTextContainer).join("");
 36 |         }
 37 |         const actionButtonContainer = helpers_1.default.recursiveSearchForKey("commentActionButtonsRenderer", obj)[0];
 38 |         if (actionButtonContainer) {
 39 |             const dislikeButton = helpers_1.default.recursiveSearchForKey("dislikeButton", actionButtonContainer);
 40 |             if (dislikeButton)
 41 |                 this.dislikeActionToken = helpers_1.default.recursiveSearchForKey("action", dislikeButton)[0];
 42 |             this.removeDislikeActionToken = helpers_1.default.recursiveSearchForKey("action", dislikeButton)[1];
 43 |             const likeButton = helpers_1.default.recursiveSearchForKey("likeButton", actionButtonContainer);
 44 |             if (likeButton) {
 45 |                 this.likeActionToken = helpers_1.default.recursiveSearchForKey("action", likeButton)[0];
 46 |                 this.removeLikeActionToken = helpers_1.default.recursiveSearchForKey("action", likeButton)[1];
 47 |             }
 48 |             this.canPerformLikeActions = !(!this.dislikeActionToken && !this.likeActionToken);
 49 |         }
 50 |     }
 51 |     like() {
 52 |         return __awaiter(this, void 0, void 0, function* () {
 53 |             if (!this.canPerformLikeActions)
 54 |                 throw new Error("It is not possible to perfrom Like Actions on this Comment Instance");
 55 |             const commentAction = yield this.httpclient.request({
 56 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
 57 |                 url: constants_1.ENDPOINT_COMMENT_ACTION,
 58 |                 data: {
 59 |                     actions: [this.likeActionToken]
 60 |                 }
 61 |             });
 62 |             this.hasLiked = commentAction.status == 200;
 63 |             return commentAction.status == 200;
 64 |         });
 65 |     }
 66 |     dislike() {
 67 |         return __awaiter(this, void 0, void 0, function* () {
 68 |             if (!this.canPerformLikeActions)
 69 |                 throw new Error("It is not possible to perfrom Like Actions on this Comment Instance");
 70 |             const commentAction = yield this.httpclient.request({
 71 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
 72 |                 url: constants_1.ENDPOINT_COMMENT_ACTION,
 73 |                 data: {
 74 |                     actions: [this.dislikeActionToken]
 75 |                 }
 76 |             });
 77 |             this.hasLiked = commentAction.status == 200 ? false : undefined;
 78 |             return commentAction.status == 200;
 79 |         });
 80 |     }
 81 |     removeLike() {
 82 |         return __awaiter(this, void 0, void 0, function* () {
 83 |             let removeToken = this.removeLikeActionToken;
 84 |             if (this.hasLiked === true) {
 85 |                 removeToken = this.removeLikeActionToken;
 86 |             }
 87 |             else if (this.hasLiked === false) {
 88 |                 removeToken = this.removeDislikeActionToken;
 89 |             }
 90 |             else {
 91 |                 console.warn("[IYOUTUBE | COMMENT] Removal of Like without knowing if it's present!");
 92 |             }
 93 |             const commentAction = yield this.httpclient.request({
 94 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
 95 |                 url: constants_1.ENDPOINT_COMMENT_ACTION,
 96 |                 data: {
 97 |                     actions: [removeToken]
 98 |                 }
 99 |             });
100 |             this.hasLiked = undefined;
101 |             return commentAction.status == 200;
102 |         });
103 |     }
104 | }
105 | exports.Comment = Comment;
106 | 


--------------------------------------------------------------------------------
/output/interfaces/CommentThread.d.ts:
--------------------------------------------------------------------------------
1 | import { WrappedHTTPClient, Comment, CommentThreadRepliesContinuatedList } from "../main";
2 | export declare class CommentThread {
3 |     httpclient: WrappedHTTPClient;
4 |     comment?: Comment;
5 |     replieList?: CommentThreadRepliesContinuatedList;
6 |     constructor(httpclient: WrappedHTTPClient);
7 |     fromCommentThreadRenderer(obj: any): void;
8 | }
9 | 


--------------------------------------------------------------------------------
/output/interfaces/CommentThread.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | exports.CommentThread = void 0;
 4 | const helpers_1 = require("../fetchers/helpers");
 5 | const main_1 = require("../main");
 6 | class CommentThread {
 7 |     constructor(httpclient) {
 8 |         this.httpclient = httpclient;
 9 |     }
10 |     fromCommentThreadRenderer(obj) {
11 |         this.comment = new main_1.Comment(this.httpclient);
12 |         this.comment.fromCommentRenderer(obj.comment);
13 |         const repliesRenderer = obj.replies;
14 |         if (repliesRenderer) {
15 |             this.replieList = new main_1.CommentThreadRepliesContinuatedList(helpers_1.default.recursiveSearchForKey("token", repliesRenderer).join(""), this.httpclient);
16 |         }
17 |     }
18 | }
19 | exports.CommentThread = CommentThread;
20 | 


--------------------------------------------------------------------------------
/output/interfaces/Format.d.ts:
--------------------------------------------------------------------------------
 1 | export interface Format {
 2 |     type: "VIDEO" | "AUDIO";
 3 |     itag: number;
 4 |     url: string;
 5 |     mime: string;
 6 |     bitrate?: number;
 7 |     averageBitrate?: number;
 8 |     quality?: string;
 9 |     height?: number;
10 |     width?: number;
11 |     fps?: number;
12 |     qualityLabel?: string;
13 |     colorInfo?: {
14 |         matrixCoefficients: string;
15 |         primaries: string;
16 |         transferCharacteristics: string;
17 |     };
18 |     audioQuality?: string;
19 |     audioSampleRate?: number;
20 |     audioChannels?: number;
21 |     loudness?: number;
22 | }
23 | 


--------------------------------------------------------------------------------
/output/interfaces/Format.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | 


--------------------------------------------------------------------------------
/output/interfaces/HTTPClient.d.ts:
--------------------------------------------------------------------------------
 1 | export interface HTTPClient {
 2 |     request(options: HTTPRequestOptions): Promise<HTTPResponse>;
 3 | }
 4 | export interface HTTPRequestOptions {
 5 |     headers?: HTTPMap;
 6 |     params?: HTTPMap;
 7 |     data?: any;
 8 |     method: HTTPRequestMethod;
 9 |     url: string;
10 |     noCache?: boolean;
11 | }
12 | export interface HTTPResponse {
13 |     status: number;
14 |     data: string;
15 |     headers: HTTPMap;
16 | }
17 | export declare enum HTTPRequestMethod {
18 |     GET = "GET",
19 |     POST = "POST"
20 | }
21 | export declare type HTTPMap = any;
22 | 


--------------------------------------------------------------------------------
/output/interfaces/HTTPClient.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | exports.HTTPRequestMethod = void 0;
4 | var HTTPRequestMethod;
5 | (function (HTTPRequestMethod) {
6 |     HTTPRequestMethod["GET"] = "GET";
7 |     HTTPRequestMethod["POST"] = "POST";
8 | })(HTTPRequestMethod = exports.HTTPRequestMethod || (exports.HTTPRequestMethod = {}));
9 | 


--------------------------------------------------------------------------------
/output/interfaces/List.d.ts:
--------------------------------------------------------------------------------
 1 | import { Video, Channel, Playlist, Comment, CommentThread } from "../main";
 2 | export declare class List {
 3 |     results: Array<Video | Channel | Playlist | Comment | CommentThread>;
 4 |     constructor(array?: Array<any>);
 5 |     getByType(type: any): (Video | Channel | Playlist | Comment | CommentThread)[];
 6 |     getVideos(): Array<Video>;
 7 |     getPlaylists(): Array<Playlist>;
 8 |     getChannels(): Array<Channel>;
 9 |     getComments(): Array<Comment>;
10 |     getCommentThreads(): Array<CommentThread>;
11 | }
12 | 


--------------------------------------------------------------------------------
/output/interfaces/List.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | exports.List = void 0;
 4 | const main_1 = require("../main");
 5 | class List {
 6 |     constructor(array) {
 7 |         if (array) {
 8 |             this.results = array;
 9 |         }
10 |         else {
11 |             this.results = new Array();
12 |         }
13 |     }
14 |     getByType(type) {
15 |         return this.results.filter((elem) => { return elem instanceof type; });
16 |     }
17 |     getVideos() {
18 |         return this.getByType(main_1.Video);
19 |     }
20 |     getPlaylists() {
21 |         return this.getByType(main_1.Playlist);
22 |     }
23 |     getChannels() {
24 |         return this.getByType(main_1.Channel);
25 |     }
26 |     getComments() {
27 |         return this.getByType(main_1.Comment);
28 |     }
29 |     getCommentThreads() {
30 |         return this.getByType(main_1.CommentThread);
31 |     }
32 | }
33 | exports.List = List;
34 | 


--------------------------------------------------------------------------------
/output/interfaces/Playlist.d.ts:
--------------------------------------------------------------------------------
 1 | import { PlaylistContinuatedList } from "../fetchers/PlaylistContinuatedList";
 2 | import { Video, Thumbnail, ContinuatedList, Channel, WrappedHTTPClient, Badge } from "../main";
 3 | export declare class Playlist {
 4 |     playlistId?: string;
 5 |     title?: string;
 6 |     description?: string;
 7 |     thumbnails?: Array<Thumbnail>;
 8 |     videoCount?: number;
 9 |     viewCount?: number;
10 |     owner?: Channel;
11 |     videos?: Array<Video>;
12 |     canReorder?: boolean;
13 |     isEditable?: boolean;
14 |     lastEditText?: string;
15 |     canLike?: boolean;
16 |     badges?: Array<Badge>;
17 |     privacyState?: "PRIVATE" | "UNLISTED" | "PUBLIC";
18 |     httpclient: WrappedHTTPClient;
19 |     continuatedList?: ContinuatedList;
20 |     likeParam?: string;
21 |     constructor(httpclient: WrappedHTTPClient);
22 |     fromPlaylistRenderer(obj: any): void;
23 |     fromGridPlaylistRenderer(obj: any): void;
24 |     fromPlaylistAddToOptionRenderer(obj: any): void;
25 |     loadAll(): Promise<void>;
26 |     getContinuatedList(): PlaylistContinuatedList;
27 |     like(): Promise<boolean>;
28 |     removeLike(): Promise<boolean>;
29 | }
30 | 


--------------------------------------------------------------------------------
/output/interfaces/Playlist.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
  3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  4 |     return new (P || (P = Promise))(function (resolve, reject) {
  5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
  9 |     });
 10 | };
 11 | Object.defineProperty(exports, "__esModule", { value: true });
 12 | exports.Playlist = void 0;
 13 | const helpers_1 = require("../fetchers/helpers");
 14 | const PlaylistContinuatedList_1 = require("../fetchers/PlaylistContinuatedList");
 15 | const HTTPClient_1 = require("./HTTPClient");
 16 | const main_1 = require("../main");
 17 | const constants_1 = require("../constants");
 18 | class Playlist {
 19 |     constructor(httpclient) {
 20 |         this.httpclient = httpclient;
 21 |     }
 22 |     fromPlaylistRenderer(obj) {
 23 |         this.playlistId = helpers_1.default.recursiveSearchForKey("playlistId", obj)[0];
 24 |         const titleContainer = helpers_1.default.recursiveSearchForKey("title", obj)[0];
 25 |         if (titleContainer)
 26 |             this.title = helpers_1.default.recursiveSearchForKey("simpleText", titleContainer)[0];
 27 |         let thumbnailContainer = helpers_1.default.recursiveSearchForKey("playlistVideoThumbnailRenderer", obj)[0];
 28 |         if (thumbnailContainer)
 29 |             this.thumbnails = helpers_1.default.recursiveSearchForKey("thumbnails", thumbnailContainer)[0];
 30 |         this.videoCount = helpers_1.default.recursiveSearchForKey("videoCount", obj)[0];
 31 |         const channelContainer = helpers_1.default.recursiveSearchForKey("shortBylineText", obj)[0];
 32 |         if (channelContainer) {
 33 |             this.owner = new main_1.Channel(this.httpclient);
 34 |             this.owner.fromPlaylistRenderer(obj);
 35 |         }
 36 |     }
 37 |     fromGridPlaylistRenderer(obj) {
 38 |         this.fromPlaylistRenderer(obj);
 39 |         const viewCountContainer = helpers_1.default.recursiveSearchForKey("thumbnailText", obj)[0];
 40 |         if (viewCountContainer) {
 41 |             this.videoCount = helpers_1.default.getNumberFromText(helpers_1.default.recursiveSearchForKey("text", viewCountContainer).join(""));
 42 |         }
 43 |         const badgesContainer = helpers_1.default.recursiveSearchForKey("badges", obj);
 44 |         if (badgesContainer) {
 45 |             const badgeRenderers = helpers_1.default.recursiveSearchForKey("metadataBadgeRenderer", badgesContainer);
 46 |             if (badgeRenderers.length > 0) {
 47 |                 this.badges = badgeRenderers.map((badgeRenderer) => ({
 48 |                     name: helpers_1.default.recursiveSearchForKey("label", badgeRenderer)[0],
 49 |                     icon: helpers_1.default.recursiveSearchForKey("iconType", badgeRenderer)[0],
 50 |                     style: helpers_1.default.recursiveSearchForKey("style", badgeRenderer)[0]
 51 |                 }));
 52 |             }
 53 |         }
 54 |         if (this.badges) {
 55 |             if (this.badges.find((a) => { return a.icon == "PRIVACY_PRIVATE"; }))
 56 |                 this.privacyState = "PRIVATE";
 57 |             else if (this.badges.find((a) => { return a.icon == "PRIVACY_UNLISTED"; }))
 58 |                 this.privacyState = "UNLISTED";
 59 |             else
 60 |                 this.privacyState = "PUBLIC";
 61 |         }
 62 |         else
 63 |             this.privacyState = "PUBLIC";
 64 |     }
 65 |     fromPlaylistAddToOptionRenderer(obj) {
 66 |         this.playlistId = helpers_1.default.recursiveSearchForKey("playlistId", obj)[0];
 67 |     }
 68 |     loadAll() {
 69 |         return __awaiter(this, void 0, void 0, function* () {
 70 |             const res = yield this.httpclient.request({
 71 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
 72 |                 url: constants_1.ENDPOINT_BROWSE,
 73 |                 data: {
 74 |                     browseId: "VL" + this.playlistId
 75 |                 }
 76 |             });
 77 |             if (res.status != 200)
 78 |                 throw new Error("Invalid Response Code");
 79 |             const resJSON = yield JSON.parse(res.data);
 80 |             if (!resJSON.contents)
 81 |                 throw new Error("Playlist not found");
 82 |             const playlistRendererContainer = helpers_1.default.recursiveSearchForKey("playlistVideoListRenderer", resJSON)[0];
 83 |             if (playlistRendererContainer) {
 84 |                 this.canReorder = helpers_1.default.recursiveSearchForKey("canReorder", playlistRendererContainer)[0];
 85 |                 this.isEditable = helpers_1.default.recursiveSearchForKey("isEditable", playlistRendererContainer)[0];
 86 |             }
 87 |             const primaryInfoRendererContainer = helpers_1.default.recursiveSearchForKey("playlistSidebarPrimaryInfoRenderer", resJSON)[0];
 88 |             if (primaryInfoRendererContainer) {
 89 |                 const statsContainer = helpers_1.default.recursiveSearchForKey("stats", primaryInfoRendererContainer)[0];
 90 |                 if (statsContainer) {
 91 |                     this.videoCount = helpers_1.default.getNumberFromText(helpers_1.default.recursiveSearchForKey("text", statsContainer[0])[0]);
 92 |                     this.viewCount = helpers_1.default.getNumberFromText(helpers_1.default.recursiveSearchForKey("simpleText", statsContainer[1])[0]);
 93 |                     this.lastEditText = helpers_1.default.recursiveSearchForKey("text", statsContainer[2]).join("");
 94 |                 }
 95 |                 const titleFormContainer = helpers_1.default.recursiveSearchForKey("titleForm", primaryInfoRendererContainer)[0];
 96 |                 if (titleFormContainer)
 97 |                     this.title = helpers_1.default.recursiveSearchForKey("simpleText", helpers_1.default.recursiveSearchForKey("textDisplayed", titleFormContainer)[0]).join("");
 98 |                 const titleContainer = primaryInfoRendererContainer.title;
 99 |                 if (titleContainer)
100 |                     this.title = helpers_1.default.recursiveSearchForKey("text", titleContainer).join("");
101 |                 const descriptionForm = helpers_1.default.recursiveSearchForKey("descriptionForm", primaryInfoRendererContainer)[0];
102 |                 if (descriptionForm)
103 |                     this.description = helpers_1.default.recursiveSearchForKey("simpleText", helpers_1.default.recursiveSearchForKey("textDisplayed", descriptionForm)[0]).join("");
104 |                 const descriptionContainer = helpers_1.default.recursiveSearchForKey("description", primaryInfoRendererContainer)[0];
105 |                 if (descriptionContainer)
106 |                     this.description = helpers_1.default.recursiveSearchForKey("text", descriptionContainer).join("");
107 |                 const thumbnailsContainer = helpers_1.default.recursiveSearchForKey("thumbnails", primaryInfoRendererContainer)[0];
108 |                 if (thumbnailsContainer)
109 |                     this.thumbnails = thumbnailsContainer;
110 |                 const likeButtonContainer = helpers_1.default.recursiveSearchForKey("toggleButtonRenderer", primaryInfoRendererContainer)[0];
111 |                 if (likeButtonContainer) {
112 |                     this.canLike = true;
113 |                     this.likeParam = helpers_1.default.recursiveSearchForKey("removeLikeParams", likeButtonContainer).join("");
114 |                 }
115 |                 else
116 |                     this.canLike = false;
117 |             }
118 |             else
119 |                 throw new Error("PrimaryInfoRenderer was missing");
120 |             const videoOwnerContainer = helpers_1.default.recursiveSearchForKey("videoOwner", resJSON)[0];
121 |             if (videoOwnerContainer) {
122 |                 this.owner = new main_1.Channel(this.httpclient);
123 |                 this.owner.fromVideoOwnerRenderer(videoOwnerContainer);
124 |             }
125 |         });
126 |     }
127 |     getContinuatedList() {
128 |         if (this.continuatedList)
129 |             return this.continuatedList;
130 |         if (this.playlistId) {
131 |             this.continuatedList = new PlaylistContinuatedList_1.PlaylistContinuatedList(this.playlistId, this.httpclient);
132 |             return this.getContinuatedList();
133 |         }
134 |         throw new Error("Cannot construct Continuated List for Playlist without the playlistID");
135 |     }
136 |     like() {
137 |         return __awaiter(this, void 0, void 0, function* () {
138 |             if (!this.likeParam || !this.canLike)
139 |                 throw new Error("Cannot add or remove Playlist because not all Data is loaded or it is not possible");
140 |             const res = yield this.httpclient.request({
141 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
142 |                 url: constants_1.ENDPOINT_LIKE,
143 |                 params: { prettyPrint: false },
144 |                 data: {
145 |                     params: this.likeParam,
146 |                     target: {
147 |                         playlistId: this.playlistId
148 |                     }
149 |                 },
150 |                 noCache: true
151 |             });
152 |             return res.status == 200;
153 |         });
154 |     }
155 |     removeLike() {
156 |         return __awaiter(this, void 0, void 0, function* () {
157 |             if (!this.likeParam || !this.canLike)
158 |                 throw new Error("Cannot add or remove Playlist because not all Data is loaded or its forbidden");
159 |             const res = yield this.httpclient.request({
160 |                 method: HTTPClient_1.HTTPRequestMethod.POST,
161 |                 url: constants_1.ENDPOINT_REMOVELIKE,
162 |                 params: { prettyPrint: false },
163 |                 data: {
164 |                     params: this.likeParam,
165 |                     target: {
166 |                         playlistId: this.playlistId
167 |                     }
168 |                 },
169 |                 noCache: true
170 |             });
171 |             return res.status == 200;
172 |         });
173 |     }
174 | }
175 | exports.Playlist = Playlist;
176 | 


--------------------------------------------------------------------------------
/output/interfaces/SearchProposal.d.ts:
--------------------------------------------------------------------------------
1 | export interface SearchProposal {
2 |     text: string;
3 | }
4 | 


--------------------------------------------------------------------------------
/output/interfaces/SearchProposal.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | 


--------------------------------------------------------------------------------
/output/interfaces/SponsorBlockSegment.d.ts:
--------------------------------------------------------------------------------
 1 | export interface SponsorBlockSegment {
 2 |     segment: number;
 3 |     UUID: string;
 4 |     actionType: string;
 5 |     category?: string;
 6 |     videoDuration?: number;
 7 |     userID?: string;
 8 |     locked?: boolean;
 9 |     votes?: number;
10 |     description?: string;
11 | }
12 | 


--------------------------------------------------------------------------------
/output/interfaces/SponsorBlockSegment.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | 


--------------------------------------------------------------------------------
/output/interfaces/StorageAdapter.d.ts:
--------------------------------------------------------------------------------
1 | export interface StorageAdapter {
2 |     set(path: string, value: string): Promise<boolean>;
3 |     get(path: string): Promise<string>;
4 |     exists(path: string): Promise<boolean>;
5 | }
6 | 


--------------------------------------------------------------------------------
/output/interfaces/StorageAdapter.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | 


--------------------------------------------------------------------------------
/output/interfaces/Thumbnail.d.ts:
--------------------------------------------------------------------------------
1 | export interface Thumbnail {
2 |     width: number;
3 |     height: number;
4 |     url: string;
5 | }
6 | 


--------------------------------------------------------------------------------
/output/interfaces/Thumbnail.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | 


--------------------------------------------------------------------------------
/output/interfaces/Video.d.ts:
--------------------------------------------------------------------------------
 1 | import { CommentSectionContinuatedList, ContinuatedList, WrappedHTTPClient, Channel, Thumbnail, CaptionTrack, CommentThread, Format, SponsorBlockSegment } from "../main";
 2 | export declare class Video {
 3 |     videoId?: any;
 4 |     title?: string;
 5 |     shortDescription?: string;
 6 |     description?: string;
 7 |     viewCount?: number;
 8 |     thumbnails?: Array<Thumbnail>;
 9 |     richThumbnails?: Array<Thumbnail>;
10 |     publishedText?: string;
11 |     publishedDate?: Date;
12 |     owner?: Channel;
13 |     playable?: boolean;
14 |     private?: boolean;
15 |     listed?: boolean;
16 |     live?: boolean;
17 |     familySafe?: boolean;
18 |     captionTracks?: Array<CaptionTrack>;
19 |     keywords?: Array<String>;
20 |     canLike?: boolean;
21 |     currentUserIsOwner?: boolean;
22 |     commentThreadList?: CommentSectionContinuatedList;
23 |     formats?: Array<Format>;
24 |     likeCount?: number;
25 |     dislikeCount?: number;
26 |     likeState?: "NONE" | "DISLIKE" | "LIKE";
27 |     sponsorSegments?: Array<SponsorBlockSegment>;
28 |     httpclient: WrappedHTTPClient;
29 |     error: boolean;
30 |     constructor(httpclient: WrappedHTTPClient);
31 |     fromVideoRenderer(obj: any): void;
32 |     fromVideoPlayerRenderer(obj: any): void;
33 |     fromGridRenderer(obj: any): void;
34 |     fromPlaylistVideoRenderer(obj: any): void;
35 |     loadAll(): Promise<void>;
36 |     loadFormats(): Promise<void>;
37 |     loadRatings(): Promise<void>;
38 |     loadSponsorSegments(): Promise<never[] | undefined>;
39 |     getCommentThreadList(): Promise<ContinuatedList | undefined>;
40 |     like(): Promise<boolean>;
41 |     dislike(): Promise<boolean>;
42 |     removeLike(): Promise<boolean>;
43 |     comment(text: string): Promise<CommentThread>;
44 | }
45 | 


--------------------------------------------------------------------------------
/output/main.d.ts:
--------------------------------------------------------------------------------
 1 | import { Explorer } from "./fetchers/Explorer";
 2 | import { ContinuatedList } from "./fetchers/ContinuatedList";
 3 | import { User } from "./fetchers/User";
 4 | import { Authenticator } from "./Authenticator";
 5 | import { Channel } from "./interfaces/Channel";
 6 | import { Video } from "./interfaces/Video";
 7 | import { Playlist } from "./interfaces/Playlist";
 8 | import { Thumbnail } from "./interfaces/Thumbnail";
 9 | import { Badge } from "./interfaces/Badge";
10 | import { HTTPClient } from "./interfaces/HTTPClient";
11 | import { StorageAdapter } from "./interfaces/StorageAdapter";
12 | import { CommentSectionContinuatedList } from "./fetchers/CommentSectionContinuatedList";
13 | import { Comment } from "./interfaces/Comment";
14 | import { CommentThread } from "./interfaces/CommentThread";
15 | import { WrappedHTTPClient } from "./WrappedHTTPClient";
16 | import { CommentThreadRepliesContinuatedList } from "./fetchers/CommentThreadRepliesContinuatedList";
17 | import { CaptionTrack } from "./interfaces/CaptionTrack";
18 | import { List } from "./interfaces/List";
19 | import { SearchProposal } from "./interfaces/SearchProposal";
20 | import { Format } from "./interfaces/Format";
21 | import { default as IYoutube } from "./IYoutube";
22 | import { SponsorBlockSegment } from "./interfaces/SponsorBlockSegment";
23 | import { HTTPRequestOptions, HTTPRequestMethod, HTTPResponse } from "./interfaces/HTTPClient";
24 | export { IYoutube as IYoutube };
25 | export { HTTPClient as HTTPClient };
26 | export { StorageAdapter as StorageAdapter };
27 | export { WrappedHTTPClient as WrappedHTTPClient };
28 | export { Explorer as Explorer };
29 | export { User as User };
30 | export { ContinuatedList as ContinuatedList };
31 | export { Authenticator as Authenticator };
32 | export { Channel as Channel };
33 | export { Video as Video };
34 | export { Playlist as Playlist };
35 | export { Thumbnail as Thumbnail };
36 | export { Badge as Badge };
37 | export { CommentSectionContinuatedList as CommentSectionContinuatedList };
38 | export { Comment as Comment };
39 | export { CommentThread as CommentThread };
40 | export { CommentThreadRepliesContinuatedList as CommentThreadRepliesContinuatedList };
41 | export { CaptionTrack as CaptionTrack };
42 | export { List as List };
43 | export { SearchProposal as SearchProposal };
44 | export { Format as Format };
45 | export { HTTPRequestMethod as HTTPRequestMethod };
46 | export { HTTPRequestOptions as HTTPRequestOptions };
47 | export { HTTPResponse as HTTPResponse };
48 | export { SponsorBlockSegment as SponsorBlockSegment };
49 | export declare const nodeDefault: () => Promise<IYoutube>;
50 | 


--------------------------------------------------------------------------------
/output/main.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 3 |     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 4 |     return new (P || (P = Promise))(function (resolve, reject) {
 5 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 6 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 7 |         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 8 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
 9 |     });
10 | };
11 | Object.defineProperty(exports, "__esModule", { value: true });
12 | exports.nodeDefault = exports.HTTPRequestMethod = exports.List = exports.CommentThreadRepliesContinuatedList = exports.CommentThread = exports.Comment = exports.CommentSectionContinuatedList = exports.Playlist = exports.Video = exports.Channel = exports.Authenticator = exports.ContinuatedList = exports.User = exports.Explorer = exports.WrappedHTTPClient = exports.IYoutube = void 0;
13 | const Explorer_1 = require("./fetchers/Explorer");
14 | Object.defineProperty(exports, "Explorer", { enumerable: true, get: function () { return Explorer_1.Explorer; } });
15 | const ContinuatedList_1 = require("./fetchers/ContinuatedList");
16 | Object.defineProperty(exports, "ContinuatedList", { enumerable: true, get: function () { return ContinuatedList_1.ContinuatedList; } });
17 | const User_1 = require("./fetchers/User");
18 | Object.defineProperty(exports, "User", { enumerable: true, get: function () { return User_1.User; } });
19 | const Authenticator_1 = require("./Authenticator");
20 | Object.defineProperty(exports, "Authenticator", { enumerable: true, get: function () { return Authenticator_1.Authenticator; } });
21 | const Channel_1 = require("./interfaces/Channel");
22 | Object.defineProperty(exports, "Channel", { enumerable: true, get: function () { return Channel_1.Channel; } });
23 | const Video_1 = require("./interfaces/Video");
24 | Object.defineProperty(exports, "Video", { enumerable: true, get: function () { return Video_1.Video; } });
25 | const Playlist_1 = require("./interfaces/Playlist");
26 | Object.defineProperty(exports, "Playlist", { enumerable: true, get: function () { return Playlist_1.Playlist; } });
27 | const CommentSectionContinuatedList_1 = require("./fetchers/CommentSectionContinuatedList");
28 | Object.defineProperty(exports, "CommentSectionContinuatedList", { enumerable: true, get: function () { return CommentSectionContinuatedList_1.CommentSectionContinuatedList; } });
29 | const Comment_1 = require("./interfaces/Comment");
30 | Object.defineProperty(exports, "Comment", { enumerable: true, get: function () { return Comment_1.Comment; } });
31 | const CommentThread_1 = require("./interfaces/CommentThread");
32 | Object.defineProperty(exports, "CommentThread", { enumerable: true, get: function () { return CommentThread_1.CommentThread; } });
33 | const WrappedHTTPClient_1 = require("./WrappedHTTPClient");
34 | Object.defineProperty(exports, "WrappedHTTPClient", { enumerable: true, get: function () { return WrappedHTTPClient_1.WrappedHTTPClient; } });
35 | const CommentThreadRepliesContinuatedList_1 = require("./fetchers/CommentThreadRepliesContinuatedList");
36 | Object.defineProperty(exports, "CommentThreadRepliesContinuatedList", { enumerable: true, get: function () { return CommentThreadRepliesContinuatedList_1.CommentThreadRepliesContinuatedList; } });
37 | const List_1 = require("./interfaces/List");
38 | Object.defineProperty(exports, "List", { enumerable: true, get: function () { return List_1.List; } });
39 | const IYoutube_1 = require("./IYoutube");
40 | Object.defineProperty(exports, "IYoutube", { enumerable: true, get: function () { return IYoutube_1.default; } });
41 | const HTTPClient_1 = require("./interfaces/HTTPClient");
42 | Object.defineProperty(exports, "HTTPRequestMethod", { enumerable: true, get: function () { return HTTPClient_1.HTTPRequestMethod; } });
43 | const nodeDefault = () => __awaiter(void 0, void 0, void 0, function* () {
44 |     const path = "./nodeDefault";
45 |     const res = yield Promise.resolve().then(() => require(path));
46 |     return res.default;
47 | });
48 | exports.nodeDefault = nodeDefault;
49 | 


--------------------------------------------------------------------------------
/output/nodeDefault.d.ts:
--------------------------------------------------------------------------------
1 | import { IYoutube } from "./main";
2 | declare const _default: IYoutube;
3 | export default _default;
4 | 


--------------------------------------------------------------------------------
/output/nodeDefault.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | const NodeFetchClientAdapter_1 = require("./adapters/NodeFetchClientAdapter");
4 | const NodeFSStorageAdapter_1 = require("./adapters/NodeFSStorageAdapter");
5 | const path = require("path");
6 | const main_1 = require("./main");
7 | exports.default = new main_1.IYoutube(new NodeFetchClientAdapter_1.NodeFetchClientAdapter(), new NodeFSStorageAdapter_1.NodeFSStorageAdapater(path.resolve(__dirname, "../datastorage")));
8 | 


--------------------------------------------------------------------------------
/output/nodeInst.d.ts:
--------------------------------------------------------------------------------
1 | import { IYoutube } from "./main";
2 | declare const _default: IYoutube;
3 | export default _default;
4 | 


--------------------------------------------------------------------------------
/output/nodeInst.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | const NodeFetchClientAdapter_1 = require("./adapters/NodeFetchClientAdapter");
4 | const NodeFSStorageAdapter_1 = require("./adapters/NodeFSStorageAdapter");
5 | const path = require("path");
6 | const main_1 = require("./main");
7 | exports.default = new main_1.IYoutube(new NodeFetchClientAdapter_1.NodeFetchClientAdapter(), new NodeFSStorageAdapter_1.NodeFSStorageAdapater(path.resolve(__dirname, "../datastorage")));
8 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "iyoutube",
 3 |     "version": "0.0.34",
 4 |     "description": "The ultimate unofficial YouTube API Client for Javascript",
 5 |     "main": "output/main.js",
 6 |     "types": "output/main.d.ts",
 7 |     "scripts": {
 8 |         "test": "npm run compile && node test/test.js",
 9 |         "testignored": "npm run compile && node test/testIgnored.js",
10 |         "compile": "tsc",
11 |         "simplepublish": "npm version patch -m 'Fix' && npm publish --access=public ./ && git push"
12 |     },
13 |     "keywords": [
14 |         "youtube",
15 |         "yt",
16 |         "youtubeapi",
17 |         "youtube-api",
18 |         "innertube",
19 |         "innertubeapi",
20 |         "inntertube-api",
21 |         "youtubei",
22 |         "iyoutube",
23 |         "googleapi",
24 |         "google-api",
25 |         "api",
26 |         "ytlike",
27 |         "like",
28 |         "ytdislike",
29 |         "dislike",
30 |         "ytcomment",
31 |         "comment",
32 |         "ytsearch",
33 |         "search",
34 |         "unofficial",
35 |         "dirty"
36 |     ],
37 |     "author": "",
38 |     "license": "ISC",
39 |     "dependencies": {
40 |         "node-fetch": "^2.6.7",
41 |         "ts-node": "^10.7.0",
42 |         "typescript": "^4.6.3"
43 |     },
44 |     "devDependencies": {
45 |         "nodemon": "^2.0.15"
46 |     },
47 |     "repository": {
48 |         "type": "git",
49 |         "url": "https://github.com/ToBiDi0410/IYoutube"
50 |     }
51 | }


--------------------------------------------------------------------------------
/src/Authenticator.ts:
--------------------------------------------------------------------------------
  1 | import { CONSOLE_COLORS, DEBUG, DEFAULT_USER_AGENT } from "./constants";
  2 | import { HTTPClient, HTTPRequestMethod } from "./interfaces/HTTPClient";
  3 | import { StorageAdapter } from "./interfaces/StorageAdapter";
  4 | 
  5 | // Extracted from Youtube APP (Originally from: pytube)
  6 | const CLIENT_ID = "861556708454-d6dlm3lh05idd8npek18k6be8ba3oc68.apps.googleusercontent.com";
  7 | const CLIENT_SECRET = "SboVhoG9s0rNafixCSGGKXAT";
  8 | 
  9 | export class Authenticator {
 10 |     httpClient : HTTPClient;
 11 |     storageAdapter : StorageAdapter;
 12 | 
 13 |     token:any = {
 14 |         access: "NULL",
 15 |         refresh: "NULL",
 16 |         type: "NULL",
 17 |         expireDate: new Date()
 18 |     };
 19 | 
 20 |     constructor(httpclient : HTTPClient, storage : StorageAdapter) {
 21 |         this.httpClient = httpclient;
 22 |         this.storageAdapter = storage;
 23 |     }
 24 | 
 25 |     async init() {
 26 |         if(DEBUG) console.log(CONSOLE_COLORS.fg.cyan + "[AUTHENTICATOR] Initializing Authenticator...", CONSOLE_COLORS.reset);
 27 | 
 28 |         if((await this.storageAdapter.exists(TOKEN_FILE))) {
 29 |             if(DEBUG) console.log(CONSOLE_COLORS.fg.magenta + "[AUTHENTICATOR] Found Token File in Storage, reading it...", CONSOLE_COLORS.reset);
 30 |             var str = await this.storageAdapter.get(TOKEN_FILE);
 31 |             if(str) {
 32 |                 this.token = JSON.parse(str);
 33 |                 if(DEBUG) console.log(CONSOLE_COLORS.bright + CONSOLE_COLORS.fg.green + "[AUTHENTICATOR] Now using Token from Storage (expires: " + new Date(this.token.expireDate).toLocaleString() + ")", CONSOLE_COLORS.reset);
 34 |             }
 35 |         }
 36 |     }
 37 | 
 38 |     requiresLogin() {
 39 |         return Object.values(this.token).includes("NULL");
 40 |     }
 41 | 
 42 |     async getNewLoginCode() {
 43 |         const res = await this.httpClient.request({
 44 |             url: "https://oauth2.googleapis.com/device/code",
 45 |             method: HTTPRequestMethod.POST,
 46 |             data: JSON.stringify({
 47 |                 client_id: CLIENT_ID,
 48 |                 scope: "https://www.googleapis.com/auth/youtube"
 49 |             }),
 50 |             headers: {
 51 |                 "content-type": "text/plain;charset=UTF-8",
 52 |                 "user-agent": DEFAULT_USER_AGENT
 53 |             }
 54 |         });
 55 |         if(res.status != 200) throw new Error("Failed to get new Google Login Code");
 56 | 
 57 |         const resJSON:any = JSON.parse(res.data);
 58 |         if(DEBUG) console.log(CONSOLE_COLORS.bright + CONSOLE_COLORS.fg.yellow + "[AUTHENTICATOR] Started Authentication Method: Device Code", CONSOLE_COLORS.reset);
 59 |         return { userCode: resJSON.user_code, deviceCode: resJSON.device_code, userUrl: resJSON.verification_url, expiresIn: resJSON.expires_in, interval: 5 };
 60 |     }
 61 | 
 62 |     async loadTokensWithDeviceCode(deviceCode: string) {
 63 |         var res:any;
 64 |         while(!res || !res.refresh_token) {
 65 |             try {
 66 |                 res = await this.httpClient.request({
 67 |                     method: HTTPRequestMethod.POST,
 68 |                     url: "https://oauth2.googleapis.com/token",
 69 |                     data: JSON.stringify({
 70 |                         client_id: CLIENT_ID,
 71 |                         client_secret: CLIENT_SECRET,
 72 |                         device_code: deviceCode,
 73 |                         grant_type: "urn:ietf:params:oauth:grant-type:device_code"
 74 |                     }),
 75 |                     headers: {
 76 |                         "content-type": "text/plain;charset=UTF-8",
 77 |                         "user-agent": DEFAULT_USER_AGENT
 78 |                     }
 79 |                 });
 80 |                 res = JSON.parse(res.data);
 81 |                 await new Promise(resolve => setTimeout(resolve, 5000));
 82 |             } catch(err) {
 83 |                 if(DEBUG) console.log("[AUTHENTICATOR] Failed to recieve Token with Code:\n", err);
 84 |             }
 85 |             
 86 |         }
 87 | 
 88 |         this.token = { type: null, access: null, refresh: res.refresh_token, expireDate: null };
 89 |         if(DEBUG) console.log(CONSOLE_COLORS.bright + CONSOLE_COLORS.fg.yellow + "[AUTHENTICATOR] Authentication Method successfull: Device Code", CONSOLE_COLORS.reset);
 90 |         await this.getToken();
 91 |     }
 92 | 
 93 |     async getToken() {
 94 |         if(this.token.access == null || (Date.now() - this.token.expireDate) > 0) {
 95 |             let res:any = await this.httpClient.request({
 96 |                 method: HTTPRequestMethod.POST,
 97 |                 url: "https://oauth2.googleapis.com/token",
 98 |                 data: JSON.stringify({
 99 |                     client_id: CLIENT_ID,
100 |                     client_secret: CLIENT_SECRET,
101 |                     grant_type: "refresh_token",
102 |                     refresh_token: this.token.refresh
103 |                 }),
104 |                 headers: {
105 |                     "content-type": "text/plain;charset=UTF-8",
106 |                     "user-agent": DEFAULT_USER_AGENT
107 |                 }
108 |             });
109 |             res = JSON.parse(res.data);
110 |             this.token = { type: res.token_type, access: res.access_token, refresh: this.token.refresh, expireDate: (new Date().getTime() + 1000 * res.expires_in) };
111 |             if(DEBUG) console.log(CONSOLE_COLORS.bright + CONSOLE_COLORS.fg.green + "[AUTHENTICATOR] Refreshed the Access Token using the refresh Token", CONSOLE_COLORS.reset);
112 |             await this.storageAdapter.set(TOKEN_FILE, JSON.stringify({...this.token }));
113 |             if(DEBUG) console.log(CONSOLE_COLORS.bright + CONSOLE_COLORS.fg.yellow + "[AUTHENTICATOR] Current Token written to Storage", CONSOLE_COLORS.reset);
114 |         }
115 |         return this.token;
116 |     }
117 | 
118 |     async getAuthorizationHeader() {
119 |         var currentToken:any = await this.getToken();
120 |         return currentToken.type + " " + currentToken.access;
121 |     }
122 | }
123 | 
124 | const TOKEN_FILE = "IYoutubeTokens.json";
125 | 
126 | //Data needs to be strigified because we are working with the raw HTTPClient, not the WrappedHTTPClient


--------------------------------------------------------------------------------
/src/IYoutube.ts:
--------------------------------------------------------------------------------
  1 | import { Authenticator } from "./Authenticator";
  2 | import { HTTPClient, HTTPRequestMethod } from "./interfaces/HTTPClient";
  3 | import { StorageAdapter } from "./interfaces/StorageAdapter";
  4 | import { WrappedHTTPClient } from "./WrappedHTTPClient";
  5 | 
  6 | import { SearchConitinuatedList, SearchType } from "./fetchers/SearchContinuatedList";
  7 | import { Explorer } from "./fetchers/Explorer";
  8 | import { ContinuatedList } from "./fetchers/ContinuatedList";
  9 | import { User } from "./fetchers/User";
 10 | import { Playlist } from "./interfaces/Playlist";
 11 | import { DEBUG, ENDPOINT_BROWSE, ENDPOINT_SEARCH_SUGGEST } from "./constants";
 12 | import { Channel, SearchProposal, Video } from "./main";
 13 | import helpers from "./fetchers/helpers";
 14 | 
 15 | export default class IYoutube {
 16 | 
 17 |     rawHttpClient: HTTPClient;
 18 |     wrappedHttpClient: WrappedHTTPClient;
 19 | 
 20 |     storageAdapter : StorageAdapter;
 21 |     authenticator: Authenticator;
 22 | 
 23 |     explorer : Explorer;
 24 |     user : User;
 25 | 
 26 |     constructor(httpClient : HTTPClient, storageAdapater : StorageAdapter) {
 27 |         this.rawHttpClient = httpClient;
 28 |         this.wrappedHttpClient = new WrappedHTTPClient(this.rawHttpClient);
 29 |         this.storageAdapter = storageAdapater;
 30 | 
 31 |         this.authenticator = new Authenticator(this.rawHttpClient, this.storageAdapter);
 32 |         this.wrappedHttpClient.authorizationHeaderCallback = () => { return this.authenticator.getAuthorizationHeader() };
 33 | 
 34 |         this.explorer = new Explorer(this.wrappedHttpClient, this);
 35 |         this.user = new User(this.wrappedHttpClient, this);
 36 |     }
 37 | 
 38 |     async init() {
 39 |         if(DEBUG) console.log("");
 40 |         await this.authenticator.init();
 41 |     }
 42 | 
 43 |     async search(term: string, type : SearchType):Promise<ContinuatedList> {
 44 |         this.throwErrorIfNotReady();
 45 |         var list = new SearchConitinuatedList(term, type, this.wrappedHttpClient);
 46 |         return list;
 47 |     }
 48 | 
 49 |     async searchProposals(term: string):Promise<Array<SearchProposal>> {
 50 |         this.throwErrorIfNotReady();
 51 |         const url = new URL(ENDPOINT_SEARCH_SUGGEST);
 52 |         url.searchParams.set("client", "youtube");
 53 |         url.searchParams.set("gs_ri", "youtube");
 54 |         url.searchParams.set("ds", "yt");
 55 |         url.searchParams.set("q", term);
 56 | 
 57 |         const result = await this.rawHttpClient.request({
 58 |             url: url.toString(),
 59 |             method: HTTPRequestMethod.GET,
 60 |         });
 61 | 
 62 |         const resultJSONText = result.data.split("(")[1].split(")")[0];
 63 |         const resultsJSON = await JSON.parse(resultJSONText)[1];
 64 |         const finalResults = resultsJSON.map((a:any) => ({ text: a[0] }));
 65 |         return finalResults;
 66 |     }
 67 | 
 68 |     async getPlaylist(playlistId: string):Promise<Playlist> {
 69 |         this.throwErrorIfNotReady();
 70 |         var pl = new Playlist(this.wrappedHttpClient);
 71 |         pl.playlistId = playlistId;
 72 |         await pl.loadAll();
 73 |         return pl;
 74 |     }
 75 | 
 76 |     async getChannel(channelId: string):Promise<Channel> {
 77 |         this.throwErrorIfNotReady();
 78 |         var ch = new Channel(this.wrappedHttpClient);
 79 |         ch.channelId = channelId;
 80 |         await ch.loadAll();
 81 |         return ch;
 82 |     }
 83 | 
 84 |     async getVideo(videoId: string):Promise<Video> {
 85 |         this.throwErrorIfNotReady();
 86 |         var v = new Video(this.wrappedHttpClient);
 87 |         v.videoId = videoId;
 88 |         await v.loadAll();
 89 |         return v;
 90 |     }
 91 | 
 92 |     getWhatToWatch():ContinuatedList {
 93 |         return new ContinuatedList({
 94 |             url: ENDPOINT_BROWSE,
 95 |             method: HTTPRequestMethod.POST,
 96 |             data: {
 97 |                 browseId: "FEwhat_to_watch"
 98 |             }
 99 |         }, (data:any) => {
100 |             const renderers = helpers.recursiveSearchForKey("richItemRenderer", data);
101 |             let contents = helpers.recursiveSearchForKey("content", renderers);
102 |             contents = contents.flat(1);
103 |             return contents;
104 |         }, this.wrappedHttpClient, true);
105 |     }
106 | 
107 |     getExplorer():Explorer {
108 |         return this.explorer;
109 |     }
110 | 
111 |     getUser():User {
112 |         return this.user;
113 |     }
114 | 
115 |     getCookies() {
116 |         return this.wrappedHttpClient.cookieString;
117 |     }
118 | 
119 |     throwErrorIfNotReady(){
120 |         if(!this.storageAdapter) throw new Error("The provided Storage Adapter was invalid");
121 |         if(!this.rawHttpClient) throw new Error("The provided HTTP Client was invalid");
122 |         if(this.authenticator.requiresLogin()) throw new Error("This Instance of IYoutube is not authenticated");
123 |     }
124 | }


--------------------------------------------------------------------------------
/src/WrappedHTTPClient.ts:
--------------------------------------------------------------------------------
  1 | import { CONSOLE_COLORS, DEBUG, DEFAULT_API_KEY, DEFAULT_CLIENT_NAME, DEFAULT_CLIENT_VERSION, DEFAULT_CONTEXT, DEFAULT_USER_AGENT } from "./constants";
  2 | import { HTTPClient, HTTPMap, HTTPRequestOptions } from "./interfaces/HTTPClient";
  3 | 
  4 | export class WrappedHTTPClient {
  5 |     client : HTTPClient;
  6 |     headers : HTTPMap;
  7 |     authorizationHeaderCallback?: Function;
  8 |     cookieString = "";
  9 | 
 10 |     constructor(client : HTTPClient) {
 11 |         this.client = client;
 12 |         this.headers = new Object();
 13 |     }
 14 | 
 15 |     async request(options : HTTPRequestOptions) {
 16 |         //If there are no Headers or Parameters, add an empty array
 17 |         if(!options.params) options.params = new Object();
 18 |         if(!options.headers) options.headers = new Object();
 19 | 
 20 |         //Add Headers
 21 |         options.headers["x-youtube-client-version"] = DEFAULT_CLIENT_VERSION;
 22 |         options.headers["x-youtube-client-name"] = DEFAULT_CLIENT_NAME;
 23 |         options.headers["user-agent"] = DEFAULT_USER_AGENT;
 24 |         options.headers["cookie"] = this.cookieString;
 25 |         options.headers = {...options.headers, ...this.headers};
 26 | 
 27 |         //Set Authorization Headers or Key
 28 |         if(this.authorizationHeaderCallback) options.headers["Authorization"] = await this.authorizationHeaderCallback();
 29 |         else options.params["key"] = DEFAULT_API_KEY;
 30 | 
 31 |         //Create URL String with Parameters
 32 |         const finalURL = new URL(options.url);
 33 |         if(options.params) 
 34 |             for(const [key, value] of Object.entries(options.params) as any)
 35 |                 finalURL.searchParams.set(key, value.toString());
 36 |         options.url = finalURL.toString();
 37 | 
 38 |         //Add Default Context to Body
 39 |         if(typeof options.data == 'object') options.data.context = {... DEFAULT_CONTEXT, ...options.data.context};
 40 | 
 41 |         //Convert the passed Object Body to JSON String Body
 42 |         if(typeof options.data != 'string') {
 43 |             options.data = JSON.stringify(options.data);
 44 |             options.headers["Content-Type"] = "application/json";
 45 |         }
 46 |       
 47 |         //Request using the HTTPClient
 48 |         if(DEBUG) console.log(CONSOLE_COLORS.fg.cyan + "[WHTTPCLIENT] Requesting Data from Endpoint: " + options.url.toString(), CONSOLE_COLORS.reset);
 49 |         var res = await this.client.request(options);
 50 |         if(DEBUG) console.log(CONSOLE_COLORS.fg.cyan + "[WHTTPCLIENT] Got respone with Code: " + res.status, CONSOLE_COLORS.reset);
 51 | 
 52 |         //Parse Recieved Cookies and save them
 53 |         if(res.headers["set-cookie"]) {
 54 |             var newCookies = parseCookies(res.headers["set-cookie"]);
 55 |             if(DEBUG) console.log(CONSOLE_COLORS.fg.magenta + "[WHTTPCLIENT] Recieved new Cookies: " + Object.keys(newCookies).join(", "), CONSOLE_COLORS.reset);
 56 | 
 57 |             if(newCookies["CONSENT"]) {
 58 |                 newCookies["CONSENT"] = "YES+cb.20210328-17-p0.en+FX+" + newCookies["CONSENT"].split("+")[1];
 59 |                 if(DEBUG) console.log(CONSOLE_COLORS.bright + CONSOLE_COLORS.fg.green + "[WHTTPCLIENT] Accepted Consent and modified Cookie: " + newCookies["CONSENT"], CONSOLE_COLORS.reset);
 60 |             }
 61 |             this.cookieString = joinCookies(newCookies, this.cookieString);
 62 |         }
 63 | 
 64 |         //Detect if Youtube knows this is a dirty Client
 65 |         if(res.data.includes("STATE_TAG_BROWSE_INSTRUCTION_MARK_AS_DIRTY")) 
 66 |             if(DEBUG) console.warn(CONSOLE_COLORS.fg.yellow + "[WHTTPCLIENT] Youtube detected this as a dirty client!", CONSOLE_COLORS.reset);
 67 | 
 68 |         return res;
 69 |     }
 70 | }
 71 | 
 72 | var ignoreCookieData = ["expires", "path", "domain", "priority"]
 73 | function parseCookies(str : string) {
 74 |     const pairs = str.split(";");
 75 |     let pairArrays = pairs.map(v => v.split("="));
 76 |     pairArrays.forEach((obj:any) => obj[0] = obj[0].replaceAll(" ", ""));
 77 |     pairArrays = pairArrays.filter((obj:any) => { return obj[0].length > 0 && !ignoreCookieData.includes(obj[0])});
 78 | 
 79 |     const pairsObject:any = new Object();
 80 |     for(const pairArray of pairArrays) {
 81 |         pairsObject[pairArray[0]] = pairArray[1];
 82 |     }
 83 |     return pairsObject;
 84 | }
 85 | 
 86 | function serializeCookies(obj: any) {
 87 |     let cookieString = "";
 88 |     for(const [key, value] of Object.entries(obj) as any) {
 89 |         if(key != null && key.length > 0) {
 90 |             const partString = (key + "=" + (value ? value : '') + "; ");
 91 |             cookieString += partString;
 92 |         }
 93 |     }
 94 | 
 95 |     cookieString = cookieString.trimEnd();
 96 |     return cookieString;
 97 | }
 98 | 
 99 | function joinCookies(str1: string | any, str2: string | any) {
100 |     const resObj = {
101 |         ... (typeof str1 == 'string' ? parseCookies(str1) : str1),
102 |         ... (typeof str2 == 'string' ? parseCookies(str2) : str2)
103 |     };
104 |     const resString = serializeCookies(resObj);
105 |     return resString;
106 | }


--------------------------------------------------------------------------------
/src/adapters/NodeFSStorageAdapter.ts:
--------------------------------------------------------------------------------
 1 | import { StorageAdapter } from "../interfaces/StorageAdapter";
 2 | import * as fs from 'fs';
 3 | import * as path from 'path';
 4 | /**
 5 |  * An Adapter for the Node FS Api, so that it can be used as Storage Adapter with
 6 |  * the IYoutube Client
 7 |  */
 8 | export class NodeFSStorageAdapater implements StorageAdapter {
 9 | 
10 |     basePath : string;
11 | 
12 |     constructor(basePath:string) {
13 |         this.basePath = basePath;
14 |         fs.mkdirSync(basePath, { recursive: true });
15 |     }
16 | 
17 |     async set(paths: string, value: string) {
18 |         try {
19 |             fs.writeFileSync(path.join(this.basePath, paths), value, { encoding: 'utf-8' });
20 |             return true;
21 |         } catch (err) {
22 |             return false;
23 |         }
24 |     }
25 | 
26 |     async get(paths: string) {
27 |         return fs.readFileSync(path.join(this.basePath, paths), { encoding: 'utf-8' }).toString();
28 |     }
29 | 
30 |     async exists(paths: string) {
31 |         return fs.existsSync(path.join(this.basePath, paths));
32 |     }
33 |     
34 | }


--------------------------------------------------------------------------------
/src/adapters/NodeFetchClientAdapter.ts:
--------------------------------------------------------------------------------
 1 | import { HTTPClient, HTTPRequestOptions } from "../interfaces/HTTPClient";
 2 | const fetch = require("node-fetch");
 3 | 
 4 | /**
 5 |  * An Adapter for the Node-Fetch Client, so that it can be used as HTTPClient with
 6 |  * the IYoutube Client
 7 |  */
 8 | export class NodeFetchClientAdapter implements HTTPClient {
 9 | 
10 |     async request(options:HTTPRequestOptions) {
11 |         var res = await fetch(options.url, {
12 |             headers: options.headers,
13 |             method: options.method,
14 |             body: options.data,
15 |         });
16 | 
17 |         const refactoredHeaders:any = new Object();
18 |         for (var pair of res.headers.entries() as any) {
19 |             refactoredHeaders[pair[0]] = pair[1]
20 |         }
21 | 
22 |         return {
23 |             status: res.status,
24 |             data: await res.text(),
25 |             headers: refactoredHeaders
26 |         };
27 |     }
28 | }


--------------------------------------------------------------------------------
/src/constants.ts:
--------------------------------------------------------------------------------
 1 | export const DEBUG = false;
 2 | export const DEFAULT_API_KEY = "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8";
 3 | export const DEFAULT_CLIENT_VERSION = "2.20220406.09.00";
 4 | export const DEFAULT_CLIENT_NAME = "1";
 5 | export const DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.75 Safari/537.36";
 6 | export const DEFAULT_CONTEXT = {
 7 |     client: {
 8 |         clientName: "WEB",
 9 |         clientVersion: DEFAULT_CLIENT_VERSION,
10 |         hl: "en",
11 |         gl: "DE",
12 |         userAgent: DEFAULT_USER_AGENT,
13 |         utcOffsetMinutes: "0"
14 |     },
15 |     request: {
16 |         useSsl: "true",
17 |         internalExperimentFlags: [],
18 |         consistencyTokenJars: [],
19 |     }
20 | }
21 | 
22 | export const CONSOLE_COLORS = {
23 |     reset: "\x1b[0m",
24 |     bright: "\x1b[1m",
25 |     dim: "\x1b[2m",
26 |     underscore: "\x1b[4m",
27 |     blink: "\x1b[5m",
28 |     reverse: "\x1b[7m",
29 |     hidden: "\x1b[8m",
30 |     
31 |     fg: {
32 |         black: "\x1b[30m",
33 |         red: "\x1b[31m",
34 |         green: "\x1b[32m",
35 |         yellow: "\x1b[33m",
36 |         blue: "\x1b[34m",
37 |         magenta: "\x1b[35m",
38 |         cyan: "\x1b[36m",
39 |         white: "\x1b[37m",
40 |         crimson: "\x1b[38m"
41 |     },
42 |     bg: {
43 |         black: "\x1b[40m",
44 |         red: "\x1b[41m",
45 |         green: "\x1b[42m",
46 |         yellow: "\x1b[43m",
47 |         blue: "\x1b[44m",
48 |         magenta: "\x1b[45m",
49 |         cyan: "\x1b[46m",
50 |         white: "\x1b[47m",
51 |         crimson: "\x1b[48m"
52 |     }
53 | };
54 | 
55 | /* Endpoints */
56 | export const ENDPOINT_BROWSE = "https://www.youtube.com/youtubei/v1/browse";
57 | export const ENDPOINT_SEARCH = "https://www.youtube.com/youtubei/v1/search";
58 | export const ENDPOINT_LIKE = "https://www.youtube.com/youtubei/v1/like/like";
59 | export const ENDPOINT_DISLIKE = "https://www.youtube.com/youtubei/v1/like/dislike";
60 | export const ENDPOINT_REMOVELIKE = "https://www.youtube.com/youtubei/v1/like/removelike";
61 | export const ENDPOINT_SUBSCRIBE = "https://www.youtube.com/youtubei/v1/subscription/subscribe";
62 | export const ENDPOINT_UNSUBSCRIBE = "https://www.youtube.com/youtubei/v1/subscription/unsubscribe";
63 | export const ENDPOINT_ADDTOPLAYLIST = "https://www.youtube.com/youtubei/v1/playlist/get_add_to_playlist";
64 | export const ENDPOINT_NEXT = "https://www.youtube.com/youtubei/v1/next";
65 | export const ENDPOINT_COMMENT_ACTION = "https://www.youtube.com/youtubei/v1/comment/perform_comment_action";
66 | export const ENDPOINT_PLAYER = "https://www.youtube.com/youtubei/v1/player";
67 | export const ENDPOINT_COMMENT_CREATE = "https://www.youtube.com/youtubei/v1/comment/create_comment";
68 | export const ENDPOINT_SEARCH_SUGGEST = "https://clients1.google.com/complete/search";
69 | export const ENDPOINT_WATCHPAGE = "https://www.youtube.com/watch";
70 | export const ENDPOINT_RATING = "https://returnyoutubedislikeapi.com/Votes";
71 | export const ENDPOINT_SPONSORBLOCK_SKIPSEGMENTS = "https://sponsor.ajay.app/api/skipSegments";
72 | 
73 | /* Error */
74 | export const ERROR_DATA_INVALID_FORMAT = new Error("The Data recieved from the Google API seems to have an invalid format. It might be that Google updated their APIs and this Method no longer Works");


--------------------------------------------------------------------------------
/src/fetchers/CommentSectionContinuatedList.ts:
--------------------------------------------------------------------------------
 1 | import { ENDPOINT_NEXT } from "../constants";
 2 | import { HTTPRequestMethod } from "../interfaces/HTTPClient";
 3 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 4 | import { ContinuatedList } from "./ContinuatedList";
 5 | import helpers from "./helpers";
 6 | 
 7 | export class CommentSectionContinuatedList extends ContinuatedList {
 8 |     constructor(initialContinuationToken : string, httpclient: WrappedHTTPClient) {
 9 |         super(
10 |             /* Request Options */
11 |             {
12 |                 url: ENDPOINT_NEXT,
13 |                 method: HTTPRequestMethod.POST,
14 |             },
15 |             
16 |             /* Processor */
17 |             async function(resJSON:any) {
18 |                 const continuationItems = helpers.recursiveSearchForKey("continuationItems", resJSON)[1];
19 |                 return continuationItems;
20 |             },
21 |             
22 |             /* Http Client */
23 |             httpclient, false);
24 |         this.continuationToken = initialContinuationToken;
25 |     }
26 | }


--------------------------------------------------------------------------------
/src/fetchers/CommentThreadRepliesContinuatedList.ts:
--------------------------------------------------------------------------------
 1 | import { ENDPOINT_NEXT } from "../constants";
 2 | import { HTTPRequestMethod } from "../interfaces/HTTPClient";
 3 | import { ContinuatedList, WrappedHTTPClient } from "../main";
 4 | import helpers from "./helpers";
 5 | 
 6 | export class CommentThreadRepliesContinuatedList extends ContinuatedList {
 7 | 
 8 |     constructor(initialContinuationToken : string, httpclient : WrappedHTTPClient) {
 9 |         super(
10 |             /* Request Options */
11 |             {
12 |                 url: ENDPOINT_NEXT,
13 |                 method: HTTPRequestMethod.POST,
14 |             },
15 |             
16 |             /* Processor */
17 |             async function(resJSON:any) {
18 |                 const continuationItems = helpers.recursiveSearchForKey("continuationItems", resJSON)[0];
19 |                 return continuationItems;
20 |             },
21 |             
22 |             /* Http Client */
23 |             httpclient, false);
24 |         this.continuationToken = initialContinuationToken;
25 |     }
26 | }


--------------------------------------------------------------------------------
/src/fetchers/ContinuatedList.ts:
--------------------------------------------------------------------------------
 1 | import helpers from "./helpers";
 2 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 3 | import { HTTPRequestOptions } from "../interfaces/HTTPClient";
 4 | import { List } from "../interfaces/List";
 5 | 
 6 | export class ContinuatedList extends List {
 7 | 
 8 |     endReached = false;
 9 |     requestOptions: HTTPRequestOptions;
10 |     httpclient: WrappedHTTPClient;
11 |     dataprocessor: Function;
12 |     continuationToken = "";
13 |     onlyContinuation = false;
14 | 
15 |     constructor(requestOptions: HTTPRequestOptions, dataprocessor: Function, httpclient : WrappedHTTPClient, onlyContinuation?:boolean) {
16 |         super();
17 |         this.requestOptions = requestOptions;
18 |         this.httpclient = httpclient;
19 |         this.dataprocessor = dataprocessor;
20 |         if(this.onlyContinuation) this.onlyContinuation = onlyContinuation as boolean;
21 |     }
22 | 
23 |     async loadFurhter() {
24 |         if(this.endReached) return [];
25 |         var joinedData = this.requestOptions.data;
26 |         if(!joinedData) joinedData = {};
27 |         if(this.continuationToken != "") {
28 |             joinedData.continuation = this.continuationToken;
29 |             if(this.onlyContinuation) joinedData = {
30 |                 continuation: this.continuationToken
31 |             }
32 |         }
33 | 
34 |         var res = await this.httpclient.request({
35 |             method: this.requestOptions.method,
36 |             url: this.requestOptions.url,
37 |             data: joinedData,
38 |             headers: this.requestOptions.headers ? this.requestOptions.headers : {},
39 |             params: this.requestOptions.params ? this.requestOptions.params : {},
40 |         });
41 |         const resJSON = await JSON.parse(res.data);
42 | 
43 |         const continuationCommand = helpers.recursiveSearchForKey("continuationCommand", resJSON)[0];
44 |         if(continuationCommand) this.continuationToken = continuationCommand.token;
45 |         else this.endReached = true;
46 | 
47 |         let items = await this.dataprocessor(resJSON);
48 |         items = helpers.processRendererItems(items, this.httpclient);
49 |         this.results = this.results.concat(items);
50 |         return items;
51 |     }
52 | }


--------------------------------------------------------------------------------
/src/fetchers/Explorer.ts:
--------------------------------------------------------------------------------
 1 | import { HTTPRequestMethod } from "../interfaces/HTTPClient";
 2 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 3 | import helpers from "./helpers";
 4 | import { Video } from "../interfaces/Video";
 5 | import IYoutube from "../IYoutube";
 6 | import { ENDPOINT_BROWSE } from "../constants";
 7 | 
 8 | export class Explorer {
 9 |     httpclient: WrappedHTTPClient;
10 |     client: IYoutube;
11 | 
12 |     constructor(httpclient : WrappedHTTPClient, client: IYoutube) {
13 |         this.httpclient = httpclient;
14 |         this.client = client;
15 |     }
16 | 
17 |     async getPopularVideos():Promise<Array<Video>> {
18 |         this.client.throwErrorIfNotReady();
19 |         const res = await this.httpclient.request({
20 |             method: HTTPRequestMethod.POST,
21 |             url: ENDPOINT_BROWSE,
22 |             params: {
23 |                 prettyPrint: false
24 |             },
25 |             data: {
26 |                 browseId: "FEexplore"
27 |             }
28 |         });
29 |         const resJSON = await JSON.parse(res.data);
30 |         
31 |         const popularShelf = helpers.recursiveSearchForKey("expandedShelfContentsRenderer", resJSON)[0];
32 |         let items = popularShelf.items;
33 |         items = helpers.processRendererItems(items, this.httpclient);
34 |         return items;
35 |     }
36 | 
37 |     async getTrendsNow():Promise<Array<Video>> {
38 |         this.client.throwErrorIfNotReady();
39 |         const res = await this.httpclient.request({
40 |             method: HTTPRequestMethod.POST,
41 |             url: ENDPOINT_BROWSE,
42 |             params: {
43 |                 prettyPrint: false
44 |             },
45 |             data: {
46 |                 browseId: "FEtrending",
47 |                 params: "6gQJRkVleHBsb3Jl"
48 |             }
49 |         });
50 | 
51 |         const resJSON = await JSON.parse(res.data);
52 | 
53 |         const categorieShelfs:Array<any> = helpers.recursiveSearchForKey("tabs", resJSON)[0];
54 |         const requestedShelf = categorieShelfs.find((a:any) => { return a.tabRenderer.title == "Now" });
55 |         const sectionListRenderer = helpers.recursiveSearchForKey("expandedShelfContentsRenderer", requestedShelf);
56 |         let items = sectionListRenderer.map((a) => ( a.items ));
57 |         items = [...items[0], ...items[1]];
58 |         items = helpers.processRendererItems(items, this.httpclient);
59 |         return items;
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/fetchers/PlaylistContinuatedList.ts:
--------------------------------------------------------------------------------
 1 | import { HTTPRequestMethod } from "../interfaces/HTTPClient";
 2 | import helpers from "./helpers";
 3 | import { ENDPOINT_BROWSE } from "../constants";
 4 | import { Video, WrappedHTTPClient } from "../main";
 5 | import { ContinuatedList } from "./ContinuatedList";
 6 | 
 7 | export class PlaylistContinuatedList extends ContinuatedList {
 8 |     constructor(playlistId : string, httpclient : WrappedHTTPClient) {
 9 |         super(
10 |         /* Request Options */
11 |         {
12 |             url: ENDPOINT_BROWSE,
13 |             method: HTTPRequestMethod.POST,
14 |             data: { 
15 |                 browseId: "VL" + playlistId
16 |             }
17 |         },
18 |         
19 |         /* Processor */
20 |         async function(resJSON:any) {
21 |             const continuationItemsContainer = helpers.recursiveSearchForKey("continuationItems", resJSON)[0];
22 |             if(continuationItemsContainer) {
23 |                 return continuationItemsContainer;
24 |             } else {
25 |                 let itemSectionRenderer = helpers.recursiveSearchForKey("playlistVideoListRenderer", resJSON)[0];
26 |                 const items = helpers.recursiveSearchForKey("contents", itemSectionRenderer)[0];
27 |                 return items;
28 |             }
29 |             
30 |         },
31 |         
32 |         /* Http Client */
33 |         httpclient, true);
34 |     }
35 | }


--------------------------------------------------------------------------------
/src/fetchers/SearchContinuatedList.ts:
--------------------------------------------------------------------------------
 1 | import { HTTPRequestMethod } from "../interfaces/HTTPClient";
 2 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 3 | import helpers from "./helpers";
 4 | import { ContinuatedList } from "./ContinuatedList";
 5 | import { ENDPOINT_SEARCH } from "../constants";
 6 | 
 7 | export class SearchConitinuatedList extends ContinuatedList {
 8 |     constructor(term : string, searchType: SearchType, httpclient : WrappedHTTPClient) {
 9 |         super(
10 |         /* Request Options */
11 |         {
12 |             url: ENDPOINT_SEARCH,
13 |             method: HTTPRequestMethod.POST,
14 |             data: { 
15 |                 query: term,
16 |                 params: searchType
17 |             }
18 |         },
19 |         
20 |         /* Processor */
21 |         async function(resJSON:any) {
22 |             let itemSectionRenderer = helpers.recursiveSearchForKey("itemSectionRenderer", resJSON);
23 |             if(itemSectionRenderer.length > 0) itemSectionRenderer = itemSectionRenderer[itemSectionRenderer.length - 1];
24 |             else itemSectionRenderer = itemSectionRenderer[0];
25 | 
26 |             const items = helpers.recursiveSearchForKey("contents", itemSectionRenderer)[0];
27 |             return items;
28 |         },
29 |         
30 |         /* Http Client */
31 |         httpclient);
32 |     }
33 | }
34 | 
35 | export enum SearchType {
36 |     VIDEO = "EgIQAQ%3D%3D",
37 |     CHANNEL = "EgIQAg%3D%3D",
38 |     PLAYLIST = "EgIQAw%3D%3D",
39 |     MOVIE = "EgIQBA%3D%3D",
40 |     ANY = ""
41 | }


--------------------------------------------------------------------------------
/src/fetchers/SubscriptionFeedContinuatedList.ts:
--------------------------------------------------------------------------------
 1 | import { HTTPRequestMethod } from "../interfaces/HTTPClient";
 2 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 3 | import helpers from "./helpers";
 4 | import { ContinuatedList } from "./ContinuatedList";
 5 | import { ENDPOINT_BROWSE } from "../constants";
 6 | 
 7 | export class SubscriptionFeedContinuatedList extends ContinuatedList {
 8 |     constructor(httpclient : WrappedHTTPClient) {
 9 |         super(
10 |         /* Request Options */
11 |         {
12 |             url: ENDPOINT_BROWSE,
13 |             method: HTTPRequestMethod.POST,
14 |             data: { 
15 |                 browseId: "FEsubscriptions"
16 |              },
17 |             params: {
18 |                 prettyPrint: false
19 |             }
20 |         },
21 |         
22 |         /* Processor */
23 |         async function(resJSON:any) {
24 |             let itemSectionRenderer = helpers.recursiveSearchForKey("itemSectionRenderer", resJSON);
25 |             if(itemSectionRenderer.length > 0) itemSectionRenderer = itemSectionRenderer[itemSectionRenderer.length - 1];
26 |             else itemSectionRenderer = itemSectionRenderer[0];
27 | 
28 |             const gridRenderers = helpers.recursiveSearchForKey("gridRenderer", resJSON);
29 |             let items:any = gridRenderers.map((a:any) => (a.items));
30 |             items = items.flat(1);
31 |             return items;
32 |         },
33 |         
34 |         /* Http Client */
35 |         httpclient);
36 |     }
37 | }


--------------------------------------------------------------------------------
/src/fetchers/User.ts:
--------------------------------------------------------------------------------
 1 | import { Channel, List } from "../main";
 2 | import { ContinuatedList } from "./ContinuatedList";
 3 | import { HTTPRequestMethod } from "../interfaces/HTTPClient";
 4 | import { Playlist } from "../interfaces/Playlist";
 5 | import IYoutube from "../IYoutube";
 6 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
 7 | import helpers from "./helpers";
 8 | import { SubscriptionFeedContinuatedList } from "./SubscriptionFeedContinuatedList";
 9 | import { ENDPOINT_ADDTOPLAYLIST, ENDPOINT_BROWSE, ERROR_DATA_INVALID_FORMAT } from "../constants";
10 | 
11 | export class User {
12 |     httpclient: WrappedHTTPClient;
13 |     client : IYoutube;
14 | 
15 |     constructor(httpclient : WrappedHTTPClient, client: IYoutube) {
16 |         this.httpclient = httpclient;
17 |         this.client = client;
18 |     }
19 | 
20 |     async getPlaylists():Promise<List> {
21 |         this.client.throwErrorIfNotReady();
22 |         const res = await this.httpclient.request({
23 |             method: HTTPRequestMethod.POST,
24 |             url: ENDPOINT_BROWSE,
25 |             params: { prettyPrint: false },
26 |             data: {
27 |                 browseId: "FElibrary"
28 |             }
29 |         });
30 |         const resJSON = await JSON.parse(res.data);
31 | 
32 |         const itemSectionRenderers = helpers.recursiveSearchForKey("itemSectionRenderer", resJSON);
33 |         const playlistItemSectionRenderer = itemSectionRenderers.find((a:any) => { 
34 |             const title = helpers.recursiveSearchForKey("text", helpers.recursiveSearchForKey("shelfRenderer", a)[0].title).join("");
35 |             return title.toLowerCase().includes("playlists");
36 |         });
37 | 
38 |         if(!playlistItemSectionRenderer) throw ERROR_DATA_INVALID_FORMAT;
39 | 
40 |         let items = helpers.recursiveSearchForKey("items", playlistItemSectionRenderer)[0];
41 |         items = helpers.processRendererItems(items, this.httpclient);
42 | 
43 |         return new List(items);
44 |     }
45 | 
46 |     async getEditablePlaylists():Promise<List> {
47 |         this.client.throwErrorIfNotReady();
48 |         const res = await this.httpclient.request({
49 |             method: HTTPRequestMethod.POST,
50 |             url: ENDPOINT_ADDTOPLAYLIST,
51 |             params: { prettyPrint: false },
52 |             data: { 
53 |                 videoIds: ["p2_nQCVPJV8"],
54 |                 excludeWatchLater: true
55 |             }
56 |         });
57 |         const resJSON = await JSON.parse(res.data);
58 | 
59 |         let playlists = helpers.recursiveSearchForKey("playlists", resJSON)[0];
60 |         playlists = playlists.map((a:any) => {
61 |             var playlist = new Playlist(this.httpclient);
62 |             playlist.fromPlaylistAddToOptionRenderer(a.playlistAddToOptionRenderer);
63 |             return playlist;
64 |         });
65 | 
66 |         return new List(playlists);
67 |     }
68 | 
69 |     async getWatchLaterPlaylist() {
70 |         return await this.client.getPlaylist("WL");
71 |     }
72 | 
73 |     async getLikedPlaylist() {
74 |         return await this.client.getPlaylist("LL");
75 |     }
76 | 
77 |     async getSubscriptions():Promise<List> {
78 |         this.client.throwErrorIfNotReady();
79 |         const res = await this.httpclient.request({
80 |             method: HTTPRequestMethod.POST,
81 |             url: ENDPOINT_BROWSE,
82 |             params: { prettyPrint: false },
83 |             data: { browseId: "FEchannels" }
84 |         });
85 |         const resJSON = await JSON.parse(res.data);
86 | 
87 |         const expandedShelfContentsRenderer = helpers.recursiveSearchForKey("expandedShelfContentsRenderer", resJSON)[0];
88 |         let items = expandedShelfContentsRenderer.items;
89 |         items = helpers.processRendererItems(items, this.httpclient);
90 |         return new List(items);
91 |     }
92 | 
93 |     getSubscriptionFeed():ContinuatedList {
94 |         this.client.throwErrorIfNotReady();
95 |         return new SubscriptionFeedContinuatedList(this.httpclient);
96 |     }
97 | }


--------------------------------------------------------------------------------
/src/fetchers/helpers.ts:
--------------------------------------------------------------------------------
  1 | import { Channel } from "../interfaces/Channel";
  2 | import { Playlist } from "../interfaces/Playlist";
  3 | import { Video } from "../interfaces/Video";
  4 | import { WrappedHTTPClient } from "../WrappedHTTPClient";
  5 | import { CONSOLE_COLORS } from "../constants";
  6 | import { Comment, CommentThread } from "../main";
  7 | 
  8 | function recursiveSearchForPair(searchKey: string, obj: any) {
  9 |     if(typeof obj != 'object') return [];
 10 | 
 11 |     let results = new Array();
 12 |     for(const [key, value] of Object.entries(obj)) {
 13 |         if(key == searchKey) results.push({key: key, value: value});
 14 |         results = results.concat(recursiveSearchForPair(searchKey, value));
 15 |     }
 16 | 
 17 |     return results;
 18 | }
 19 | 
 20 | function recursiveSearchForKey(searchKey: string, obj: any) {
 21 |     if(typeof obj != 'object') return [];
 22 | 
 23 |     let results = new Array();
 24 |     for(const [key, value] of Object.entries(obj)) {
 25 |         if(key == searchKey) results.push(value);
 26 |         results = results.concat(recursiveSearchForKey(searchKey, value));
 27 |     }
 28 | 
 29 |     return results;
 30 | }
 31 | 
 32 | function getNumberFromText(str: string):number {
 33 |     if(str == "No views") return 0;
 34 | 
 35 |     str = str.split(" ")[0];
 36 | 
 37 |     var number = 0.0;
 38 |     if(str.endsWith("M")) {
 39 |         number = parseFloat(replaceAll("M", "", str));
 40 |         number = number * 1000000;
 41 |     } else if(str.endsWith("K")) {
 42 |         number = parseFloat(replaceAll("K", "", str));
 43 |         number = number * 1000;
 44 |     } else {
 45 |         str = replaceAll(".", "", str);
 46 |         str = replaceAll(",", "", str);
 47 |         number = parseInt(str);
 48 |     }
 49 | 
 50 |     return number;
 51 | }
 52 | 
 53 | function replaceAll(search:string, value: string, source:string) {
 54 |     return source.replace(new RegExp(escapeRegExp(search), 'g'), value);
 55 | }
 56 | 
 57 | function processRendererItems(arr : Array<any>, httpclient: WrappedHTTPClient) {
 58 |     let processedList = arr.map((elem:any) => {
 59 |         /* Video */
 60 |         if(elem.videoRenderer) {
 61 |             var video = new Video(httpclient);
 62 |             video.fromVideoRenderer(elem.videoRenderer);
 63 |             return video;
 64 |         } else if (elem.gridVideoRenderer) {
 65 |             var video = new Video(httpclient);
 66 |             video.fromGridRenderer(elem.gridVideoRenderer);
 67 |             return video;
 68 |         } else if (elem.playlistVideoRenderer) {
 69 |             var video = new Video(httpclient);
 70 |             video.fromPlaylistVideoRenderer(elem.playlistVideoRenderer);
 71 |             return video;
 72 |         }
 73 | 
 74 |         /* Channel */
 75 |         else if (elem.channelRenderer) {
 76 |             var channel = new Channel(httpclient);
 77 |             channel.fromChannelRenderer(elem.channelRenderer);
 78 |             return channel;
 79 |         } else if(elem.gridChannelRenderer) {
 80 |             var channel = new Channel(httpclient);
 81 |             channel.fromGridChannelRenderer(elem.gridChannelRenderer);
 82 |             return channel;
 83 |         }
 84 | 
 85 |         /* Comments */
 86 |         else if(elem.commentThreadRenderer) {
 87 |             var commentThread = new CommentThread(httpclient);
 88 |             commentThread.fromCommentThreadRenderer(elem.commentThreadRenderer)
 89 |             return commentThread;
 90 |         } else if(elem.commentRenderer) {
 91 |             var comment = new Comment(httpclient);
 92 |             comment.fromCommentRenderer(elem.commentRenderer);
 93 |             return comment;
 94 |         }
 95 |         
 96 |         /* Playlist */
 97 |         else if(elem.playlistRenderer) {
 98 |             var playlist = new Playlist(httpclient);
 99 |             playlist.fromPlaylistRenderer(elem.playlistRenderer);
100 |             return playlist;
101 |         }
102 | 
103 |         else if(elem.gridPlaylistRenderer) {
104 |             var playlist = new Playlist(httpclient);
105 |             playlist.fromGridPlaylistRenderer(elem.gridPlaylistRenderer);
106 |             return playlist;
107 |         }
108 | 
109 |         /* Ignored */
110 |         else if(elem.continuationItemRenderer || elem.shelfRenderer) {
111 |             return undefined;
112 |         }
113 | 
114 |         /* Unknown */
115 |         else {
116 |             console.warn(CONSOLE_COLORS.fg.yellow + "[IYOUTUBE] Failed to Process Item with Type(s): " + Object.keys(elem), CONSOLE_COLORS.reset);
117 |             return undefined;
118 |         }
119 |     });
120 |     processedList = processedList.filter((a:any) => { return a != undefined;});
121 |     return processedList;
122 | }
123 | 
124 | function getVideoDefaultThumbnail(videoId:string) {
125 |     return {
126 |         url: "https://i.ytimg.com/vi/" + videoId + "/maxresdefault.jpg",
127 |         height: 1,
128 |         width: 1
129 |     }
130 | }
131 | 
132 | function getIndexBefore(str: string, index: number, source: string) {
133 |     var before = source.substring(0, index);
134 |     return before.lastIndexOf(str);
135 | }
136 | 
137 | function getIndexAfter(str: string, index: number, source: string) {
138 |     var after = source.substring(index, source.length);
139 |     return index + after.indexOf(str);
140 | }
141 | 
142 | function escapeRegExp(string:string) {
143 |     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
144 | }
145 | 
146 | export default {
147 |     recursiveSearchForPair,
148 |     recursiveSearchForKey,
149 |     getNumberFromText,
150 |     processRendererItems,
151 |     getVideoDefaultThumbnail,
152 |     replaceAll,
153 |     getIndexAfter,
154 |     getIndexBefore
155 | }


--------------------------------------------------------------------------------
/src/formatsChipher.ts:
--------------------------------------------------------------------------------
 1 | //Worked out from: https://github.com/TeamNewPipe/NewPipeExtractor
 2 | import helpers from "./fetchers/helpers";
 3 | import { HTTPRequestMethod } from "./interfaces/HTTPClient";
 4 | import { WrappedHTTPClient } from "./WrappedHTTPClient";
 5 | 
 6 | const REGEXES = [
 7 |   new RegExp("(?:\\b|[^a-zA-Z0-9$])([a-zA-Z0-9$]{2,})\\s*=\\s*function\\(\\s*a\\s*\\)" + "\\s*\\{\\s*a\\s*=\\s*a\\.split\\(\\s*\"\"\\s*\\)"),
 8 |   new RegExp("\\bm=([a-zA-Z0-9$]{2,})\\(decodeURIComponent\\(h\\.s\\)\\)"),
 9 |   new RegExp("\\bc&&\\(c=([a-zA-Z0-9$]{2,})\\(decodeURIComponent\\(c\\)\\)"),
10 |   new RegExp("([\\w$]+)\\s*=\\s*function\\((\\w+)\\)\\{\\s*\\2=\\s*\\2\\.split\\(\"\"\\)\\s*;"),
11 |   new RegExp("\\b([\\w$]{2,})\\s*=\\s*function\\((\\w+)\\)\\{\\s*\\2=\\s*\\2\\.split\\(\"\"\\)\\s*;"),
12 |   new RegExp("\\bc\\s*&&\\s*d\\.set\\([^,]+\\s*,\\s*(:encodeURIComponent\\s*\\()([a-zA-Z0-9$]+)\\(")
13 | ];
14 | 
15 | export async function decipher(formats: Array<any>, playerURL: string, httpClient: WrappedHTTPClient) {
16 |   const playerResults = await httpClient.request({
17 |     method: HTTPRequestMethod.GET,
18 |     url: playerURL
19 |   });
20 | 
21 |   const playerJS = playerResults.data;
22 | 
23 |   let deobfuscateFunctionName:any = "";
24 |   for(const reg of REGEXES) {
25 |     deobfuscateFunctionName = matchGroup1(reg, playerJS);
26 |     if(deobfuscateFunctionName) {
27 |       break;
28 |     }
29 |   }
30 | 
31 |   const functionPattern = new RegExp("(" + deobfuscateFunctionName.replace("$", "\\$") + "=function\\([a-zA-Z0-9_]+\\)\\{.+?\\})");
32 |   const deobfuscateFunction = "var " + matchGroup1(functionPattern, playerJS) + ";";
33 | 
34 |   const helperObjectName = matchGroup1(new RegExp(";([A-Za-z0-9_\\$]{2})\\...\\("), deobfuscateFunction);
35 |   const helperPattern = new RegExp("(var " + helperObjectName + "=\\{.+?\\}\\};)");
36 |   const helperObject = matchGroup1(helperPattern, helpers.replaceAll("\n", "", playerJS));
37 |   
38 |   const finalFunc = eval(`(function getDecipherFunction() {
39 |     ` + helperObject + `
40 |     ` + deobfuscateFunction + `
41 | 
42 |     return (val) => ` + deobfuscateFunctionName + `;
43 |   })()`)();
44 | 
45 |   for(const format of formats) {
46 |     if(format.signatureCipher) {
47 |       const signatureParams = parseQuery(format.signatureCipher);
48 |       const resolvedSignature = finalFunc(signatureParams.s);
49 |       const finalURL = new URL(signatureParams.url);
50 |       finalURL.searchParams.set(signatureParams.sp, resolvedSignature)
51 |       format.url = finalURL.toString();
52 |     }
53 |   }
54 | 
55 |   return formats;
56 | }
57 | 
58 | 
59 | function matchGroup1(regex: RegExp, str: string) {
60 |   const res = regex.exec(str);
61 |   if(!res) return "";
62 |   return res[1];
63 | }
64 | 
65 | function parseQuery(queryString:string) {
66 |   var query:any = {};
67 |   var pairs = (queryString[0] === '?' ? queryString.substr(1) : queryString).split('&');
68 |   for (var i = 0; i < pairs.length; i++) {
69 |       var pair = pairs[i].split('=');
70 |       query[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1] || '');
71 |   }
72 |   return query;
73 | }


--------------------------------------------------------------------------------
/src/interfaces/Badge.ts:
--------------------------------------------------------------------------------
1 | export interface Badge {
2 |     name: string,
3 |     icon: string,
4 |     style?: string,
5 | }


--------------------------------------------------------------------------------
/src/interfaces/CaptionTrack.ts:
--------------------------------------------------------------------------------
1 | export interface CaptionTrack {
2 |     baseUrl: string;
3 |     translateable: boolean;
4 |     languageCode: string;
5 |     name: string;
6 | }


--------------------------------------------------------------------------------
/src/interfaces/Channel.ts:
--------------------------------------------------------------------------------
  1 | import { ENDPOINT_BROWSE, ENDPOINT_SUBSCRIBE, ENDPOINT_UNSUBSCRIBE } from "../constants";
  2 | import { ContinuatedList, Thumbnail, Badge, Video, WrappedHTTPClient  } from "../main";
  3 | import helpers from "../fetchers/helpers"
  4 | import { HTTPRequestMethod } from "./HTTPClient";
  5 | import { ChannelLink } from "./ChannelLink";
  6 | 
  7 | 
  8 | export class Channel {
  9 |     channelId?: string;
 10 |     title?: string;
 11 |     description?: string;
 12 |     shortDescription?: string;
 13 |     badges?: Array<Badge>;
 14 |     thumbnails?: Array<Thumbnail>;
 15 |     banners?: Array<Thumbnail>;
 16 |     mobileBanners?: Array<Thumbnail>;
 17 |     tvBanners?: Array<Thumbnail>;
 18 |     videoCount?: number;
 19 |     subscribed?: boolean;
 20 |     subscriberCount?: number;
 21 |     country?: string;
 22 |     viewCount?: number;
 23 |     joinDate?: Date;
 24 |     channelLinks?: Array<ChannelLink>;
 25 |     otherChannels?: Array<Channel>;
 26 |     featuredVideo?: Video;
 27 | 
 28 |     httpclient: WrappedHTTPClient;
 29 | 
 30 |     constructor(httpclient: WrappedHTTPClient) {
 31 |         this.httpclient = httpclient;
 32 |     }
 33 | 
 34 |     fromVideoRenderer(obj: any) {
 35 |         const ownerTextContainer = helpers.recursiveSearchForKey("ownerText", obj)[0];
 36 |         if(ownerTextContainer) {
 37 |             this.title = helpers.recursiveSearchForKey("text", ownerTextContainer)[0];
 38 |             this.channelId = helpers.recursiveSearchForKey("browseId", ownerTextContainer)[0];
 39 |         }
 40 | 
 41 |         const ownerBadgeContainer = helpers.recursiveSearchForKey("ownerBadges", obj);
 42 |         this.#parseOwnerBadges(ownerBadgeContainer);
 43 | 
 44 |         const ownerThumbnailContainer = helpers.recursiveSearchForKey("channelThumbnailWithLinkRenderer", obj)[0];
 45 |         if(ownerThumbnailContainer) {
 46 |             this.thumbnails = helpers.recursiveSearchForKey("thumbnails", ownerThumbnailContainer)[0];
 47 |         }
 48 | 
 49 |         this.#cleanup;
 50 |     }
 51 | 
 52 |     fromChannelRenderer(obj: any) {
 53 |         this.channelId = helpers.recursiveSearchForKey("channelId", obj)[0];
 54 | 
 55 |         const titleContainer = helpers.recursiveSearchForKey("title", obj)[0];
 56 |         if(titleContainer)
 57 |             this.title = helpers.recursiveSearchForKey("simpleText", titleContainer)[0];
 58 | 
 59 |         const thumbnailContainer = helpers.recursiveSearchForKey("thumbnail", obj)[0];
 60 |         if(thumbnailContainer) {
 61 |             this.thumbnails = helpers.recursiveSearchForKey("thumbnails", thumbnailContainer)[0];
 62 |         }
 63 | 
 64 |         const descriptionContainer = helpers.recursiveSearchForKey("descriptionSnippet", obj)[0];
 65 |         if(descriptionContainer)
 66 |             this.shortDescription = helpers.recursiveSearchForKey("text", descriptionContainer).join("");
 67 | 
 68 |         const videoCountContainer = helpers.recursiveSearchForKey("videoCountText", obj)[0];
 69 |         if(videoCountContainer)
 70 |             this.videoCount = helpers.getNumberFromText(helpers.recursiveSearchForKey("text", videoCountContainer).join(""));
 71 | 
 72 |         const subscriberCountContainer = helpers.recursiveSearchForKey("subscriberCountText", obj)[0];
 73 |         if(subscriberCountContainer) 
 74 |             this.subscriberCount = helpers.getNumberFromText(helpers.recursiveSearchForKey("simpleText", subscriberCountContainer)[0]);
 75 | 
 76 |         const ownerBadgeContainer = helpers.recursiveSearchForKey("ownerBadges", obj);
 77 |         this.#parseOwnerBadges(ownerBadgeContainer);
 78 | 
 79 |         this.subscribed = helpers.recursiveSearchForKey("subscribed", obj)[0];
 80 | 
 81 |         this.#cleanup();
 82 |     }
 83 | 
 84 |     fromGridVideoRenderer(obj: any) {
 85 |         const shortBylineText = helpers.recursiveSearchForKey("shortBylineText", obj)[0];
 86 |         if(shortBylineText) {
 87 |             this.title = helpers.recursiveSearchForKey("text", shortBylineText)[0];
 88 |             this.channelId = helpers.recursiveSearchForKey("browseId", shortBylineText)[0];
 89 |         }
 90 | 
 91 |         const ownerBadgeContainer = helpers.recursiveSearchForKey("ownerBadges", obj);
 92 |         if(ownerBadgeContainer.length > 0) {
 93 |             const badgeRenderers = helpers.recursiveSearchForKey("metadataBadgeRenderer", ownerBadgeContainer);
 94 |             if(badgeRenderers.length > 0) {
 95 |                 this.badges = new Array();
 96 |                 for(const badgeRenderer of badgeRenderers) {
 97 |                     this.badges.push({
 98 |                         name: helpers.recursiveSearchForKey("label", badgeRenderer)[0],
 99 |                         icon: helpers.recursiveSearchForKey("iconType", badgeRenderer)[0],
100 |                     });
101 |                 }
102 |             }
103 |         }
104 |     }
105 | 
106 |     fromPlaylistRenderer(obj: any) {
107 |         this.fromGridVideoRenderer(obj);
108 |     }
109 | 
110 |     fromVideoOwnerRenderer(obj:any) {
111 |         const browseEndpoint = helpers.recursiveSearchForKey("browseEndpoint", obj)[0];
112 |         if(browseEndpoint)
113 |             this.channelId = helpers.recursiveSearchForKey("browseId", browseEndpoint).join("");
114 | 
115 |         const titleContainer = helpers.recursiveSearchForKey("title", obj);
116 |         if(titleContainer)
117 |             this.title = helpers.recursiveSearchForKey("text", titleContainer).join("");
118 | 
119 |         const thumbnailContainer = helpers.recursiveSearchForKey("thumbnails", obj)[0];
120 |         if(thumbnailContainer)
121 |             this.thumbnails = thumbnailContainer;
122 |     }
123 | 
124 |     fromPlaylistVideoRendererBylineText(obj:any) {
125 |         this.title = helpers.recursiveSearchForKey("text", obj).join("");
126 |         this.channelId = helpers.recursiveSearchForKey("browseId", obj).join("");
127 |     }
128 | 
129 |     fromGridChannelRenderer(obj: any) {
130 |         this.channelId = helpers.recursiveSearchForKey("channelId", obj).join("");
131 |         this.subscribed = helpers.recursiveSearchForKey("subscribed", obj)[0];
132 |         
133 |         const titleContainer = helpers.recursiveSearchForKey("title", obj)[0];
134 |         if(titleContainer) {
135 |             this.title = helpers.recursiveSearchForKey("simpleText", titleContainer).join("");
136 |         }
137 | 
138 |         const thumbnailContainer = helpers.recursiveSearchForKey("thumbnails", obj)[0];
139 |         if(thumbnailContainer) {
140 |            this.thumbnails = thumbnailContainer; 
141 |         }
142 | 
143 |     }
144 | 
145 |     fromCommentRenderer(obj: any) {
146 |         const navigationEndpoint = helpers.recursiveSearchForKey("authorEndpoint", obj)[0];
147 |         if(navigationEndpoint) 
148 |             this.channelId = helpers.recursiveSearchForKey("browseId", navigationEndpoint)[0];
149 | 
150 |         const titleContainer = helpers.recursiveSearchForKey("authorText", obj)[0];
151 |         if(titleContainer)
152 |             this.title = helpers.recursiveSearchForKey("simpleText", titleContainer).join("");
153 | 
154 |         const authorThumbnailContainer = helpers.recursiveSearchForKey("authorThumbnail", obj)[0];
155 |         if(authorThumbnailContainer)
156 |             this.thumbnails = helpers.recursiveSearchForKey("thumbnails", authorThumbnailContainer)[0];
157 |     }
158 | 
159 |     fromPlayerMicroRenderer(obj: any) {
160 |         this.channelId = obj.externalChannelId;
161 |         this.title = obj.ownerChannelName;
162 |     }
163 | 
164 |     async loadAll() {
165 |         await this.loadDetailsFromOverviewPage();
166 |         await this.loadDetailsFromAboutPage();
167 |         await this.loadDetailsFromChannelsPages();
168 |     }
169 | 
170 |     async loadDetailsFromOverviewPage() {
171 |         const channelOverview = await this.httpclient.request({
172 |             method: HTTPRequestMethod.POST,
173 |             url: ENDPOINT_BROWSE,
174 |             data: {
175 |                 browseId: this.channelId,
176 |             }
177 |         });
178 |         const overviewJSON = await JSON.parse(channelOverview.data);
179 |         this.#parseC4FromHeader(overviewJSON);        
180 | 
181 |         let overviewTabRenderer = helpers.recursiveSearchForKey("tabRenderer", overviewJSON);
182 |         overviewTabRenderer = overviewTabRenderer.find((a:any) => a.title.toLowerCase() == "home");
183 | 
184 |         const featuredRenderer = helpers.recursiveSearchForKey("channelFeaturedContentRenderer", overviewTabRenderer)[0];
185 |         if(featuredRenderer) {
186 |             const videoRenderer = helpers.recursiveSearchForKey("videoRenderer", featuredRenderer)[0];
187 |             if(videoRenderer) {
188 |                 this.featuredVideo = new Video(this.httpclient);
189 |                 this.featuredVideo.fromVideoRenderer(videoRenderer);
190 |             }
191 |         }
192 | 
193 |         const videoPlayerRenderer = helpers.recursiveSearchForKey("channelVideoPlayerRenderer", overviewTabRenderer)[0];
194 |         if(videoPlayerRenderer) {
195 |             this.featuredVideo = new Video(this.httpclient);
196 |             this.featuredVideo.fromVideoPlayerRenderer(videoPlayerRenderer);
197 |         }
198 |     }
199 | 
200 |     async loadDetailsFromAboutPage() {
201 |         const channelAbout = await this.httpclient.request({
202 |             method: HTTPRequestMethod.POST,
203 |             url: ENDPOINT_BROWSE,
204 |             data: {
205 |                 browseId: this.channelId,
206 |                 params: channelBrowseType.DETAILS
207 |             }
208 |         });
209 |         const aboutJSON = await JSON.parse(channelAbout.data);
210 |         this.#parseC4FromHeader(aboutJSON);        
211 | 
212 |         const aboutRenderer = helpers.recursiveSearchForKey("channelAboutFullMetadataRenderer", aboutJSON);
213 |         const descriptionContainer = helpers.recursiveSearchForKey("description", aboutRenderer)[0];
214 |         if(descriptionContainer)
215 |             this.description = helpers.recursiveSearchForKey("simpleText", descriptionContainer).join("");
216 | 
217 |         const countryContainer = helpers.recursiveSearchForKey("country", aboutRenderer)[0];
218 |         if(countryContainer)
219 |             this.country = helpers.recursiveSearchForKey("simpleText", countryContainer).join("");
220 | 
221 |         const joinDateContainer = helpers.recursiveSearchForKey("joinedDateText", aboutRenderer)[0];
222 |         if(joinDateContainer) {
223 |             const dateParts = helpers.recursiveSearchForKey("text", joinDateContainer).join("").split(" ");
224 |             dateParts.shift(); //Remove the 'Joined' Prefix
225 |             this.joinDate = new Date(dateParts.join(", "));
226 |         }
227 |             
228 |         const viewCountContainer = helpers.recursiveSearchForKey("viewCountText", aboutRenderer)[0];
229 |         if(viewCountContainer)
230 |             this.viewCount = helpers.getNumberFromText(helpers.recursiveSearchForKey("simpleText", viewCountContainer).join(""));
231 | 
232 |         const links = helpers.recursiveSearchForKey("primaryLinks", aboutRenderer)[0];
233 |         if(links) {
234 |             this.channelLinks = links.map((link:any) => {
235 |                 var linkObj:ChannelLink = { 
236 |                     title: helpers.recursiveSearchForKey("simpleText", link).join(""),
237 |                     url: helpers.recursiveSearchForKey("url", helpers.recursiveSearchForKey("navigationEndpoint", link)[0])[0],
238 |                     thumbnails: helpers.recursiveSearchForKey("thumbnails", link)[0]
239 |                 }
240 | 
241 |                 //Resolve YouTube Redirect Links
242 |                 if(linkObj.url && linkObj.url.startsWith("https://www.youtube.com/redirect?")) {
243 |                     linkObj.url = new URL(linkObj.url).searchParams.get("q") as string;
244 |                 } 
245 | 
246 |                 return linkObj;
247 |             });
248 |         }
249 |     }
250 | 
251 |     async loadDetailsFromChannelsPages() {
252 |         const channelChannels = await this.httpclient.request({
253 |             method: HTTPRequestMethod.POST,
254 |             url: ENDPOINT_BROWSE,
255 |             data: {
256 |                 browseId: this.channelId,
257 |                 params: channelBrowseType.CHANNELS
258 |             }
259 |         });
260 |         const channelsJSON = await JSON.parse(channelChannels.data);
261 |         this.#parseC4FromHeader(channelsJSON);   
262 | 
263 |         let channelsTabRenderer = helpers.recursiveSearchForKey("tabRenderer", channelsJSON);
264 |         channelsTabRenderer = channelsTabRenderer.find((a:any) => a.title.toLowerCase() == "channels");
265 |         
266 |         let channelItems = helpers.recursiveSearchForKey("items", channelsTabRenderer);
267 |         if(channelItems.length > 0) {
268 |             channelItems = channelItems.flat(1); //Join all Arrays of Items together (for multiple headings)
269 |             this.otherChannels = helpers.processRendererItems(channelItems, this.httpclient) as Array<Channel>;
270 |         }
271 |     }
272 | 
273 |     #parseC4FromHeader(obj:any) {
274 |         const headerContainer = helpers.recursiveSearchForKey("c4TabbedHeaderRenderer", obj)[0];
275 |         if(headerContainer) {
276 |             this.title = headerContainer.title;
277 |             this.subscribed = helpers.recursiveSearchForKey("subscribed", headerContainer)[0];
278 |             this.#parseOwnerBadges(helpers.recursiveSearchForKey("badges", headerContainer));
279 | 
280 |             const subscriberCountContainer = helpers.recursiveSearchForKey("subscriberCountText", headerContainer)[0];
281 |             if(subscriberCountContainer)
282 |                 this.subscriberCount = helpers.getNumberFromText(helpers.recursiveSearchForKey("simpleText", subscriberCountContainer).join(""));
283 | 
284 |             this.thumbnails = helpers.recursiveSearchForKey("thumbnails", headerContainer.avatar)[0];
285 |             this.banners = helpers.recursiveSearchForKey("thumbnails", headerContainer.banner)[0];
286 |             this.mobileBanners = helpers.recursiveSearchForKey("thumbnails", headerContainer.mobileBanner)[0];
287 |             this.tvBanners = helpers.recursiveSearchForKey("thumbnails", headerContainer.tvBanner)[0];
288 | 
289 |         }
290 |     }
291 | 
292 |     #parseOwnerBadges(ownerBadgeContainer:Array<any>) {
293 |         if(ownerBadgeContainer.length > 0) {
294 |             const badgeRenderers = helpers.recursiveSearchForKey("metadataBadgeRenderer", ownerBadgeContainer);
295 |             if(badgeRenderers.length > 0) {
296 |                 this.badges = badgeRenderers.map((badgeRenderer:any) => ({
297 |                         name: helpers.recursiveSearchForKey("label", badgeRenderer)[0],
298 |                         icon: helpers.recursiveSearchForKey("iconType", badgeRenderer)[0],
299 |                 }));
300 |             }
301 |         }
302 |     }
303 | 
304 |     #cleanup() {
305 |         if(this.thumbnails) this.thumbnails.forEach((a) => {
306 |             if(a.url.startsWith("//")) a.url = "https:" + a.url;
307 |         })
308 |     }
309 | 
310 |     getUploadList():ContinuatedList {
311 |         return new ContinuatedList(
312 |         //Http Request Options
313 |         {
314 |             method: HTTPRequestMethod.POST,
315 |             url: ENDPOINT_BROWSE,
316 |             data: {
317 |                 browseId: this.channelId,
318 |                 params: channelBrowseType.VIDEOS
319 |             }
320 |         },
321 |         
322 |         // Data Processor
323 |         (data:any) => {
324 |             let videosTabRenderer = helpers.recursiveSearchForKey("tabRenderer", data);
325 |             videosTabRenderer = videosTabRenderer.find((a:any) => a.title.toLowerCase() == "videos");
326 |     
327 |             if(videosTabRenderer) {
328 |                 const gridRendererContainer = helpers.recursiveSearchForKey("gridRenderer", videosTabRenderer)[0];
329 |                 if(gridRendererContainer) {
330 |                     const items = helpers.recursiveSearchForKey("items", gridRendererContainer)[0];
331 |                     return items;
332 |                 }
333 |             } else {
334 |                 return helpers.recursiveSearchForKey("continuationItems", data)[0];
335 |             }
336 |         }, this.httpclient, true);
337 |     }
338 | 
339 |     async subscribe() {
340 |         const res = await this.httpclient.request({
341 |             method: HTTPRequestMethod.POST,
342 |             url: ENDPOINT_SUBSCRIBE,
343 |             params: {
344 |                 prettyPrint: false
345 |             },
346 |             data: { 
347 |                 channelIds: [this.channelId],
348 |                 params: "EgIIAhgA"
349 |             }
350 |         });
351 |         if(res.status == 200) this.subscribed = true;
352 |         return res.status == 200;
353 |     }
354 | 
355 |     async unsubscribe() {
356 |         const res = await this.httpclient.request({
357 |             method: HTTPRequestMethod.POST,
358 |             url: ENDPOINT_UNSUBSCRIBE,
359 |             params: {
360 |                 prettyPrint: false
361 |             },
362 |             data: { 
363 |                 channelIds: [this.channelId],
364 |                 params: "CgIIAhgA"
365 |             }
366 |         });
367 |         if(res.status == 200) this.subscribed = false;
368 |         return res.status == 200;
369 |     }
370 | }
371 | 
372 | enum channelBrowseType {
373 |     DETAILS = "EgVhYm91dA%3D%3D",
374 |     CHANNELS = "EghjaGFubmVscw%3D%3D",
375 |     VIDEOS = "EgZ2aWRlb3M%3D",
376 | }


--------------------------------------------------------------------------------
/src/interfaces/ChannelBadge.ts:
--------------------------------------------------------------------------------
1 | export interface ChannelBadge {
2 |     name: string,
3 |     icon: string
4 | }


--------------------------------------------------------------------------------
/src/interfaces/ChannelLink.ts:
--------------------------------------------------------------------------------
1 | import { Thumbnail } from "../main";
2 | 
3 | export interface ChannelLink {
4 |     url: string;
5 |     title: string;
6 |     thumbnails?: Array<Thumbnail>;
7 | }


--------------------------------------------------------------------------------
/src/interfaces/Comment.ts:
--------------------------------------------------------------------------------
  1 | import { Channel, WrappedHTTPClient } from "../main";
  2 | import helpers from "../fetchers/helpers";
  3 | import { HTTPRequestMethod } from "./HTTPClient";
  4 | import { ENDPOINT_COMMENT_ACTION } from "../constants";
  5 | 
  6 | export class Comment {
  7 |     httpclient: WrappedHTTPClient;
  8 | 
  9 |     commentId?: string;
 10 |     text?: string;
 11 |     author?: Channel;
 12 |     authorIsChannelOwner?: boolean;
 13 |     likeCount?: number;
 14 |     hasLiked?: boolean;
 15 |     publishedText?: string;
 16 | 
 17 |     likeActionToken?:string;
 18 |     dislikeActionToken?:string;
 19 |     removeLikeActionToken?:string;
 20 |     removeDislikeActionToken?:string;
 21 |     canPerformLikeActions?:boolean;
 22 | 
 23 |     constructor(httpclient: WrappedHTTPClient) {
 24 |         this.httpclient = httpclient;
 25 |     }
 26 | 
 27 |     fromCommentRenderer(obj: any) {
 28 |         this.commentId = helpers.recursiveSearchForKey("commentId", obj)[0];
 29 | 
 30 |         const contentContainer = helpers.recursiveSearchForKey("contentText", obj)[0];
 31 |         if(contentContainer)
 32 |             this.text = helpers.recursiveSearchForKey("text", contentContainer).join("");
 33 | 
 34 |         this.author = new Channel(this.httpclient);
 35 |         this.author.fromCommentRenderer(obj);
 36 |         this.authorIsChannelOwner = helpers.recursiveSearchForKey("authorIsChannelOwner", obj)[0];
 37 | 
 38 |         const likeCountContainer = helpers.recursiveSearchForKey("voteCount", obj)[0];
 39 |         if(likeCountContainer)
 40 |             this.likeCount = helpers.getNumberFromText(helpers.recursiveSearchForKey("simpleText", likeCountContainer).join(""));
 41 | 
 42 |         this.hasLiked = helpers.recursiveSearchForKey("isLiked", obj)[0];
 43 | 
 44 |         const publishedTimeTextContainer = helpers.recursiveSearchForKey("publishedTimeText", obj)[0];
 45 |         if(publishedTimeTextContainer) {
 46 |             this.publishedText = helpers.recursiveSearchForKey("text", publishedTimeTextContainer).join("");
 47 |         }
 48 | 
 49 |         const actionButtonContainer = helpers.recursiveSearchForKey("commentActionButtonsRenderer", obj)[0];
 50 |         if(actionButtonContainer) {
 51 |             const dislikeButton = helpers.recursiveSearchForKey("dislikeButton", actionButtonContainer);
 52 |             if(dislikeButton)
 53 |                 this.dislikeActionToken = helpers.recursiveSearchForKey("action", dislikeButton)[0];
 54 |                 this.removeDislikeActionToken = helpers.recursiveSearchForKey("action", dislikeButton)[1];
 55 | 
 56 |             const likeButton = helpers.recursiveSearchForKey("likeButton", actionButtonContainer);
 57 |             if(likeButton) {
 58 |                 this.likeActionToken = helpers.recursiveSearchForKey("action", likeButton)[0];
 59 |                 this.removeLikeActionToken = helpers.recursiveSearchForKey("action", likeButton)[1];
 60 |             }
 61 | 
 62 |             this.canPerformLikeActions = !(!this.dislikeActionToken && !this.likeActionToken);
 63 |         }
 64 |     }
 65 | 
 66 |     async like() {
 67 |         if(!this.canPerformLikeActions) throw new Error("It is not possible to perfrom Like Actions on this Comment Instance");
 68 |         const commentAction = await this.httpclient.request({
 69 |             method: HTTPRequestMethod.POST,
 70 |             url: ENDPOINT_COMMENT_ACTION,
 71 |             data: {
 72 |                 actions: [this.likeActionToken]
 73 |             }
 74 |         });
 75 |         this.hasLiked = commentAction.status == 200;
 76 |         return commentAction.status == 200;
 77 |     }
 78 | 
 79 |     async dislike() {
 80 |         if(!this.canPerformLikeActions) throw new Error("It is not possible to perfrom Like Actions on this Comment Instance");
 81 |         const commentAction = await this.httpclient.request({
 82 |             method: HTTPRequestMethod.POST,
 83 |             url: ENDPOINT_COMMENT_ACTION,
 84 |             data: {
 85 |                 actions: [this.dislikeActionToken]
 86 |             }
 87 |         });
 88 |         this.hasLiked = commentAction.status == 200 ? false : undefined;
 89 |         return commentAction.status == 200;
 90 |     }
 91 | 
 92 |     async removeLike() {
 93 |         let removeToken = this.removeLikeActionToken;
 94 |         if(this.hasLiked === true) {
 95 |             removeToken = this.removeLikeActionToken;
 96 |         } else if(this.hasLiked === false) {
 97 |             removeToken = this.removeDislikeActionToken;
 98 |         } else {
 99 |             console.warn("[IYOUTUBE | COMMENT] Removal of Like without knowing if it's present!");
100 |         }
101 | 
102 |         const commentAction = await this.httpclient.request({
103 |             method: HTTPRequestMethod.POST,
104 |             url: ENDPOINT_COMMENT_ACTION,
105 |             data: {
106 |                 actions: [removeToken]
107 |             }
108 |         });
109 |         this.hasLiked = undefined;
110 |         return commentAction.status == 200;
111 |     }
112 | }


--------------------------------------------------------------------------------
/src/interfaces/CommentThread.ts:
--------------------------------------------------------------------------------
 1 | import helpers from "../fetchers/helpers";
 2 | import { WrappedHTTPClient, Comment, CommentThreadRepliesContinuatedList } from "../main"
 3 | 
 4 | export class CommentThread {
 5 |     httpclient: WrappedHTTPClient;
 6 | 
 7 |     comment?: Comment
 8 |     replieList?: CommentThreadRepliesContinuatedList;
 9 | 
10 |     constructor(httpclient: WrappedHTTPClient) {
11 |         this.httpclient = httpclient;
12 |     }
13 | 
14 |     fromCommentThreadRenderer(obj: any) {
15 |         this.comment = new Comment(this.httpclient);
16 |         this.comment.fromCommentRenderer(obj.comment);
17 | 
18 |         const repliesRenderer = obj.replies;
19 |         if(repliesRenderer) {
20 |             this.replieList = new CommentThreadRepliesContinuatedList(helpers.recursiveSearchForKey("token", repliesRenderer).join(""), this.httpclient);
21 |         }
22 |     }
23 | }


--------------------------------------------------------------------------------
/src/interfaces/Format.ts:
--------------------------------------------------------------------------------
 1 | export interface Format {
 2 |     type: "VIDEO" | "AUDIO";
 3 |     itag: number;
 4 |     url: string;
 5 |     mime: string;
 6 | 
 7 |     //Common
 8 |     bitrate?: number;
 9 |     averageBitrate?: number;
10 |     quality?: string;
11 | 
12 |     //Video
13 |     height?: number;
14 |     width?: number;
15 |     fps?: number;
16 |     qualityLabel?: string;
17 |     colorInfo?: {
18 |         matrixCoefficients: string,
19 |         primaries: string,
20 |         transferCharacteristics: string
21 |     }
22 | 
23 |     //Audio
24 |     audioQuality?: string;
25 |     audioSampleRate?: number;
26 |     audioChannels?: number;
27 |     loudness?: number;
28 | }


--------------------------------------------------------------------------------
/src/interfaces/HTTPClient.ts:
--------------------------------------------------------------------------------
 1 | export interface HTTPClient {
 2 |     request(options: HTTPRequestOptions):Promise<HTTPResponse>;
 3 | }
 4 | 
 5 | export interface HTTPRequestOptions {
 6 |     headers?: HTTPMap,
 7 |     params?: HTTPMap
 8 |     data?: any,
 9 |     method: HTTPRequestMethod,
10 |     url: string,
11 |     noCache?: boolean
12 | }
13 | 
14 | export interface HTTPResponse {
15 |     status: number,
16 |     data: string,
17 |     headers: HTTPMap
18 | }
19 | 
20 | export enum HTTPRequestMethod {
21 |     GET = "GET",
22 |     POST = "POST"
23 | }
24 | 
25 | export type HTTPMap = any;


--------------------------------------------------------------------------------
/src/interfaces/List.ts:
--------------------------------------------------------------------------------
 1 | import { Video, Channel, Playlist, Comment, CommentThread } from "../main";
 2 | 
 3 | export class List {
 4 |     results: Array<Video | Channel | Playlist | Comment | CommentThread>;
 5 | 
 6 |     constructor(array?:Array<any>) {
 7 |         if(array) {
 8 |             this.results = array;
 9 |         } else {
10 |             this.results = new Array();
11 |         }
12 |     }
13 | 
14 |     getByType(type: any) {
15 |         return this.results.filter((elem) => { return elem instanceof type });
16 |     }
17 | 
18 |     getVideos():Array<Video> {
19 |         return this.getByType(Video) as Array<Video>
20 |     }
21 | 
22 |     getPlaylists():Array<Playlist> {
23 |         return this.getByType(Playlist) as Array<Playlist>;
24 |     }
25 | 
26 |     getChannels():Array<Channel> {
27 |         return this.getByType(Channel) as Array<Channel>;
28 |     }
29 | 
30 |     getComments():Array<Comment> {
31 |         return this.getByType(Comment) as Array<Comment>;
32 |     }
33 | 
34 |     getCommentThreads():Array<CommentThread> {
35 |         return this.getByType(CommentThread) as Array<CommentThread>;
36 |     }
37 | }


--------------------------------------------------------------------------------
/src/interfaces/Playlist.ts:
--------------------------------------------------------------------------------
  1 | import helpers from "../fetchers/helpers";
  2 | import { PlaylistContinuatedList } from "../fetchers/PlaylistContinuatedList";
  3 | import { HTTPRequestMethod } from "./HTTPClient";
  4 | import { Video, Thumbnail, ContinuatedList, Channel, WrappedHTTPClient, Badge } from "../main";
  5 | import { ENDPOINT_BROWSE, ENDPOINT_LIKE, ENDPOINT_REMOVELIKE } from "../constants";
  6 | 
  7 | export class Playlist {
  8 |     playlistId?: string;
  9 |     title?: string;
 10 |     description?: string;
 11 |     thumbnails?: Array<Thumbnail>;
 12 |     videoCount?: number;
 13 |     viewCount?: number;
 14 |     owner?: Channel;
 15 |     videos?:Array<Video>
 16 |     canReorder?: boolean;
 17 |     isEditable?:boolean;
 18 |     lastEditText?:string;
 19 |     canLike?: boolean;
 20 |     badges?: Array<Badge>;
 21 |     privacyState?: "PRIVATE" | "UNLISTED" | "PUBLIC";
 22 | 
 23 |     httpclient: WrappedHTTPClient;
 24 | 
 25 |     continuatedList?: ContinuatedList;
 26 |     likeParam?: string;
 27 | 
 28 |     constructor(httpclient : WrappedHTTPClient) {
 29 |         this.httpclient = httpclient;
 30 |     }
 31 | 
 32 |     fromPlaylistRenderer(obj:any) {
 33 |         this.playlistId = helpers.recursiveSearchForKey("playlistId", obj)[0];
 34 | 
 35 |         const titleContainer = helpers.recursiveSearchForKey("title", obj)[0];
 36 |         if(titleContainer)
 37 |             this.title = helpers.recursiveSearchForKey("simpleText", titleContainer)[0];
 38 | 
 39 |         let thumbnailContainer = helpers.recursiveSearchForKey("playlistVideoThumbnailRenderer", obj)[0];
 40 |         if(thumbnailContainer)
 41 |             this.thumbnails = helpers.recursiveSearchForKey("thumbnails", thumbnailContainer)[0];
 42 | 
 43 |         this.videoCount = helpers.recursiveSearchForKey("videoCount", obj)[0];
 44 | 
 45 |         const channelContainer = helpers.recursiveSearchForKey("shortBylineText", obj)[0];
 46 |         if(channelContainer) {
 47 |             this.owner = new Channel(this.httpclient);
 48 |             this.owner.fromPlaylistRenderer(obj);
 49 |         }
 50 |     }
 51 | 
 52 |     fromGridPlaylistRenderer(obj: any) {
 53 |         this.fromPlaylistRenderer(obj);
 54 | 
 55 |         const viewCountContainer = helpers.recursiveSearchForKey("thumbnailText", obj)[0];
 56 |         if(viewCountContainer) {
 57 |             this.videoCount = helpers.getNumberFromText(helpers.recursiveSearchForKey("text", viewCountContainer).join(""));
 58 |         }
 59 | 
 60 |         const badgesContainer = helpers.recursiveSearchForKey("badges", obj);
 61 |         if(badgesContainer) {
 62 |             const badgeRenderers = helpers.recursiveSearchForKey("metadataBadgeRenderer", badgesContainer);
 63 |             if(badgeRenderers.length > 0) {
 64 |                 this.badges = badgeRenderers.map((badgeRenderer:any) => ({
 65 |                     name: helpers.recursiveSearchForKey("label", badgeRenderer)[0],
 66 |                     icon: helpers.recursiveSearchForKey("iconType", badgeRenderer)[0],
 67 |                     style: helpers.recursiveSearchForKey("style", badgeRenderer)[0]
 68 |                 }));
 69 |             }
 70 |         }
 71 | 
 72 |         if(this.badges) {
 73 |             if(this.badges.find((a) => { return a.icon == "PRIVACY_PRIVATE" })) this.privacyState = "PRIVATE";
 74 |             else if(this.badges.find((a) => { return a.icon == "PRIVACY_UNLISTED" })) this.privacyState = "UNLISTED";
 75 |             else this.privacyState = "PUBLIC";
 76 |         } else this.privacyState = "PUBLIC";
 77 |     }
 78 | 
 79 |     fromPlaylistAddToOptionRenderer(obj: any) {
 80 |         this.playlistId = helpers.recursiveSearchForKey("playlistId", obj)[0];
 81 |     }
 82 | 
 83 |     async loadAll() {
 84 |         const res = await this.httpclient.request({
 85 |             method: HTTPRequestMethod.POST,
 86 |             url: ENDPOINT_BROWSE,
 87 |             data: {
 88 |                 browseId: "VL" + this.playlistId
 89 |             }
 90 |         });
 91 |         if(res.status != 200) throw new Error("Invalid Response Code");
 92 |         const resJSON = await JSON.parse(res.data);
 93 |         if(!resJSON.contents) throw new Error("Playlist not found");
 94 | 
 95 |         const playlistRendererContainer = helpers.recursiveSearchForKey("playlistVideoListRenderer", resJSON)[0];
 96 | 
 97 |         if(playlistRendererContainer) {
 98 |             this.canReorder = helpers.recursiveSearchForKey("canReorder", playlistRendererContainer)[0];
 99 |             this.isEditable = helpers.recursiveSearchForKey("isEditable", playlistRendererContainer)[0];
100 |         }
101 | 
102 |         const primaryInfoRendererContainer = helpers.recursiveSearchForKey("playlistSidebarPrimaryInfoRenderer", resJSON)[0];
103 |         if(primaryInfoRendererContainer) {
104 |             const statsContainer = helpers.recursiveSearchForKey("stats", primaryInfoRendererContainer)[0];
105 |             if(statsContainer) {
106 |                 this.videoCount = helpers.getNumberFromText(helpers.recursiveSearchForKey("text", statsContainer[0])[0]);
107 |                 this.viewCount = helpers.getNumberFromText(helpers.recursiveSearchForKey("simpleText", statsContainer[1])[0]);
108 |                 this.lastEditText = helpers.recursiveSearchForKey("text", statsContainer[2]).join("");
109 |             }
110 | 
111 |             //Can edit title
112 |             const titleFormContainer = helpers.recursiveSearchForKey("titleForm", primaryInfoRendererContainer)[0];
113 |             if(titleFormContainer)
114 |                 this.title = helpers.recursiveSearchForKey("simpleText", helpers.recursiveSearchForKey("textDisplayed", titleFormContainer)[0]).join("");
115 | 
116 |             //Cannot edit title
117 |             const titleContainer = primaryInfoRendererContainer.title;
118 |             if(titleContainer)
119 |                 this.title = helpers.recursiveSearchForKey("text", titleContainer).join("");
120 | 
121 |             //Can edit description
122 |             const descriptionForm = helpers.recursiveSearchForKey("descriptionForm", primaryInfoRendererContainer)[0];
123 |             if(descriptionForm)
124 |                 this.description = helpers.recursiveSearchForKey("simpleText", helpers.recursiveSearchForKey("textDisplayed", descriptionForm)[0]).join("");
125 | 
126 |             //Cannot edit description
127 |             const descriptionContainer = helpers.recursiveSearchForKey("description", primaryInfoRendererContainer)[0];
128 |             if(descriptionContainer)
129 |                 this.description= helpers.recursiveSearchForKey("text", descriptionContainer).join("");
130 | 
131 |             const thumbnailsContainer = helpers.recursiveSearchForKey("thumbnails", primaryInfoRendererContainer)[0];
132 |             if(thumbnailsContainer)
133 |                 this.thumbnails = thumbnailsContainer;
134 | 
135 |             const likeButtonContainer = helpers.recursiveSearchForKey("toggleButtonRenderer", primaryInfoRendererContainer)[0];
136 |             if(likeButtonContainer) {
137 |                 this.canLike = true;
138 |                 this.likeParam = helpers.recursiveSearchForKey("removeLikeParams", likeButtonContainer).join("");
139 |             } else this.canLike = false;
140 | 
141 |         } else throw new Error("PrimaryInfoRenderer was missing");
142 | 
143 |         const videoOwnerContainer = helpers.recursiveSearchForKey("videoOwner", resJSON)[0];
144 |         if(videoOwnerContainer) {
145 |             this.owner = new Channel(this.httpclient);
146 |             this.owner.fromVideoOwnerRenderer(videoOwnerContainer);
147 |         }
148 | 
149 |     }
150 | 
151 |     getContinuatedList():PlaylistContinuatedList {
152 |         if(this.continuatedList) return this.continuatedList;
153 | 
154 |         if(this.playlistId) {
155 |             this.continuatedList = new PlaylistContinuatedList(this.playlistId, this.httpclient);
156 |             return this.getContinuatedList();
157 |         }
158 |         
159 |         throw new Error("Cannot construct Continuated List for Playlist without the playlistID");
160 |     }
161 | 
162 |     async like() {
163 |         if(!this.likeParam || !this.canLike) throw new Error("Cannot add or remove Playlist because not all Data is loaded or it is not possible");
164 | 
165 |         const res = await this.httpclient.request({
166 |             method: HTTPRequestMethod.POST,
167 |             url: ENDPOINT_LIKE,
168 |             params: { prettyPrint: false },
169 |             data: {
170 |                 params: this.likeParam,
171 |                 target: {
172 |                     playlistId: this.playlistId
173 |                 }
174 |             },
175 |             noCache: true
176 |         });
177 |         return res.status == 200;
178 |     }
179 | 
180 |     async removeLike() {
181 |         if(!this.likeParam || !this.canLike) throw new Error("Cannot add or remove Playlist because not all Data is loaded or its forbidden");
182 | 
183 |         const res = await this.httpclient.request({
184 |             method: HTTPRequestMethod.POST,
185 |             url: ENDPOINT_REMOVELIKE,
186 |             params: { prettyPrint: false },
187 |             data: {
188 |                 params: this.likeParam,
189 |                 target: {
190 |                     playlistId: this.playlistId
191 |                 }
192 |             },
193 |             noCache: true
194 |         });
195 |         return res.status == 200;
196 |     }
197 | 
198 |     //TODO LOAD EXTENDED INFORMATION
199 | }


--------------------------------------------------------------------------------
/src/interfaces/SearchProposal.ts:
--------------------------------------------------------------------------------
1 | export interface SearchProposal {
2 |     text: string
3 | }


--------------------------------------------------------------------------------
/src/interfaces/SponsorBlockSegment.ts:
--------------------------------------------------------------------------------
 1 | export interface SponsorBlockSegment {
 2 |     segment: number,
 3 |     UUID: string,
 4 |     actionType: string,
 5 |     category?: string,
 6 |     videoDuration?: number,
 7 |     userID?: string,
 8 |     locked?: boolean,
 9 |     votes?: number,
10 |     description?: string
11 | 
12 | }


--------------------------------------------------------------------------------
/src/interfaces/StorageAdapter.ts:
--------------------------------------------------------------------------------
1 | export interface StorageAdapter {
2 |     set(path: string, value: string):Promise<boolean>
3 |     get(path: string):Promise<string>
4 |     exists(path: string):Promise<boolean>
5 | }


--------------------------------------------------------------------------------
/src/interfaces/Thumbnail.ts:
--------------------------------------------------------------------------------
1 | export interface Thumbnail {
2 |     width: number;
3 |     height: number;
4 |     url: string;
5 | }


--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
 1 | import { Explorer } from "./fetchers/Explorer";
 2 | import { ContinuatedList } from "./fetchers/ContinuatedList";
 3 | import { User } from "./fetchers/User";
 4 | import { Authenticator } from "./Authenticator";
 5 | import { Channel } from "./interfaces/Channel";
 6 | import { Video } from "./interfaces/Video";
 7 | import { Playlist } from "./interfaces/Playlist";
 8 | import { Thumbnail } from "./interfaces/Thumbnail";
 9 | import { Badge } from "./interfaces/Badge";
10 | import { HTTPClient } from "./interfaces/HTTPClient";
11 | import { StorageAdapter } from "./interfaces/StorageAdapter";
12 | import { CommentSectionContinuatedList } from "./fetchers/CommentSectionContinuatedList";
13 | import { Comment } from "./interfaces/Comment";
14 | import { CommentThread } from "./interfaces/CommentThread";
15 | import { WrappedHTTPClient } from "./WrappedHTTPClient";
16 | import { CommentThreadRepliesContinuatedList } from "./fetchers/CommentThreadRepliesContinuatedList";
17 | import { CaptionTrack } from "./interfaces/CaptionTrack";
18 | import { List } from "./interfaces/List";
19 | import { SearchProposal } from "./interfaces/SearchProposal";
20 | import { Format } from "./interfaces/Format";
21 | import { default as IYoutube } from "./IYoutube";
22 | import { SponsorBlockSegment } from "./interfaces/SponsorBlockSegment";
23 | import { HTTPRequestOptions, HTTPRequestMethod, HTTPResponse } from "./interfaces/HTTPClient";
24 | 
25 | 
26 | export { IYoutube as IYoutube }
27 | export { HTTPClient as HTTPClient }
28 | export { StorageAdapter as StorageAdapter }
29 | export { WrappedHTTPClient as WrappedHTTPClient }
30 | 
31 | export { Explorer as Explorer }
32 | export { User as User }
33 | export { ContinuatedList as ContinuatedList }
34 | 
35 | export { Authenticator as Authenticator }
36 | export { Channel as Channel }
37 | export { Video as Video }
38 | export { Playlist as Playlist }
39 | export { Thumbnail as Thumbnail }
40 | export { Badge as Badge }
41 | export { CommentSectionContinuatedList as CommentSectionContinuatedList }
42 | export { Comment as Comment }
43 | export { CommentThread as CommentThread }
44 | export { CommentThreadRepliesContinuatedList as CommentThreadRepliesContinuatedList }
45 | export { CaptionTrack as CaptionTrack }
46 | export { List as List }
47 | export { SearchProposal as SearchProposal }
48 | export { Format as Format }
49 | export { HTTPRequestMethod as HTTPRequestMethod }
50 | export { HTTPRequestOptions as HTTPRequestOptions }
51 | export { HTTPResponse as HTTPResponse }
52 | export { SponsorBlockSegment as SponsorBlockSegment }
53 | 
54 | //Skips Webpack checks
55 | export const nodeDefault = async ():Promise<IYoutube> => {
56 |     const path = "./nodeDefault";
57 |     const res = await import(path);
58 |     return res.default;
59 | }


--------------------------------------------------------------------------------
/src/nodeDefault.ts:
--------------------------------------------------------------------------------
1 | import { NodeFetchClientAdapter } from "./adapters/NodeFetchClientAdapter";
2 | import { NodeFSStorageAdapater } from "./adapters/NodeFSStorageAdapter";
3 | 
4 | //Default Export for most NodeJS
5 | import * as path from 'path';
6 | import { IYoutube } from "./main";
7 | 
8 | export default new IYoutube(new NodeFetchClientAdapter(), new NodeFSStorageAdapater(path.resolve(__dirname, "../datastorage")));


--------------------------------------------------------------------------------
/test/test.js:
--------------------------------------------------------------------------------
 1 | /* Import Library */
 2 | const iyoutube = require("../");
 3 | 
 4 | //OR ESM:
 5 | //import * as iyoutube from 'iyoutube';
 6 | 
 7 | (async function() {
 8 |     //Get new Instance for Node.JS (! REQUIRES ASYNC USAGE !)
 9 |     const ytClient = await iyoutube.nodeDefault();
10 | 
11 |     //Init the Client
12 |     await ytClient.init();
13 | 
14 |     //Check if there needs to be User Login
15 |     if (ytClient.authenticator.requiresLogin()) {
16 |         //Get new Codes for Login
17 |         var codes = await ytClient.authenticator.getNewLoginCode();
18 | 
19 |         //Display message with Code and URL for User Action
20 |         console.log("This program requires Login at: " + codes.userUrl);
21 |         console.log("Use the following Code: " + codes.userCode);
22 | 
23 |         //Load the Tokens with the Device Code (will wait until finished)
24 |         await ytClient.authenticator.loadTokensWithDeviceCode(codes.deviceCode);
25 |         console.log("Thank you for login!");
26 |     }
27 |     //We are now Authenticated and can get started
28 | 
29 |     var testPlaylist = await ytClient.getUser().getLikedPlaylist(); //Get the Watch Later Playlist
30 |     await testPlaylist.loadAll(); //Load all Details we can get
31 |     console.log(testPlaylist.videoCount);
32 | 
33 |     var testPlaylistVideos = testPlaylist.getContinuatedList(); //Get the Continuated List
34 |     await testPlaylistVideos.loadFurhter(); //Load Batch of Videos into List
35 |     console.log(testPlaylistVideos.getVideos().length);
36 |     await testPlaylistVideos.loadFurhter(); //Load next Batch of Videos into List
37 |     console.log(testPlaylistVideos.getVideos().length);
38 |     console.log(testPlaylistVideos.endReached);
39 | 
40 |     //Dirty way of getting the Results (without any Type), use the Getters instead!
41 |     console.log(testPlaylistVideos.results);
42 | 
43 |     var testWhat = ytClient.getWhatToWatch(); //Get the Start Page Video List (what to watch Page)
44 |     await testWhat.loadFurhter(); //Load Batch of Videos from List
45 |     console.log(testWhat.getVideos().length);
46 |     await testWhat.loadFurhter(); //Load Batch of Videos from List
47 |     console.log(testWhat.getVideos().length);
48 | 
49 |     // The Video Amount per Batch varies from List Type (e.g Playlist, Search) but also from Randomness of the Youtube API
50 |     // Hint: loadFurther() returns the new Videos and adds them to the results at the same Time
51 | })();


--------------------------------------------------------------------------------
/todo.md:
--------------------------------------------------------------------------------
 1 | ## Todo
 2 | 
 3 | ##### Channels:
 4 | - [X] Fetch all Information
 5 | - [X] Get Channel Uploads
 6 | - [ ] Get Discussion Section
 7 | 
 8 | ##### Videos:
 9 | - [X] Fetch all Information (Youtube Player Response)
10 | - [X] Stream URL Decryption & Video/Audio Formats
11 | - [X] Get Comment Section
12 | - [X] Like and Dislike Comments
13 | - [X] Write Comments on Video
14 | - [ ] Delete own Comments
15 | - [ ] Write Comments on Comment Threads
16 | 
17 | ##### Playlists:
18 | - [ ] Add & Remove Videos
19 | - [ ] Create & Delete
20 | - [ ] Change Order
21 | 
22 | 
23 | General: Documentation, Bugfixes, Enhancements
24 | 
25 | ###### Please keep in mind that I'm working on this Project in my spare time!
26 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "compilerOptions": {
 3 |       "outDir": "output",
 4 |       "target": "ES2015",
 5 |       "removeComments": true,
 6 |       "module": "CommonJS",
 7 |       "declaration": true,
 8 |       "strict": true,
 9 |       "preserveConstEnums": true,
10 |     },
11 |     "include": ["./src/*", "./src/adapters/*"],
12 | }


--------------------------------------------------------------------------------