1.3.6

Bumps [follow-redirects](https://github.com/follow-redirects/follow-redirects) from 1.14.7 to 1.14.8.
- [Release notes](https://github.com/follow-redirects/follow-redirects/releases)
- [Commits](https://github.com/follow-redirects/follow-redirects/compare/v1.14.7...v1.14.8)

---
updated-dependencies:
- dependency-name: follow-redirects
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/ISSUE_TEMPLATE/FEATURE.md

@@ -0,0 +1,19 @@
+---
+name: Feature Request
+about: Use this template for requesting new features
+title: "[FEATURE NAME]"
+labels: enhancement
+assignees: 
+---
+
+## Expected Behavior
+
+Please describe the behavior you are expecting
+
+## Current Behavior
+
+What is the current behavior?
+
+## Sample Code
+
+If applicable, provide a sample code snippet that demonstrates the gist of the feature you're proposing. This can be either from a usage standpoint, or an implementation standpoint.

.github/ISSUE_TEMPLATE/ISSUE.md

@@ -0,0 +1,39 @@
+---
+name: Issue Report
+about: Use this template to report a problem
+title: "[VERSION] [PROBLEM SUMMARY]"
+labels: bug
+assignees: 
+---
+
+## Expected Behavior
+
+Please describe the behavior you are expecting
+
+## Current Behavior
+
+What is the current behavior?
+
+## Failure Information (for bugs)
+
+Please help provide information about the failure if this is a bug. If it is not a bug, please remove the rest of this template.
+
+### Steps to Reproduce
+
+Please provide detailed steps for reproducing the issue.
+
+1. step 1
+2. step 2
+3. you get it...
+
+### Failure Logs
+
+Please include any relevant log snippets or files here.
+
+## Checklist
+
+- [ ] I am running the latest version
+- [ ] I checked the documentation and found no answer
+- [ ] I checked to make sure that this issue has not already been filed
+- [ ] I'm reporting the issue to the correct repository (for multi-repository projects)
+- [ ] I have provided sufficient information

.github/ISSUE_TEMPLATE/QUESTION.md

@@ -0,0 +1,15 @@
+---
+name: Question
+about: Use this template to ask a question about the project
+title: "[QUESTION SUMMARY]"
+labels: question
+assignees: 
+---
+
+## Question
+
+State your question
+
+## Sample Code
+
+Please include relevant code snippets or files that provide context for your question.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/PULL_REQUEST_TEMPLATE/pull_request_template.md

@@ -0,0 +1,27 @@
+# Pull Request Template
+
+## Description
+
+Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change.
+
+Fixes # (issue)
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] This change requires a documentation update
+
+## Checklist:
+
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my own code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] I have checked my code and corrected any misspellings

.github/workflows/node.js.yml

@@ -1,6 +1,5 @@
 # This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
 # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-# TODO: Make actual tests instead of just running the examples file
 
 name: Build
 
@@ -17,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [ 12.x, 14.x, 15.x]
+        node-version: [ 14.x, 15.x, 16.x ]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:
@@ -27,4 +26,4 @@ jobs:
       with:
         node-version: ${{ matrix.node-version }}
     - run: npm install
-    - run: node ./examples
+    - run: npm test

examples/index.js

@@ -2,23 +2,34 @@
 
 const fs = require('fs');
 const Innertube = require('..');
+const creds_path = './yt_oauth_creds.json';
+const creds = fs.existsSync(creds_path) && JSON.parse(fs.readFileSync(creds_path).toString()) || {};
 
 async function start() {
   const youtube = await new Innertube();
+  
+  youtube.ev.on('auth', (data) => {
+    if (data.status === 'AUTHORIZATION_PENDING') {
+      console.info(`Hello!\nOn your phone or computer, go to ${data.verification_url} and enter the code ${data.code}`);
+    } else if (data.status === 'SUCCESS') {
+      fs.writeFileSync(creds_path, JSON.stringify(data.credentials));
+      console.info('Successfully signed-in, enjoy!');
+    }
+  });
+  
+  youtube.ev.on('update-credentials', (data) => {
+    fs.writeFileSync(creds_path, JSON.stringify(data.credentials));
+    console.info('Credentials updated!', data);
+  });
+
+  await youtube.signIn(creds);
 
-  // Searching, getting details about videos & making interactions:
   const search = await youtube.search('Looking for life on Mars - documentary');
   console.info('Search results:', search);
-  
-  if (search.videos.length === 0) 
-    return console.error('Could not find any video about that on YouTube.');
-  
+
   const video = await youtube.getDetails(search.videos[0].id).catch((error) => error);
   console.info('Video details:', video);
- 
-  if (video instanceof Error) 
-    return console.error('Could not get details for ' + search.videos[0].title);
-  
+
   if (youtube.logged_in) {
     const myNotifications = await youtube.getNotifications();
     console.info('My notifications:', myNotifications);

lib/Actions.js

@@ -5,9 +5,19 @@ const Axios = require('axios');
 const Utils = require('./Utils');
 const Constants = require('./Constants');
 
+/**
+ * Performs direct interactions on YouTube.
+ *
+ * @param {Innertube} session A valid Innertube session.
+ * @param {string} engagement_type Type of engagement.
+ * @param {object} args Engagement arguments.
+ * @returns {Promise.<object>} { success: boolean, status_code: number } | { success: boolean, status_code: number, message: string }
+ */
 async function engage(session, engagement_type, args = {}) {
-  if (!session.logged_in) throw new Error('You are not logged in');
-  let data = {};
+  if (!session.logged_in) throw new Error('You are not signed-in');
+
+  let data;
+
   switch (engagement_type) {
     case 'like/like':
     case 'like/dislike':
@@ -23,42 +33,104 @@ async function engage(session, engagement_type, args = {}) {
     case 'subscription/unsubscribe':
       data = {
         context: session.context,
-        channelIds: [args.channel_id]
+        channelIds: [args.channel_id],
+        params: engagement_type == 'subscription/subscribe' ? 'EgIIAhgA' : 'CgIIAhgA'
       };
       break;
     case 'comment/create_comment':
       data = {
         context: session.context,
         commentText: args.text,
-        createCommentParams: Utils.generateCommentParams(args.video_id)
+        createCommentParams: Utils.encodeCommentParams(args.video_id)
       };
       break;
     default:
   }
 
-  const response = await Axios.post(`${Constants.urls.YT_BASE_URL}/youtubei/v1/${engagement_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`, JSON.stringify(data), Constants.innertube_request_opts({ session, id: args.video_id, data })).catch((error) => error);
+  const response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/${engagement_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`,
+    JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session, id: args.video_id, data })).catch((error) => error);
+
   if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
+
   return {
     success: true,
     status_code: response.status
   };
 }
 
-async function browse(session, action_type) {
-  if (!session.logged_in) throw new Error('You are not logged in');
+/**
+ * Accesses YouTube's various sections.
+ *
+ * @param {Innertube} session - A valid Innertube session.
+ * @param {string} action_type - Type of action.
+ * @param {object} args - Action argumenets.
+ * @returns {Promise.<object>} { success: boolean, status_code: number, data: object } | { success: boolean, status_code: number, message: string } 
+ */
+async function browse(session, action_type, args = {}) {
+  if (!session.logged_in && (action_type != 'lyrics' || action_type != 'music_playlist'))
+    throw new Error('You are not signed-in');
+
   let data;
+
   switch (action_type) {
+    case 'account_notifications':
+      data = {
+        context: session.context,
+        browseId: 'SPaccount_notifications'
+      };
+      break;
+    case 'account_privacy':
+      data = {
+        context: session.context,
+        browseId: 'SPaccount_privacy'
+      };
+      break;
+    case 'history':
+      data = {
+        context: session.context,
+        browseId: 'FEhistory'
+      }
+      break;
+    case 'home_feed':
+      data = {
+        context: session.context,
+        browseId: 'FEwhat_to_watch'
+      };
+      break;
     case 'subscriptions_feed':
       data = {
         context: session.context,
         browseId: 'FEsubscriptions'
       };
       break;
+    case 'lyrics':
+    case 'music_playlist':
+      const context = JSON.parse(JSON.stringify(session.context)); // deep copy the context obj so we don't accidentally change it
+
+      context.client.originalUrl = Constants.URLS.YT_MUSIC_URL;
+      context.client.clientVersion = Constants.YTMUSIC_VERSION;
+      context.client.clientName = 'WEB_REMIX';
+
+      data = {
+        context,
+        browseId: args.browse_id
+      }
+      break;
+    case 'playlist':
+      data = {
+        context: session.context,
+        browseId: args.browse_id
+      }
+      break;
     default:
   }
-  
-  const response = await Axios.post(`${Constants.urls.YT_BASE_URL}/youtubei/v1/browse${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`, JSON.stringify(data), Constants.innertube_request_opts({ session })).catch((error) => error);
+
+  const client_domain = args.ytmusic && Constants.URLS.YT_MUSIC_URL || Constants.URLS.YT_BASE_URL;
+  const response = await Axios.post(`${client_domain}/youtubei/v1/browse${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`,
+    JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session, ytmusic: args.ytmusic })).catch((error) => error);
+
   if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
+
   return {
     success: true,
     status_code: response.status,
@@ -66,9 +138,152 @@ async function browse(session, action_type) {
   };
 }
 
-async function notifications(session, action_type, args = {}) {
-  if (!session.logged_in) throw new Error('You are not logged in');
+
+/**
+ * Account settings endpoints.
+ *
+ * @param {Innertube} session - A valid Innertube session.
+ * @param {string} action_type - Type of action.
+ * @param {object} args - Action argumenets.
+ * @returns {Promise.<object>} { success: boolean, status_code: number, data: object } | { success: boolean, status_code: number, message: string } 
+ */
+async function account(session, action_type, args = {}) {
+  if (!session.logged_in) throw new Error('You are not signed-in');
+
   let data;
+
+  switch (action_type) {
+    case 'account/account_menu':
+      data = { context: session.context };
+      break;
+    case 'account/set_setting':
+      data = {
+        context: session.context,
+        newValue: {
+          boolValue: args.new_value
+        },
+        settingItemId: args.setting_item_id
+      }
+      break;
+    default:
+      break;
+  }
+
+  const response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/${action_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`,
+    JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session })).catch((error) => error);
+
+  if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
+
+  return {
+    success: true,
+    status_code: response.status,
+    data: response.data
+  };
+}
+
+/**
+ * Accesses YouTube Music endpoints under /youtubei/v1/music/.
+ * 
+ * @param {Innertube} session - A valid Innertube session.
+ * @param {string} action_type - Type of action.
+ * @param {object} args - Action arguments.
+ * @todo Implement more actions.
+ * @returns 
+ */
+async function music(session, action_type, args) {
+  const context = JSON.parse(JSON.stringify(session.context)); // deep copy the context obj so we don't accidentally change it
+
+  context.client.originalUrl = Constants.URLS.YT_MUSIC_URL;
+  context.client.clientVersion = Constants.YTMUSIC_VERSION;
+  context.client.clientName = 'WEB_REMIX';
+
+  let data;
+
+  switch (action_type) {
+    case 'get_search_suggestions':
+      data = {
+        context,
+        input: args.input || ''
+      };
+      break;
+    default:
+      break;
+  }
+
+  const response = await Axios.post(`${Constants.URLS.YT_MUSIC_URL}/youtubei/v1/music/${action_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`,
+    JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session, ytmusic: true })).catch((error) => error);
+
+  if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
+
+  return {
+    success: true,
+    status_code: response.status,
+    data: response.data
+  };
+}
+
+/**
+ * Performs searches on YouTube.
+ *
+ * @param {Innertube} session - A valid Innertube session.
+ * @param {string} client - YouTube client: YOUTUBE | YTMUSIC
+ * @param {object} args - Search arguments.
+ * @returns {Promise.<object>} - { success: boolean, status_code: number, data: object } | { success: boolean, status_code: number, message: string } 
+ */
+async function search(session, client, args = {}) {
+  if (!args.query) throw new Error('No query was provided');
+
+  let data;
+
+  switch (client) {
+    case 'YOUTUBE':
+      data = {
+        context: session.context,
+        params: Utils.encodeFilter(args.options.period, args.options.duration, args.options.order),
+        query: args.query
+      };
+      break;
+    case 'YTMUSIC':
+      const context = JSON.parse(JSON.stringify(session.context)); // deep copy the context obj so we don't accidentally change it
+
+      context.client.originalUrl = Constants.URLS.YT_MUSIC_URL;
+      context.client.clientVersion = Constants.YTMUSIC_VERSION;
+      context.client.clientName = 'WEB_REMIX';
+
+      data = {
+        context: context,
+        query: args.query
+      };
+      break;
+    default:
+      break;
+  }
+
+  const response = await Axios.post(`${client === 'YOUTUBE' && Constants.URLS.YT_BASE_URL || Constants.URLS.YT_MUSIC_URL}/youtubei/v1/search${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`,
+    JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session, ytmusic: client === 'YTMUSIC' })).catch((error) => error);
+
+  if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
+
+  return {
+    success: true,
+    status_code: response.status,
+    data: response.data
+  };
+}
+
+/**
+ * Interacts with YouTube's notification system.
+ *
+ * @param {Innertube} session - A valid Innertube session.
+ * @param {string} action_type - Type of action.
+ * @param {object} args - Action arguments.
+ * @returns {Promise.<object>} - { success: boolean, status_code: number, data: object } | { success: boolean, status_code: number, message: string } 
+ */
+async function notifications(session, action_type, args = {}) {
+  if (!session.logged_in) throw new Error('You are not signed-in');
+
+  let data;
+
   switch (action_type) {
     case 'modify_channel_preference':
       let pref_types = { PERSONALIZED: 1, ALL: 2, NONE: 3 };
@@ -91,9 +306,12 @@ async function notifications(session, action_type, args = {}) {
     default:
   }
 
-  const response = await Axios.post(`${Constants.urls.YT_BASE_URL}/youtubei/v1/notification/${action_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`, JSON.stringify(data), Constants.innertube_request_opts({ session })).catch((error) => error);
+  const response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/notification/${action_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`,
+    JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session })).catch((error) => error);
+
   if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
   if (action_type === 'modify_channel_preference') return { success: true, status_code: response.status };
+
   return {
     success: true,
     status_code: response.status,
@@ -101,13 +319,28 @@ async function notifications(session, action_type, args = {}) {
   };
 }
 
+/**
+ * Interacts with YouTube's livechat system.
+ *
+ * @param {Innertube} session - A valid Innertube session.
+ * @param {string} action_type - Type of action.
+ * @param {object} args - Action arguments.
+ * @returns {Promise.<object>} - { success: boolean, status_code: number, data: object } | { success: boolean, status_code: number, message: string } 
+ */
 async function livechat(session, action_type, args = {}) {
   let data;
+
   switch (action_type) {
-    case 'live_chat/send_message': 
+    case 'live_chat/get_live_chat':
       data = {
         context: session.context,
-        params: Utils.generateMessageParams(args.channel_id, args.video_id),
+        continuation: args.ctoken
+      };
+      break;
+    case 'live_chat/send_message':
+      data = {
+        context: session.context,
+        params: Utils.encodeMessageParams(args.channel_id, args.video_id),
         clientMessageId: `ytjs-${Uuid.v4()}`,
         richMessage: {
           textSegments: [{ text: args.text }]
@@ -125,36 +358,85 @@ async function livechat(session, action_type, args = {}) {
         params: args.cmd_params
       };
       break;
+    case 'updated_metadata':
+      data = {
+        context: session.context,
+        videoId: args.video_id
+      };
+      args.continuation && (data.continuation = args.continuation);
+      break;
     default:
   }
-  
-  const response = await Axios.post(`${Constants.urls.YT_BASE_URL}/youtubei/v1/${action_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`, JSON.stringify(data), Constants.innertube_request_opts({ session, params: args.params })).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
+
+  const response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/${action_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`,
+    JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session, params: args.params })).catch((error) => error);
+
+  if (response instanceof Error) return { success: false, message: response.message };
+
+  return { success: true, data: response.data };
 }
 
-async function getContinuation(session, info = {}) {
-  let data = { context: session.context };
-  info.continuation_token && (data.continuation = info.continuation_token);
+/**
+ * Gets detailed data for a video.
+ *
+ * @param {Innertube} session - A valid Innertube session.
+ * @param {object} args - Request arguments.
+ * @returns {Promise.<object>} - Video data.
+ */
+async function getVideoInfo(session, args = {}) {
+  let response;
 
-  if (info.video_id) {
-    data.videoId = info.video_id;
-    data.racyCheckOk = true;
-    data.contentCheckOk = false;
-    data.autonavState = 'STATE_NONE';
-    data.playbackContext = {
-      vis: 0,
-      lactMilliseconds: '-1'
-    };
-    data.captionsRequested = false;
+  !args.desktop &&
+    (response = await Axios.get(`${Constants.URLS.YT_WATCH_PAGE}?v=${args.id}&t=8s&pbj=1`, Constants.INNERTUBE_REQOPTS({ session, id: args.id, desktop: false })).catch((error) => error)) ||
+    (response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/player${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`,
+      JSON.stringify(Constants.VIDEO_INFO_REQBODY(args.id, session.sts, session.context)), Constants.INNERTUBE_REQOPTS({ session, id: args.id, desktop: true })).catch((error) => error));
+
+  if (response instanceof Error) throw new Error(`Could not get video info: ${response.message}`);
+
+  return response.data;
+}
+
+/**
+ * Requests continuation for previously performed actions.
+ *
+ * @param {Innertube} session - A valid Innertube session.
+ * @param {object} args - Continuation arguments.
+ * @returns {Promise.<object>} - { success: boolean, status_code: number, data: object } | { success: boolean, status_code: number, message: string } 
+ */
+async function getContinuation(session, args = {}) {
+  let data = { context: session.context };
+  args.continuation_token && (data.continuation = args.continuation_token);
+
+  if (args.video_id) {
+    data.videoId = args.video_id;
+    if (args.ytmusic) {
+      const context = JSON.parse(JSON.stringify(session.context)); // deep copy the context obj so we don't accidentally change it
+
+      context.client.originalUrl = Constants.URLS.YT_MUSIC_URL;
+      context.client.clientVersion = Constants.YTMUSIC_VERSION;
+      context.client.clientName = 'WEB_REMIX';
+
+      data.context = context;
+      data.isAudioOnly = true;
+      data.tunerSettingValue = 'AUTOMIX_SETTING_NORMAL';
+    } else {
+      data.racyCheckOk = true;
+      data.contentCheckOk = false;
+      data.autonavState = 'STATE_NONE';
+      data.playbackContext = {
+        vis: 0,
+        lactMilliseconds: '-1'
+      }
+      data.captionsRequested = false;
+    }
   }
 
-  const response = await Axios.post(`${Constants.urls.YT_BASE_URL}/youtubei/v1/next${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`, JSON.stringify(data), Constants.innertube_request_opts({ session })).catch((error) => error);
+  const client_domain = args.ytmusic && Constants.URLS.YT_MUSIC_URL || Constants.URLS.YT_BASE_URL;
+  const response = await Axios.post(`${client_domain}/youtubei/v1/next${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`,
+    JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session, ytmusic: args.ytmusic })).catch((error) => error);
+
   if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
+
   return {
     success: true,
     status_code: response.status,
@@ -162,4 +444,24 @@ async function getContinuation(session, info = {}) {
   };
 }
 
-module.exports = { engage, browse, notifications, livechat, getContinuation };
+/**
+ * Gets search suggestions.
+ * 
+ * @param {Innertube} session 
+ * @param {string} query 
+ * @returns 
+ */
+async function getYTSearchSuggestions(session, query) {
+  const response = await Axios.get(`${Constants.URLS.YT_SUGGESTIONS}search?client=firefox&ds=yt&q=${query}`,
+   Constants.DEFAULT_HEADERS(session)).catch((error) => error);
+
+  if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
+
+  return {
+    success: true,
+    status_code: response.status,
+    data: response.data
+  };
+}
+
+module.exports = { engage, browse, account, music, search, notifications, livechat, getVideoInfo, getContinuation, getYTSearchSuggestions };

lib/Constants.js

@@ -2,328 +2,143 @@
 
 const Utils = require('./Utils');
 
-const urls = {
-  YT_BASE_URL: 'https://www.youtube.com',
-  YT_MOBILE_URL: 'https://m.youtube.com',
-  YT_WATCH_PAGE: 'https://m.youtube.com/watch',
-};
-
-const oauth = {
-  scope: 'http://gdata.youtube.com https://www.googleapis.com/auth/youtube-paid-content',
-  grant_type: 'http://oauth.net/grant_type/device/1.0',
-  model_name: 'ytlr::'
-};
-
-const oauth_reqopts = {
-  headers: {
-    'accept': '*/*',
-    'origin': urls.YT_BASE_URL,
-    'user-agent': 'Mozilla/5.0 (ChromiumStylePlatform) Cobalt/Version',
-    'content-type': 'application/json',
-    'referer': `${urls.YT_BASE_URL}/tv`,
-    'accept-language': 'en-US'
-  }
-};
-
-const default_headers = (session) => {
-  return {
-    headers: {
-      'Cookie': session.cookie,
-      'user-agent': Utils.getRandomUserAgent('desktop').userAgent,
-      'Referer': 'https://www.google.com/',
-      'Accept': 'text/html',
-      'Accept-Language': 'en-US,en',
-      'Accept-Encoding': 'gzip',
-      'Upgrade-Insecure-Requests': 1
-    }
-  };
-};
-
-const innertube_request_opts = (info) => {
-  info.desktop === undefined && (info.desktop = true);
-  let req_opts = {
-    params: info.params || {},
-    headers: {
-      'accept': '*/*',
-      'user-agent': Utils.getRandomUserAgent(info.desktop ? 'desktop' : 'mobile').userAgent,
-      'content-type': 'application/json',
-      'accept-language': 'en-US,en;q=0.9',
-      'x-goog-authuser': 0,
-      'x-goog-visitor-id': info.session.context.client.visitorData,
-      'x-youtube-client-name': info.desktop ? 1 : 2,
-      'x-youtube-client-version': info.session.context.client.clientVersion,
-      'x-youtube-chrome-connected': 'source=Chrome,mode=0,enable_account_consistency=true,supervised=false,consistency_enabled_by_default=false',
-      'x-origin': info.desktop ? urls.YT_BASE_URL : urls.YT_MOBILE_URL,
-      'origin': info.desktop ? urls.YT_BASE_URL : urls.YT_MOBILE_URL,
-    }
-  };
-  
-  info.id && (req_opts.headers.referer = (info.desktop ? urls.YT_BASE_URL : urls.YT_MOBILE_URL) + '/watch?v=' + info.id);
-
-  if (info.session.logged_in && info.desktop) {
-    req_opts.headers.Cookie = info.session.cookie;
-    req_opts.headers.authorization = info.session.cookie.length < 1 ? `Bearer ${info.session.access_token}` : info.session.auth_apisid;
-  }
-
-  return req_opts;
-};
-
-const video_details_reqbody = (id, sts, context) => {
-  return {
-    playbackContext: {
-      contentPlaybackContext: {
-        'currentUrl': '/watch?v=' + id,
-        'vis': 0,
-        'splay': false,
-        'autoCaptionsDefaultOn': false,
-        'autonavState': 'STATE_OFF',
-        'html5Preference': 'HTML5_PREF_WANTS',
-        'signatureTimestamp': sts,
-        'referer': urls.YT_BASE_URL,
-        'lactMilliseconds': '-1'
+module.exports = {
+  URLS: {
+    YT_BASE_URL: 'https://www.youtube.com',
+    YT_MUSIC_URL: 'https://music.youtube.com',
+    YT_MOBILE_URL: 'https://m.youtube.com',
+    YT_WATCH_PAGE: 'https://m.youtube.com/watch',
+    YT_SUGGESTIONS: 'https://suggestqueries.google.com/complete/'
+  },
+  OAUTH: {
+    SCOPE: 'http://gdata.youtube.com https://www.googleapis.com/auth/youtube-paid-content',
+    GRANT_TYPE: 'http://oauth.net/grant_type/device/1.0',
+    MODEL_NAME: 'ytlr::',
+    HEADERS: {
+      headers: {
+        'accept': '*/*',
+        'origin': 'https://www.youtube.com',
+        'user-agent': 'Mozilla/5.0 (ChromiumStylePlatform) Cobalt/Version',
+        'content-type': 'application/json',
+        'referer': `https://www.youtube.com/tv`,
+        'accept-language': 'en-US'
       }
-    },
-    context: context,
-    videoId: id
-  };
-};
-
-const stream_headers = (range) => {
-  let headers = {
+    }
+  },
+  DEFAULT_HEADERS: (session) => {
+    return {
+      headers: {
+        'Cookie': session.cookie,
+        'user-agent': Utils.getRandomUserAgent('desktop').userAgent,
+        'Referer': 'https://www.google.com/',
+        'Accept': 'text/html',
+        'Accept-Language': 'en-US,en',
+        'Accept-Encoding': 'gzip',
+        'Upgrade-Insecure-Requests': 1
+      }
+    };
+  },
+  STREAM_HEADERS: {
     'Accept': '*/*',
     'User-Agent': Utils.getRandomUserAgent('desktop').userAgent,
     'Connection': 'keep-alive',
-    'Origin': urls.YT_BASE_URL,
-    'Referer': urls.YT_BASE_URL,
+    'Origin': 'https://www.youtube.com',
+    'Referer': 'https://www.youtube.com',
     'DNT': '?1'
-  };
-  range && (headers.Range = range);
-  return headers;
-};
+  },
+  INNERTUBE_REQOPTS: (info) => {
+    info.desktop === undefined && (info.desktop = true);
+    const origin = info.ytmusic && 'https://music.youtube.com' ||
+      info.desktop && 'https://www.youtube.com' || 'https://m.youtube.com';
 
-const formatVideoData = (data, context, desktop) => {
-  let video_details = {};
-  let metadata = {};
+    let req_opts = {
+      params: info.params || {},
+      headers: {
+        'accept': '*/*',
+        'user-agent': Utils.getRandomUserAgent(info.desktop ? 'desktop' : 'mobile').userAgent,
+        'content-type': 'application/json',
+        'accept-language': 'en-US,en;q=0.9',
+        'x-goog-authuser': 0,
+        'x-goog-visitor-id': info.session.context.client.visitorData || '',
+        'x-youtube-client-name': info.desktop ? 1 : 2,
+        'x-youtube-client-version': info.session.context.client.clientVersion,
+        'x-youtube-chrome-connected': 'source=Chrome,mode=0,enable_account_consistency=true,supervised=false,consistency_enabled_by_default=false',
+        'x-origin': origin,
+        'origin': origin,
+      }
+    };
 
-  if (desktop) {
-    metadata.embed = data.microformat.playerMicroformatRenderer.embed;
-    metadata.view_count = parseInt(data.videoDetails.viewCount);
-    metadata.average_rating = data.videoDetails.averageRating;
-    metadata.length_seconds = data.microformat.playerMicroformatRenderer.lengthSeconds;
-    metadata.channel_id = data.videoDetails.channelId;
-    metadata.channel_url = data.microformat.playerMicroformatRenderer.ownerProfileUrl;
-    metadata.external_channel_id = data.microformat.playerMicroformatRenderer.externalChannelId;
-    metadata.is_live_content = data.videoDetails.isLiveContent;
-    metadata.is_family_safe = data.microformat.playerMicroformatRenderer.isFamilySafe;
-    metadata.is_unlisted = data.microformat.playerMicroformatRenderer.isUnlisted;
-    metadata.is_private = data.videoDetails.isPrivate;
-    metadata.has_ypc_metadata = data.microformat.playerMicroformatRenderer.hasYpcMetadata;
-    metadata.category = data.microformat.playerMicroformatRenderer.category;
-    metadata.channel_name = data.microformat.playerMicroformatRenderer.ownerChannelName;
-    metadata.publish_date = data.microformat.playerMicroformatRenderer.publishDate || 'N/A';
-    metadata.upload_date = data.microformat.playerMicroformatRenderer.uploadDate || 'N/A';
-    metadata.keywords = data.videoDetails.keywords || [];
+    info.id && (req_opts.headers.referer = (info.desktop ? 'https://www.youtube.com' : 'https://m.youtube.com') + '/watch?v=' + info.id);
 
-    video_details.title = data.videoDetails.title;
-    video_details.description = data.videoDetails.shortDescription;
-    video_details.thumbnail = data.videoDetails.thumbnail.thumbnails.slice(-1)[0];
-    video_details.metadata = metadata;
-  } else {
-    metadata.embed = data[2].playerResponse.microformat.playerMicroformatRenderer.embed;
-    metadata.likes = parseInt(data[3].response.contents.singleColumnWatchNextResults.results.results.contents[1].slimVideoMetadataSectionRenderer.contents[1].slimVideoActionBarRenderer.buttons[0].slimMetadataToggleButtonRenderer.button.toggleButtonRenderer.defaultText.accessibility.accessibilityData.label.replace(/\D/g, ''));
-    metadata.dislikes = parseInt(data[3].response.contents.singleColumnWatchNextResults.results.results.contents[1].slimVideoMetadataSectionRenderer.contents[1].slimVideoActionBarRenderer.buttons[1].slimMetadataToggleButtonRenderer.button.toggleButtonRenderer.defaultText.accessibility.accessibilityData.label.replace(/\D/g, ''));
-    metadata.view_count = parseInt(data[2].playerResponse.videoDetails.viewCount);
-    metadata.average_rating = data[2].playerResponse.videoDetails.averageRating;
-    metadata.length_seconds = data[2].playerResponse.microformat.playerMicroformatRenderer.lengthSeconds;
-    metadata.channel_id = data[2].playerResponse.videoDetails.channelId;
-    metadata.channel_url = data[2].playerResponse.microformat.playerMicroformatRenderer.ownerProfileUrl;
-    metadata.external_channel_id = data[2].playerResponse.microformat.playerMicroformatRenderer.externalChannelId;
-    metadata.is_live_content = data[2].playerResponse.videoDetails.isLiveContent;
-    metadata.is_family_safe = data[2].playerResponse.microformat.playerMicroformatRenderer.isFamilySafe;
-    metadata.is_unlisted = data[2].playerResponse.microformat.playerMicroformatRenderer.isUnlisted;
-    metadata.is_private = data[2].playerResponse.videoDetails.isPrivate;
-    metadata.has_ypc_metadata = data[2].playerResponse.microformat.playerMicroformatRenderer.hasYpcMetadata;
-    metadata.category = data[2].playerResponse.microformat.playerMicroformatRenderer.category;
-    metadata.channel_name = data[2].playerResponse.microformat.playerMicroformatRenderer.ownerChannelName;
-    metadata.publish_date = data[2].playerResponse.microformat.playerMicroformatRenderer.publishDate;
-    metadata.upload_date = data[2].playerResponse.microformat.playerMicroformatRenderer.uploadDate;
-    metadata.keywords = data[2].playerResponse.videoDetails.keywords;
+    if (info.session.logged_in && info.desktop) {
+      req_opts.headers.Cookie = info.session.cookie;
+      req_opts.headers.authorization = info.session.cookie.length < 1 ? `Bearer ${info.session.access_token}` : info.session.auth_apisid;
+    }
 
-    video_details.title = data[2].playerResponse.videoDetails.title;
-    video_details.description = data[2].playerResponse.videoDetails.shortDescription;
-    video_details.thumbnail = data[2].playerResponse.videoDetails.thumbnail.thumbnails.slice(-1)[0];
+    return req_opts;
+  },
+  VIDEO_INFO_REQBODY: (id, sts, context) => {
+    return {
+      playbackContext: {
+        contentPlaybackContext: {
+          'currentUrl': '/watch?v=' + id,
+          'vis': 0,
+          'splay': false,
+          'autoCaptionsDefaultOn': false,
+          'autonavState': 'STATE_OFF',
+          'html5Preference': 'HTML5_PREF_WANTS',
+          'signatureTimestamp': sts,
+          'referer': 'https://www.youtube.com',
+          'lactMilliseconds': '-1'
+        }
+      },
+      context: context,
+      videoId: id
+    };
+  },
+  YTMUSIC_VERSION: '1.20211213.00.00',
+  METADATA_KEYS: [
+    'embed', 'view_count', 'average_rating',
+    'length_seconds', 'channel_id', 'channel_url',
+    'external_channel_id', 'is_live_content', 'is_family_safe',
+    'is_unlisted', 'is_private', 'has_ypc_metadata',
+    'category', 'owner_channel_name', 'publish_date',
+    'upload_date', 'keywords', 'available_countries',
+    'owner_profile_url'
+  ],
+  BLACKLISTED_KEYS: [
+    'is_owner_viewing', 'is_unplugged_corpus',
+    'is_crawlable', 'allow_ratings', 'author'
+  ],
+  ACCOUNT_SETTINGS: {
+    // Notifications
+    SUBSCRIPTIONS: 'NOTIFICATION_SUBSCRIPTION_NOTIFICATIONS',
+    RECOMMENDED_VIDEOS: 'NOTIFICATION_RECOMMENDATION_WEB_CONTROL',
+    CHANNEL_ACTIVITY: 'NOTIFICATION_COMMENT_WEB_CONTROL',
+    COMMENT_REPLIES: 'NOTIFICATION_COMMENT_REPLY_OTHER_WEB_CONTROL',
+    USER_MENTION: 'NOTIFICATION_USER_MENTION_WEB_CONTROL',
+    SHARED_CONTENT: 'NOTIFICATION_RETUBING_WEB_CONTROL',
 
-    // Functions
-    video_details.like = () => {};
-    video_details.dislike = () => {};
-    video_details.removeLike = () => {};
-    video_details.subscribe = () => {};
-    video_details.unsubscribe = () => {};
-    video_details.comment = () => {};
-    video_details.getComments = () => {};
-    video_details.setNotificationPref = () => {};
-    video_details.getLivechat = () => {};
-
-    // Additional metadata
-    video_details.metadata = metadata;
+    // Privacy 
+    PLAYLISTS_PRIVACY: 'PRIVACY_DISCOVERABLE_SAVED_PLAYLISTS',
+    SUBSCRIPTIONS_PRIVACY: 'PRIVACY_DISCOVERABLE_SUBSCRIPTIONS'
+  },
+  BASE64_DIALECT: {
+    NORMAL: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'.split(''),
+    REVERSE: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_'.split('')
+  },
+  FUNCS_REGEX: /d\.push\(e\)|d\.reverse\(\)|d\[0\]\)\[0\]\)|f=d\[0];d\[0\]|d\.length;d\.splice\(e,1\)|function\(\){for\(var|function\(d,e,f\){var|function\(d\){for\(var|reverse\(\)\.forEach|unshift\(d\.pop\(\)\)|function\(d,e\){for\(var f/,
+  FUNCS: {
+    PUSH: 'd.push(e)',
+    REVERSE_1: 'd.reverse()',
+    REVERSE_2: 'function(d){for(var',
+    SPLICE: 'd.length;d.splice(e,1)',
+    SWAP0_1: 'd[0])[0])',
+    SWAP0_2: 'f=d[0];d[0]',
+    ROTATE_1: 'reverse().forEach',
+    ROTATE_2: 'unshift(d.pop())',
+    BASE64_DIA: 'function(){for(var',
+    TRANSLATE_1: 'function(d,e){for(var f',
+    TRANSLATE_2: 'function(d,e,f){var'
   }
-  return video_details;
-};
-
-const base64_alphabet = {
-  normal: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'.split(''),
-  reverse: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_'.split('')
-};
-
-const filters = (order) => { 
-  // It seems like all of these are just proto buffers, so I think it'll be easy to refactor
-  switch (order) {
-    case 'any,any,relevance':
-      return 'EgIQAQ%3D%3D';
-    case 'hour,any,relevance':
-      return 'EgIIAQ%3D%3D';
-    case 'day,any,relevance':
-      return 'EgQIAhAB';
-    case 'week,any,relevance':
-      return 'EgQIAxAB';
-    case 'month,any,relevance':
-      return 'EgQIBBAB';
-    case 'year,any,relevance':
-      return 'EgQIBRAB';
-    case 'any,short,relevance':
-      return 'EgQQARgB';
-    case 'hour,short,relevance':
-      return 'EgYIARABGAE%3D';
-    case 'day,short,relevance':
-      return 'EgYIAhABGAE%3D';
-    case 'week,short,relevance':
-      return 'EgYIAxABGAE%3D';
-    case 'month,short,relevance':
-      return 'EgYIBBABGAE%3D';
-    case 'year,short,relevance':
-      return 'EgYIBRABGAE%3D';
-    case 'any,long,relevance':
-      return 'EgQQARgC';
-    case 'hour,long,relevance':
-      return 'EgYIARABGAI%3D';
-    case 'day,long,relevance':
-      return 'EgYIAhABGAI%3D';
-    case 'week,long,relevance':
-      return 'EgYIAxABGAI%3D';
-    case 'month,long,relevance':
-      return 'EgYIBBABGAI%3D';
-    case 'year,long,relevance':
-      return 'EgYIBRABGAI%3D';
-    case 'any,any,age':
-      return 'CAISAhAB';
-    case 'hour,any,age':
-      return 'CAISBAgBEAE%3D';
-    case 'day,any,age':
-      return 'CAISBAgCEAE%3D';
-    case 'week,any,age':
-      return 'CAISBAgDEAE%3D';
-    case 'month,any,age':
-      return 'CAISBAgEEAE%3D';
-    case 'year,any,age':
-      return 'CAISBAgFEAE%3D';
-    case 'any,short,age':
-      return 'CAISBBABGAE%3D';
-    case 'hour,short,age':
-      return 'CAISBggBEAEYAQ%3D%3D';
-    case 'day,short,age':
-      return 'CAISBggCEAEYAQ%3D%3D';
-    case 'week,short,age':
-      return 'CAISBggDEAEYAQ%3D%3D';
-    case 'month,short,age':
-      return 'CAISBggEEAEYAQ%3D%3D';
-    case 'year,short,age':
-      return 'CAISBggFEAEYAQ%3D%3D';
-    case 'any,long,age':
-      return 'CAISBBABGAI%3D';
-    case 'hour,long,age':
-      return 'CAISBggBEAEYAg%3D%3D';
-    case 'day,long,age':
-      return 'CAISBggCEAEYAg%3D%3D';
-    case 'week,long,age':
-      return 'CAISBggDEAEYAg%3D%3D';
-    case 'month,long,age':
-      return 'CAISBggEEAEYAg%3D%3D';
-    case 'year,long,age':
-      return 'CAISBggFEAEYAg%3D%3D';
-    case 'any,any,views':
-      return 'CAMSAhAB';
-    case 'hour,any,views':
-      return 'CAMSBAgBEAE%3D';
-    case 'day,any,views':
-      return 'CAMSBAgCEAE%3D';
-    case 'week,any,views':
-      return 'CAMSBAgDEAE%3D';
-    case 'month,any,views':
-      return 'CAMSBAgEEAE%3D';
-    case 'year,any,views':
-      return 'CAMSBAgFEAE%3D';
-    case 'any,short,views':
-      return 'CAMSBBABGAE%3D';
-    case 'hour,short,views':
-      return 'CAMSBggBEAEYAQ%3D%3D';
-    case 'day,short,views':
-      return 'CAMSBggCEAEYAQ%3D%3D';
-    case 'week,short,views':
-      return 'CAMSBggDEAEYAQ%3D%3D';
-    case 'month,short,views':
-      return 'CAMSBggEEAEYAQ%3D%3D';
-    case 'year,short,views':
-      return 'CAMSBggFEAEYAQ%3D%3D';
-    case 'any,long,views':
-      return 'CAMSBBABGAI%3D';
-    case 'hour,long,views':
-      return 'CAMSBggBEAEYAg%3D%3D';
-    case 'day,long,views':
-      return 'CAMSBggCEAEYAg%3D%3D';
-    case 'week,long,views':
-      return 'CAMSBggDEAEYAg%3D%3D';
-    case 'month,long,views':
-      return 'CAMSBggEEAEYAg%3D%3D';
-    case 'year,long,views':
-      return 'CAMSBggFEAEYAg%3D%3D';
-    case 'any,any,rating':
-      return 'CAESAhAB';
-    case 'hour,any,rating':
-      return 'CAESBAgBEAE%3D';
-    case 'day,any,rating':
-      return 'CAESBAgCEAE%3D';
-    case 'week,any,rating':
-      return 'CAESBAgDEAE%3D';
-    case 'month,any,rating':
-      return 'CAESBAgEEAE%3D';
-    case 'year,any,rating':
-      return 'CAESBAgFEAE%3D';
-    case 'any,short,rating':
-      return 'CAESBBABGAE%3D';
-    case 'hour,short,rating':
-      return 'CAESBggBEAEYAQ%3D%3D';
-    case 'day,short,rating':
-      return 'CAESBggCEAEYAQ%3D%3D';
-    case 'week,short,rating':
-      return 'CAESBggDEAEYAQ%3D%3D';
-    case 'month,short,rating':
-      return 'CAESBggEEAEYAQ%3D%3D';
-    case 'year,short,rating':
-      return 'CAESBggFEAEYAQ%3D%3D';
-    case 'any,long,rating':
-      return 'CAESBBABGAI%3D';
-    case 'hour,long,rating':
-      return 'CAESBggBEAEYAg%3D%3D';
-    case 'day,long,rating':
-      return 'CAESBggCEAEYAg%3D%3D';
-    case 'week,long,rating':
-      return 'CAESBggDEAEYAg%3D%3D';
-    case 'month,long,rating':
-      return 'CAESBggEEAEYAg%3D%3D';
-    case 'year,long,rating':
-      return 'CAESBggFEAEYAg%3D%3D';
-    default:
-  }
-};
-
-module.exports = { urls, oauth, oauth_reqopts, default_headers, innertube_request_opts, video_details_reqbody, stream_headers, formatVideoData, base64_alphabet, filters };
+};

lib/Innertube.js

@@ -5,165 +5,442 @@ const Stream = require('stream');
 const OAuth = require('./OAuth');
 const Utils = require('./Utils');
 const Player = require('./Player');
+const Parser = require('./Parser');
 const NToken = require('./NToken');
 const Actions = require('./Actions');
 const Livechat = require('./Livechat');
 const Constants = require('./Constants');
-const SigDecipher = require('./SigDecipher');
+const SigDecipher = require('./Sig');
 const EventEmitter = require('events');
-const TimeToSeconds = require('time-to-seconds');
 const CancelToken = Axios.CancelToken;
 
-class Innertube extends EventEmitter {
+class Innertube {
+  #player;
+  #retry_count;
+
+  /**
+   * ```js
+   * const Innertube = require('youtubei.js');
+   * const youtube = await new Innertube();
+   * ```
+   * @param {string} [cookie]
+   * @returns {Innertube}
+   * @constructor
+   */
   constructor(cookie) {
-    super();
     this.cookie = cookie || '';
-    return this.init();
+    this.#retry_count = 0;
+    return this.#init();
   }
 
-  async init() {
-    const response = await Axios.get(Constants.urls.YT_BASE_URL, Constants.default_headers(this)).catch((error) => error);
-    if (response instanceof Error) throw new Error(`Could not extract Innertube data: ${response.message}`);
+  async #init() {
+    const response = await Axios.get(Constants.URLS.YT_BASE_URL, Constants.DEFAULT_HEADERS(this)).catch((error) => error);
+    if (response instanceof Error) throw new Error(`Could not retrieve Innertube session: ${response.message}`);
 
     try {
-      const innertube_data = JSON.parse(`{${Utils.getStringBetweenStrings(response.data, 'ytcfg.set({', '});')}}`);
-      if (innertube_data.INNERTUBE_CONTEXT) {
-        this.context = innertube_data.INNERTUBE_CONTEXT;
-        this.key = innertube_data.INNERTUBE_API_KEY;
-        this.id_token = innertube_data.ID_TOKEN;
-        this.session_token = innertube_data.XSRF_TOKEN;
-        this.player_url = innertube_data.PLAYER_JS_URL;
-        this.logged_in = innertube_data.LOGGED_IN;
-        this.sts = innertube_data.STS;
+      const data = JSON.parse(`{${Utils.getStringBetweenStrings(response.data, 'ytcfg.set({', '});')}}`);
+      if (data.INNERTUBE_CONTEXT) {
+        this.key = data.INNERTUBE_API_KEY;
+        this.context = data.INNERTUBE_CONTEXT;
+
+        this.player_url = data.PLAYER_JS_URL;
+        this.logged_in = data.LOGGED_IN;
+        this.sts = data.STS;
+
         this.context.client.hl = 'en';
         this.context.client.gl = 'US';
 
-        this.player = new Player(this);
-        await this.player.init();
+        /**
+         * @event auth - Fired when signing in to an account.
+         * @event update-credentials - Fired when the access token is no longer valid.
+         * @type {EventEmitter}
+         */
+        this.ev = new EventEmitter();
+
+        this.#player = new Player(this);
+        await this.#player.init();
 
         if (this.logged_in && this.cookie.length > 1) {
           this.auth_apisid = Utils.getStringBetweenStrings(this.cookie, 'PAPISID=', ';');
           this.auth_apisid = Utils.generateSidAuth(this.auth_apisid);
         }
+
+        this.#initMethods();
       } else {
-        return this.init();
+        throw new Error('Could not retrieve Innertube session due to unknown reasons');
       }
     } catch (err) {
-      return this.init();
+      this.#retry_count += 1;
+      if (this.#retry_count >= 10) throw new Error(`Could not retrieve Innertube session: ${err.message}`);
+      return this.#init();
     }
     return this;
   }
 
-  signIn(credentials = {}) {
-    return new Promise(async (resolve, reject) => {
-      const oauth = new OAuth(credentials);
-      if (credentials.access_token && credentials.refresh_token) {
-        let token_validity = await oauth.checkTokenValidity(credentials.access_token, this);
-        if (token_validity === 'VALID') {
-          this.access_token = credentials.access_token;
-          this.refresh_token = credentials.refresh_token;
-          this.logged_in = true;
-          resolve();
-        } else {
-          oauth.refreshAccessToken(credentials.refresh_token);
-          oauth.on('refresh-token', (data) => {
-            this.access_token = data.access_token;
-            this.refresh_token = credentials.refresh_token;
-            this.logged_in = true;
-            this.emit('update-credentials', {
-              access_token: data.access_token,
-              refresh_token: credentials.refresh_token,
-              status: data.status
-            });
-            resolve();
-          });
+  #initMethods() {
+    this.account = {
+      info: () => this.getAccountInfo(),
+      settings: {
+        notifications: {
+          /**
+           * Notify about activity from the channels you're subscribed to.
+           * 
+           * @param {boolean} new_value 
+           * @returns {Promise<{success: boolean; status_code: string; }>}
+           */
+          setSubscriptions: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.SUBSCRIPTIONS, 'account_notifications', new_value),
+
+          /**
+           * Recommended content notifications.
+           * 
+           * @param {boolean} new_value 
+           * @returns {Promise<{success: boolean; status_code: string; }>}
+           */
+          setRecommendedVideos: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.RECOMMENDED_VIDEOS, 'account_notifications', new_value),
+
+          /**
+           * Notify about activity on your channel.
+           * 
+           * @param {boolean} new_value 
+           * @returns {Promise<{success: boolean; status_code: string; }>}
+           */
+          setChannelActivity: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.CHANNEL_ACTIVITY, 'account_notifications', new_value),
+
+          /**
+           * Notify about replies to your comments.
+           * 
+           * @param {boolean} new_value 
+           * @returns {Promise<{success: boolean; status_code: string; }>}
+           */
+          setCommentReplies: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.COMMENT_REPLIES, 'account_notifications', new_value),
+
+          /**
+           * Notify when others mention your channel.
+           * 
+           * @param {boolean} new_value 
+           * @returns {Promise<{success: boolean; status_code: string; }>}
+           */
+          setMentions: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.USER_MENTION, 'account_notifications', new_value),
+
+          /**
+           * Notify when others share your content on their channels.
+           * 
+           * @param {boolean} new_value 
+           * @returns {Promise<{success: boolean; status_code: string; }>}
+           */
+          setSharedContent: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.SHARED_CONTENT, 'account_notifications', new_value)
+        },
+        privacy: {
+          /**
+           * If set to true, your subscriptions won't be visible to others.
+           * 
+           * @param {boolean} new_value 
+           * @returns {Promise<{success: boolean; status_code: string; }>}
+           */
+          setSubscriptionsPrivate: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.SUBSCRIPTIONS_PRIVACY, 'account_privacy', new_value),
+
+          /**
+           * If set to true, saved playlists won't appear on your channel.
+           * 
+           * @param {boolean} new_value 
+           * @returns {Promise<{success: boolean; status_code: string; }>}
+           */
+          setSavedPlaylistsPrivate: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.PLAYLISTS_PRIVACY, 'account_privacy', new_value)
         }
+      }
+    }
+
+    this.interact = {
+      /**
+       * Likes a given video.
+       * 
+       * @param {string} video_id
+       * @returns {Promise<{success: boolean; status_code: string; }>}
+       */
+      like: (video_id) => Actions.engage(this, 'like/like', { video_id }),
+
+      /**
+       * Diskes a given video.
+       * 
+       * @param {string} video_id
+       * @returns {Promise<{success: boolean; status_code: string; }>}
+       */
+      dislike: (video_id) => Actions.engage(this, 'like/dislike', { video_id }),
+
+      /**
+       * Removes a like/dislike.
+       * 
+       * @param {string} video_id 
+       * @returns {Promise<{success: boolean; status_code: string; }>} 
+       */
+      removeLike: (video_id) => Actions.engage(this, 'like/removelike', { video_id }),
+
+      /**
+       * Posts a comment on a given video.
+       * 
+       * @param {string} video_id 
+       * @param {string} text 
+       * @returns {Promise<{success: boolean; status_code: string; }>}
+       */
+      comment: (video_id, text) => Actions.engage(this, 'comment/create_comment', { video_id, text }),
+
+      /**
+       * Subscribes to a given channel.
+       * 
+       * @param {string} channel_id 
+       * @returns {Promise<{success: boolean; status_code: string; }>}
+       */
+      subscribe: (channel_id) => Actions.engage(this, 'subscription/subscribe', { channel_id }),
+
+      /**
+       * Unsubscribes from a given channel.
+       * 
+       * @param {string} channel_id 
+       * @returns {Promise<{success: boolean; status_code: string; }>}
+       */
+      unsubscribe: (channel_id) => Actions.engage(this, 'subscription/unsubscribe', { channel_id }),
+
+      /**
+       * Changes notification preferences for a given channel.
+       * Only works with channels you are subscribed to.
+       * 
+       * @param {string} channel_id 
+       * @param {string} type PERSONALIZED | ALL | NONE
+       * @returns {Promise<{success: boolean; status_code: string; }>} 
+       */
+      changeNotificationPreferences: (channel_id, type) => Actions.notifications(this, 'modify_channel_preference', { channel_id, pref: type || 'NONE' }),
+    };
+  }
+
+  /**
+   * Internal method to perform changes on an account's settings.
+   * 
+   * @param {string} setting_id 
+   * @param {string} type 
+   * @param {string} new_value 
+   * @returns {Promise<{success: boolean; status_code: string; }>}
+   */
+  async #setSetting(setting_id, type, new_value) {
+    const response = await Actions.browse(this, type);
+
+    const contents = response.data.contents.twoColumnBrowseResultsRenderer.tabs[0]
+      .tabRenderer.content.sectionListRenderer.contents[1]
+      .itemSectionRenderer.contents.find((content) => content.settingsOptionsRenderer.options)
+      .settingsOptionsRenderer.options;
+
+    const option = contents.find((option) => option.settingsSwitchRenderer.enableServiceEndpoint.setSettingEndpoint.settingItemIdForClient == setting_id);
+
+    const setting_item_id = option.settingsSwitchRenderer.enableServiceEndpoint.setSettingEndpoint.settingItemId;
+    const set_setting = await Actions.account(this, 'account/set_setting', { new_value, setting_item_id });
+
+    return {
+      success: set_setting.success,
+      status_code: response.status_code,
+    }
+  }
+
+  /**
+   * Signs-in to a google account.
+   *
+   * @param {object} auth_info
+   * @param {string} auth_info.access_token - Token used to sign in.
+   * @param {string} auth_info.refresh_token - Token used to get a new access token.
+   * @param {Date} auth_info.expires - Access token's expiration date, which is usually 24hrs-ish
+   * @returns {Promise.<void>}
+   */
+  signIn(auth_info = {}) {
+    return new Promise(async (resolve) => {
+      const oauth = new OAuth(auth_info);
+      if (auth_info.access_token) {
+        if (!oauth.isTokenValid()) {
+          const tokens = await oauth.refreshAccessToken();
+          auth_info.refresh_token = tokens.credentials.refresh_token;
+          auth_info.access_token = tokens.credentials.access_token;
+          this.ev.emit('update-credentials', { credentials: tokens.credentials, status: tokens.status });
+        }
+
+        this.access_token = auth_info.access_token;
+        this.refresh_token = auth_info.refresh_token;
+        this.logged_in = true;
+
+        resolve();
       } else {
         oauth.on('auth', (data) => {
           if (data.status === 'SUCCESS') {
-            this.emit('auth', data);
-            this.access_token = data.access_token;
-            this.refresh_token = data.refresh_token;
+            this.ev.emit('auth', { credentials: data.credentials, status: data.status });
+            this.access_token = data.credentials.access_token;
+            this.refresh_token = data.credentials.refresh_token;
             this.logged_in = true;
             resolve();
           } else {
-            this.emit('auth', data);
+            this.ev.emit('auth', data);
           }
         });
       }
     });
   }
 
-  async search(query, options = { period: 'any', order: 'relevance', duration: 'any' }) {
-    if (!query) throw new Error('No query was provided');
+  /**
+   * Returns information about the account being used.
+   * @returns {Promise<{ name: string; photo: Array<object>; country: string; language: string; }>}
+   */
+  async getAccountInfo() {
+    const response = await Actions.account(this, 'account/account_menu');
+    if (!response.success) throw new Error('Could not get account info');
 
-    const response = await Axios.post(`${Constants.urls.YT_BASE_URL}/youtubei/v1/search${this.logged_in && this.cookie.length < 1 ? '' : `?key=${this.key}`}`, JSON.stringify({ context: this.context, params: Constants.filters(options.period + ',' + options.duration + ',' + options.order), query }), Constants.innertube_request_opts({ session: this })).catch((error) => error);
-    if (response instanceof Error) throw new Error(`Could not search on YouTube: ${response.message}`);
+    const menu = response.data.actions[0].openPopupAction.popup.multiPageMenuRenderer;
 
-    let content = response.data.contents.twoColumnSearchResultsRenderer.primaryContents.sectionListRenderer.contents[0].itemSectionRenderer.contents;
-    let search_response = {};
-
-    search_response.search_metadata = {};
-    search_response.search_metadata.query = content[0].showingResultsForRenderer ? content[0].showingResultsForRenderer.originalQuery.simpleText : query;
-    search_response.search_metadata.corrected_query = content[0].showingResultsForRenderer ? content[0].showingResultsForRenderer.correctedQueryEndpoint.searchEndpoint.query : query;
-    search_response.search_metadata.estimated_results = parseInt(response.data.estimatedResults);
-    search_response.videos = content.map((data) => {
-      if (!data.videoRenderer) return;
-      let video = data.videoRenderer;
-      return {
-        title: video.title.runs[0].text,
-        description: video.detailedMetadataSnippets && video.detailedMetadataSnippets[0].snippetText.runs.map((item) => item.text).join('') || 'N/A',
-        author: video.ownerText.runs[0].text,
-        id: video.videoId,
-        url: `https://youtu.be/${video.videoId}`,
-        channel_url: `${Constants.urls.YT_BASE_URL}${video.ownerText.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url}`,
-        metadata: {
-          view_count: video.viewCountText && video.viewCountText.simpleText || 'N/A',
-          short_view_count_text: {
-            simple_text: video.shortViewCountText && video.shortViewCountText.simpleText || 'N/A',
-            accessibility_label: video.shortViewCountText && (video.shortViewCountText.accessibility && video.shortViewCountText.accessibility.accessibilityData.label || 'N/A') || 'N/A',
-          },
-          thumbnails: video.thumbnail.thumbnails,
-          duration: {
-            seconds: TimeToSeconds(video.lengthText && video.lengthText.simpleText || '0'),
-            simple_text: video.lengthText && video.lengthText.simpleText || 'N/A',
-            accessibility_label: video.lengthText && video.lengthText.accessibility.accessibilityData.label || 'N/A'
-          },
-          published: video.publishedTimeText && video.publishedTimeText.simpleText || 'N/A',
-          badges: video.badges && video.badges.map((item) => item.metadataBadgeRenderer.label) || 'N/A',
-          owner_badges: video.ownerBadges && video.ownerBadges.map((item) => item.metadataBadgeRenderer.tooltip) || 'N/A '
-        }
-      };
-    }).filter((video_block) => video_block !== undefined);
-    return search_response;
+    return {
+      name: menu.header.activeAccountHeaderRenderer.accountName.simpleText,
+      photo: menu.header.activeAccountHeaderRenderer.accountPhoto.thumbnails,
+      country: menu.sections[1].multiPageMenuSectionRenderer.items[2].compactLinkRenderer.subtitle.simpleText,
+      language: menu.sections[1].multiPageMenuSectionRenderer.items[1].compactLinkRenderer.subtitle.simpleText
+    }
   }
 
-  async getDetails(id) {
-    if (!id) return { error: 'Missing video id' };
+  /**
+   * Searches on YouTube.
+   *
+   * @param {string} query - Search query.
+   * @param {object} options - Search options.
+   * @param {string} options.client - Client used to perform the search, can be: `YTMUSIC` or `YOUTUBE`. 
+   * @param {string} options.period - Filter videos uploaded within a period, can be: any | hour | day | week | month | year
+   * @param {string} options.order - Filter results by order, can be: relevance | rating | age | views
+   * @param {string} options.duration - Filter video results by duration, can be: any | short | long
+   * @returns {Promise.<{ query: string; corrected_query: string; estimated_results: number; videos: [] } |
+   * { songs: []; videos: []; albums: []; playlists: [] }>} 
+   */
+  async search(query, options = { client: 'YOUTUBE', period: 'any', order: 'relevance', duration: 'any' }) {
+    const response = await Actions.search(this, options.client, { query, options });
+    if (!response.success) throw new Error(`Could not search on YouTube: ${response.message}`);
 
-    const data = await this.requestVideoInfo(id, false);
-    const video_data = Constants.formatVideoData(data, this, false);
+    const data = new Parser(this, response.data, {
+      client: options.client,
+      data_type: 'SEARCH',
+      query
+    }).parse();
 
-    if (video_data.metadata.is_live_content) {
-      const data_continuation = await Actions.getContinuation(this, { video_id: id });
-      if (!data_continuation.data.contents.twoColumnWatchNextResults.conversationBar) return;
-      video_data.getLivechat = () => new Livechat(this, data_continuation.data.contents.twoColumnWatchNextResults.conversationBar.liveChatRenderer.continuations[0].reloadContinuationData.continuation, video_data.metadata.channel_id, id);
+    return data;
+  }
+
+  /**
+   * Gets search suggestions.
+   * 
+   * @param {string} input - The search query.
+   * @param {string} [client='YOUTUBE'] - Client used to retrieve search suggestions, can be: `YOUTUBE` or `YTMUSIC`.
+   * @returns {Promise.<[{ text: string; bold_text: string }]>}
+   */
+  async getSearchSuggestions(input, { client = 'YOUTUBE' }) {
+    if (client == 'YOUTUBE') {
+      const response = await Actions.getYTSearchSuggestions(this, input);
+      if (!response.success) throw new Error('Could not get search suggestions');
+
+      return response.data[1].map((item) => {
+        return {
+          text: item.trim(),
+          bold_text: response.data[0].trim()
+        };
+      });
+    } else if (client == 'YTMUSIC') {
+      const response = await Actions.music(this, 'get_search_suggestions', { input });
+      if (!response.success) throw new Error('Could not get search suggestions');
+      if (!response.data.contents) return [];
+
+      const contents = response.data.contents[0].searchSuggestionsSectionRenderer.contents;
+      return contents.map((item) => {
+        let suggestion;
+
+        if (item.historySuggestionRenderer) {
+          suggestion = item.historySuggestionRenderer.suggestion;
+        } else {
+          suggestion = item.searchSuggestionRenderer.suggestion;
+        }
+
+        return {
+          text: suggestion.runs.map((run) => run.text).join('').trim(),
+          bold_text: suggestion.runs[0].text.trim()
+        };
+      });
+    }
+  }
+
+  /**
+  * Gets details for a video.
+  *
+  * @param {string} video_id - The id of the video.
+  * @return {Promise.<{ title: string; description: string; thumbnail: []; metadata: {} }>}
+  */
+  async getDetails(video_id) {
+    if (!video_id) throw new Error('You must provide a video id');
+
+    const data = await Actions.getVideoInfo(this, { id: video_id, is_desktop: false });
+    const refined_data = new Parser(this, data, { client: 'YOUTUBE', data_type: 'VIDEO_INFO', desktop_v: false }).parse();
+
+    if (refined_data.metadata.is_live_content) {
+      const data_continuation = await Actions.getContinuation(this, { video_id });
+      if (data_continuation.data.contents.twoColumnWatchNextResults.conversationBar) {
+        refined_data.getLivechat = () => new Livechat(this, data_continuation.data.contents.twoColumnWatchNextResults.conversationBar.liveChatRenderer.continuations[0].reloadContinuationData.continuation, refined_data.metadata.channel_id, video_id);
+      } else {
+        refined_data.getLivechat = () => { };
+      }
     } else {
-      video_data.getLivechat = () => {};
+      refined_data.getLivechat = () => { };
     }
 
-    video_data.like = () => Actions.engage(this, 'like/like', { video_id: id });
-    video_data.dislike = () => Actions.engage(this, 'like/dislike', { video_id: id });
-    video_data.removeLike = () => Actions.engage(this, 'like/removelike', { video_id: id });
-    video_data.subscribe = () => Actions.engage(this, 'subscription/subscribe', { video_id: id, channel_id: video_data.metadata.channel_id });
-    video_data.unsubscribe = () => Actions.engage(this, 'subscription/unsubscribe', { video_id: id, channel_id: video_data.metadata.channel_id });
-    video_data.comment = text => Actions.engage(this, 'comment/create_comment', { video_id: id, text });
-    video_data.getComments = () => this.getComments(id);
-    video_data.setNotificationPref = pref => Actions.notifications(this, 'modify_channel_preference', { channel_id: video_data.metadata.channel_id, pref: pref || 'NONE' });
+    refined_data.like = () => Actions.engage(this, 'like/like', { video_id });
+    refined_data.dislike = () => Actions.engage(this, 'like/dislike', { video_id });
+    refined_data.removeLike = () => Actions.engage(this, 'like/removelike', { video_id });
+    refined_data.subscribe = () => Actions.engage(this, 'subscription/subscribe', { channel_id: refined_data.metadata.channel_id });
+    refined_data.unsubscribe = () => Actions.engage(this, 'subscription/unsubscribe', { channel_id: refined_data.metadata.channel_id });
+    refined_data.comment = (text) => Actions.engage(this, 'comment/create_comment', { video_id, text });
+    refined_data.getComments = () => this.getComments(video_id);
+    refined_data.changeNotificationPreferences = (type) => Actions.notifications(this, 'modify_channel_preference', { channel_id: refined_data.metadata.channel_id, pref: type || 'NONE' });
 
-    return video_data;
+    return refined_data;
   }
 
+  /**
+  * Retrieves the lyrics for a given song if available.
+  * 
+  * @param {string} video_id 
+  * @returns {Promise.<string>} Song lyrics
+  */
+  async getLyrics(video_id) {
+    const data_continuation = await Actions.getContinuation(this, { video_id: video_id, ytmusic: true });
+
+    const lyrics_tab = data_continuation.data.contents.singleColumnMusicWatchNextResultsRenderer.tabbedRenderer
+      .watchNextTabbedResultsRenderer.tabs.find((obj) => obj.tabRenderer.title == 'Lyrics');
+
+    const response = await Actions.browse(this, 'lyrics', { ytmusic: true, browse_id: lyrics_tab.tabRenderer.endpoint.browseEndpoint.browseId });
+    if (!response.data.contents.sectionListRenderer) throw new Error(response.data.contents.messageRenderer.text.runs[0].text);
+
+    const lyrics = response.data.contents.sectionListRenderer.contents[0].musicDescriptionShelfRenderer.description.runs[0].text;
+    return lyrics;
+  }
+
+  /**
+   * Parses a given playlist.
+   * 
+   * @param {string} playlist_id - The id of the playlist.
+   * @param {object} options - { client: YOUTUBE | YTMUSIC }
+   * @param {string} options.client - Client used to parse the playlist, can be: `YTMUSIC` | `YOUTUBE`
+   * @returns {Promise.<
+   *  { title: string; description: string; total_items: string; last_updated: string; views: string; items: [] } |
+   *  { title: string; description: string; total_items: number; duration: string; year: string; items: [] }>}
+   */
+  async getPlaylist(playlist_id, options = { client: 'YOUTUBE' }) {
+    const response = await Actions.browse(this, options.client == 'YTMUSIC' ? 'music_playlist' : 'playlist', { ytmusic: options.client == 'YTMUSIC', browse_id: `VL${playlist_id}` });
+    const data = new Parser(this, response.data, { client: options.client, data_type: 'PLAYLIST' }).parse();
+    return data;
+  }
+
+  /**
+  * Gets the comments section of a video.
+  *
+  * @param {string} video_id - The id of the video.
+  * @param {string} [token] - Continuation token (optional).
+  * @return {Promise.<[{ comments: []; comment_count: string }]>
+  */
   async getComments(video_id, token) {
     let comment_section_token;
 
@@ -202,7 +479,7 @@ class Innertube extends EventEmitter {
           published: thread.commentThreadRenderer.comment.commentRenderer.publishedTimeText.runs[0].text,
           is_liked: thread.commentThreadRenderer.comment.commentRenderer.isLiked,
           is_channel_owner: thread.commentThreadRenderer.comment.commentRenderer.authorIsChannelOwner,
-          like_count: thread.commentThreadRenderer.comment.commentRenderer.voteCount.simpleText,
+          like_count: thread.commentThreadRenderer.comment.commentRenderer.voteCount && thread.commentThreadRenderer.comment.commentRenderer.voteCount.simpleText || 'N/A',
           reply_count: thread.commentThreadRenderer.comment.commentRenderer.replyCount || 0,
           id: thread.commentThreadRenderer.comment.commentRenderer.commentId,
         }
@@ -213,9 +490,79 @@ class Innertube extends EventEmitter {
     return comments_section;
   }
 
+  /**
+   * Returns your watch history.
+   * @returns {Promise.<[{ id: string; title: string; channel: string; metadata: {} }]>}
+   */
+  async getHistory() {
+    const response = await Actions.browse(this, 'history');
+    const contents = response.data.contents.twoColumnBrowseResultsRenderer.tabs[0]
+      .tabRenderer.content.sectionListRenderer.contents;
+
+    const history = [];
+
+    contents.forEach((section) => {
+      if (!section.itemSectionRenderer) return;
+      const section_items = section.itemSectionRenderer.contents;
+      section_items.forEach((item) => {
+        const content = {
+          id: item.videoRenderer.videoId,
+          title: item.videoRenderer.title.runs.map((run) => run.text).join(' '),
+          channel: item.videoRenderer.shortBylineText && item.videoRenderer.shortBylineText.runs[0].text || 'N/A',
+          metadata: {
+            view_count: item.videoRenderer.viewCountText && item.videoRenderer.viewCountText.simpleText || 'N/A',
+            thumbnail: item.videoRenderer.thumbnail && item.videoRenderer.thumbnail.thumbnails.slice(-1)[0] || [],
+            moving_thumbnail: item.videoRenderer.richThumbnail && item.videoRenderer.richThumbnail.movingThumbnailRenderer.movingThumbnailDetails.thumbnails[0] || [],
+            published: item.videoRenderer.publishedTimeText && item.videoRenderer.publishedTimeText.simpleText || 'N/A',
+            duration: item.videoRenderer.lengthText && item.videoRenderer.lengthText.simpleText || 'N/A',
+            badges: item.videoRenderer.badges && item.videoRenderer.badges.map((badge) => badge.metadataBadgeRenderer.label) || 'N/A',
+            owner_badges: item.videoRenderer.ownerBadges && item.videoRenderer.ownerBadges.map((badge) => badge.metadataBadgeRenderer.tooltip) || 'N/A'
+          }
+        };
+        history.push(content);
+      });
+    });
+
+    return history;
+  }
+
+  /**
+  * Returns YouTube's home feed.
+  * @returns {Promise.<[{ id: string; title: string; channel: string; metadata: {} }]>}
+  */
+  async getHomeFeed() {
+    const response = await Actions.browse(this, 'home_feed');
+    if (!response.success) throw new Error('Could not get home feed');
+
+    const contents = response.data.contents.twoColumnBrowseResultsRenderer.tabs[0].tabRenderer.content.richGridRenderer.contents;
+
+    return contents.map((item) => {
+      const content = item.richItemRenderer && item.richItemRenderer.content.videoRenderer &&
+        item.richItemRenderer.content || undefined;
+
+      if (content) return {
+        id: content.videoRenderer.videoId,
+        title: content.videoRenderer.title.runs.map((run) => run.text).join(' '),
+        channel: content.videoRenderer.shortBylineText && content.videoRenderer.shortBylineText.runs[0].text || 'N/A',
+        metadata: {
+          view_count: content.videoRenderer.viewCountText && content.videoRenderer.viewCountText.simpleText || 'N/A',
+          thumbnail: content.videoRenderer.thumbnail && content.videoRenderer.thumbnail.thumbnails.slice(-1)[0] || [],
+          moving_thumbnail: content.videoRenderer.richThumbnail && content.videoRenderer.richThumbnail.movingThumbnailRenderer.movingThumbnailDetails.thumbnails[0] || [],
+          published: content.videoRenderer.publishedTimeText && content.videoRenderer.publishedTimeText.simpleText || 'N/A',
+          badges: content.videoRenderer.badges && content.videoRenderer.badges.map((badge) => badge.metadataBadgeRenderer.label) || [],
+          owner_badges: content.videoRenderer.ownerBadges && content.videoRenderer.ownerBadges.map((badge) => badge.metadataBadgeRenderer.tooltip) || []
+        }
+      }
+    }).filter((video) => video);
+  }
+
+  /**
+  * Returns your subscription feed.
+  * @returns {Promise.<{ today: []; yesterday: []; this_week: [] }>}
+  */
   async getSubscriptionsFeed() {
     const response = await Actions.browse(this, 'subscriptions_feed');
-    if (!response.success) throw new Error('Could not fetch subscriptions feed');
+    if (!response.success) throw new Error('Could not get subscriptions feed');
 
     const contents = response.data.contents.twoColumnBrowseResultsRenderer.tabs[0].tabRenderer.content.sectionListRenderer.contents;
     const subscriptions_feed = {};
@@ -231,12 +578,12 @@ class Innertube extends EventEmitter {
 
       section_items.forEach((item) => {
         const content = {
-          title: item.gridVideoRenderer.title.runs.map((run) => run.text).join(' '),
           id: item.gridVideoRenderer.videoId,
+          title: item.gridVideoRenderer.title.runs.map((run) => run.text).join(' '),
           channel: item.gridVideoRenderer.shortBylineText && item.gridVideoRenderer.shortBylineText.runs[0].text || 'N/A',
           metadata: {
             view_count: item.gridVideoRenderer.viewCountText && item.gridVideoRenderer.viewCountText.simpleText || 'N/A',
-            thumbnail: item.gridVideoRenderer.thumbnail && item.gridVideoRenderer.thumbnail.thumbnails || [],
+            thumbnail: item.gridVideoRenderer.thumbnail && item.gridVideoRenderer.thumbnail.thumbnails.slice(-1)[0] || [],
             published: item.gridVideoRenderer.publishedTimeText && item.gridVideoRenderer.publishedTimeText.simpleText || 'N/A',
             badges: item.gridVideoRenderer.badges && item.gridVideoRenderer.badges.map((badge) => badge.metadataBadgeRenderer.label) || 'N/A',
             owner_badges: item.gridVideoRenderer.ownerBadges && item.gridVideoRenderer.ownerBadges.map((badge) => badge.metadataBadgeRenderer.tooltip) || 'N/A'
@@ -250,6 +597,10 @@ class Innertube extends EventEmitter {
     return subscriptions_feed;
   }
 
+  /**
+   * Retrieves your notifications.
+   * @returns {Promise.<[{ title: string; sent_time: string; channel_name: string; channel_thumbnail: {}; video_thumbnail: {}; video_url: string; read: boolean; notification_id: string }]>}
+   */
   async getNotifications() {
     const response = await Actions.notifications(this, 'get_notification_menu');
     if (!response.success) throw new Error('Could not fetch notifications');
@@ -272,20 +623,118 @@ class Innertube extends EventEmitter {
     }).filter((notification_block) => notification_block);
   }
 
+  /**
+   * Returns unseen notifications count.
+   * @returns {Promise.<number>} unseen notifications count.
+   */
   async getUnseenNotificationsCount() {
     const response = await Actions.notifications(this, 'get_unseen_count');
-    if (!response.success) throw new Error('Could not fetch unseen notifications count');
+    if (!response.success) throw new Error('Could not get unseen notifications count');
     return response.data.unseenCount;
   }
 
-  async requestVideoInfo(id, desktop) {
-    let response;
-    !desktop && (response = await Axios.get(`${Constants.urls.YT_WATCH_PAGE}?v=${id}&t=8s&pbj=1`, Constants.innertube_request_opts({ session: this, id, desktop: false })).catch((error) => error)) ||
-      (response = await Axios.post(`${Constants.urls.YT_BASE_URL}/youtubei/v1/player${this.logged_in && this.cookie.length < 1 ? '' : `?key=${this.key}`}`, JSON.stringify(Constants.video_details_reqbody(id, this.sts, this.context)), Constants.innertube_request_opts({ session: this, id, desktop: true })).catch((error) => error));
-    if (response instanceof Error) throw new Error('Could not retrieve watch page info: ' + response.message);
-    return response.data;
+  /**
+   * Internal method to process and filter formats.
+   * 
+   * @param {object} options 
+   * @param {object} video_data 
+   * @returns {object.<{ selected_format: {}; formats: [] }>}
+   */
+  #chooseFormat(options, video_data) {
+    let formats = [];
+
+    formats = formats
+      .concat(video_data.streamingData.formats || [])
+      .concat(video_data.streamingData.adaptiveFormats || []);
+
+    formats.forEach((format) => {
+      format.url = format.url || format.signatureCipher || format.cipher;
+
+      if (format.signatureCipher || format.cipher) {
+        format.url = new SigDecipher(format.url, this.#player).decipher();
+      }
+
+      const url_components = new URL(format.url);
+      url_components.searchParams.set('cver', this.context.client.clientVersion);
+      url_components.searchParams.set('ratebypass', 'yes');
+      
+      if (url_components.searchParams.get('n')) {
+        url_components.searchParams.set('n', new NToken(this.#player.ntoken_sc).transform(url_components.searchParams.get('n')));
+      }
+
+      format.url = url_components.toString();
+      format.has_audio = !!format.audioBitrate || !!format.audioQuality;
+      format.has_video = !!format.qualityLabel;
+
+      delete format.cipher;
+      delete format.signatureCipher;
+    });
+
+    formats.hls_manifest_url = video_data.streamingData.hlsManifestUrl || undefined;
+    formats.dash_manifest_url = video_data.streamingData.dashManifestUrl || undefined;
+
+    let format;
+    let bitrates;
+    let filtered_formats;
+
+    filtered_formats = ({
+      'video': formats.filter((format) => format.has_video && !format.has_audio),
+      'audio': formats.filter((format) => format.has_audio && !format.has_video),
+      'videoandaudio': formats.filter((format) => format.has_video && format.has_audio)
+    })[options.type] || formats.filter((format) => format.has_video && format.has_audio);
+
+    if (options.type != 'videoandaudio') {
+      let streams;
+
+      options.type != 'audio' &&
+        (streams = filtered_formats.filter((format) => format.mimeType.includes(options.format || 'mp4') && format.qualityLabel == options.quality)) ||
+        (streams = filtered_formats.filter((format) => format.mimeType.includes(options.format || 'mp4')));
+
+      streams == undefined || streams.length == 0 &&
+        (streams = filtered_formats.filter((format) => format.quality == 'medium'));
+
+      bitrates = streams.map((format) => format.bitrate);
+      format = streams.filter((format) => format.bitrate === Math.max(...bitrates))[0];
+    } else {
+      format = filtered_formats[0];
+    }
+
+    return { selected_format: format, formats };
   }
 
+  /**
+   * An alternative to {@link download}.
+   * Returns deciphered streaming data.
+   * 
+   * @param {string} id - The id of the video.
+   * @param {object} options - Download options.
+   * @param {string} options.quality - Video quality; 360p, 720p, 1080p, etc....
+   * @param {string} options.type - Download type, can be: video, audio or videoandaudio
+   * @param {string} options.format - File format
+   * @returns {Promise.<{ selected_format: {}; formats: [] }>}
+   */
+  async getStreamingData(id, options = {}) {
+    options.quality = options.quality || '360p';
+    options.type = options.type || 'videoandaudio';
+    options.format = options.format || 'mp4';
+
+    const data = await Actions.getVideoInfo(this, { id, desktop: true });
+    const streaming_data = this.#chooseFormat(options, data);
+    if (!streaming_data.selected_format) throw new Error('Could not find any suitable format.');
+
+    return streaming_data;
+  }
+
+  /**
+   * Downloads a given video. If you only need the direct download link take a look at {@link getStreamingData}.
+   * 
+   * @param {string} id - The id of the video.
+   * @param {object} options - Download options.
+   * @param {string} options.quality - Video quality; 360p, 720p, 1080p, etc....
+   * @param {string} options.type - Download type, can be: video, audio or videoandaudio
+   * @param {string} options.format - File format
+   * @return {ReadableStream}
+   */
   download(id, options = {}) {
     if (!id) throw new Error('Missing video id');
 
@@ -297,81 +746,25 @@ class Innertube extends EventEmitter {
     let cancelled = false;
 
     const stream = new Stream.PassThrough();
-    this.requestVideoInfo(id, true).then(async (video_data) => {
-      let formats = [];
+    Actions.getVideoInfo(this, { id, desktop: true }).then(async (video_data) => {
+      if (video_data.playabilityStatus.status === 'LOGIN_REQUIRED')
+        return stream.emit('error', { message: 'You must login to download age-restricted videos.', error_type: 'LOGIN_REQUIRED', playability_status: video_data.playabilityStatus.status });
+      if (!video_data.streamingData)
+        return stream.emit('error', { message: 'Streaming data not available.', error_type: 'NO_STREAMING_DATA', playability_status: video_data.playabilityStatus.status });
 
-      if (video_data.playabilityStatus.status === 'LOGIN_REQUIRED') return stream.emit('error', { message: 'You must login to download age-restricted videos.', error_type: 'LOGIN_REQUIRED', playability_status: video_data.playabilityStatus.status });
-      if (!video_data.streamingData) return stream.emit('error', { message: 'Streaming data not available.', error_type: 'NO_STREAMING_DATA', playability_status: video_data.playabilityStatus.status });
+      const { selected_format: format, formats } = this.#chooseFormat(options, video_data);
 
-      formats = formats.concat(video_data.streamingData.formats || []).concat(video_data.streamingData.adaptiveFormats || []);
-      formats.forEach((format) => {
-        format.url = format.url || format.signatureCipher || format.cipher;
-
-        if (format.signatureCipher || format.cipher) {
-          format.url = new SigDecipher(format.url, this.context.client.clientVersion, this.player).decipher();
-        } else {
-          const url_components = new URL(format.url);
-          url_components.searchParams.set('cver', this.context.client.clientVersion);
-          url_components.searchParams.set('ratebypass', 'yes');
-          url_components.searchParams.set('n', new NToken(this.player.ntoken_sc).transform(url_components.searchParams.get('n')));
-          format.url = url_components.toString();
-        }
-
-        format.has_audio = !!format.audioBitrate || !!format.audioQuality;
-        format.has_video = !!format.qualityLabel;
-
-        delete format.cipher;
-        delete format.signatureCipher;
-      });
-
-      formats.hls_manifest_url = video_data.streamingData.hlsManifestUrl || undefined;
-      formats.dash_manifest_url = video_data.streamingData.dashManifestUrl || undefined;
-
-      const video_details = Constants.formatVideoData(video_data, this, true);
-
-      let url;
-      let bitrates;
-      let filtered_streams;
-
-      switch (options.type) {
-        case 'video':
-          filtered_streams = formats.filter((format) => format.has_video && !format.has_audio);
-          break;
-        case 'audio':
-          filtered_streams = formats.filter((format) => format.has_audio && !format.has_video);
-          break;
-        case 'videoandaudio':
-          filtered_streams = formats.filter((format) => format.has_video && format.has_audio);
-          break;
-        default:
-          filtered_streams = formats.filter((format) => format.has_video && format.has_audio);
-          break;
-      }
-
-      if (options.type != 'videoandaudio') {
-        let streams;
-
-        options.type != 'audio' && (streams = filtered_streams.filter((format) => format.mimeType.includes(options.format || 'mp4') && format.qualityLabel == options.quality)) ||
-          (streams = filtered_streams.filter((format) => format.mimeType.includes(options.format || 'mp4')));
-
-        streams == undefined || streams.length == 0 && (streams = filtered_streams.filter((format) => format.quality == 'medium'));
-
-        bitrates = streams.map((format) => format.bitrate);
-        url = streams.filter((format) => format.bitrate === Math.max(...bitrates))[0];
-      }
-
-      const selected_format = options.type == 'videoandaudio' ? filtered_streams[0] : url;
-      if (!selected_format) {
+      if (!format)
         return stream.emit('error', { message: 'Could not find any suitable format.', type: 'FORMAT_UNAVAILABLE' });
-      } else {
-        stream.emit('info', { video_details, selected_format, formats });
-      }
 
-      if (options.type == 'videoandaudio') {
-        const response = await Axios.get(selected_format.url, {
+      const video_details = new Parser(this, video_data, { client: 'YOUTUBE', data_type: 'VIDEO_INFO', desktop_v: true }).parse();
+      stream.emit('info', { video_details, selected_format: format, formats });
+
+      if (options.type == 'videoandaudio' && !options.range) {
+        const response = await Axios.get(format.url, {
           responseType: 'stream',
           cancelToken: new CancelToken(function executor(c) { cancel = c; }),
-          headers: Constants.stream_headers()
+          headers: Constants.STREAM_HEADERS
         }).catch((error) => error);
 
         if (response instanceof Error) {
@@ -382,39 +775,50 @@ class Innertube extends EventEmitter {
         }
 
         let downloaded_size = 0;
+
         response.data.on('data', (chunk) => {
           downloaded_size += chunk.length;
           let size = (response.headers['content-length'] / 1024 / 1024).toFixed(2);
           let percentage = Math.floor((downloaded_size / response.headers['content-length']) * 100);
-          stream.emit('progress', { chunk_size: chunk.length, downloaded_size: (downloaded_size / 1024 / 1024).toFixed(2), percentage, size, raw_data: { chunk_size: chunk.length, downloaded: downloaded_size, size: response.headers['content-length'] } });
+
+          stream.emit('progress', {
+            size,
+            percentage,
+            chunk_size: chunk.length,
+            downloaded_size: (downloaded_size / 1024 / 1024).toFixed(2),
+            raw_data: {
+              chunk_size: chunk.length,
+              downloaded: downloaded_size,
+              size: response.headers['content-length']
+            }
+          });
         });
 
         response.data.on('error', (err) => {
-          if (cancelled) {
-            stream.emit('error', { message: 'The download was cancelled.', type: 'DOWNLOAD_CANCELLED' });
-          } else {
+          cancelled &&
+            stream.emit('error', { message: 'The download was cancelled.', type: 'DOWNLOAD_CANCELLED' }) ||
             stream.emit('error', { message: err.message, type: 'DOWNLOAD_ABORTED' });
-          }
         });
 
         response.data.pipe(stream, { end: true });
       } else {
         const chunk_size = 1048576 * 10; // 10MB
 
-        let chunk_start = 0;
-        let chunk_end = chunk_size;
+        let chunk_start = (options.range && options.range.start || 0);
+        let chunk_end = (options.range && options.range.end || chunk_size);
         let downloaded_size = 0;
-        let end = false;
+        let must_end = false;
 
         stream.emit('start');
 
         const downloadChunk = async () => {
-          if (chunk_end >= selected_format.contentLength) end = true;
+          (chunk_end >= format.contentLength || options.range) && (must_end = true);
+          options.range && (format.contentLength = options.range.end);
 
-          const response = await Axios.get(`${selected_format.url}&range=${chunk_start}-${chunk_end || ''}`, {
+          const response = await Axios.get(`${format.url}&range=${chunk_start}-${chunk_end || ''}`, {
             responseType: 'stream',
             cancelToken: new CancelToken(function executor(c) { cancel = c; }),
-            headers: Constants.stream_headers()
+            headers: Constants.STREAM_HEADERS
           }).catch((error) => error);
 
           if (response instanceof Error) {
@@ -424,29 +828,40 @@ class Innertube extends EventEmitter {
 
           response.data.on('data', (chunk) => {
             downloaded_size += chunk.length;
-            let size = (selected_format.contentLength / 1024 / 1024).toFixed(2);
-            let percentage = Math.floor((downloaded_size / selected_format.contentLength) * 100);
-            stream.emit('progress', { chunk_size: chunk.length, downloaded_size: (downloaded_size / 1024 / 1024).toFixed(2), percentage, size, raw_data: { chunk_size: chunk.length, downloaded: downloaded_size, size: response.headers['content-length'] } });
+
+            let size = (format.contentLength / 1024 / 1024).toFixed(2);
+            let percentage = Math.floor((downloaded_size / format.contentLength) * 100);
+
+            stream.emit('progress', {
+              size,
+              percentage,
+              chunk_size: chunk.length,
+              downloaded_size: (downloaded_size / 1024 / 1024).toFixed(2),
+              raw_data: {
+                chunk_size: chunk.length,
+                downloaded: downloaded_size,
+                size: response.headers['content-length']
+              }
+            });
           });
 
           response.data.on('error', (err) => {
-            if (cancelled) {
-              stream.emit('error', { message: 'The download was cancelled.', type: 'DOWNLOAD_CANCELLED' });
-            } else {
+            cancelled &&
+              stream.emit('error', { message: 'The download was cancelled.', type: 'DOWNLOAD_CANCELLED' }) ||
               stream.emit('error', { message: err.message, type: 'DOWNLOAD_ABORTED' });
-            }
           });
 
           response.data.on('end', () => {
-            if (!end) {
+            if (!must_end && !options.range) {
               chunk_start = chunk_end + 1;
               chunk_end += chunk_size;
               downloadChunk();
             }
           });
 
-          response.data.pipe(stream, { end });
+          response.data.pipe(stream, { end: must_end });
         };
+
         downloadChunk();
       }
     });

lib/Livechat.js

@@ -1,8 +1,6 @@
 'use strict';
 
-const Axios = require('axios');
 const Actions = require('./Actions');
-const Constants = require('./Constants');
 const EventEmitter = require('events');
 
 class Livechat extends EventEmitter {
@@ -19,12 +17,55 @@ class Livechat extends EventEmitter {
     this.poll_intervals_ms = 1000;
     this.running = true;
 
-    this.poll();
+    this.#poll();
   }
 
-  enqueueActionGroup(group) {
+  async #poll() {
+    if (!this.running) return;
+
+    const livechat = await Actions.livechat(this.session, 'live_chat/get_live_chat', { ctoken: this.ctoken });
+    if (!livechat.success) {
+      this.emit('error', { message: `Failed polling livechat: ${livechat.message}. Retrying...` });
+      return await this.#poll();
+    }
+
+    const continuation_contents = livechat.data.continuationContents;
+    const action_group = continuation_contents.liveChatContinuation.actions;
+    this.#enqueueActionGroup(action_group);
+
+    this.message_queue.forEach((message) => {
+      if (this.id_cache.includes(message.id)) return;
+      setTimeout(() => this.emit('chat-update', message), message.timestamp / 1000 - new Date().getTime());
+      this.id_cache.push(message.id);
+    });
+
+    this.message_queue = [];
+
+    const data = { video_id: this.video_id };
+    if (this.metadata_ctoken) data.continuation = this.metadata_ctoken;
+
+    const updated_metadata = await Actions.livechat(this.session, 'updated_metadata', data);
+    if (!updated_metadata.success) {
+      this.emit('error', { message: `Failed polling livechat metadata: ${livechat.message}.` });
+    }
+
+    this.metadata_ctoken = updated_metadata.data.continuation.timedContinuationData.continuation;
+
+    const metadata = updated_metadata.data.actions;
+    this.emit('update-metadata', {
+      likes: metadata[1].updateToggleButtonTextAction.defaultText.simpleText,
+      view_count: {
+        simple_text: metadata[0].updateViewershipAction.viewCount.videoViewCountRenderer.viewCount.simpleText,
+        short_view_count: metadata[0].updateViewershipAction.viewCount.videoViewCountRenderer.extraShortViewCount.simpleText
+      }
+    });
+
+    this.livechat_poller = setTimeout(async () => await this.#poll(), this.poll_intervals_ms);
+  }
+
+  #enqueueActionGroup(group) {
     group.forEach((action) => {
-      if (!action.addChatItemAction) return; //TODO: handle different action types 
+      if (!action.addChatItemAction) return; //TODO: handle different action types
       const message_content = action.addChatItemAction.item.liveChatTextMessageRenderer;
       if (!message_content) return;
 
@@ -43,48 +84,6 @@ class Livechat extends EventEmitter {
     });
   }
 
-  async poll() {
-    if (!this.running) return;
-
-    let data;
-
-    data = { context: this.session.context, continuation: this.ctoken };
-    const livechat = await Axios.post(`${Constants.urls.YT_BASE_URL}/youtubei/v1/live_chat/get_live_chat${this.session.logged_in && this.session.cookie.length < 1 ? '' : `?key=${this.session.key}`}`, JSON.stringify(data), Constants.innertube_request_opts({ session: this.session, data, desktop: true }));
-    if (livechat instanceof Error) throw new Error(`Error polling livechat: ${livechat.message}`);
-
-    const continuation_contents = livechat.data.continuationContents;
-    const action_group = continuation_contents.liveChatContinuation.actions;
-    this.enqueueActionGroup(action_group);
-
-    // Why don't we just emit the message directly? Well, enqueueing the messages is necessary so they are not emitted in a “messy” way, funny enough that's exactly how YouTube does it in its livechat js player.
-    this.message_queue.forEach((message, index) => {
-      if (this.id_cache.includes(message.id)) return;
-      setTimeout(() => this.emit('chat-update', message), message.timestamp / 1000 - new Date().getTime());
-      this.id_cache.push(message.id);
-    });
-
-    this.message_queue = [];
-
-    data = { context: this.session.context, videoId: this.video_id };
-    if (this.metadata_ctoken) data.continuation = this.metadata_ctoken;
-
-    const updated_metadata = await Axios.post(`${Constants.urls.YT_BASE_URL}/youtubei/v1/updated_metadata${this.session.logged_in && this.session.cookie.length < 1 ? '' : `?key=${this.session.key}`}`, JSON.stringify(data), Constants.innertube_request_opts({ session: this.session, data, desktop: true }));
-    if (updated_metadata instanceof Error) throw new Error(`Error polling updated metadata: ${updated_metadata.message}`);
-    this.metadata_ctoken = updated_metadata.data.continuation.timedContinuationData.continuation;
-
-    const metadata = updated_metadata.data.actions;
-    this.emit('update-metadata', {
-      likes: metadata[1].updateToggleButtonTextAction.defaultText.simpleText,
-      dislikes: metadata[2].updateToggleButtonTextAction.defaultText.simpleText,
-      view_count: {
-        simple_text: metadata[0].updateViewershipAction.viewCount.videoViewCountRenderer.viewCount.simpleText,
-        short_view_count: metadata[0].updateViewershipAction.viewCount.videoViewCountRenderer.extraShortViewCount.simpleText
-      }
-    });
-
-    this.livechat_poller = setTimeout(async () => await this.poll(), this.poll_intervals_ms);
-  }
-
   async sendMessage(text) {
     const message = await Actions.livechat(this.session, 'live_chat/send_message', { text, channel_id: this.channel_id, video_id: this.video_id });
     if (!message.success) return message;
@@ -104,7 +103,7 @@ class Livechat extends EventEmitter {
     return {
       success: true,
       status_code: message.status_code,
-      deleteMessage,
+      deleteMessage: deleteMessage,
       message_data: {
         text: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.message.runs.map((item) => item.text).join(' '),
         author: {
@@ -118,8 +117,12 @@ class Livechat extends EventEmitter {
     };
   }
 
+  /**
+   * Blocks a user.
+   * @todo Implement this method.
+   * @param {object} msg_params 
+   */
   async blockUser(msg_params) {
-    /* TODO: Implement this */
     throw new Error('Not implemented');
   }
 

lib/NToken.js

@@ -6,130 +6,137 @@ const Constants = require('./Constants');
 class NToken {
   constructor(raw_code) {
     this.raw_code = raw_code;
-    this.null_placeholder_regex = /c\[(.*?)\]=c/g;
-    this.transformation_calls_regex = /c\[(.*?)\]\((.+?)\)/g;
+    this.placeholders_regex = /c\[(.*?)\]=c/g;
+    this.calls_regex = /c\[(.*?)\]\((.+?)\)/g;
   }
 
+  /**
+   * Solves throttling challange by transforming the n token.
+   * 
+   * @param {string} n token.
+   * @returns {string} transformed token.
+   */
   transform(n) {
     let n_token = n.split('');
 
     try {
-      let transformations = this.getTransformationData(this.raw_code);
-
-      // Identifies the necessary transformation data and emulates them accordingly.
+      let transformations = this.#getTransformationData();
       transformations = transformations.map((el) => {
         if (el != null && typeof el != 'number') {
           const is_reverse_base64 = el.includes('case 65:');
-          if (el.includes('function(d){for(var')) {
-            el = (arr) => this.pushSplice(arr);
-          } else if (el.includes('d.push(e)')) {
-            el = (arr, item) => this.push(arr, item);
-          } else if (el.includes('d.reverse()')) {
-            el = (arr) => this.reverse(arr);
-          } else if (el.includes('d.length;d.splice(e,1)')) {
-            el = (arr, index) => this.spliceOnce(arr, index);
-          } else if (el.includes('d[0])[0])')) {
-            el = (arr, index) => this.spliceTwice(arr, index);
-          } else if (el.includes('reverse().forEach')) {
-            el = (arr, index) => this.spliceReverseUnshift(arr, index);
-          } else if (el.includes('f=d[0];d[0]')) {
-            el = (arr, index) => this.swapFirstItem(arr, index);
-          } else if (el.includes('unshift(d.pop())')) {
-            el = (arr, index) => this.unshiftPop(arr, index);
-          } else if (el.includes('switch')) {
-            el = (arr, e) => this.translateAB(arr, e, is_reverse_base64);
-          } else if (el === 'b') {
-            el = n_token;
-          }
+          (({ // Identifies the transformation functions
+            [Constants.FUNCS.PUSH]: () => el = (arr, i) => this.#push(arr, i),
+            [Constants.FUNCS.SPLICE]: () => el = (arr, i) => this.#splice(arr, i),
+            [Constants.FUNCS.SWAP0_1]: () => el = (arr, i) => this.#swap0(arr, i),
+            [Constants.FUNCS.SWAP0_2]: () => el = (arr, i) => this.#swap0(arr, i),
+            [Constants.FUNCS.ROTATE_1]: () => el = (arr, i) => this.#rotate(arr, i),
+            [Constants.FUNCS.ROTATE_2]: () => el = (arr, i) => this.#rotate(arr, i),
+            [Constants.FUNCS.REVERSE_1]: () => el = (arr) => this.#reverse(arr),
+            [Constants.FUNCS.REVERSE_2]: () => el = (arr) => this.#reverse(arr),
+            [Constants.FUNCS.BASE64_DIA]: () => el = () => this.#getBase64Dia(is_reverse_base64),
+            [Constants.FUNCS.TRANSLATE_1]: () => el = (arr, token) => this.#translate1(arr, token, is_reverse_base64),
+            [Constants.FUNCS.TRANSLATE_2]: () => el = (arr, token, base64_dic) => this.#translate2(arr, token, base64_dic)
+          })[this.#getFunc(el)] || (() => el === 'b' && (el = n_token)))();
         }
         return el;
       });
 
-      // Fills the null placeholders with a copy of the transformations array.
-      let null_placeholder_positions = [...this.raw_code.matchAll(this.null_placeholder_regex)].map((item) => parseInt(item[1]));
-      null_placeholder_positions.forEach((pos) => transformations[pos] = transformations);
+      // Fills all placeholders with the transformations array
+      const placeholder_indexes = [...this.raw_code.matchAll(this.placeholders_regex)].map((item) => parseInt(item[1]));
+      placeholder_indexes.forEach((i) => transformations[i] = transformations);
 
-      // Parses and emulates calls to functions of the transformations array.
-      let transformation_calls = [...Utils.getStringBetweenStrings(this.raw_code.replace(/\n/g, ''), 'try{', '}catch').matchAll(this.transformation_calls_regex)].map((params) => ({ index: params[1], params: params[2] }));
-      transformation_calls.forEach((data) => {
-        const index = data.index;
+      // Parses and emulates calls to the functions of the transformations array
+      const function_calls = [...Utils.getStringBetweenStrings(this.raw_code.replace(/\n/g, ''), 'try{', '}catch')
+        .matchAll(this.calls_regex)].map((params) => ({ index: params[1], params: params[2] }));
+
+      function_calls.forEach((data) => {
         const param_index = data.params.split(',').map((param) => param.match(/c\[(.*?)\]/)[1]);
-        transformations[index](transformations[param_index[0]], transformations[param_index[1]]);
+        const base64_dia = (param_index[2] && transformations[param_index[2]]());
+        transformations[data.index](transformations[param_index[0]], transformations[param_index[1]], base64_dia);
       });
     } catch (err) {
+      console.error(`Could not transform n-token (${n}), download may be throttled:`, err.message);
       return n;
     }
-
     return n_token.join('');
   }
 
-  getTransformationData() {
-    // These variable names have always been the same since earlier player versions, so it should not be a problem for now.
-    let transformation_data = `[${Utils.getStringBetweenStrings(this.raw_code.replace(/\n/g, ''), 'c=[', '];c')}]`;
-    transformation_data = transformation_data
-      .replace(/function\(d,e\)/g, '"function(d,e)')
-      .replace(/function\(d\)/g, '"function(d)')
-      .replace(/,b,/g, ',"b",')
-      .replace(/,b/g, ',"b"')
-      .replace(/b,/g, '"b",')
-      .replace(/b]/g, '"b"]')
-      .replace(/\[b/g, '["b"')
-      .replace(/}]/g, '"]')
-      .replace(/},/g, '}",')
-      .replace(/""/g, '')
-      .replace(/length]\)}"/g, 'length])}');
-
-    return JSON.parse(transformation_data);
+  #getFunc(el) {
+    return el.match(Constants.FUNCS_REGEX);
   }
 
-  translateAB(arr, index, is_reverse_base64) {
-    let characters = is_reverse_base64 && Constants.base64_alphabet.reverse || Constants.base64_alphabet.normal;
-    arr.forEach(function(char, index, loc) {
+  /**
+   * Takes the n-transform data, refines it, and then returns a readable json array.
+   * @returns {object}
+   */
+  #getTransformationData() {
+    const data = `[${Utils.getStringBetweenStrings(this.raw_code.replace(/\n/g, ''), 'c=[', '];c')}]`;
+    return JSON.parse(Utils.refineNTokenData(data));
+  }
+
+  /**
+   * Gets a base64 alphabet and uses it as a lookup table to modify n.
+   * @returns
+   */
+  #translate1(arr, token, is_reverse_base64) {
+    const characters = is_reverse_base64 && Constants.BASE64_DIALECT.REVERSE || Constants.BASE64_DIALECT.NORMAL;
+    arr.forEach(function (char, index, loc) {
       this.push(loc[index] = characters[(characters.indexOf(char) - characters.indexOf(this[index]) + 64) % characters.length]);
-    }, index.split(''));
+    }, token.split(''));
   }
 
-  unshiftPop(arr, index) {
-    index = (index % arr.length + arr.length) % arr.length;
-    for (; index--;) {
-      arr.unshift(arr.pop());
-    }
+  #translate2(arr, token, characters) {
+    let chars_length = characters.length;
+    arr.forEach(function (char, index, loc) {
+      this.push(loc[index] = characters[(characters.indexOf(char) - characters.indexOf(this[index]) + index + chars_length--) % characters.length]);
+    }, token.split(''));
   }
 
-  swapFirstItem(arr, index) {
-    let oldValue = arr[0];
+  /**
+   * Returns the requested base64 dialect, currently this is only used by 'translate2'.
+   * @returns {string[]}
+   */
+  #getBase64Dia(is_reverse_base64) {
+    const characters = is_reverse_base64 && Constants.BASE64_DIALECT.REVERSE || Constants.BASE64_DIALECT.NORMAL;
+    return characters;
+  }
+
+  /**
+   * Swaps the first element with the one at the given index.
+   * @returns
+   */
+  #swap0(arr, index) {
+    const old_elem = arr[0];
     index = (index % arr.length + arr.length) % arr.length;
     arr[0] = arr[index];
-    arr[index] = oldValue;
+    arr[index] = old_elem;
   }
 
-  spliceReverseUnshift(arr, index) {
+  /**
+   * Rotates elements of the array.
+   * @returns
+   */
+  #rotate(arr, index) {
     index = (index % arr.length + arr.length) % arr.length;
-    arr.splice(-index).reverse().forEach((f) => arr.unshift(f));
+    arr.splice(-index).reverse().forEach((el) => arr.unshift(el));
   }
 
-  spliceOnce(arr, index) {
+  /**
+   * Deletes one element at the given index.
+   * @returns
+   */
+  #splice(arr, index) {
     index = (index % arr.length + arr.length) % arr.length;
     arr.splice(index, 1);
   }
 
-  spliceTwice(arr, index) {
-    index = (index % arr.length + arr.length) % arr.length;
-    arr.splice(0, 1, arr.splice(index, 1, arr[0])[0]);
-  }
-
-  pushSplice(arr) {
-    for (let index = arr.length; index;)
-      arr.push(arr.splice(--index, 1)[0]);
-  }
-
-  push(arr, item) {
-    arr.push(item);
-  }
-
-  reverse(arr) {
+  #reverse(arr) {
     arr.reverse();
   }
+
+  #push(arr, item) {
+    arr.push(item);
+  }
 }
 
 module.exports = NToken;

lib/OAuth.js

@@ -1,91 +1,38 @@
 'use strict';
 
 const Axios = require('axios');
-const Utils = require('./Utils');
 const Constants = require('./Constants');
 const EventEmitter = require('events');
-const Uuid = require("uuid");
+const Uuid = require('uuid');
 
 class OAuth extends EventEmitter {
-  constructor(creds) {
+  constructor(auth_info) {
     super();
-    // Default interval between requests when waiting for authorization.
+    this.auth_info = auth_info;
     this.refresh_interval = 5;
 
-    // OAuth URLs:
-    this.oauth_code_url = `${Constants.urls.YT_BASE_URL}/o/oauth2/device/code`;
-    this.oauth_token_url = `${Constants.urls.YT_BASE_URL}/o/oauth2/token`;
+    this.oauth_code_url = `${Constants.URLS.YT_BASE_URL}/o/oauth2/device/code`;
+    this.oauth_token_url = `${Constants.URLS.YT_BASE_URL}/o/oauth2/token`;
+    this.guide_url = `${Constants.URLS.YT_BASE_URL}/youtubei/v1/guide`;
 
-    // Used to check whether an access token is valid or not.
-    this.guide_url = `${Constants.urls.YT_BASE_URL}/youtubei/v1/guide`;
+    this.model_name = Constants.OAUTH.MODEL_NAME;
+    this.grant_type = Constants.OAUTH.GRANT_TYPE;
+    this.scope = Constants.OAUTH.SCOPE;
 
-    // These are always the same, so we shouldn't have any problems for now.
-    this.model_name = Constants.oauth.model_name;
-    this.grant_type = Constants.oauth.grant_type;
-    this.scope = Constants.oauth.scope;
-
-    // Script that contains important information such as client id and client secret.
     this.auth_script_regex = /<script id=\"base-js\" src=\"(.*?)\" nonce=".*?"><\/script>/;
+    this.identity_regex = /.+?={};var .+?={clientId:\"(?<id>.+?)\",.+?:\"(?<secret>.+?)\"},/;
 
-    // Used to find the credentials inside the script.
-    this.identity_regex = /var .+?=\"(?<id>.+?)\",.?=\"(?<secret>.+?)\"/;
-
-    if (creds.access_token != undefined && creds.refresh_token != undefined) return;
-    this.requestAuthCode();
+    if (auth_info.access_token) return;
+    this.#requestAuthCode();
   }
 
-  waitForAuth(device_code) {
-    const data = {
-      client_id: this.client_id,
-      client_secret: this.client_secret,
-      code: device_code,
-      grant_type: this.grant_type
-    };
+  /**
+   * Asks the OAuth server for an auth code.
+   * @returns {Promise.<void>}
+   */
+  async #requestAuthCode() {
+    const identity = await this.#getClientIdentity();
 
-    setTimeout(async () => {
-      const response = await Axios.post(this.oauth_token_url, JSON.stringify(data), Constants.oauth_reqopts).catch((error) => error);
-      if (response instanceof Error)
-        return this.emit('auth', {
-          error: 'Could not get auth token.',
-          status: 'FAILED'
-        });
-
-      if (response.data.error) {
-        switch (response.data.error) {
-          case 'slow_down':
-          case 'authorization_pending':
-            this.waitForAuth(device_code);
-            break;
-          case 'access_denied':
-            this.emit('auth', {
-              error: 'The access was denied.',
-              status: 'ACCESS_DENIED'
-            });
-            break;
-          case 'expired_token':
-            this.emit('auth', {
-              error: 'The device code has expired, requesting a new one.',
-              status: 'DEVICE_CODE_EXPIRED'
-            });
-            this.requestAuthCode();
-            break;
-          default:
-        }
-      } else {
-        this.emit('auth', {
-          access_token: response.data.access_token,
-          refresh_token: response.data.refresh_token,
-          token_type: response.data.token_type,
-          expires: response.data.expires_in,
-          scope: response.data.scope,
-          status: 'SUCCESS'
-        });
-      }
-    }, 1000 * this.refresh_interval);
-  }
-
-  async requestAuthCode() {
-    const identity = await this.getClientIdentity();
     this.client_id = identity.id;
     this.client_secret = identity.secret;
 
@@ -96,7 +43,8 @@ class OAuth extends EventEmitter {
       model_name: this.model_name
     };
 
-    const response = await Axios.post(this.oauth_code_url, JSON.stringify(data), Constants.oauth_reqopts).catch((error) => error);
+    const response = await Axios.post(this.oauth_code_url, JSON.stringify(data), Constants.OAUTH.HEADERS).catch((error) => error);
+
     if (response instanceof Error)
       return this.emit('auth', {
         error: 'Could not get auth code.',
@@ -112,59 +60,140 @@ class OAuth extends EventEmitter {
 
     this.refresh_interval = response.data.interval;
 
-    // Keeps requesting at a specific rate until the authorization is granted or denied.
-    this.waitForAuth(response.data.device_code);
+    this.#waitForAuth(response.data.device_code);
   }
 
-  async getClientIdentity() {
-    // The first request is made to get the auth script url, hard-coding it isn't viable as it changes overtime.
-    const yttv_response = await Axios.get(`${Constants.urls.YT_BASE_URL}/tv`, Constants.oauth_reqopts).catch((error) => error);
-    if (yttv_response instanceof Error) throw new Error(`Could not extract client identify: ${yttv_response.message}`);
+  /**
+   * Waits for sign-in authorization.
+   *
+   * @param {string} device_code Client's device code.
+   * @returns 
+   */
+  #waitForAuth(device_code) {
+    const data = {
+      client_id: this.client_id,
+      client_secret: this.client_secret,
+      code: device_code,
+      grant_type: this.grant_type
+    };
 
-    // Here we get the script and extract the necessary data to proceed with the auth flow.
-    const url_body = this.auth_script_regex.exec(yttv_response.data)[1];
-    const script_url = `${Constants.urls.YT_BASE_URL}/${url_body}`;
-    const response = await Axios.get(script_url, Constants.default_headers).catch((error) => error);
-    if (response instanceof Error) throw new Error(`Could not extract client identify: ${response.message}`);
+    setTimeout(async () => {
+      const response = await Axios.post(this.oauth_token_url, JSON.stringify(data), Constants.OAUTH.HEADERS).catch((error) => error);
+      if (response instanceof Error)
+        return this.emit('auth', {
+          error: 'Could not get authentication token.',
+          status: 'FAILED'
+        });
 
-    const identity_function = Utils.getStringBetweenStrings(response.data, 'YTLR_STORAGE_NAMESPACE",', 'reloadAppFlushLogsMaxTimeoutMs:');
-    const client_identity = identity_function.replace(/\n/g, '').match(this.identity_regex);
-    return client_identity.groups;
+      if (response.data.error) {
+        switch (response.data.error) {
+          case 'slow_down':
+          case 'authorization_pending':
+            this.#waitForAuth(device_code);
+            break;
+          case 'access_denied':
+            this.emit('auth', {
+              error: 'Access was denied.',
+              status: 'ACCESS_DENIED'
+            });
+            break;
+          case 'expired_token':
+            this.emit('auth', {
+              error: 'The device code has expired, requesting a new one.',
+              status: 'DEVICE_CODE_EXPIRED'
+            });
+            this.#requestAuthCode();
+            break;
+          default:
+        }
+      } else {
+        const expiration_date = new Date(new Date().getTime() + response.data.expires_in * 1000);
+
+        this.emit('auth', {
+          credentials: {
+            access_token: response.data.access_token,
+            refresh_token: response.data.refresh_token,
+            expires: expiration_date,
+          },
+          token_type: response.data.token_type,
+          status: 'SUCCESS'
+        });
+      }
+    }, 1000 * this.refresh_interval);
   }
 
-  async refreshAccessToken(refresh_token) {
-    const identity = await this.getClientIdentity();
+  /**
+   * Gets a new access token using a refresh token.
+   * @returns {object.<{ credentials: { access_token: string; refresh_token: string; expires: Date }; status: string }>}
+   */
+  async refreshAccessToken() {
+    const identity = await this.#getClientIdentity();
 
     const data = {
       client_id: identity.id,
       client_secret: identity.secret,
-      refresh_token,
+      refresh_token: this.auth_info.refresh_token,
       grant_type: 'refresh_token',
     };
 
-    const response = await Axios.post(this.oauth_token_url, JSON.stringify(data), Constants.oauth_reqopts).catch((error) => error);
-    if (response instanceof Error)
-      return this.emit('refresh-token', {
+    const response = await Axios.post(this.oauth_token_url, JSON.stringify(data), Constants.OAUTH.HEADERS).catch((error) => error);
+    if (response instanceof Error) {
+      this.emit('auth', {
         error: 'Could not refresh access token.',
         status: 'FAILED'
       });
 
-    this.emit('refresh-token', {
-      access_token: response.data.access_token,
+      return {
+        credentials: {
+          access_token: this.auth_info.access_token,
+          refresh_token: this.auth_info.refresh_token,
+          expires: this.auth_info.expires
+        },
+        status: 'FAILED'
+      };
+    }
+
+    const expiration_date = new Date(new Date().getTime() + response.data.expires_in * 1000);
+
+    return {
+      credentials: {
+        refresh_token: this.auth_info.refresh_token,
+        access_token: response.data.access_token,
+        expires: expiration_date
+      },
       token_type: response.data.token_type,
-      expires: response.data.expires_in,
-      scope: response.data.scope,
       status: 'SUCCESS'
-    });
+    };
   }
 
-  async checkTokenValidity(access_token, session) {
-    let headers = Constants.innertube_request_opts({ session }).headers;
-    headers.authorization = `Bearer ${access_token}`;
+  /**
+   * Gets client identity data.
+   * @returns {Promise.<{ id: string; secret: string }>} 
+   */
+  async #getClientIdentity() {
+    // This request is made to get the auth script url, hard-coding it isn't viable as it changes overtime.
+    const yttv_response = await Axios.get(`${Constants.URLS.YT_BASE_URL}/tv`, Constants.OAUTH.HEADERS).catch((error) => error);
+    if (yttv_response instanceof Error) throw new Error(`Could not extract client identity: ${yttv_response.message}`);
 
-    const response = await Axios.post(this.guide_url, JSON.stringify({ context: session.context }), { headers }).catch((error) => error);
-    if (response instanceof Error) return 'INVALID';
-    return 'VALID';
+    // Here we download the script and extract the necessary data to proceed with the auth flow.
+    const url_body = this.auth_script_regex.exec(yttv_response.data)[1];
+    const script_url = `${Constants.URLS.YT_BASE_URL}/${url_body}`;
+
+    const response = await Axios.get(script_url, Constants.DEFAULT_HEADERS).catch((error) => error);
+    if (response instanceof Error) throw new Error(`Could not extract client identity: ${response.message}`);
+
+    const client_identity = response.data.replace(/\n/g, '').match(this.identity_regex);
+    return client_identity.groups;
+  }
+
+  /**
+   * Checks access token validity.
+   * @returns {boolean} true | false
+   */
+  isTokenValid() {
+    const timestamp = new Date(this.auth_info.expires).getTime();
+    const is_valid = new Date().getTime() < timestamp;
+    return is_valid;
   }
 }
 

lib/Parser.js

@@ -0,0 +1,287 @@
+'use strict';
+
+const Utils = require('./Utils');
+const Constants = require('./Constants');
+
+/**
+ * Takes raw data from the Innertube API and refines it. 
+ * Mainly used for video data and search results, as those are more complex to parse.
+ */
+class Parser {
+  constructor(session, data, args = {}) {
+    this.session = session;
+    this.data = data;
+    this.args = args;
+  }
+
+  parse() {
+    return this.args.client === 'YOUTUBE' ? ({
+      SEARCH: () => this.#parseVideoSearch(),
+      PLAYLIST: () => this.#parsePlaylist(),
+      VIDEO_INFO: () => this.#parseVideoInfo()
+    })[this.args.data_type]() : ({
+      SEARCH: () => this.#parseMusicSearch(),
+      PLAYLIST: () => this.#parseMusicPlaylist()
+    })[this.args.data_type]();
+  }
+
+  #parseVideoSearch() {
+    const response = {};
+
+    const contents = this.data.contents.twoColumnSearchResultsRenderer
+      .primaryContents.sectionListRenderer.contents[0].itemSectionRenderer
+      .contents;
+
+    // TODO: Implement search continuation
+    // const continuation_token = this.data.contents.twoColumnSearchResultsRenderer
+    //   .primaryContents.sectionListRenderer.contents[1].continuationItemRenderer
+    //   .continuationEndpoint.continuationCommand.token;
+
+    response.query = contents[0].showingResultsForRenderer && contents[0].showingResultsForRenderer.originalQuery.simpleText || this.args.query;
+    response.corrected_query = contents[0].showingResultsForRenderer && contents[0].showingResultsForRenderer.correctedQueryEndpoint.searchEndpoint.query || this.args.query;
+    response.estimated_results = parseInt(this.data.estimatedResults);
+
+    response.videos = contents.map((data) => {
+      if (!data.videoRenderer) return;
+      const video = data.videoRenderer;
+      return {
+        title: video.title.runs[0].text,
+        description: video.detailedMetadataSnippets && video.detailedMetadataSnippets[0].snippetText.runs.map((item) => item.text).join('') || 'N/A',
+        author: video.ownerText.runs[0].text,
+        id: video.videoId,
+        url: `https://youtu.be/${video.videoId}`,
+        channel_url: `${Constants.URLS.YT_BASE_URL}${video.ownerText.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url}`,
+        metadata: {
+          view_count: video.viewCountText && video.viewCountText.simpleText || 'N/A',
+          short_view_count_text: {
+            simple_text: video.shortViewCountText && video.shortViewCountText.simpleText || 'N/A',
+            accessibility_label: video.shortViewCountText && (video.shortViewCountText.accessibility && video.shortViewCountText.accessibility.accessibilityData.label || 'N/A') || 'N/A',
+          },
+          thumbnails: video.thumbnail.thumbnails,
+          duration: {
+            seconds: Utils.timeToSeconds(video.lengthText && video.lengthText.simpleText || '0'),
+            simple_text: video.lengthText && video.lengthText.simpleText || 'N/A',
+            accessibility_label: video.lengthText && video.lengthText.accessibility.accessibilityData.label || 'N/A'
+          },
+          published: video.publishedTimeText && video.publishedTimeText.simpleText || 'N/A',
+          badges: video.badges && video.badges.map((item) => item.metadataBadgeRenderer.label) || 'N/A',
+          owner_badges: video.ownerBadges && video.ownerBadges.map((item) => item.metadataBadgeRenderer.tooltip) || 'N/A '
+        }
+      };
+    }).filter((video) => video);
+
+    return response;
+  }
+
+  #parsePlaylist() {
+    const details = this.data.sidebar.playlistSidebarRenderer.items[0];
+    const metadata = {
+      title: this.data.metadata.playlistMetadataRenderer.title,
+      description: details.playlistSidebarPrimaryInfoRenderer.description.simpleText || 'N/A',
+      total_items: details.playlistSidebarPrimaryInfoRenderer.stats[0].runs[0].text,
+      last_updated: details.playlistSidebarPrimaryInfoRenderer.stats[2].runs[1].text,
+      views: details.playlistSidebarPrimaryInfoRenderer.stats[1].simpleText
+    }
+
+    const playlist_content = this.data.contents.twoColumnBrowseResultsRenderer.tabs[0]
+      .tabRenderer.content.sectionListRenderer.contents[0]
+      .itemSectionRenderer.contents[0].playlistVideoListRenderer.contents;
+
+    const items = playlist_content.map((item) => {
+      if (item.playlistVideoRenderer)
+      return {
+        id: item.playlistVideoRenderer.videoId,
+        title: item.playlistVideoRenderer.title.runs[0].text,
+        author: item.playlistVideoRenderer.shortBylineText.runs[0].text,
+        duration: {
+          seconds: Utils.timeToSeconds(item.playlistVideoRenderer.lengthText && item.playlistVideoRenderer.lengthText.simpleText || '0'),
+          simple_text: item.playlistVideoRenderer.lengthText && item.playlistVideoRenderer.lengthText.simpleText || 'N/A',
+          accessibility_label: item.playlistVideoRenderer.lengthText && item.playlistVideoRenderer.lengthText.accessibility.accessibilityData.label || 'N/A'
+        },
+        thumbnail: item.playlistVideoRenderer.thumbnail.thumbnails,
+      }
+    });
+
+    return {
+      ...metadata,
+      items
+    }
+  }
+
+  #parseMusicSearch() {
+    const tabs = this.data.contents.tabbedSearchResultsRenderer.tabs;
+    const contents = tabs[0].tabRenderer.content.sectionListRenderer.contents;
+
+    if (contents.length <= 1)
+      return { songs: [], videos: [], albums: [], playlists: [] };
+
+    const songs_ms = contents.find((content) => content.musicShelfRenderer.title.runs[0].text == 'Songs');
+    const songs = songs_ms.musicShelfRenderer.contents.map((item) => {
+      const list_item = item.musicResponsiveListItemRenderer;
+      if (list_item.playlistItemData)
+        return {
+          id: list_item.playlistItemData.videoId,
+          title: list_item.flexColumns[0].musicResponsiveListItemFlexColumnRenderer.text.runs[0].text,
+          artist: list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[2].text,
+          album: list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[4].text,
+          duration: list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[6].text,
+          thumbnail: list_item.thumbnail.musicThumbnailRenderer.thumbnail,
+          getLyrics: () => this.session.getLyrics(list_item.playlistItemData.videoId)
+        };
+    }).filter((item) => item); // Filters out undefined items, which are usually generated by unavailable videos.
+
+    const videos_ms = contents.find((content) => content.musicShelfRenderer.title.runs[0].text == 'Videos');
+    const videos = videos_ms.musicShelfRenderer.contents.map((item) => {
+      const list_item = item.musicResponsiveListItemRenderer;
+      if (list_item.playlistItemData)
+        return {
+          id: list_item.playlistItemData.videoId,
+          title: list_item.flexColumns[0].musicResponsiveListItemFlexColumnRenderer.text.runs[0].text,
+          author: list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[2].text,
+          views: list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[4].text,
+          duration: list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[6].text,
+          thumbnail: list_item.thumbnail.musicThumbnailRenderer.thumbnail,
+          getLyrics: () => this.session.getLyrics(list_item.playlistItemData.videoId)
+        };
+    }).filter((item) => item);
+
+    const albums_ms = contents.find((content) => content.musicShelfRenderer.title.runs[0].text == 'Albums');
+    const albums = albums_ms.musicShelfRenderer.contents.map((item) => {
+      const list_item = item.musicResponsiveListItemRenderer;
+      return {
+        title: list_item.flexColumns[0].musicResponsiveListItemFlexColumnRenderer.text.runs[0].text,
+        author: list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[2].text,
+        year: list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs.find((run) => /^[12][0-9]{3}$/.test(run.text)).text,
+        thumbnail: list_item.thumbnail.musicThumbnailRenderer.thumbnail,
+      };
+    });
+
+    const playlists_ms = contents.find((content) => content.musicShelfRenderer.title.runs[0].text == 'Community playlists');
+    const playlists = playlists_ms.musicShelfRenderer.contents.map((item) => {
+      const list_item = item.musicResponsiveListItemRenderer;
+      const watch_playlist_endpoint = list_item.overlay.musicItemThumbnailOverlayRenderer.content.musicPlayButtonRenderer
+        .playNavigationEndpoint.watchPlaylistEndpoint;
+
+      return {
+        id: watch_playlist_endpoint.playlistId,
+        title: list_item.flexColumns[0].musicResponsiveListItemFlexColumnRenderer.text.runs[0].text,
+        author: list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[2].text,
+        channel_id: list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[2].navigationEndpoint.browseEndpoint.browseId,
+        total_items: parseInt(list_item.flexColumns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[4].text.match(/\d+/g)),
+      };
+    });
+
+    return { songs, videos, albums, playlists };
+  }
+
+  #parseMusicPlaylist() {
+    const details = this.data.header.musicDetailHeaderRenderer;
+
+    const metadata = {
+      title: details.title.runs[0].text,
+      description: details.description && details.description.runs.map((run) => run.text).join('') || 'N/A',
+      total_items: parseInt(details.secondSubtitle.runs[0].text.match(/\d+/g)),
+      duration: details.secondSubtitle.runs[2].text,
+      year: details.subtitle.runs[4].text
+    };
+
+    const contents = this.data.contents.singleColumnBrowseResultsRenderer.tabs[0].tabRenderer.content.sectionListRenderer.contents;
+    const playlist_content = contents[0].musicPlaylistShelfRenderer.contents;
+
+    const items = playlist_content.map((item) => {
+      const item_renderer = item.musicResponsiveListItemRenderer;
+      const fixed_columns = item_renderer.fixedColumns;
+      const flex_columns = item_renderer.flexColumns;
+
+      return {
+        id: item_renderer.playlistItemData && item_renderer.playlistItemData.videoId,
+        title: flex_columns[0].musicResponsiveListItemFlexColumnRenderer.text.runs[0].text,
+        author: flex_columns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[0].text,
+        duration: fixed_columns[0].musicResponsiveListItemFixedColumnRenderer.text.runs[0].text,
+        thumbnail: item_renderer.thumbnail.musicThumbnailRenderer.thumbnail.thumbnails
+      }
+    }).filter((item) => item.id);
+
+    return {
+      ...metadata,
+      items
+    }
+  }
+
+  #parseVideoInfo() {
+    const desktop_v = this.args.desktop_v;
+
+    const playability_status = desktop_v && this.data.playabilityStatus ||
+      this.data[2].playerResponse.playabilityStatus;
+
+    if (playability_status.status == 'ERROR')
+      throw new Error(`Could not retrieve details for this video: ${playability_status.status} - ${playability_status.reason}`);
+
+    const details = desktop_v && this.data.videoDetails ||
+      this.data[2].playerResponse.videoDetails;
+
+    const microformat = desktop_v && this.data.microformat.playerMicroformatRenderer ||
+      this.data[2].playerResponse.microformat.playerMicroformatRenderer;
+
+    const streaming_data = desktop_v && this.data.streamingData ||
+      this.data[2].playerResponse.streamingData;
+
+    const response = {
+      id: '',
+      title: '',
+      description: '',
+      thumbnail: [],
+      metadata: {}
+    };
+
+    const mf_raw_data = Object.entries(microformat);
+    const dt_raw_data = Object.entries(details);
+
+    mf_raw_data.forEach((entry) => {
+      const key = Utils.camelToSnake(entry[0]);
+      if (Constants.METADATA_KEYS.includes(key)) {
+        key == 'view_count' && (response.metadata[key] = parseInt(entry[1])) ||
+          key == 'owner_profile_url' && (response.metadata.channel_url = entry[1]) ||
+          key == 'owner_channel_name' && (response.metadata.channel_name = entry[1]) ||
+          (response.metadata[key] = entry[1]);
+      } else {
+        response[key] = entry[1];
+      }
+    });
+
+    dt_raw_data.forEach((entry) => {
+      const key = Utils.camelToSnake(entry[0]);
+      if (Constants.BLACKLISTED_KEYS.includes(key)) return;
+      if (Constants.METADATA_KEYS.includes(key)) {
+        key == 'view_count' && (response.metadata[key] = parseInt(entry[1])) ||
+          (response.metadata[key] = entry[1]);
+      } else {
+        key == 'short_description' && (response.description = entry[1]) ||
+          key == 'thumbnail' && (response.thumbnail = entry[1].thumbnails.slice(-1)[0]) ||
+          key == 'video_id' && (response.id = entry[1]) ||
+          (response[key] = entry[1]);
+      }
+    });
+
+    if (!desktop_v) {
+      const dislike_available = this.data[3].response.contents.singleColumnWatchNextResults.results.results.contents[1]
+        .slimVideoMetadataSectionRenderer.contents[1].slimVideoActionBarRenderer.buttons[1].slimMetadataToggleButtonRenderer
+        .button.toggleButtonRenderer.defaultText.accessibility && true || false;
+
+      response.metadata.likes = parseInt(this.data[3].response.contents.singleColumnWatchNextResults.results.results.contents[1]
+        .slimVideoMetadataSectionRenderer.contents[1].slimVideoActionBarRenderer.buttons[0].slimMetadataToggleButtonRenderer
+        .button.toggleButtonRenderer.defaultText.accessibility.accessibilityData.label.replace(/\D/g, ''));
+
+      response.metadata.dislikes = dislike_available && parseInt(this.data[3].response.contents.singleColumnWatchNextResults.results.results.contents[1]
+        .slimVideoMetadataSectionRenderer.contents[1].slimVideoActionBarRenderer.buttons[1].slimMetadataToggleButtonRenderer
+        .button.toggleButtonRenderer.defaultText.accessibility.accessibilityData.label.replace(/\D/g, '')) || 0;
+    }
+
+    response.metadata.available_qualities = [...new Set(streaming_data.adaptiveFormats.filter(v => v.qualityLabel)
+      .map(v => v.qualityLabel).sort((a, b) => + a.replace(/\D/gi, '') - + b.replace(/\D/gi, '')))];
+
+    return response;
+  }
+}
+
+module.exports = Parser;

lib/Player.js

@@ -1,45 +1,48 @@
 'use strict';
 
-const fs = require('fs');
+const Fs = require('fs');
 const Axios = require('axios');
 const Utils = require('./Utils');
 const Constants = require('./Constants');
 
 class Player {
-  constructor(innertube_session) {
-    this.session = innertube_session;
+  constructor(session) {
+    this.session = session;
     this.player_name = Utils.getStringBetweenStrings(this.session.player_url, '/player/', '/');
     this.tmp_cache_dir = __dirname.slice(0, -3) + 'cache';
   }
 
   async init() {
-    if (fs.existsSync(`${this.tmp_cache_dir}/${this.player_name}.js`)) {
-      const player_data = fs.readFileSync(`${this.tmp_cache_dir}/${this.player_name}.js`).toString();
-      this.getSigDecipherCode(player_data);
-      this.getNEncoder(player_data);
+    if (Fs.existsSync(`${this.tmp_cache_dir}/${this.player_name}.js`)) {
+      const player_data = Fs.readFileSync(`${this.tmp_cache_dir}/${this.player_name}.js`).toString();
+      this.sig_decipher_sc = this.#getSigDecipherCode(player_data);
+      this.ntoken_sc = this.#getNEncoder(player_data);
     } else {
-      const response = await Axios.get(`${Constants.urls.YT_BASE_URL}${this.session.player_url}`, { path: this.session.playerUrl, headers: { 'content-type': 'text/javascript', 'user-agent': Utils.getRandomUserAgent('desktop').userAgent } }).catch((error) => error);
+      const response = await Axios.get(`${Constants.URLS.YT_BASE_URL}${this.session.player_url}`, { path: this.session.playerUrl, headers: { 'content-type': 'text/javascript', 'user-agent': Utils.getRandomUserAgent('desktop').userAgent } }).catch((error) => error);
       if (response instanceof Error) throw new Error('Could not download player script: ' + response.message);
 
       try {
-        // Caches the current player so we don't have to download it all the time
-        fs.mkdirSync(this.tmp_cache_dir, { recursive: true });
-        fs.writeFileSync(`${this.tmp_cache_dir}/${this.player_name}.js`, response.data);
-      } catch (err) {}
+        // Deletes old players
+        Fs.existsSync(this.tmp_cache_dir) && Fs.rmSync(this.tmp_cache_dir, { recursive: true });
 
-      this.getSigDecipherCode(response.data);
-      this.getNEncoder(response.data);
+        // Caches the current player so we don't have to download it all the time.
+        Fs.mkdirSync(this.tmp_cache_dir, { recursive: true });
+        Fs.writeFileSync(`${this.tmp_cache_dir}/${this.player_name}.js`, response.data);
+      } catch (err) { }
+
+      this.sig_decipher_sc = this.#getSigDecipherCode(response.data);
+      this.ntoken_sc = this.#getNEncoder(response.data);
     }
   }
 
-  getSigDecipherCode(data) {
-    const manipulation_algorithm_code = Utils.getStringBetweenStrings(data, 'this.audioTracks};var', '};');
-    const manipulation_sequence_code = Utils.getStringBetweenStrings(data, 'function(a){a=a.split("")', 'return a.join("")}');
-    this.sig_decipher_sc = manipulation_algorithm_code + manipulation_sequence_code;
+  #getSigDecipherCode(data) {
+    const sig_alg_sc = Utils.getStringBetweenStrings(data, 'this.audioTracks};var', '};');
+    const sig_data = Utils.getStringBetweenStrings(data, 'function(a){a=a.split("")', 'return a.join("")}');
+    return sig_alg_sc + sig_data;
   }
 
-  getNEncoder(data) {
-    this.ntoken_sc = `var b=a.split("")${Utils.getStringBetweenStrings(data, 'b=a.split("")', '}return b.join("")}')}} return b.join("");`;
+  #getNEncoder(data) {
+    return `var b=a.split("")${Utils.getStringBetweenStrings(data, 'b=a.split("")', '}return b.join("")}')}} return b.join("");`;
   }
 }
 

lib/Sig.js

@@ -1,20 +1,21 @@
 'use strict';
 
-const NToken = require('./NToken');
 const QueryString = require('querystring');
 
 class SigDecipher {
-  constructor(url, cver, player) {
+  constructor(url, player) {
     this.url = url;
-    this.cver = cver;
     this.player = player;
     this.func_regex = /(.{2}):function\(.*?\){(.*?)}/g;
     this.actions_regex = /;.{2}\.(.{2})\(.*?,(.*?)\)/g;
   }
 
+  /**
+  * Deciphers signature.
+  */
   decipher() {
     const args = QueryString.parse(this.url);
-    const functions = this.getFunctions();
+    const functions = this.#getFunctions();
 
     function splice(arr, end) {
       arr.splice(0, end);
@@ -49,15 +50,11 @@ class SigDecipher {
     }
 
     const url_components = new URL(args.url);
-
-    args.sp !== undefined ? url_components.searchParams.set(args.sp, signature.join('')) : url_components.searchParams.set('signature', signature.join(''));
-    url_components.searchParams.set('cver', this.cver);
-    url_components.searchParams.set('ratebypass', 'yes');
-    url_components.searchParams.set('n', new NToken(this.player.ntoken_sc).transform(url_components.searchParams.get('n')));
+    args.sp ? url_components.searchParams.set(args.sp, signature.join('')) : url_components.searchParams.set('signature', signature.join(''));
     return url_components.toString();
   }
 
-  getFunctions() {
+  #getFunctions() {
     let func;
     let func_name = [];
 

lib/Utils.js

@@ -5,6 +5,12 @@ const Proto = require('protons');
 const Crypto = require('crypto');
 const UserAgent = require('user-agents');
 
+/**
+ * Returns a random user agent.
+ *
+ * @param {string} type - mobile | desktop
+ * @returns {object}
+ */
 function getRandomUserAgent(type) {
   switch (type) {
     case 'mobile':
@@ -15,6 +21,12 @@ function getRandomUserAgent(type) {
   }
 }
 
+/**
+ * Generates an authentication token from a cookies' sid.
+ *
+ * @param {string} sid - Sid extracted from cookies 
+ * @returns {string}
+ */
 function generateSidAuth(sid) {
   const youtube = 'https://www.youtube.com';
   const timestamp = Math.floor(new Date().getTime() / 1000);
@@ -27,6 +39,13 @@ function generateSidAuth(sid) {
   return ['SAPISIDHASH', [timestamp, gen_hash].join('_')].join(' ');
 }
 
+/**
+ * Gets a string between two delimiters.
+ *
+ * @param {string} data - The data.
+ * @param {string} start_string - Start string.
+ * @param {string} end_string - End string.
+ */
 function getStringBetweenStrings(data, start_string, end_string) {
   const regex = new RegExp(`${escapeStringRegexp(start_string)}(.*?)${escapeStringRegexp(end_string)}`, "s");
   const match = data.match(regex);
@@ -37,6 +56,38 @@ function escapeStringRegexp(string) {
   return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
 }
 
+/**
+ * Converts time (h:m:s) to seconds.
+ * 
+ * @param {string} time 
+ * @returns {number} seconds
+ */
+function timeToSeconds(time) {
+  let params = time.split(':');
+  return parseInt(({
+    3: +params[0] * 3600 + +params[1] * 60 + +params[2],
+    2: +params[0] * 60 + +params[1],
+    1: +params[0]
+  })[params.length]);
+}
+
+/**
+ * Converts strings in camelCase to snake_case.
+ *
+ * @param {string} string The string in camelCase.
+ * @returns {string}
+ */
+function camelToSnake(string) {
+  return string[0].toLowerCase() + string.slice(1, string.length).replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+
+/**
+ * Encodes notification preferences protobuf.
+ *
+ * @param {string} channel_id
+ * @param {string} index
+ * @returns {string}
+ */
 function encodeNotificationPref(channel_id, index) {
   const youtube_proto = Proto(Fs.readFileSync(`${__dirname}/proto/youtube.proto`));
 
@@ -52,7 +103,14 @@ function encodeNotificationPref(channel_id, index) {
   return encodeURIComponent(Buffer.from(buf).toString('base64'));
 }
 
-function generateMessageParams(channel_id, video_id) {
+/**
+ * Encodes livestream message protobuf.
+ *
+ * @param {string} channel_id
+ * @param {string} video_id 
+ * @returns {string}
+ */
+function encodeMessageParams(channel_id, video_id) {
   const youtube_proto = Proto(Fs.readFileSync(`${__dirname}/proto/youtube.proto`));
 
   const buf = youtube_proto.LiveMessageParams.encode({
@@ -69,7 +127,13 @@ function generateMessageParams(channel_id, video_id) {
   return Buffer.from(encodeURIComponent(Buffer.from(buf).toString('base64'))).toString('base64');
 }
 
-function generateCommentParams(video_id) {
+/**
+ * Encodes comment params protobuf.
+ *
+ * @param {string} video_id
+ * @returns {string}
+ */
+function encodeCommentParams(video_id) {
   const youtube_proto = Proto(Fs.readFileSync(`${__dirname}/proto/youtube.proto`));
 
   const buf = youtube_proto.CreateCommentParams.encode({
@@ -83,4 +147,47 @@ function generateCommentParams(video_id) {
   return encodeURIComponent(Buffer.from(buf).toString('base64'));
 }
 
-module.exports = { getRandomUserAgent, generateSidAuth, getStringBetweenStrings, generateMessageParams, generateCommentParams, encodeNotificationPref };
+/**
+ * Encodes search filter protobuf
+ *
+ * @param {string} period - Period in which a video is uploaded: any | hour | day | week | month | year
+ * @param {string} duration - The duration of a video: any | short | long
+ * @param {string} order - The order of the search results: relevance | rating | age | views
+ * @returns {string}
+ */
+function encodeFilter(period, duration, order) {
+  const youtube_proto = Proto(Fs.readFileSync(`${__dirname}/proto/youtube.proto`));
+
+  const periods = { 'any': null, 'hour': 1, 'day': 2, 'week': 3, 'month': 4, 'year': 5 };
+  const durations = { 'any': null, 'short': 1, 'long': 2 };
+  const orders = { 'relevance': null, 'rating': 1, 'age': 2, 'views': 3 };
+
+  const search_filter_buff = youtube_proto.SearchFilter.encode({
+    number: orders[order],
+    filter: {
+      param_0: periods[period],
+      param_1: (period == 'hour' && order == 'relevance') ? null : 1,
+      param_2: durations[duration]
+    }
+  });
+
+  return encodeURIComponent(Buffer.from(search_filter_buff).toString('base64'));
+}
+
+/**
+ * Turns the ntoken transform data into a valid json array
+ * 
+ * @param {string} data 
+ * @returns {string}
+ */
+function refineNTokenData(data) {
+  return data
+    .replace(/function\(d,e\)/g, '"function(d,e)').replace(/function\(d\)/g, '"function(d)')
+    .replace(/function\(\)/g, '"function()').replace(/function\(d,e,f\)/g, '"function(d,e,f)')
+    .replace(/\[function\(d,e,f\)/g, '["function(d,e,f)').replace(/,b,/g, ',"b",')
+    .replace(/,b/g, ',"b"').replace(/b,/g, '"b",').replace(/b]/g, '"b"]')
+    .replace(/\[b/g, '["b"').replace(/}]/g, '"]').replace(/},/g, '}",')
+    .replace(/""/g, '').replace(/length]\)}"/g, 'length])}');
+}
+
+module.exports = { getRandomUserAgent, generateSidAuth, getStringBetweenStrings, camelToSnake, timeToSeconds, encodeMessageParams, encodeCommentParams, encodeNotificationPref, encodeFilter, refineNTokenData };

lib/proto/youtube.proto

@@ -31,4 +31,14 @@ message CreateCommentParams {
   }
   Params params = 5;
   int32 number = 10;
+}
+
+message SearchFilter {
+  int32 number = 1;
+  message Filter {
+    int32 param_0 = 1;
+    int32 param_1 = 2;
+    int32 param_2 = 3;
+  }
+  Filter filter = 2;
 }

package-lock.json

@@ -1,17 +1,16 @@
 {
   "name": "youtubei.js",
-  "version": "1.2.4",
+  "version": "1.3.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "youtubei.js",
-      "version": "1.2.4",
+      "version": "1.3.6",
       "license": "MIT",
       "dependencies": {
         "axios": "^0.21.4",
         "protons": "^2.0.3",
-        "time-to-seconds": "^1.1.5",
         "user-agents": "^1.0.778",
         "uuid": "^8.3.2"
       }
@@ -54,9 +53,9 @@
       }
     },
     "node_modules/follow-redirects": {
-      "version": "1.14.4",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.4.tgz",
-      "integrity": "sha512-zwGkiSXC1MUJG/qmeIFH2HBJx9u0V46QGUe3YR1fXG8bXQxq7fLj0RjLZQ5nubr9qNJUZrH+xUcwXEoXNpfS+g==",
+      "version": "1.14.8",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.8.tgz",
+      "integrity": "sha512-1x0S9UVJHsQprFcEC/qnNzBLcIxsjAV905f/UkQxbclCsoTWlacCNOpQa/anodLl2uaEKFhfWOvM2Qg77+15zA==",
       "funding": [
         {
           "type": "individual",
@@ -78,9 +77,9 @@
       "integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8="
     },
     "node_modules/multiformats": {
-      "version": "9.4.9",
-      "resolved": "https://registry.npmjs.org/multiformats/-/multiformats-9.4.9.tgz",
-      "integrity": "sha512-zA84TTJcRfRMpjvYqy63piBbSEdqlIGqNNSpP6kspqtougqjo60PRhIFo+oAxrjkof14WMCImvr7acK6rPpXLw=="
+      "version": "9.6.4",
+      "resolved": "https://registry.npmjs.org/multiformats/-/multiformats-9.6.4.tgz",
+      "integrity": "sha512-fCCB6XMrr6CqJiHNjfFNGT0v//dxOBMrOMqUIzpPc/mmITweLEyhvMpY9bF+jZ9z3vaMAau5E8B68DW77QMXkg=="
     },
     "node_modules/protocol-buffers-schema": {
       "version": "3.6.0",
@@ -106,15 +105,6 @@
         "varint": "~5.0.0"
       }
     },
-    "node_modules/time-to-seconds": {
-      "version": "1.1.5",
-      "resolved": "https://registry.npmjs.org/time-to-seconds/-/time-to-seconds-1.1.5.tgz",
-      "integrity": "sha512-mpzJDHGF4VdhiahyusCUSy+BWJdN3q8Cluzfy0n7GMU9IIj+HJDX9bbbr7wVSUiqmRn1vqhhfECgdfj+SByu2A==",
-      "engines": {
-        "node": ">=15.0.1",
-        "vscode": "^1.22.0"
-      }
-    },
     "node_modules/uint8arrays": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/uint8arrays/-/uint8arrays-3.0.0.tgz",
@@ -124,9 +114,9 @@
       }
     },
     "node_modules/underscore": {
-      "version": "1.13.1",
-      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.1.tgz",
-      "integrity": "sha512-hzSoAVtJF+3ZtiFX0VgfFPHEDRm7Y/QPjGyNo4TVdnDTdft3tr8hEkD25a1jC+TjTuE7tkHGKkhwCgs9dgBB2g=="
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.2.tgz",
+      "integrity": "sha512-ekY1NhRzq0B08g4bGuX4wd2jZx5GnKz6mKSqFL4nqBlfyMGiG10gDFhDTMEfYmDL6Jy0FUIZp7wiRB+0BP7J2g=="
     },
     "node_modules/underscore-keypath": {
       "version": "0.0.22",
@@ -137,9 +127,9 @@
       }
     },
     "node_modules/user-agents": {
-      "version": "1.0.814",
-      "resolved": "https://registry.npmjs.org/user-agents/-/user-agents-1.0.814.tgz",
-      "integrity": "sha512-OU3lCkkaUCghnZiZuN2edSJ+//ituJihs3P1FCjCDwe1tMBS8eni68CQ0TBbPoVPDtoAqxM3Z7qbP7EWGlhBxA==",
+      "version": "1.0.943",
+      "resolved": "https://registry.npmjs.org/user-agents/-/user-agents-1.0.943.tgz",
+      "integrity": "sha512-0qfnGXlAO9jbfiFAnhKG3CIWxyfr7s5WgwVlV7ns2jnl8BwQI0rTJ4bdx0HR7FasInT9TCvsulmZgLgBQHbkZA==",
       "dependencies": {
         "dot-json": "^1.2.2",
         "lodash.clonedeep": "^4.5.0"
@@ -189,9 +179,9 @@
       }
     },
     "follow-redirects": {
-      "version": "1.14.4",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.4.tgz",
-      "integrity": "sha512-zwGkiSXC1MUJG/qmeIFH2HBJx9u0V46QGUe3YR1fXG8bXQxq7fLj0RjLZQ5nubr9qNJUZrH+xUcwXEoXNpfS+g=="
+      "version": "1.14.8",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.8.tgz",
+      "integrity": "sha512-1x0S9UVJHsQprFcEC/qnNzBLcIxsjAV905f/UkQxbclCsoTWlacCNOpQa/anodLl2uaEKFhfWOvM2Qg77+15zA=="
     },
     "lodash.clonedeep": {
       "version": "4.5.0",
@@ -199,9 +189,9 @@
       "integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8="
     },
     "multiformats": {
-      "version": "9.4.9",
-      "resolved": "https://registry.npmjs.org/multiformats/-/multiformats-9.4.9.tgz",
-      "integrity": "sha512-zA84TTJcRfRMpjvYqy63piBbSEdqlIGqNNSpP6kspqtougqjo60PRhIFo+oAxrjkof14WMCImvr7acK6rPpXLw=="
+      "version": "9.6.4",
+      "resolved": "https://registry.npmjs.org/multiformats/-/multiformats-9.6.4.tgz",
+      "integrity": "sha512-fCCB6XMrr6CqJiHNjfFNGT0v//dxOBMrOMqUIzpPc/mmITweLEyhvMpY9bF+jZ9z3vaMAau5E8B68DW77QMXkg=="
     },
     "protocol-buffers-schema": {
       "version": "3.6.0",
@@ -227,11 +217,6 @@
         "varint": "~5.0.0"
       }
     },
-    "time-to-seconds": {
-      "version": "1.1.5",
-      "resolved": "https://registry.npmjs.org/time-to-seconds/-/time-to-seconds-1.1.5.tgz",
-      "integrity": "sha512-mpzJDHGF4VdhiahyusCUSy+BWJdN3q8Cluzfy0n7GMU9IIj+HJDX9bbbr7wVSUiqmRn1vqhhfECgdfj+SByu2A=="
-    },
     "uint8arrays": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/uint8arrays/-/uint8arrays-3.0.0.tgz",
@@ -241,9 +226,9 @@
       }
     },
     "underscore": {
-      "version": "1.13.1",
-      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.1.tgz",
-      "integrity": "sha512-hzSoAVtJF+3ZtiFX0VgfFPHEDRm7Y/QPjGyNo4TVdnDTdft3tr8hEkD25a1jC+TjTuE7tkHGKkhwCgs9dgBB2g=="
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.2.tgz",
+      "integrity": "sha512-ekY1NhRzq0B08g4bGuX4wd2jZx5GnKz6mKSqFL4nqBlfyMGiG10gDFhDTMEfYmDL6Jy0FUIZp7wiRB+0BP7J2g=="
     },
     "underscore-keypath": {
       "version": "0.0.22",
@@ -254,9 +239,9 @@
       }
     },
     "user-agents": {
-      "version": "1.0.814",
-      "resolved": "https://registry.npmjs.org/user-agents/-/user-agents-1.0.814.tgz",
-      "integrity": "sha512-OU3lCkkaUCghnZiZuN2edSJ+//ituJihs3P1FCjCDwe1tMBS8eni68CQ0TBbPoVPDtoAqxM3Z7qbP7EWGlhBxA==",
+      "version": "1.0.943",
+      "resolved": "https://registry.npmjs.org/user-agents/-/user-agents-1.0.943.tgz",
+      "integrity": "sha512-0qfnGXlAO9jbfiFAnhKG3CIWxyfr7s5WgwVlV7ns2jnl8BwQI0rTJ4bdx0HR7FasInT9TCvsulmZgLgBQHbkZA==",
       "requires": {
         "dot-json": "^1.2.2",
         "lodash.clonedeep": "^4.5.0"
@@ -273,4 +258,4 @@
       "integrity": "sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow=="
     }
   }
-}
+}

package.json

@@ -1,12 +1,13 @@
 {
   "name": "youtubei.js",
-  "version": "1.2.4",
+  "version": "1.3.6",
   "description": "An object-oriented library that allows you to search, get detailed info about videos, subscribe, unsubscribe, like, dislike, comment, download videos and much more!",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node test"
   },
   "author": "LuanRT",
+  "funding": "https://ko-fi.com/luanrt",
   "license": "MIT",
   "directories": {
     "example": "examples",
@@ -15,7 +16,6 @@
   "dependencies": {
     "axios": "^0.21.4",
     "protons": "^2.0.3",
-    "time-to-seconds": "^1.1.5",
     "user-agents": "^1.0.778",
     "uuid": "^8.3.2"
   },
@@ -24,23 +24,25 @@
     "url": "git+https//github.com/LuanRT/YouTube.js.git"
   },
   "keywords": [
+    "yt",
+    "ytdl",
     "youtube",
     "youtube-dl",
+    "youtubedl",
+    "youtube-downloader",
     "innertube",
     "innertubeapi",
     "livechat",
-    "api",
-    "search",
-    "like",
-    "dislike",
-    "comment",
-    "automation",
     "downloader",
-    "comments-section",
-    "youtube-downloader"
+    "dislike",
+    "search",
+    "comment",
+    "like",
+    "api",
+    "dl"
   ],
   "bugs": {
     "url": "https://github.com/LuanRT/YouTube.js/issues"
   },
   "homepage": "https://github.com/LuanRT/YouTube.js#readme"
-}
+}

test/constants.js

@@ -0,0 +1,24 @@
+'use strict';
+
+module.exports = {
+  test_url: 's=t%3DQ%3DAv2TLJ2sbQFV5msp4j7v71gS1rsXNd6QH2V1KpxGlaOD%3DIC46mVzTVTW_2zttE32HKH7XO1jkyfOJs58avqMLKdvRdgIQRw8JQ0qOA&sp=sig&url=https://r1---sn-hxtxgcg-8qjl.googlevideo.com/videoplayback%3Fexpire%3D1635863482%26ei%3DWveAYdqsB6KPobIPjtWwYA%26ip%3D128.201.98.50%26id%3Do-ABuHwkfRnd4hOQoDKRKn7ZHvuLEPAPKkYhiYKpTwLrY7%26itag%3D18%26source%3Dyoutube%26requiressl%3Dyes%26mh%3DG3%26mm%3D31%252C29%26mn%3Dsn-hxtxgcg-8qjl%252Csn-gpv7dned%26ms%3Dau%252Crdu%26mv%3Dm%26mvi%3D1%26pl%3D24%26initcwndbps%3D397500%26vprv%3D1%26mime%3Dvideo%252Fmp4%26ns%3Dv9CYauI2ycUgrV6wOERCNxsG%26gir%3Dyes%26clen%3D7275579%26ratebypass%3Dyes%26dur%3D218.290%26lmt%3D1540416860737282%26mt%3D1635841731%26fvip%3D4%26fexp%3D24001373%252C24007246%26c%3DWEB%26txp%3D5531432%26n%3DD8yGa-DC5m2Dwv--%26sparams%3Dexpire%252Cei%252Cip%252Cid%252Citag%252Csource%252Crequiressl%252Cvprv%252Cmime%252Cns%252Cgir%252Cclen%252Cratebypass%252Cdur%252Clmt%26lsparams%3Dmh%252Cmm%252Cmn%252Cms%252Cmv%252Cmvi%252Cpl%252Cinitcwndbps%26lsig%3DAG3C_xAwRAIgdS6ux5rh5ulfwh8c6_Kt2cOdyS51OxPlxSUoB5k5x9YCICOgRiuFsZwAqJmxvBrCuq3CKk1S4YeAxEq3zPLvzAvX',
+  expected_url: 'https://r1---sn-hxtxgcg-8qjl.googlevideo.com/videoplayback?expire=1635863482&ei=WveAYdqsB6KPobIPjtWwYA&ip=128.201.98.50&id=o-ABuHwkfRnd4hOQoDKRKn7ZHvuLEPAPKkYhiYKpTwLrY7&itag=18&source=youtube&requiressl=yes&mh=G3&mm=31%2C29&mn=sn-hxtxgcg-8qjl%2Csn-gpv7dned&ms=au%2Crdu&mv=m&mvi=1&pl=24&initcwndbps=397500&vprv=1&mime=video%2Fmp4&ns=v9CYauI2ycUgrV6wOERCNxsG&gir=yes&clen=7275579&ratebypass=yes&dur=218.290&lmt=1540416860737282&mt=1635841731&fvip=4&fexp=24001373%2C24007246&c=WEB&txp=5531432&n=D8yGa-DC5m2Dwv--&sparams=expire%2Cei%2Cip%2Cid%2Citag%2Csource%2Crequiressl%2Cvprv%2Cmime%2Cns%2Cgir%2Cclen%2Cratebypass%2Cdur%2Clmt&lsparams=mh%2Cmm%2Cmn%2Cms%2Cmv%2Cmvi%2Cpl%2Cinitcwndbps&lsig=AG3C_xAwRAIgdS6ux5rh5ulfwh8c6_Kt2cOdyS51OxPlxSUoB5k5x9YCICOgRiuFsZwAqJmxvBrCuq3CKk1S4YeAxEq3zPLvzAvX&sig=AOq0QJ8wRQIgdRvdKLMqva85sJOfykj1OX7HKH23Ettz2_WTVTzVm64CIQDOalGxpK1V2Ht6dNXsr1Sg17v7j4psm5VFQbs2JLT2vA%3D%3D',
+  original_ntoken: 'PqjqqJjdB9K821VIisj',
+  expected_ntoken: 'AxwyS-osUl1WhMUd1',
+  client_version: '2.20211101.01.00',
+  test_video_id: 'dQw4w9WgXcQ',
+  sig_decipher_sc: `fB={RP:function(a,b){a.splice(0,b)},
+Td:function(a){a.reverse()},
+kq:function(a,b){var c=a[0];a[0]=a[b%a.length];a[b%a.length]=c};fB.kq(a,35);fB.RP(a,2);fB.kq(a,46);fB.Td(a,6);`,
+  n_scramble_sc: `var b=a.split(""),c=[-470482026,-691770757,function(d,e){e=(e%d.length+d.length)%d.length;d.splice(-e).reverse().forEach(function(f){d.unshift(f)})},
+b,258876269,-1426380890,318754300,-68090711,-2064438462,-1886316521,1913911047,1635047330,function(d,e){e=(e%d.length+d.length)%d.length;d.splice(-e).reverse().forEach(function(f){d.unshift(f)})},
+-1815897225,1940621629,-714586149,-1723898467,null,778601498,2145333248,1245726977,1952270083,268207944,244274044,null,function(d,e){e=(e%d.length+d.length)%d.length;d.splice(0,1,d.splice(e,1,d[0])[0])},
+null,-762271981,604636391,1087224318,-931565987,-338396815,function(d,e){for(e=(e%d.length+d.length)%d.length;e--;)d.unshift(d.pop())},
+2126741474,function(d){for(var e=d.length;e;)d.push(d.splice(--e,1)[0])},
+-1874551858,-1238260579,498106911,1913911047,-1951114300,-504396507,b,344510945,905306344,b,function(d,e){e=(e%d.length+d.length)%d.length;var f=d[0];d[0]=d[e];d[e]=f},
+909033134,1027812119,1686673079,function(d,e){d.push(e)},
+-1902376100,function(d,e){e=(e%d.length+d.length)%d.length;d.splice(e,1)},
+"push",function(d,e){for(var f=64,h=[];++f-h.length-32;)switch(f){case 58:f=96;continue;case 91:f=44;break;case 65:f=47;continue;case 46:f=153;case 123:f-=58;default:h.push(String.fromCharCode(f))}d.forEach(function(l,m,n){this.push(n[m]=h[(h.indexOf(l)-h.indexOf(this[m])+m-32+f--)%h.length])},e.split(""))}];
+c[17]=c;c[24]=c;c[26]=c;try{c[45](c[17],c[38]),c[12](c[44],c[29]),c[45](c[26],c[0]),c[51](c[41],c[13]),c[12](c[41],c[27]),c[12](c[26],c[11]),c[39](c[17],c[49]),c[9](c[38],c[47]),c[26](c[40],c[0]),c[7](c[8],c[44]),c[14](c[54],c[0]),c[18](c[3],c[25]),c[7](c[33],c[36]),c[15](c[19],c[14]),c[7](c[19],c[9]),c[7](c[6],c[12]),c[41](c[33],c[35]),c[7](c[40],c[5]),c[50](c[42]),c[13](c[14],c[17]),c[6](c[35],c[51]),c[26](c[48],c[50]),c[26](c[35],c[0]),c[6](c[21],c[46]),c[15](c[21],c[42]),c[1](c[2],c[43]),c[15](c[2],
+c[31]),c[1](c[21],c[25]),c[22](c[30],c[17]),c[15](c[44],c[46]),c[22](c[44],c[11]),c[22](c[23],c[38]),c[1](c[23],c[14]),c[35](c[23],c[44]),c[11](c[53],c[20]),c[9](c[51]),c[31](c[51],c[28]),c[18](c[51],c[35]),c[46](c[53],c[6]),c[52](c[51],c[49]),c[11](c[53],c[15])}catch(d){return"enhanced_except_75MBkOz-_w8_"+a} return b.join("");`
+};

test/index.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const Fs = require('fs');
+const Innertube = require('..');
+const NToken = require('../lib/NToken');
+const SigDecipher = require('../lib/Sig');
+const Constants = require('./constants');
+
+let failed_tests = 0;
+
+async function performTests() {
+  const youtube = await new Innertube().catch((error) => error);
+  assert(!(youtube instanceof Error), `should retrieve Innertube configuration data`, youtube);
+
+  if (!(youtube instanceof Error)) {
+    const search = await youtube.search('Carl Sagan - Documentary').catch((error) => error);
+    assert(!(search instanceof Error) && search.videos.length >= 1, `should search videos`, search);
+
+    const details = await youtube.getDetails(Constants.test_video_id).catch((error) => error);
+    assert(!(details instanceof Error), `should retrieve details for ${Constants.test_video_id}`, details);
+
+    const comments = await youtube.getComments(Constants.test_video_id).catch((error) => error);
+    assert(!(comments instanceof Error), `should retrieve comments for ${Constants.test_video_id}`, comments);
+
+    const video = await downloadVideo(Constants.test_video_id, youtube).catch((error) => error);
+    assert(!(video instanceof Error), `should download video (${Constants.test_video_id})`, video);
+  }
+
+
+  const n_token = new NToken(Constants.n_scramble_sc).transform(Constants.original_ntoken);
+  assert(n_token == Constants.expected_ntoken, `should transform n token into ${Constants.expected_ntoken}`, n_token);
+
+  const transformed_url = new SigDecipher(Constants.test_url, { sig_decipher_sc: Constants.sig_decipher_sc }).decipher();
+  assert(transformed_url == Constants.expected_url, `should correctly decipher signature`, transformed_url);
+
+  if (failed_tests > 0)
+    throw new Error('Some tests have failed');
+}
+
+function downloadVideo(id, youtube) {
+  return new Promise((resolve, reject) => {
+    let got_video_info = false;
+    const stream = youtube.download(id, { type: 'videoandaudio' });
+    stream.pipe(Fs.createWriteStream(`./${id}.mp4`));
+    stream.on('end', () => Fs.existsSync(`./${id}.mp4`) && got_video_info && resolve() || reject());
+    stream.on('info', () => got_video_info = true);
+    stream.on('error', (err) => reject(err));
+  });
+}
+
+function assert(outcome, description, data) {
+  const pass_fail = outcome ? 'pass' : 'fail';
+
+  console.info(pass_fail, ':', description);
+  !outcome && (failed_tests += 1);
+  !outcome && console.error('Error: ', data);
+
+  return outcome;
+}
+
+performTests();