fix: search continuations not being parsed correctly (#173)

* feat: add `TitleAndButtonListHeader`

* fix: continuations not being parsed correctly

* chore: add a test

* chore(package): bump version to 2.0.2

* chore: lint

.editorconfig

@@ -0,0 +1,12 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = false
+insert_final_newline = false

.eslintignore

@@ -0,0 +1,8 @@
+.git
+.github
+test/
+cache/
+src/proto/youtube.ts
+coverage/
+node_modules/
+dist/

.eslintrc.yml

@@ -0,0 +1,87 @@
+plugins:
+  [ '@typescript-eslint', 'eslint-plugin-tsdoc' ]
+env:
+  commonjs: true
+  es2021: true
+  node: true
+extends: [ eslint:recommended, 'plugin:@typescript-eslint/recommended' ]
+parser: '@typescript-eslint/parser'
+parserOptions:
+  ecmaVersion: latest
+overrides:
+  - 
+    files:
+      - '**/*.js'
+    rules:
+      'tsdoc/syntax': 'off'
+rules:
+  max-len:
+    - error
+    -
+      code: 200
+      ignoreComments: true
+      ignoreTrailingComments: true
+      ignoreStrings: true
+      ignoreTemplateLiterals: true
+      ignoreRegExpLiterals: true
+
+  quotes: [error, single] 
+
+  '@typescript-eslint/ban-types': 'off'
+  'tsdoc/syntax': 'warn'
+  '@typescript-eslint/no-explicit-any': 'off'
+
+  no-template-curly-in-string: error
+  no-unreachable-loop: error
+  no-unused-private-class-members: 'off'
+  no-prototype-builtins: 'off'
+  no-async-promise-executor: 'off'
+  no-case-declarations: 'off'
+  no-return-assign: 'off'
+  no-floating-decimal: error
+  no-implied-eval: error
+  arrow-spacing: error
+  no-invalid-this: error
+  no-lone-blocks: 'off'
+  no-new-func: error
+  no-new-wrappers: error
+  no-new: error
+  no-void: error
+  no-octal-escape: error
+  no-self-compare: error
+  no-sequences: error
+  no-throw-literal: error
+  no-unmodified-loop-condition: error
+  no-useless-call: error
+  no-useless-concat: error
+  no-useless-escape: error
+  no-useless-return: error
+  no-else-return: error
+  no-lonely-if: error
+  no-undef-init: error
+  no-unneeded-ternary: error
+  no-var: error
+  no-multi-spaces: error
+  no-multiple-empty-lines: ["error", { "max": 2, "maxEOF": 0 }]
+  no-tabs: error
+  no-trailing-spaces: error
+ 
+  brace-style: error
+  new-parens: error
+  space-infix-ops: error
+  template-curly-spacing: error
+  wrap-regex: error
+  capitalized-comments: error
+  prefer-template: error
+
+  keyword-spacing: ["error", { "before": true } ]
+  array-bracket-spacing: ["error", "always"]
+  arrow-parens: ["error", "always"]
+  comma-dangle: ["error", "never"]
+  comma-spacing: ["error", { "before": false, "after": true }]
+  computed-property-spacing: ["error", "never"]
+  func-call-spacing: ["error", "never"]
+  indent: ["error", 2, { "SwitchCase": 1 }]
+  key-spacing: ["error", { "beforeColon": false }]
+  semi: ["error", "always"]
+  operator-assignment: ["error", "always"]

.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: luanrt
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/ISSUE_TEMPLATE/config.yml

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

.github/ISSUE_TEMPLATE/feature.yml

@@ -0,0 +1,33 @@
+name: Feature request
+description: Use this template to suggest new features
+labels: [enhancement]
+body:
+
+  - type: textarea
+    id: feature-description
+    attributes:
+      label: Describe your suggestion
+      placeholder: How would it work?
+    validations:
+      required: true
+
+  - type: textarea
+    id: other-details
+    attributes:
+      label: Other details
+      placeholder: |
+        Additional details and attachments.
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      options:
+        - label: I am running the latest version.
+          required: true
+        - label: I checked the documentation and found no answer.
+          required: true
+        - label: I have searched the existing issues and made sure this is not a duplicate.
+          required: true
+        - label: I have provided sufficient information.
+          required: true

.github/ISSUE_TEMPLATE/issue.yml

@@ -0,0 +1,77 @@
+name: Issue Report
+title: "<version> <title>"
+description: Use this template to report a problem
+labels: [bug]
+body:
+  - type: textarea
+    id: reproduce-steps
+    attributes:
+      label: Steps to reproduce
+      description: Please provide detailed steps for reproducing the issue.
+      placeholder: |
+        Example:
+          1. Step 1
+          2. Step 2
+          3. You get it..
+    validations:
+      required: true
+  
+  - type: textarea
+    id: failure-logs
+    attributes:
+      label: Failure Logs
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: Expected behavior
+      description: What did you expect to happen?
+    validations:
+      required: true
+
+  - type: textarea
+    id: current-behavior
+    attributes:
+      label: Current behavior
+      description: What is the current behavior?
+    validations:
+      required: true
+
+  - type: dropdown
+    id: version
+    attributes:
+      label: Version
+      description: What version of the library are you running?
+      options:
+        - Default
+        - Edge
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Anything else?
+      description: |
+        Links? References? Anything that will give us more context about the issue you are encountering!
+        
+        Tip: You can attach images or log files by clicking this area to highlight it and then dragging files in.
+    validations:
+      required: false
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      options:
+        - label: I am running the latest version.
+          required: false
+        - label: I checked the documentation and found no answer.
+          required: true
+        - label: I have searched the existing issues and made sure this is not a duplicate.
+          required: true
+        - label: I have provided sufficient information.
+          required: true

.github/ISSUE_TEMPLATE/question.yml

@@ -0,0 +1,33 @@
+name: Question
+description: Use this template to ask a question about the project
+labels: [question]
+body:
+
+  - type: textarea
+    id: question
+    attributes:
+      label: Question
+      placeholder: What do you want to know?
+    validations:
+      required: true
+
+  - type: textarea
+    id: other-details
+    attributes:
+      label: Other details
+      placeholder: |
+        Additional details and attachments.
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      options:
+        - label: I am running the latest version.
+          required: true
+        - label: I checked the documentation and found no answer.
+          required: true
+        - label: I have searched the existing issues and made sure this is not a duplicate.
+          required: true
+        - label: I have provided sufficient information.
+          required: true

.github/labeler_config.yml

@@ -0,0 +1,59 @@
+version: 1
+labels:
+  - label: "breaking-change"
+    title: "^refactor!:.*"
+    
+  - label: "enhancement"
+    title: "^feat:.*"
+    
+  - label: "bug"
+    title: "^fix:.*"
+ 
+  - label: "github"
+    files:
+      - ".github/.*"
+      
+  - label: "git"
+    files:
+      - ".gitignore"
+      - ".gitattributes"
+      
+  - label: "tests"
+    files:
+      - "test/.*"
+    
+  - label: "docs"
+    files:
+      - "docs/.*"
+      - "README.md"
+      
+  - label: "parser"
+    files:
+      - "src/parser/.*"
+      - "src/Innertube.ts"
+      
+  - label: "core"
+    files:
+      - "src/core/.*"
+      
+  - label: "protobuf"
+    files:
+      - "src/proto/.*"
+  
+  - label: "xsmall-diff"
+    size-below: 10
+    
+  - label: "small-diff"
+    size-above: 9
+    size-below: 100
+    
+  - label: "medium-diff"
+    size-above: 99
+    size-below: 500
+    
+  - label: "large-diff"
+    size-above: 499
+    size-below: 1000
+    
+  - label: "xlarge-diff"
+    size-above: 999

.github/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/release.yml

@@ -0,0 +1,20 @@
+changelog:
+  exclude:
+    labels:
+      - ignore-for-release
+    authors:
+      - octocat
+  categories:
+    - title: Breaking Changes
+      labels:
+        - Semver-Major
+        - breaking-change
+    - title: New Features
+      labels:
+        - Semver-Minor
+        - enhancement
+    - title: Bug Fixes
+        - bug
+    - title: Other Changes
+      labels:
+        - "*"

.github/workflows/labeler.yml

@@ -0,0 +1,16 @@
+name: Label PRs
+
+on:
+- pull_request_target
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: srvaroa/labeler@master
+      with:
+          config_path: .github/labeler_config.yml
+      env:
+        GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"

.github/workflows/lint.yml

@@ -0,0 +1,17 @@
+name: Lint
+
+on: [push, pull_request]
+
+jobs:
+  eslint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-node@v3
+
+      - name: npm install and lint
+        run: |
+          npm install
+          npm run lint

.github/workflows/node.js.yml

@@ -1,7 +1,4 @@
-# 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
-
-name: Build
+name: Tests
 
 on:
   push:
@@ -16,7 +13,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [ 14.x, 15.x, 16.x ]
+        node-version: [ 16.x, 18.x ]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:
@@ -26,4 +23,4 @@ jobs:
       with:
         node-version: ${{ matrix.node-version }}
     - run: npm install
-    - run: npm test
+    - run: npm run test

.github/workflows/stale.yml

@@ -15,5 +15,5 @@ jobs:
   recent activity. It will be closed if no further activity occurs. Thank you
   for your contributions.'
         stale-pr-message: 'This PR has been automatically marked as stale because it has not had recent activity. Remove the stale label or comment or this will be closed in 2 days'
-        days-before-stale: 6
-        days-before-close: 2
+        days-before-stale: 60
+        days-before-close: 4

.gitignore

@@ -0,0 +1,71 @@
+# YouTube player cache directory
+cache/
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+# pnpm
+.pnpm-debug.log*
+pnpm-lock.yaml
+
+# Downloaded assets
+*.mp4
+*.webm
+*.mkv
+
+# Temporary files for testing
+tmp/
+
+# Build output
+dist/
+bundle/*.js.*
+bundle/*.js
+
+# MacOS
+.DS_Store

.npmignore

@@ -0,0 +1,6 @@
+**
+
+src/
+!dist/**
+!README.md
+!bundle/**

CONTRIBUTING.md

@@ -0,0 +1,103 @@
+# Contributing to YouTube.js
+
+Thank you for taking the time to contribute! 
+The following is a set of guidelines for contributing to YouTube.js.
+___
+* [Issues](#issues)
+  * [Create a new issue](#issue-1)
+  * [Solve an issue](#issue-2)
+
+* [Make changes](#changes)
+  * [Commit your updates](#changes-1)
+  * [Create a PR](#changes-2)
+  * [Run tests](#test)
+  * [Lint your code](#lint)
+  * [Build for node](#build-1)
+  * [Bundle for browsers](#build-2)
+  * [Compile proto file](#build-3)
+  * [Build parser map](#build-4)
+  
+## Issues
+
+<a id="issue-1"></a>
+#### Create a new issue
+If you find a problem, search if an issue already exists. If a related issue doesn't exist, you can open a new issue using a relevant issue form.
+
+<a id="issue-2"></a>
+#### Solve an issue
+Scan through the existing issues to find one that interests you. You can narrow down the search using labels as filters. If you find an issue to work on, you are welcome to open a PR with a fix.
+
+<a id="changes"></a>
+## Make changes
+
+1. Fork the repository 
+2. Install or update to **Node.js v16**
+3. Create a working branch and start with your changes!
+
+<a id="changes-1"></a>
+#### Commit your updates
+
+Commit the changes once you're happy with them.
+
+<a id="changes-2"></a>
+#### Pull Request
+
+When you think the code is ready for review a pull request should be created on Github. Owners of the repository will watch out for new PR‘s and review them in regular intervals.
+
+- Fill the template.
+- Link the PR to an issue, if you are solving one.
+- Enable the checkbox to allow maintainer edits so the branch can be updated for a merge.
+- Changes may be requested before a PR can be merged.
+- As you update your PR and apply changes, mark each conversation as resolved.
+
+<a id="test"></a>
+#### Test
+
+```bash
+npm run test
+```
+
+<a id="lint"></a>
+#### Lint
+
+```bash
+npm run lint
+```
+
+Or
+
+```bash
+npm run lint:fix
+```
+
+<a id="build-1"></a>
+#### Build for Node
+
+```bash
+npm run build:node
+```
+
+<a id="build-2"></a>
+#### Build for browsers 
+
+```bash
+npm run build:browser
+```
+Or:
+```bash
+npm run build:browser:prod
+```
+
+<a id="build-3"></a>
+#### Compile proto file
+
+```bash
+// TODO
+```
+
+<a id="build-4"></a>
+#### Build parser map
+
+```bash
+npm run build:parser-map
+```

LICENSE

@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

browser.ts

@@ -0,0 +1,9 @@
+// Deno and browser runtimes
+
+import Innertube from './src/Innertube';
+
+export * from './src/utils';
+export { YTNodes } from './src/parser/map';
+export { default as Parser } from './src/parser';
+export { default as Innertube } from './src/Innertube';
+export default Innertube;

bundle/browser.d.ts

@@ -0,0 +1 @@
+export * from '../dist/browser';

docs/API/account.md

@@ -0,0 +1,112 @@
+# Account
+
+YouTube account manager.
+
+## API
+
+* Account 
+  * [.channel](#channel)
+  * [.getInfo()](#getinfo)
+  * [.getTimeWatched()](#gettimewatched)
+  * [.getSettings()](#getsettings)
+  * [.getAnalytics](#getanalytics)
+
+<a name="channel"></a>
+### channel
+
+Channel settings.
+
+**Returns:** `object`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<channel>#editName(new_name)`
+  - Edits the name of the channel.
+
+- `<channel>#editDescription(new_description)`
+  - Edits channel description.
+
+- `<channel>#getBasicAnalytics()`
+  - Alias for [`Account#getAnalytics()`](#getanalytics) — returns basic channel analytics.
+
+</p>
+</details>
+
+<a name="getinfo"></a>
+### getInfo()
+
+Retrieves account information.
+
+**Returns:** `Promise.<AccountInfo>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<accountinfo>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details>
+
+<a name="gettimewatched"></a>
+### getTimeWatched()
+
+Retrieves time watched statistics.
+
+**Returns:** `Promise.<TimeWatched>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<timewatched>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details>
+
+<a name="getsettings"></a>
+### getSettings()
+
+Retrieves YouTube settings.
+
+**Returns:** `Promise.<Settings>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<settings>#selectSidebarItem(name)`
+  - Selects an item from the sidebar menu. Use `settings#sidebar_items` to see available items.
+
+- `<settings>#getSettingOption(name)`
+  - Finds a setting by name and returns it. Use `settings#setting_options` to see available options.
+
+- `<settings>#setting_options`
+  - Returns settings available in the page.
+
+- `<settings>#sidebar_items`
+  - Returns options available in the sidebar menu.
+
+</p>
+</details>
+
+<a name="getanalytics"></a>
+### getAnalytics()
+
+Retrieves basic channel analytics.
+
+**Returns:** `Promise.<Analytics>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<analytics>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details>

docs/API/interaction-manager.md

@@ -0,0 +1,108 @@
+# InteractionManager
+
+Handles direct interactions.
+
+## API
+
+* InteractionManager 
+  * [.like(video_id)](#like) 
+  * [.dislike(video_id)](#dislike) 
+  * [.removeLike(video_id)](#removelike) 
+  * [.subscribe(video_id)](#subscribe) 
+  * [.unsubscribe(video_id)](#unsubscribe) 
+  * [.comment(video_id, text)](#comment) 
+  * [.translate(text, target_language, args?)](#translate) 
+  * [.setNotificationPreferences(channel_id, type)](#setnotificationpreferences) 
+
+<a name="like"></a>
+### like(video_id)
+
+Likes given video.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="dislike"></a>
+### dislike(video_id)
+
+Dislikes given video.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="removelike"></a>
+### removeLike(video_id)
+
+Remover like/dislike.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="subscribe"></a>
+### subscribe(channel_id)
+
+Subscribes to given channel.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| channel_id | `string` | Channel id |
+
+<a name="unsubscribe"></a>
+### unsubscribe(channel_id)
+
+Unsubscribes from given channel.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| channel_id | `string` | Channel id |
+
+<a name="comment"></a>
+### comment(video_id, text)
+
+Posts a comment on given video.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+| text | `string` | Comment content |
+
+<a name="translate"></a>
+### translate(text, target_language, args?)
+
+Translates given text using YouTube's comment translation feature.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| text | `string` | Text to be translated |
+| target_language | `string` | ISO language code |
+| args? | `object` | Additional arguments |
+
+<a name="setnotificationpreferences"></a>
+### setNotificationPreferences(channel_id, type)
+
+Changes notification preferences for a given channel.
+Only works with channels you are subscribed to.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| channel_id | `string` | Channel id |
+| type | `string` | `PERSONALIZED`, `ALL` or `NONE` |

docs/API/music.md

@@ -0,0 +1,271 @@
+# Music
+
+YouTube Music class.
+
+## API
+
+* Music 
+  * [.getInfo(video_id)](#getinfo)
+  * [.search(query, filters?)](#search)
+  * [.getHomeFeed()](#gethomefeed)
+  * [.getExplore()](#getexplore)
+  * [.getLibrary()](#getlibrary)
+  * [.getArtist(artist_id)](#getartist)
+  * [.getAlbum(album_id)](#getalbum)
+  * [.getPlaylist(playlist_id)](#getplaylist)
+  * [.getLyrics(video_id)](#getlyrics)
+  * [.getUpNext(video_id)](#getupnext)
+  * [.getRelated(video_id)](#getrelated)
+  * [.getRecap()](#getrecap)
+  * [.getSearchSuggestions(query)](#getsearchsuggestions)
+
+<a name="getinfo"></a>
+### getInfo(video_id)
+
+Retrieves track info.
+
+**Returns:** `Promise.<TrackInfo>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="search"></a>
+### search(query, filters?)
+
+Searches on YouTube Music.
+
+**Returns:** `Promise.<Search>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| query | `string` | Search query |
+| filters? | `object` | Search filters |
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<search>#getMore(shelf)`
+  - Equivalent to clicking on the shelf to load more items.
+
+- `<search>#getContinuation()`
+  - Retrieves continuation, only works for individual sections or filtered results.
+
+- `<search>#selectFilter(name)`
+  - Applies given filter to the search.
+
+- `<search>#has_continuation`
+  - Checks if continuation is available.
+
+- `<search>#filters`
+  - Returns available filters.
+
+- `<search>#songs`
+  - Returns songs shelf.
+
+- `<search>#videos`
+  - Returns videos shelf.
+
+- `<search>#albums`
+  - Returns albums shelf.
+
+- `<search>#artists`
+  - Returns artists shelf.
+
+- `<search>#playlists`
+  - Returns songs shelf.
+
+- `<search>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details> 
+
+<a name="gethomefeed"></a>
+### getHomeFeed()
+
+Retrieves home feed.
+
+**Returns:** `Promise.<HomeFeed>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<homefeed>#getContinuation()`
+  - Retrieves continuation, only works for individual sections or filtered results.
+
+- `<homefeed>#has_continuation`
+  - Checks if continuation is available.
+
+- `<homefeed>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details> 
+
+<a name="getexplore"></a>
+### getExplore()
+
+Retrieves “Explore” feed.
+
+**Returns:** `Promise.<Explore>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<explore>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details> 
+
+<a name="getlibrary"></a>
+### getLibrary()
+
+Retrieves library.
+
+**Returns:** `Promise.<Library>`
+
+<!-- TODO: document Library's methods and getters. -->
+
+<a name="getartist"></a>
+### getArtist(artist_id)
+
+Retrieves artist's info & content.
+
+**Returns:** `Promise.<Artist>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| artist_id | `string` | Artist id |
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<artist>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details> 
+
+<a name="getalbum"></a>
+### getAlbum(album_id)
+
+Retrieves given album.
+
+**Returns:** `Promise.<Album>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| album_id | `string` | Album id |
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<album>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details> 
+
+<a name="getplaylist"></a>
+### getPlaylist(playlist_id)
+
+Retrieves given playlist.
+
+**Returns:** `Promise.<Playlist>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| playlist_id | `string` | Playlist id |
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<playlist>#getRelated()`
+  - Retrieves related playlists.
+
+- `<playlist>#getSuggestions()`
+  - Retrieves playlist suggestions.
+
+- `<playlist>#getContinuation()`
+  - Retrieves continuation.
+
+- `<playlist>#has_continuation`
+  - Checks if continuation is available.
+
+- `<playlist>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details> 
+
+<a name="getlyrics"></a>
+### getLyrics(video_id)
+
+Retrieves song lyrics.
+
+**Returns:** `Promise.<{ text: string; footer: object; }>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="getupnext"></a>
+### getUpNext(video_id)
+
+Retrieves up next content.
+
+**Returns:** `Promise.<PlaylistPanel>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="getrelated"></a>
+### getRelated(video_id)
+
+Retrieves related content.
+
+**Returns:** `Promise.<Array.<MusicCarouselShelf | MusicDescriptionShelf>>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="getrecap"></a>
+### getRecap()
+
+Retrieves your YouTube Music recap.
+
+**Returns:** `Promise.<Recap>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<recap>#getPlaylist()`
+  - Retrieves recap playlist.
+
+- `<recap>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details> 
+
+<a name="getsearchsuggestions"></a>
+### getSearchSuggestions(query)
+
+Retrieves search suggestions.
+
+**Returns:** `Promise.<Array.<SearchSuggestion | HistorySuggestion>>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| query | `string` | Search query |

docs/API/playlist.md

@@ -0,0 +1,72 @@
+# PlaylistManager
+
+Playlist management class.
+
+## API
+
+* PlaylistManager
+  * [.create(title, video_ids)](#create) 
+  * [.delete(playlist_id)](#delete) 
+  * [.addVideos(playlist_id, video_ids)](#addvideos) 
+  * [.removeVideos(playlist_id, video_ids)](#removevideos) 
+  * [.moveVideo(playlist_id, moved_video_id, predecessor_video_id)](#movevideo) 
+
+<a name="create"></a>
+### create(title, video_ids)
+
+Creates a playlist.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| title | `string` | Playlist name |
+| video_ids | `string[]` | array of videos |
+
+<a name="delete"></a>
+### delete(playlist_id)
+
+Deletes given playlist.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| playlist_id | `string` | Playlist id |
+
+<a name="addvideos"></a>
+### addVideos(playlist_id, video_ids)
+
+Adds videos to given playlist.
+
+**Returns:** `Promise.<{ playlist_id: string; action_result: any[] }>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| playlist_id | `string` | Playlist id |
+| video_ids | `string` | array of videos |
+
+<a name="removevideos"></a>
+### removeVideos(playlist_id, video_ids)
+
+Removes videos from given playlist.
+
+**Returns:** `Promise.<{ playlist_id: string; action_result: any[] }>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| playlist_id | `string` | Playlist id |
+| video_ids | `string` | array of videos |
+
+<a name="movevideo"></a>
+### moveVideo(playlist_id, moved_video_id, predecessor_video_id)
+
+Moves a video to a new position within a given playlist.
+
+**Returns:** `Promise.<{ playlist_id: string; action_result: any[] }>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| playlist_id | `string` | Playlist id |
+| moved_video_id | `string` | the video to be moved |
+| predecessor_video_id | `string` | the video present in the target position |

docs/API/session.md

@@ -0,0 +1,83 @@
+# Session
+
+Represents an InnerTube session.
+
+## API
+
+* Session
+  * [.signIn(credentials?)](#signin) ⇒ `function`
+  * [.signOut()](#signout) ⇒ `function`
+  * [.key](#key) ⇒ `getter`
+  * [.api_version](#api_version) ⇒ `getter`
+  * [.client_version](#client_version) ⇒ `getter`
+  * [.client_name](#client_name) ⇒ `getter`
+  * [.context](#context) ⇒ `getter`
+  * [.player](#player) ⇒ `getter`
+  * [.lang](#lang) ⇒ `getter`
+
+<a name="signin"></a>
+### signIn(credentials?)
+
+Signs in with given credentials. 
+
+**Returns:** `Promise<void>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| credentials? | `Credentials` | OAuth credentials |
+
+<a name="signout"></a>
+### signOut()
+
+Signs out of the current account.
+
+**Returns:** `Promise<ActionsResponse>`
+
+<a name="key"></a>
+### key
+
+InnerTube API key.
+
+**Returns:** `string`
+
+<a name="api_version"></a>
+### key
+
+InnerTube API version.
+
+**Returns:** `string`
+
+<a name="client_version"></a>
+### client_version
+
+InnerTube client version.
+
+**Returns:** `string`
+
+<a name="client_name"></a>
+### client_name
+
+InnerTube client name.
+
+**Returns:** `string`
+
+<a name="context"></a>
+### context
+
+InnerTube context.
+
+**Returns:** `Context`
+
+<a name="player"></a>
+### player
+
+Player script object.
+
+**Returns:** `Player`
+
+<a name="lang"></a>
+### lang
+
+Client language.
+
+**Returns:** `string`

docs/API/studio.md

@@ -0,0 +1,33 @@
+# Studio
+
+YouTube Studio class (WIP).
+
+## API
+
+* Studio 
+  * [.setThumbnail(video_id, buffer)](#setthumbnail)
+  * [.upload(file, metadata)](#upload)
+
+<a name="setthumbnail"></a>
+### setThumbnail(video_id, buffer)
+
+Uploads a custom thumbnail and sets it for a video.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+| buffer | `Uint8Array` | Thumbnail buffer |
+
+<a name="upload"></a>
+### upload(file, metadata)
+
+Uploads a video to YouTube.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| file | `BodyInit` | Video file |
+| metadata | `VideoMetadata` | Video metadata |

examples/auth/README.md

@@ -0,0 +1,49 @@
+# Authentication via OAuth
+
+## Usage
+
+Before using any methods which require authentication, you have to authenticate the session:
+
+```js
+// 'auth-pending' is fired with the info needed to sign in via OAuth.
+yt.session.on('auth-pending', (data) => {
+    // data.verification_url contains the URL to visit to authenticate.
+    // data.user_code contains the code to enter on the website.
+});
+
+// 'auth' is fired once the authentication is complete
+yt.session.on('auth', ({ credentials }) => {
+  // do something with the credentials, eg; save them in a database.
+  console.log('Sign in successful');
+});
+
+// 'update-credentials' is fired when the access token expires, if you do not save the updated credentials any subsequent request will fail 
+yt.session.on('update-credentials', ({ credentials }) => {
+  // do something with the updated credentials
+});
+  
+await yt.session.signIn(/* credentials */);
+```
+
+### Cache Credentials
+
+If you don't wish to sign in every time you start the session, you can cache the credentials. Note that this SHOULD NOT be used in production, save your credentials in a database/file instead and pass them to `Session#signIn(creds?)` when signing in.
+
+```js
+// If you use this, the next call to signIn won't fire 'auth-pending' instead just 'auth'
+await yt.session.oauth.cacheCredentials();
+```
+
+**Note:** When using cached credentials, you are still required to make a call to `Session#signIn()`.
+
+### Sign Out
+
+The sign out method may be used to sign out of the current session. This should also remove the cached credentials.
+
+```js
+await yt.session.signOut();
+
+// if you don't want to sign out of the current session
+// and only want to delete the cached credentials, use:
+await yt.session.oauth.removeCache();
+```

examples/auth/index.js

@@ -0,0 +1,37 @@
+const { Innertube, UniversalCache } = require('youtubei.js');
+
+(async () => {
+  const yt = await Innertube.create({
+    // required if you wish to use OAuth#cacheCredentials
+    cache: new UniversalCache()
+  });
+
+  // 'auth-pending' is fired with the info needed to sign in via OAuth.
+  yt.session.on('auth-pending', (data) => {
+    console.log(`Go to ${data.verification_url} in your browser and enter code ${data.user_code} to authenticate.`);
+  });
+
+  // 'auth' is fired once the authentication is complete
+  yt.session.on('auth', ({ credentials }) => {
+    console.log('Sign in successful:', credentials);
+  });
+
+  // 'update-credentials' is fired when the access token expires, if you do not save the updated credentials any subsequent request will fail 
+  yt.session.on('update-credentials', ({ credentials }) => {
+    console.log('Credentials updated:', credentials);
+  });
+
+  // Attempt to sign in
+  await yt.session.signIn();
+
+  // ... do something after sign in
+
+  // You may cache the session for later use
+  // If you use this, the next call to signIn won't fire 'auth-pending' instead just 'auth'.
+  await yt.session.oauth.cacheCredentials();
+
+
+  // Sign out of the session
+  // this will also remove the cached credentials
+  await yt.session.signOut();
+})();

examples/browser/README.md

@@ -0,0 +1,26 @@
+# Browser Usage Example
+
+YouTube.js works in the browser!
+
+## How to use
+
+To use YouTube.js in the browser you must proxy requests through your own server. You can see our simple reference implementation in Deno in `examples/browser/proxy/deno.ts`.
+
+Once the proxy is set up you need to tell Innertube about it when instantiating it.
+
+```ts
+import { Innertube } from "youtubei.js/build/browser";
+
+const yt = await Innertube.create({
+    browser_proxy: {
+        host: "localhost",
+        schema: 'http',
+    }
+})
+```
+
+after that you can use the library as normal.
+
+## Example
+
+We've got a full example in `examples/browser/web` using vite.

examples/browser/proxy/deno.ts

@@ -0,0 +1,82 @@
+import { serve } from 'https://deno.land/std@0.148.0/http/server.ts';
+
+const port = 8080;
+
+function copyHeader(headerName: string, to: Headers, from: Headers) {
+  const hdrVal = from.get(headerName);
+  if (hdrVal) {
+    to.set(headerName, hdrVal);
+  }
+}
+
+const handler = async (request: Request): Promise<Response> => {
+  // if options send do CORS preflight
+  if (request.method === 'OPTIONS') {
+    const response = new Response('', {
+      status: 200,
+      headers: new Headers({
+        'Access-Control-Allow-Origin': request.headers.get('origin') || '*',
+        'Access-Control-Allow-Methods': '*',
+        'Access-Control-Allow-Headers':
+          'Origin, X-Requested-With, Content-Type, Accept, Authorization, x-goog-visitor-id, x-origin, x-youtube-client-version, Accept-Language, Range',
+        'Access-Control-Max-Age': '86400',
+        'Access-Control-Allow-Credentials': 'true',
+      }),
+    });
+    return response;
+  }
+
+  const url = new URL(request.url, `http://localhost/`);
+  if (!url.searchParams.has('__host')) {
+    return new Response(
+      'Request is formatted incorrectly. Please include __host in the query string.',
+      { status: 400 },
+    );
+  }
+
+  // Set the URL host to the __host parameter
+  url.host = url.searchParams.get('__host')!;
+  url.protocol = 'https';
+  url.port = '443';
+  url.searchParams.delete('__host');
+
+  // Copy headers from the request to the new request
+  const request_headers = new Headers(
+    JSON.parse(url.searchParams.get('__headers') || '{}'),
+  );
+  copyHeader('range', request_headers, request.headers);
+  copyHeader('user-agent', request_headers, request.headers);
+  url.searchParams.delete('__headers');
+
+  // Make the request to YouTube
+  const fetchRes = await fetch(url, {
+    method: request.method,
+    headers: request_headers,
+    body: request.body,
+  });
+
+  // Construct the return headers
+  const headers = new Headers();
+
+  // copy content headers
+  copyHeader('content-length', headers, fetchRes.headers);
+  copyHeader('content-type', headers, fetchRes.headers);
+  copyHeader('content-disposition', headers, fetchRes.headers);
+
+  // add cors headers
+  headers.set(
+    'Access-Control-Allow-Origin',
+    request.headers.get('origin') || '*',
+  );
+  headers.set('Access-Control-Allow-Headers', '*');
+  headers.set('Access-Control-Allow-Methods', '*');
+  headers.set('Access-Control-Allow-Credentials', 'true');
+
+  // Return the proxied response
+  return new Response(fetchRes.body, {
+    status: fetchRes.status,
+    headers: headers,
+  });
+};
+
+await serve(handler, { port });

examples/browser/web/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

examples/browser/web/favicon.svg

@@ -0,0 +1,15 @@
+<svg width="410" height="404" viewBox="0 0 410 404" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M399.641 59.5246L215.643 388.545C211.844 395.338 202.084 395.378 198.228 388.618L10.5817 59.5563C6.38087 52.1896 12.6802 43.2665 21.0281 44.7586L205.223 77.6824C206.398 77.8924 207.601 77.8904 208.776 77.6763L389.119 44.8058C397.439 43.2894 403.768 52.1434 399.641 59.5246Z" fill="url(#paint0_linear)"/>
+<path d="M292.965 1.5744L156.801 28.2552C154.563 28.6937 152.906 30.5903 152.771 32.8664L144.395 174.33C144.198 177.662 147.258 180.248 150.51 179.498L188.42 170.749C191.967 169.931 195.172 173.055 194.443 176.622L183.18 231.775C182.422 235.487 185.907 238.661 189.532 237.56L212.947 230.446C216.577 229.344 220.065 232.527 219.297 236.242L201.398 322.875C200.278 328.294 207.486 331.249 210.492 326.603L212.5 323.5L323.454 102.072C325.312 98.3645 322.108 94.137 318.036 94.9228L279.014 102.454C275.347 103.161 272.227 99.746 273.262 96.1583L298.731 7.86689C299.767 4.27314 296.636 0.855181 292.965 1.5744Z" fill="url(#paint1_linear)"/>
+<defs>
+<linearGradient id="paint0_linear" x1="6.00017" y1="32.9999" x2="235" y2="344" gradientUnits="userSpaceOnUse">
+<stop stop-color="#41D1FF"/>
+<stop offset="1" stop-color="#BD34FE"/>
+</linearGradient>
+<linearGradient id="paint1_linear" x1="194.651" y1="8.81818" x2="236.076" y2="292.989" gradientUnits="userSpaceOnUse">
+<stop stop-color="#FFEA83"/>
+<stop offset="0.0833333" stop-color="#FFDD35"/>
+<stop offset="1" stop-color="#FFA800"/>
+</linearGradient>
+</defs>
+</svg>

examples/browser/web/index.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + TS</title>
+  </head>
+  <body>
+    <form>
+      <input type="text" name="id" placeholder="Video ID" />
+      <input type="submit" value="Play" />
+    </form>
+    <span id="video_name">
+      Library is loading...
+    </span>
+    <video></video>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

examples/browser/web/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "web",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "typescript": "^4.6.4",
+    "vite": "^3.0.0"
+  },
+  "dependencies": {
+    "dashjs": "^4.4.0"
+  }
+}

examples/browser/web/public/service-worker.js

@@ -0,0 +1,3 @@
+/* eslint-disable */
+var u=new Set(["www.youtube.com","music.youtube.com","suggestqueries.google.com","youtubei.googleapis.com","youtubei.googleapis.com","green-youtubei.sandbox.googleapis.com","release-youtubei.sandbox.googleapis.com","test-youtubei.sandbox.googleapis.com","cami-youtubei.sandbox.googleapis.com","uytfe.sandbox.google.com"]);self.addEventListener("fetch",o=>{try{let s=new URL(o.request.url).hostname;if(!u.has(s))return}catch(s){return}let e=new URL(o.request.url);e.searchParams.set("__host",e.host),e.host=e.searchParams.get("__proxy");let t=new Request(e,o.request);o.respondWith(fetch(t))});
+//# sourceMappingURL=service-worker.js.map

examples/browser/web/public/service-worker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../browser/client/service-worker.ts"],
+  "sourcesContent": ["// We need to proxy requests to youtube to our own server to avoid CORS issues\n\n/// <reference lib=\"WebWorker\" />\n\n// export empty type because of tsc --isolatedModules flag\nexport type {};\ndeclare const self: ServiceWorkerGlobalScope;\n\nconst hosts = new Set([\n    \"www.youtube.com\",\n    \"music.youtube.com\",\n    \"suggestqueries.google.com\",\n    \"youtubei.googleapis.com\",\n    \"youtubei.googleapis.com\",\n    \"green-youtubei.sandbox.googleapis.com\",\n    \"release-youtubei.sandbox.googleapis.com\",\n    \"test-youtubei.sandbox.googleapis.com\",\n    \"cami-youtubei.sandbox.googleapis.com\",\n    \"uytfe.sandbox.google.com\"\n]);\n\nself.addEventListener('fetch', event => {\n    try {\n        const host = new URL(event.request.url).hostname;\n        if (!hosts.has(host))\n            return;\n    } catch {\n        return;\n    }\n    const url =  new URL(event.request.url);\n    url.searchParams.set('__host', url.host);\n    url.host = url.searchParams.get('__proxy')!;\n\n    // we should proxy this to our own server\n    const request = new Request(url, event.request);\n\n    event.respondWith(fetch(request));\n});\n"],
+  "mappings": ";AAQA,GAAM,GAAQ,GAAI,KAAI,CAClB,kBACA,oBACA,4BACA,0BACA,0BACA,wCACA,0CACA,uCACA,uCACA,0BACJ,CAAC,EAED,KAAK,iBAAiB,QAAS,GAAS,CACpC,GAAI,CACA,GAAM,GAAO,GAAI,KAAI,EAAM,QAAQ,GAAG,EAAE,SACxC,GAAI,CAAC,EAAM,IAAI,CAAI,EACf,MACR,OAAQ,EAAN,CACE,MACJ,CACA,GAAM,GAAO,GAAI,KAAI,EAAM,QAAQ,GAAG,EACtC,EAAI,aAAa,IAAI,SAAU,EAAI,IAAI,EACvC,EAAI,KAAO,EAAI,aAAa,IAAI,SAAS,EAGzC,GAAM,GAAU,GAAI,SAAQ,EAAK,EAAM,OAAO,EAE9C,EAAM,YAAY,MAAM,CAAO,CAAC,CACpC,CAAC",
+  "names": []
+}

examples/browser/web/public/vite.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

examples/browser/web/src/main.ts

@@ -0,0 +1,99 @@
+import './style.css';
+import { Innertube, UniversalCache } from '../../../../bundle/browser';
+import dashjs from 'dashjs';
+
+async function main() {
+  const yt = await Innertube.create({
+    fetch: async (input: RequestInfo | URL, init?: RequestInit) => {
+      // url
+      const url = typeof input === 'string'
+        ? new URL(input)
+        : input instanceof URL
+        ? input
+        : new URL(input.url);
+
+      // transform the url for use with our proxy
+      url.searchParams.set('__host', url.host);
+      url.host = 'localhost:8080';
+      url.protocol = 'http';
+
+      const headers = init?.headers
+        ? new Headers(init.headers)
+        : input instanceof Request
+        ? input.headers
+        : new Headers();
+
+      // now serialize the headers
+      url.searchParams.set('__headers', JSON.stringify([...headers]));
+
+      // copy over the request
+      const request = new Request(
+        url,
+        input instanceof Request ? input : undefined,
+      );
+
+      headers.delete('user-agent');
+
+      // fetch the url
+      return fetch(request, init ? {
+        ...init,
+        headers
+      } : {
+        headers
+      });
+    },
+    cache: new UniversalCache(),
+  });
+
+  const span = document.getElementById('video_name') as HTMLSpanElement;
+  const form = document.querySelector('form') as HTMLFormElement;
+
+  span.textContent = 'Library ready';
+
+  let player: dashjs.MediaPlayerClass | undefined;
+
+  form.addEventListener('submit', async (e) => {
+    e.preventDefault();
+
+    span.textContent = 'Loading...';
+
+    const video_id = document.querySelector<HTMLInputElement>(
+      'input[type=text]',
+    )?.value;
+    if (!video_id) {
+      span.textContent = 'No video id';
+      return;
+    }
+    try {
+      const video = await yt.getInfo(video_id);
+
+      console.log(video);
+      span.textContent = video.basic_info.title || null;
+
+      const dash = video.toDash((url) => {
+        url.searchParams.set('__host', url.host);
+        url.host = 'localhost:8080';
+        url.protocol = 'http';
+        return url;
+      });
+
+      const uri = 'data:application/dash+xml;charset=utf-8;base64,' +
+        btoa(dash);
+
+      // create and append video element
+      const video_element = document.querySelector('video') as HTMLVideoElement;
+      video_element.setAttribute('controls', 'true');
+      // use dash.js to parse the manifest
+      if (player) {
+        player.destroy();
+      }
+      player = dashjs.MediaPlayer().create();
+      player.initialize(video_element, uri, true);
+    } catch (error) {
+      span.textContent = 'An error occurred (see console)';
+      console.error(error);
+    }
+  });
+}
+
+main();

examples/browser/web/src/style.css

@@ -0,0 +1,12 @@
+body {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+}
+
+video {
+  max-width: calc(100vw - 1rem);
+  width: fit-content;
+  max-height: calc(90vh - 12rem);
+}

examples/browser/web/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

examples/browser/web/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "moduleResolution": "Node",
+    "strict": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "noEmit": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

examples/channel/basic-info.ts

@@ -0,0 +1,42 @@
+import { Innertube, UniversalCache } from 'youtubei.js';
+
+(async () => {
+  const yt = await Innertube.create({ cache: new UniversalCache() });
+
+  const channel = await yt.getChannel('UCX6OQ3DkcsbYNE6H8uQQuVA');
+
+  console.info('Viewing channel:', channel.header.author.name);
+  console.info('Family Safe:', channel.metadata.is_family_safe);
+
+  const about = await channel.getAbout();
+
+  console.info('Country:', about.country.toString());
+
+  console.info('\nLists the following videos:');
+  const videos = await channel.getVideos();
+
+  for (const video of videos.videos) {
+    console.info('Video:', video.title.toString());
+  }
+
+  console.info('\nLists the following playlists:');
+  const playlists = await channel.getPlaylists();
+
+  for (const playlist of playlists.playlists) {
+    console.info('Playlist:', playlist.title.toString());
+  }
+
+  console.info('\nLists the following channels:');
+  const channels = await channel.getChannels();
+ 
+  for (const channel of channels.channels) {
+    console.info('Channel:', channel.author.name);
+  }
+
+  console.info('\nLists the following community posts:');
+  const posts = await channel.getCommunity();
+ 
+  for (const post of posts.posts) {
+    console.info('Post:', post.content.toString().substring(0, 20) + '...');
+  }
+})();

examples/comments/Comment.md

@@ -0,0 +1,34 @@
+## Comment
+Contains information about a single comment. A [`Comment`](../../lib/parser/contents/classes/Comment.js) can be a top-level comment or a reply to a top-level comment.
+
+## API
+
+* Comment
+  * [.like](#like) ⇒ `function`
+  * [.dislike](#dislike) ⇒ `function`
+  * [.reply](#comment) ⇒ `function`
+  * [.translate](#translate) ⇒ `function`
+
+<a name="like"></a>
+### like()
+Likes the comment.
+
+**Returns:** `Promise.<{ success: boolean, status_code: number, data: object }>`
+
+<a name="dislike"></a>
+### dislike()
+Dislikes the comment.
+
+**Returns:** `Promise.<{ success: boolean, status_code: number, data: object }>`
+
+<a name="reply"></a>
+### reply(text)
+Creates a reply to the comment. **Note:** To create a top-level comment, use the [`Comments#comment(text)`](./README.md#comment)  method.
+
+**Returns:** `Promise.<{ success: boolean, status_code: number, data: object }>`
+
+<a name="translate"></a>
+### translate(target_language)
+Translates the comment to the given language.
+
+**Returns:** `Promise.<{ success: boolean, status_code: number, data: object, content: string }>`

examples/comments/CommentThread.md

@@ -0,0 +1,35 @@
+# CommentThread
+
+A `CommentThread` represents a top-level comment and its replies.
+
+## API
+
+* CommentThread
+  * [.comment](#comment) ⇒ `Comment`
+  * [.replies](#replies) ⇒ `Comment[]`
+  * [.getReplies](#getreplies) ⇒ `function`
+  * [.getContinuation](#getcontinuation) ⇒ `function`
+
+<a name="comment"></a>
+### comment
+The top-level comment. **Note:** More about `Comment` [here](./Comment.md).
+
+**Type:** [`Comment`](../../lib/parser/contents/classes/Comment.js)
+
+<a name="replies"></a>
+### replies
+An array of replies to the top-level comment. (not populated until [`getReplies()`](#getreplies) is called).
+
+**Type:** [`Comment[]`](../../lib/parser/contents/classes/Comment.js)
+
+<a name="getreplies"></a>
+### getReplies()
+Retrieves replies to the top-level comment and attaches a [`replies`](#replies) array to the original `CommentThread` object and returns it.
+
+**Returns:** [`Promise.<CommentThread>`](../../lib/parser/contents/classes/CommentThread.js)
+
+<a name="getcontinuation"></a>
+### getContinuation()
+Retrieves next batch of replies and adds them to the [`replies`](#replies) array. **Note:** [`getReplies()`](#getreplies) must be called before using this.
+
+**Returns:** [`Promise.<CommentThread>`](../../lib/parser/contents/classes/CommentThread.js)

examples/comments/README.md

@@ -0,0 +1,47 @@
+## Comments
+YouTube.js has full support for comments, including comment actions such as liking, disliking, replying etc.
+
+## Usage
+Get a [`Comments`](../../lib/parser/youtube/Comments.js) instance:
+
+```js
+const comments = await yt.getComments(VIDEO_ID);
+```
+
+## API
+* Comments
+  * [.contents](#commentthread) ⇒ `CommentThread[]`
+  * [.createComment](#createComment) ⇒ `function`
+  * [.getContinuation](#getc) ⇒ `function`
+  * [.page](#page) ⇒ `getter`
+
+<a name="commentthread"></a>
+### contents
+A list of comment threads. **Note:** More about comment threads [**here**](./CommentThread.md).
+
+**Type:** [`CommentThread[]`](../../lib/parser/contents/classes/CommentThread.js)
+
+<a name="createComment"></a>
+### createComment(text)
+Creates a top-level comment.
+
+| Param | Type | Description |
+| --- | --- | --- |
+| text | `string` | Comment content |
+
+**Returns:** `Promise<ActionsResponse>`
+
+<a name="getc"></a>
+### getContinuation()
+Retrieves next batch of comment threads.
+
+**Returns:** [`Promise.<Comments>`](../../lib/parser/youtube/Comments.ts)
+
+<a name="page"></a>
+### page
+Returns original InnerTube response (sanitized).
+
+**Returns:** `ParsedResponse`
+
+## Example
+See [`index.ts`]('./index.ts').

examples/comments/index.ts

@@ -0,0 +1,39 @@
+import { Innertube, UniversalCache } from 'youtubei.js';
+
+(async () => {
+  const yt = await Innertube.create({ cache: new UniversalCache() });
+
+  const comments = await yt.getComments('a-rqu-hjobc');
+ 
+  console.info(`This video has ${comments.header?.comments_count.toString() || 'N/A'} comments.\n`);
+
+  for (const thread of comments.contents) {
+    const comment = thread.comment;
+    
+    if (comment) {
+      console.info(
+        `${comment.author.name} • ${comment.published}\n`,
+        `${comment.content.toString()}`, '\n',
+        `Likes: ${comment.vote_count.short_text}`, '\n'
+      );
+     
+      if (comment.reply_count > 0) {
+        console.info('Replies:', '\n');
+
+        const comment_thread = await thread.getReplies();
+       
+        if (comment_thread.replies) {
+          for (const reply of comment_thread.replies) {
+            console.info(
+              `> ${reply.author.name} • ${reply.published}\n`,
+              `${reply.content.toString()}`, '\n',
+              `Likes: ${reply.vote_count.short_text}`, '\n'
+            );
+          }
+        }
+      }
+    }
+    
+    console.log('\n');
+  }
+})();

examples/deno/README.md

@@ -0,0 +1,7 @@
+# Deno example
+
+Run this example with:
+
+```
+deno run --allow-net --allow-write index.ts
+```

examples/deno/index.ts

@@ -0,0 +1,16 @@
+import { Innertube } from '../../bundle/browser.js';
+
+const yt = await Innertube.create();
+
+const video = await yt.getInfo('dQw4w9WgXcQ');
+
+console.log('Video title is', video.basic_info.title);
+
+const file = await Deno.open('test.mp4', {
+  write: true,
+  create: true,
+});
+
+const stream = await video.download();
+
+stream.pipeTo(file.writable);

examples/download/index.ts

@@ -0,0 +1,45 @@
+import { Innertube, UniversalCache } from 'youtubei.js';
+import { readFileSync, existsSync, mkdirSync, createWriteStream } from 'fs';
+import { streamToIterable } from 'youtubei.js/dist/src/utils/Utils';
+
+(async () => {
+  const yt = await Innertube.create({ cache: new UniversalCache() });
+  
+  const search = await yt.music.search('No Copyright Background Music', { type: 'album' });
+  
+  if (!search.results)
+    throw new Error('Filter "type" must be used');
+    
+  const album = await yt.music.getAlbum(search.results[0].id as string);
+  
+  if (!album.contents)
+    throw new Error('Album appears to be empty');
+    
+  console.info(`Album "${album.header.title.toString()}" by ${album.header.author?.name}`, '\n');
+  
+  for (const song of album.contents) {
+    const stream = await yt.download(song.id as string, {
+      type: 'audio', // audio, video or audio+video
+      quality: 'best', // best, bestefficiency, 144p, 240p, 480p, 720p and so on.
+      format: 'mp4' // media container format 
+    });
+    
+    console.info(`Downloading ${song.title} (${song.id})`);
+    
+    const dir = `./${album.header.title.toString()}`;
+    
+    if (!existsSync(dir)) {
+      mkdirSync(dir);
+    }
+    
+    const file = createWriteStream(`${dir}/${song.title?.replace(/\//g, '')}.m4a`);
+    
+    for await (const chunk of streamToIterable(stream)) {
+      file.write(chunk);
+    }
+    
+    console.info(`${song.id} - Done!`, '\n');
+  }
+  
+  console.info(`Downloaded ${album.header.song_count}!`);
+})();

examples/index.js

@@ -1,92 +0,0 @@
-'use strict';
-
-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);
-
-  const search = await youtube.search('Looking for life on Mars - documentary');
-  console.info('Search results:', search);
-
-  const video = await youtube.getDetails(search.videos[0].id).catch((error) => error);
-  console.info('Video details:', video);
-
-  if (youtube.logged_in) {
-    const myNotifications = await youtube.getNotifications();
-    console.info('My notifications:', myNotifications);
-
-    const like = await video.like();
-    if (like.success) {
-      console.info('Video marked as liked!');
-    }
-
-    const dislike = await video.dislike();
-    if (dislike.success) {
-      console.info('Video marked as disliked!');
-    }
-
-    const removeDislikeOrLike = await video.removeLike();
-    if (removeDislikeOrLike.success) {
-      console.info('Removed the dislike/like!')
-    }
-
-    const myComment = await video.comment('Haha, nice!');
-    if (myComment.success) {
-      console.info('Comment successfully posted!')
-    }
-
-    const subscribe = await video.subscribe();
-    if (subscribe.success) {
-      console.info('Just subscribed to', video.metadata.channel_name + '!');
-    }
-
-    const unsubscribe = await video.unsubscribe();
-    if (unsubscribe.success) {
-      console.info('Just unsubscribed from', video.metadata.channel_name + ' :(');
-    }
-  }
-
-  // Downloading videos:
-  const stream = youtube.download(search.videos[0].id, {
-    format: 'mp4', // Optional, ignored when type is set to audio and defaults to mp4, and I recommend to leave it as it is
-    quality: '360p', // if a video doesn't have a specific quality it'll fall back to 360p, this is ignored when type is set to audio
-    type: 'videoandaudio' // can be “video”, “audio” and “videoandaudio”
-  });
-
-  stream.pipe(fs.createWriteStream(`./${search.videos[0].id}.mp4`));
-
-  stream.on('start', () => {
-    console.info('[DOWNLOADER]', 'Starting download now!');
-  });
-
-  stream.on('info', (info) => {
-    console.info('[DOWNLOADER]', `Downloading ${info.video_details.title} by ${info.video_details.metadata.channel_name}`);
-  });
-
-  stream.on('end', () => {
-    console.info('[DOWNLOADER]', 'Done!');
-  });
-
-  stream.on('error', (err) => console.error('[ERROR]', err));
-}
-
-start();

examples/livechat/README.md

@@ -0,0 +1,72 @@
+## Live Chat
+
+The library's Live Chat parser and poller were heavily based on YouTube's original compiled code, this makes it behave in a similar if not identical way to YouTube's Live Chat. Here you can do all sorts of funny things, ex; track messages, donations, polls, and much more.
+
+## Usage 
+
+Before fetching a Live Chat, you have to retrieve the target livestream's info:
+
+```js
+const info = await yt.getInfo('video_id');
+```
+
+Then you may request a Live Chat instance:
+```js
+const livechat = await info.getLiveChat();
+```
+
+## API
+
+* LiveChat
+  * [.ev](#ev) ⇒ `EventEmitter`
+  * [.start](#start) ⇒ `function`
+  * [.stop](#stop) ⇒ `function`
+  * [.sendMessage](#sendmessage) ⇒ `function`
+
+<a name="ev"></a>
+### ev
+Live Chat's EventEmitter.
+
+**Events:**
+
+- `start`
+ 
+  Arguments:
+  | Type | Description |
+  | --- | --- |                                       
+  | `LiveChatContinuation` | Initial chat data, actions, info, etc. |
+
+- `chat-update`
+ 
+  Arguments:
+  | Type | Description |
+  | --- | --- |
+  | `ChatAction` | Chat Action |
+
+- `metadata-update`
+ 
+  Arguments:
+  | Type | Description |
+  | --- | --- |
+  | `LiveMetadata` | LiveStream Metadata |
+
+<a name="start"></a>
+### start()
+Starts the Live Chat.
+
+<a name="stop"></a>
+### stop()
+Stops the Live Chat.
+
+<a name="sendmessage"></a>
+### sendMessage(text)
+Sends a message.
+
+| Param | Type | Description |
+| --- | --- | --- |
+| text | `string` | Message content |
+
+**Returns:** `Promise<ObservedArray<AddChatItemAction>>`
+
+## Example
+See [`index.ts`]('./index.ts').

examples/livechat/index.ts

@@ -0,0 +1,82 @@
+import { Innertube, UniversalCache } from 'youtubei.js';
+import { LiveChatContinuation } from 'youtubei.js/dist/src/parser';
+
+import LiveChat, { ChatAction, LiveMetadata } from 'youtubei.js/dist/src/parser/youtube/LiveChat';
+
+import Video from 'youtubei.js/dist/src/parser/classes/Video';
+import AddChatItemAction from 'youtubei.js/dist/src/parser/classes/livechat/AddChatItemAction';
+import MarkChatItemAsDeletedAction from 'youtubei.js/dist/src/parser/classes/livechat/MarkChatItemAsDeletedAction';
+
+import LiveChatTextMessage from 'youtubei.js/dist/src/parser/classes/livechat/items/LiveChatTextMessage';
+import LiveChatPaidMessage from 'youtubei.js/dist/src/parser/classes/livechat/items/LiveChatPaidMessage';
+
+(async () => {
+  const yt = await Innertube.create({ cache: new UniversalCache() });
+  
+  const search = await yt.search('Lofi girl live');
+  const info = await yt.getInfo(search.videos[0].as(Video).id);
+
+  const livechat = await info.getLiveChat();
+  
+  livechat.on('start', (initial_data: LiveChatContinuation) => {
+    /**
+     * Initial info is what you see when you first open a Live Chat — this is; inital actions (pinned messages, top donations..), account's info and so on.
+     */
+     
+    console.info(`Hey ${initial_data.viewer_name || 'N/A'}, welcome to Live Chat!`);
+  });
+  
+  livechat.on('chat-update', (action: ChatAction) => {
+    /**
+     * An action represents what is being added to
+     * the live chat. All actions have a `type` property,
+     * including their item (if the action has an item).
+     *
+     * Below are a few examples of how this can be used.
+     */
+
+    if (action.is(AddChatItemAction)) {
+      const item = action.as(AddChatItemAction).item;
+   
+      if (!item)
+        return console.info('Action did not have an item.', action);
+      
+      const hours = new Date(item.hasKey('timestamp') ? item.timestamp : Date.now()).toLocaleTimeString('en-US', {
+        hour: '2-digit',
+        minute: '2-digit'
+      });
+      
+      switch (item.type) {
+        case 'LiveChatTextMessage':
+          console.info(
+            `${hours} - ${item.as(LiveChatTextMessage).author?.name.toString()}:\n` +
+            `${item.as(LiveChatTextMessage).message.toString()}\n`
+          );
+          break;
+        case 'LiveChatPaidMessage':
+          console.info(
+            `${hours} - ${item.as(LiveChatPaidMessage).author.name.toString()}:\n` +
+            `${item.as(LiveChatPaidMessage).purchase_amount}\n`
+          );
+          break;
+        default:
+          console.debug(action);
+          break;
+      }
+    }
+      
+    if (action.is(MarkChatItemAsDeletedAction)) {
+      console.warn(`Message ${action.target_item_id} just got deleted and should be replaced with ${action.deleted_state_message.toString()}!`, '\n');
+    }
+  });
+
+  livechat.on('metadata-update', (metadata: LiveMetadata) => {
+    console.info(`
+      VIEWS: ${metadata.views?.view_count.toString()}
+      LIKES: ${metadata.likes?.default_text}
+      DATE: ${metadata.date?.date_text}
+    `);
+  });
+
+  livechat.start();
+})();

examples/parser/index.ts

@@ -0,0 +1,37 @@
+import { Parser } from 'youtubei.js';
+
+import SectionList from 'youtubei.js/dist/src/parser/classes/SectionList';
+import SingleColumnBrowseResults from 'youtubei.js/dist/src/parser/classes/SingleColumnBrowseResults';
+
+import MusicVisualHeader from 'youtubei.js/dist/src/parser/classes/MusicVisualHeader';
+import MusicImmersiveHeader from 'youtubei.js/dist/src/parser/classes/MusicImmersiveHeader';
+import MusicCarouselShelf from 'youtubei.js/dist/src/parser/classes/MusicCarouselShelf';
+import MusicDescriptionShelf from 'youtubei.js/dist/src/parser/classes/MusicDescriptionShelf';
+import MusicShelf from 'youtubei.js/dist/src/parser/classes/MusicShelf';
+
+import { readFileSync } from 'fs';
+
+// Artist page response from YouTube Music
+const data = readFileSync('./artist.json').toString();
+
+const page = Parser.parseResponse(JSON.parse(data));
+
+const header = page.header.item().as(MusicImmersiveHeader, MusicVisualHeader);
+
+console.info('Header:', header);
+
+// The parser encapsulates all arrays in a proxy object.
+// A proxy intercepts access to the actual data, allowing
+// the parser to add type safety and many utility methods
+// that make working with InnerTube much easier.
+const tab = page.contents.item().as(SingleColumnBrowseResults).tabs.get({ selected: false });
+
+if (!tab)
+  throw new Error('Target tab not found');
+
+if (!tab.content)
+  throw new Error('Target tab appears to be empty');
+  
+const sections = tab.content?.as(SectionList).contents.array().as(MusicCarouselShelf, MusicDescriptionShelf, MusicShelf);
+
+console.info('Sections:', sections);

examples/upload/index.ts

@@ -0,0 +1,35 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { Innertube, UniversalCache } from 'youtubei.js';
+
+const creds_path = './my_yt_creds.json';
+const creds = existsSync(creds_path) ? JSON.parse(readFileSync(creds_path).toString()) : undefined;
+
+(async () => {
+  const yt = await Innertube.create({ cache: new UniversalCache() });
+  
+  yt.session.on('auth-pending', (data: any) => {
+    console.info(`Hello!\nOn your phone or computer, go to ${data.verification_url} and enter the code ${data.user_code}`);
+  });
+
+  yt.session.on('auth', (data: any) => {
+    writeFileSync(creds_path, JSON.stringify(data.credentials));
+    console.info('Successfully signed in!');
+  });
+
+  yt.session.on('update-credentials', (data: any) => {
+    writeFileSync(creds_path, JSON.stringify(data.credentials));
+    console.info('Credentials updated!', data);
+  });
+
+  await yt.session.signIn(creds);
+  
+  const file = readFileSync('./my_awesome_video.mp4');
+  
+  const upload = await yt.studio.upload(file.buffer, {
+    title: 'Wow!',
+    description: new Date().toString(),
+    privacy: 'UNLISTED'
+  });
+
+  console.info('Done!');
+})();

index.js

@@ -1 +0,0 @@
-module.exports = require('./lib/Innertube');

index.ts

@@ -0,0 +1,21 @@
+import { getRuntime } from './src/utils/Utils';
+
+// Polyfill fetch for node
+if (getRuntime() === 'node') {
+  // eslint-disable-next-line
+  const undici = require('undici');
+  Reflect.set(globalThis, 'fetch', undici.fetch);
+  Reflect.set(globalThis, 'Headers', undici.Headers);
+  Reflect.set(globalThis, 'Request', undici.Request);
+  Reflect.set(globalThis, 'Response', undici.Response);
+  Reflect.set(globalThis, 'FormData', undici.FormData);
+  Reflect.set(globalThis, 'File', undici.File);
+}
+
+import Innertube from './src/Innertube';
+
+export * from './src/utils';
+export { YTNodes } from './src/parser/map';
+export { default as Parser } from './src/parser';
+export { default as Innertube } from './src/Innertube';
+export default Innertube;

jest.config.js

@@ -0,0 +1,17 @@
+
+
+module.exports = {
+  projects: [
+    {
+      displayName: 'node',
+      roots: [ '<rootDir>/test' ],
+      testTimeout: 10000,
+      transform: {
+        "^.+\\.(ts|tsx)$": "ts-jest",
+      },
+      moduleFileExtensions: ["ts", "tsx", "js"],
+      testMatch: [ '**/*.test.ts' ],
+      setupFiles: []
+    }
+  ]
+};

lib/Actions.js

@@ -1,317 +0,0 @@
-'use strict';
-
-const Uuid = require('uuid');
-const Axios = require('axios');
-const Utils = require('./Utils');
-const Constants = require('./Constants');
-
-/**
- * Performs direct interactions on YouTube.
- *
- * @param {object} session A valid Innertube session.
- * @param {string} engagement_type Type of engagement.
- * @param {object} args Engagement arguments.
- * @returns {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 signed-in');
-
-  let data;
-  switch (engagement_type) {
-    case 'like/like':
-    case 'like/dislike':
-    case 'like/removelike':
-      data = {
-        context: session.context,
-        target: {
-          videoId: args.video_id
-        }
-      };
-      break;
-    case 'subscription/subscribe':
-    case 'subscription/unsubscribe':
-      data = {
-        context: session.context,
-        channelIds: [args.channel_id]
-      };
-      break;
-    case 'comment/create_comment':
-      data = {
-        context: session.context,
-        commentText: args.text,
-        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_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
-  };
-}
-
-/**
- * Accesses YouTube's various sections.
- *
- * @param {object} session A valid Innertube session.
- * @param {string} action_type Type of action.
- * @returns {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) throw new Error('You are not signed-in');
-
-  let data;
-  switch (action_type) { // TODO: Handle more actions
-    case 'home_feed':
-      data = {
-        context: session.context,
-        browseId: 'FEwhat_to_watch'
-      };
-      break;
-    case 'subscriptions_feed':
-      data = {
-        context: session.context,
-        browseId: 'FEsubscriptions'
-      };
-      break;
-    default:
-  }
-
-  const client_domain = args.ytmusic && Constants.URLS.YT_MUSIC_URL || Constants.URLS.YT_BASE_URL;
-  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_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
-  };
-}
-
-/**
- * Performs searches on YouTube.
- *
- * @param {object} session A valid Innertube session.
- * @param {string} client YouTube client: YOUTUBE | YTMUSIC
- * @param {object} args Search arguments.
- * @returns {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 yt_music_context = JSON.parse(JSON.stringify(session.context)); // deep copy the context obj so we don't accidentally change it
-
-      yt_music_context.client.originalUrl = Constants.URLS.YT_MUSIC_URL;
-      yt_music_context.client.clientVersion = '1.20211213.00.00';
-      yt_music_context.client.clientName = 'WEB_REMIX';
-
-      data = {
-        context: yt_music_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 {object} session A valid Innertube session.
- * @param {string} action_type Type of action.
- * @param {object} args Action arguments.
- * @returns {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 };
-      data = {
-        context: session.context,
-        params: Utils.encodeNotificationPref(args.channel_id, pref_types[args.pref.toUpperCase()])
-      };
-      break;
-    case 'get_notification_menu':
-      data = {
-        context: session.context,
-        notificationsMenuRequestType: 'NOTIFICATIONS_MENU_REQUEST_TYPE_INBOX'
-      };
-      break;
-    case 'get_unseen_count':
-      data = {
-        context: session.context
-      };
-      break;
-    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_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,
-    data: response.data
-  };
-}
-
-
-/**
- * Interacts with YouTube's livechat system.
- *
- * @param {object} session A valid Innertube session.
- * @param {string} action_type Type of action.
- * @param {object} args Action arguments.
- * @returns {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/get_live_chat':
-      data = {
-        context: session.context,
-        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 }]
-        }
-      };
-      break;
-    case 'live_chat/get_item_context_menu':
-      data = {
-        context: session.context
-      };
-      break;
-    case 'live_chat/moderate':
-      data = {
-        context: session.context,
-        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_REQOPTS({ session, params: args.params })).catch((error) => error);
-  if (response instanceof Error) return { success: false, message: response.message };
-
-  return { success: true, data: response.data };
-}
-
-
-/**
- * Gets detailed data for a video.
- *
- * @param {object} session A valid Innertube session.
- * @param {object} args Request arguments.
- * @returns {object} Video data.
- */
-async function getVideoInfo(session, args = {}) {
-  let response;
-
-  !args.is_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 {object} session A valid Innertube session.
- * @param {object} args Continuation arguments.
- * @returns {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 yt_music_context = JSON.parse(JSON.stringify(session.context)); // deep copy the context obj so we don't accidentally change it
-
-      yt_music_context.client.originalUrl = Constants.URLS.YT_MUSIC_URL;
-      yt_music_context.client.clientVersion = '1.20211213.00.00';
-      yt_music_context.client.clientName = 'WEB_REMIX';
-
-      data.context = yt_music_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 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,
-    data: response.data
-  };
-}
-
-module.exports = { engage, browse, search, notifications, livechat, getVideoInfo, getContinuation };

lib/Constants.js

@@ -1,139 +0,0 @@
-'use strict';
-
-const Utils = require('./Utils');
-
-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'
-  },
-  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'
-      }
-    }
-  },
-  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': 'https://www.youtube.com',
-    'Referer': 'https://www.youtube.com',
-    'DNT': '?1'
-  },
-  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';
-      
-    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,
-      }
-    };
-
-    info.id && (req_opts.headers.referer = (info.desktop ? 'https://www.youtube.com' : 'https://m.youtube.com') + '/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;
-  },
-  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
-    };
-  },
-  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'
-  ],
-  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 k=f|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 k=f'
-  },
-  // Just a helper function, felt like Utils.js wasn't the right place for it:
-  formatNTransformData: (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])}');
-  }
-};

lib/Innertube.js

@@ -1,493 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-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('./Sig');
-const EventEmitter = require('events');
-const CancelToken = Axios.CancelToken;
-
-class Innertube {
-  constructor(cookie) {
-    this.cookie = cookie || '';
-    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 retrieve Innertube session: ${response.message}`);
-
-    try {
-      const data = JSON.parse(`{${Utils.getStringBetweenStrings(response.data, 'ytcfg.set({', '});')}}`);
-      if (data.INNERTUBE_CONTEXT) {
-        this.context = data.INNERTUBE_CONTEXT;
-        this.key = data.INNERTUBE_API_KEY;
-        this.id_token = data.ID_TOKEN;
-        this.session_token = data.XSRF_TOKEN;
-        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.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);
-        }
-      } else {
-        throw new Error('Could not retrieve Innertube session due to unknown reasons');
-      }
-    } catch (err) {
-      this.retry_count += 1;
-      if (this.retry_count >= 10) throw new Error(`Could not retrieve Innertube session: ${err.message}`);
-      return this.#init();
-    }
-    return this;
-  }
-
-  /**
-   * Signs-in to a google account.
-   *
-   * @param {object} auth_info { refresh_token: string, access_token: string, expires: string }
-   * @returns {Promise<void>}
-   */
-  signIn(auth_info = {}) {
-    return new Promise(async (resolve, reject) => {
-      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.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.ev.emit('auth', data);
-          }
-        });
-      }
-    });
-  }
-
-  /**
-   * Searches on YouTube.
-   *
-   * @param {string} query Search query.
-   * @param {object} options { client: YOUTUBE | YTMUSIC, period: any | hour | day | week | month | year , order: relevance | rating | age | views, duration: any | short | long }
-   * @returns {Promise<object>} Search results.
-   */
-  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 refined_data = new Parser(this, response.data, {
-      client: options.client,
-      data_type: 'SEARCH',
-      query
-    }).parse();
-
-    return refined_data;
-  }
-
-  /**
-  * Gets details for a video.
-  *
-  * @param {string} id The id of the video.
-  */
-  async getDetails(id) {
-    if (!id) throw new Error('You must provide a video id');
-
-    const data = await Actions.getVideoInfo(this, { 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: 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, id);
-      } else {
-        refined_data.getLivechat = () => { };
-      }
-    } else {
-      refined_data.getLivechat = () => { };
-    }
-
-    refined_data.like = () => Actions.engage(this, 'like/like', { video_id: id });
-    refined_data.dislike = () => Actions.engage(this, 'like/dislike', { video_id: id });
-    refined_data.removeLike = () => Actions.engage(this, 'like/removelike', { video_id: id });
-    refined_data.subscribe = () => Actions.engage(this, 'subscription/subscribe', { video_id: id, channel_id: refined_data.metadata.channel_id });
-    refined_data.unsubscribe = () => Actions.engage(this, 'subscription/unsubscribe', { video_id: id, channel_id: refined_data.metadata.channel_id });
-    refined_data.comment = text => Actions.engage(this, 'comment/create_comment', { video_id: id, text });
-    refined_data.getComments = () => this.getComments(id);
-    refined_data.setNotificationPref = pref => Actions.notifications(this, 'modify_channel_preference', { channel_id: refined_data.metadata.channel_id, pref: pref || 'NONE' });
-
-    return refined_data;
-  }
-
-  /**
-  * Gets the comments section of a video.
-  *
-  * @param {string} video_id The id of the video.
-  * @param {string} token Continuation token (optional).
-  */
-  async getComments(video_id, token) {
-    let comment_section_token;
-
-    if (!token) {
-      const data_continuation = await Actions.getContinuation(this, { video_id });
-      const item_section_renderer = data_continuation.data.contents.twoColumnWatchNextResults.results.results.contents.find((item) => item.itemSectionRenderer);
-      comment_section_token = item_section_renderer.itemSectionRenderer.contents[0].continuationItemRenderer.continuationEndpoint.continuationCommand.token;
-    }
-
-    const response = await Actions.getContinuation(this, { continuation_token: comment_section_token || token });
-    if (!response.success) throw new Error('Could not fetch comments section');
-
-    const comments_section = { comments: [] };
-    !token && (comments_section.comment_count = response.data.onResponseReceivedEndpoints[0].reloadContinuationItemsCommand.continuationItems && response.data.onResponseReceivedEndpoints[0].reloadContinuationItemsCommand.continuationItems[0].commentsHeaderRenderer.countText.runs[0].text || 'N/A');
-
-    let continuation_token;
-    !token && (continuation_token = response.data.onResponseReceivedEndpoints[1].reloadContinuationItemsCommand.continuationItems.find((item) => item.continuationItemRenderer).continuationItemRenderer.continuationEndpoint.continuationCommand.token) ||
-      (continuation_token = response.data.onResponseReceivedEndpoints[0].appendContinuationItemsAction.continuationItems.find((item) => item.continuationItemRenderer).continuationItemRenderer.continuationEndpoint.continuationCommand.token);
-
-    comments_section.getContinuation = () => this.getComments(video_id, continuation_token);
-
-    let contents;
-    !token && (contents = response.data.onResponseReceivedEndpoints[1].reloadContinuationItemsCommand.continuationItems) ||
-      (contents = response.data.onResponseReceivedEndpoints[0].appendContinuationItemsAction.continuationItems);
-
-    contents.forEach((thread) => {
-      if (!thread.commentThreadRenderer) return;
-      const comment = {
-        text: thread.commentThreadRenderer.comment.commentRenderer.contentText.runs.map((t) => t.text).join(' '),
-        author: {
-          name: thread.commentThreadRenderer.comment.commentRenderer.authorText.simpleText,
-          thumbnail: thread.commentThreadRenderer.comment.commentRenderer.authorThumbnail.thumbnails,
-          channel_id: thread.commentThreadRenderer.comment.commentRenderer.authorEndpoint.browseEndpoint.browseId
-        },
-        metadata: {
-          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 && thread.commentThreadRenderer.comment.commentRenderer.voteCount.simpleText || 'N/A',
-          reply_count: thread.commentThreadRenderer.comment.commentRenderer.replyCount || 0,
-          id: thread.commentThreadRenderer.comment.commentRenderer.commentId,
-        }
-      };
-      comments_section.comments.push(comment);
-    });
-
-    return comments_section;
-  }
-
-  /**
-  * Returns YouTube's home feed.
-  * @returns {Promise<object>} home feed.
-  */
-  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) || 'N/A',
-          owner_badges: content.videoRenderer.ownerBadges && content.videoRenderer.ownerBadges.map((badge) => badge.metadataBadgeRenderer.tooltip) || 'N/A'
-        }
-      }
-    }).filter((video) => video);
-  }
-
-  /**
-  * Returns your subscription feed.
-  * @returns {Promise<object>} subs feed.
-  */
-  async getSubscriptionsFeed() {
-    const response = await Actions.browse(this, '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 = {};
-
-    contents.forEach((section) => {
-      if (!section.itemSectionRenderer) return;
-
-      const section_contents = section.itemSectionRenderer.contents[0];
-      const section_items = section_contents.shelfRenderer.content.gridRenderer.items;
-
-      const key = section_contents.shelfRenderer.title.runs[0].text;
-      subscriptions_feed[key.toLowerCase().replace(/ +/g, '_')] = [];
-
-      section_items.forEach((item) => {
-        const content = {
-          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.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'
-          }
-        };
-
-        subscriptions_feed[key.toLowerCase().replace(/ +/g, '_')].push(content);
-      });
-    });
-
-    return subscriptions_feed;
-  }
-
-  /**
-   * Returns your notifications.
-   * @returns {Promise<object>} notifications.
-   */
-  async getNotifications() {
-    const response = await Actions.notifications(this, 'get_notification_menu');
-    if (!response.success) throw new Error('Could not fetch notifications');
-
-    const contents = response.data.actions[0].openPopupAction.popup.multiPageMenuRenderer.sections[0];
-    if (!contents.multiPageMenuNotificationSectionRenderer) return { error: 'You don\'t have any notification.' };
-    return contents.multiPageMenuNotificationSectionRenderer.items.map((notification) => {
-      if (!notification.notificationRenderer) return;
-      notification = notification.notificationRenderer;
-      return {
-        title: notification.shortMessage.simpleText,
-        sent_time: notification.sentTimeText.simpleText,
-        channel_name: notification.contextualMenu.menuRenderer.items[1].menuServiceItemRenderer.text.runs[1].text,
-        channel_thumbnail: notification.thumbnail.thumbnails[0],
-        video_thumbnail: notification.videoThumbnail.thumbnails[0],
-        video_url: `https://youtu.be/${notification.navigationEndpoint.watchEndpoint.videoId}`,
-        read: notification.read,
-        notification_id: notification.notificationId,
-      };
-    }).filter((notification_block) => notification_block);
-  }
-
-  /**
-   * Returns the amount of notifications you haven't seen.
-   * @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 get unseen notifications count');
-    return response.data.unseenCount;
-  }
-
-  /**
-   * Downloads a video from YouTube.
-   * 
-   * @param {string} id The id of the video.
-   * @param {object} options Download options: { quality?: string, type?: string, format?: string }
-   */
-  download(id, options = {}) {
-    if (!id) throw new Error('Missing video id');
-
-    options.quality = options.quality || '360p';
-    options.type = options.type || 'videoandaudio';
-    options.format = options.format || 'mp4';
-
-    let cancel;
-    let cancelled = false;
-
-    const stream = new Stream.PassThrough();
-    Actions.getVideoInfo(this, { id, is_desktop: true }).then(async (video_data) => {
-      let formats = [];
-
-      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 });
-
-      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;
-
-      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) {
-        return stream.emit('error', { message: 'Could not find any suitable format.', type: 'FORMAT_UNAVAILABLE' });
-      } else {
-        const refined_data = new Parser(this, video_data, { client: 'YOUTUBE', data_type: 'VIDEO_INFO', desktop_v: true }).parse();
-        stream.emit('info', { video_details: refined_data, selected_format, formats });
-      }
-
-      if (options.type == 'videoandaudio' && !options.range) {
-        const response = await Axios.get(selected_format.url, {
-          responseType: 'stream',
-          cancelToken: new CancelToken(function executor(c) { cancel = c; }),
-          headers: Constants.STREAM_HEADERS
-        }).catch((error) => error);
-
-        if (response instanceof Error) {
-          stream.emit('error', { message: response.message, type: 'REQUEST_FAILED' });
-          return stream;
-        } else {
-          stream.emit('start');
-        }
-
-        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'] } });
-        });
-
-        response.data.on('error', (err) => {
-          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 = (options.range && options.range.start || 0);
-        let chunk_end = (options.range && options.range.end || chunk_size);
-        let downloaded_size = 0;
-        let must_end = false;
-
-        stream.emit('start');
-
-        const downloadChunk = async () => {
-          (chunk_end >= selected_format.contentLength || options.range) && (must_end = true);
-          options.range && (selected_format.contentLength = options.range.end);
-
-          const response = await Axios.get(`${selected_format.url}&range=${chunk_start}-${chunk_end || ''}`, {
-            responseType: 'stream',
-            cancelToken: new CancelToken(function executor(c) { cancel = c; }),
-            headers: Constants.STREAM_HEADERS
-          }).catch((error) => error);
-
-          if (response instanceof Error) {
-            stream.emit('error', { message: response.message, type: 'REQUEST_FAILED' });
-            return stream;
-          }
-
-          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'] } });
-          });
-
-          response.data.on('error', (err) => {
-            if (cancelled) {
-              stream.emit('error', { message: 'The download was cancelled.', type: 'DOWNLOAD_CANCELLED' });
-            } else {
-              stream.emit('error', { message: err.message, type: 'DOWNLOAD_ABORTED' });
-            }
-          });
-
-          response.data.on('end', () => {
-            if (!must_end && !options.range) {
-              chunk_start = chunk_end + 1;
-              chunk_end += chunk_size;
-              downloadChunk();
-            }
-          });
-
-          response.data.pipe(stream, { end: must_end });
-        };
-        downloadChunk();
-      }
-    });
-
-    stream.cancel = () => {
-      cancelled = true;
-      cancel();
-    };
-
-    return stream;
-  }
-}
-
-module.exports = Innertube;

lib/Livechat.js

@@ -1,133 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-const Actions = require('./Actions');
-const Constants = require('./Constants');
-const EventEmitter = require('events');
-
-class Livechat extends EventEmitter {
-  constructor(session, token, channel_id, video_id) {
-    super(session);
-    this.ctoken = token;
-    this.session = session;
-    this.video_id = video_id;
-    this.channel_id = channel_id;
-
-    this.message_queue = [];
-    this.id_cache = [];
-
-    this.poll_intervals_ms = 1000;
-    this.running = true;
-
-    this.#poll();
-  }
-
-  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
-      const message_content = action.addChatItemAction.item.liveChatTextMessageRenderer;
-      if (!message_content) return;
-
-      const message = {
-        text: message_content.message.runs.map((item) => item.text).join(' '),
-        author: {
-          name: message_content.authorName && message_content.authorName.simpleText || 'N/',
-          channel_id: message_content.authorExternalChannelId,
-          profile_picture: message_content.authorPhoto.thumbnails
-        },
-        timestamp: message_content.timestampUsec,
-        id: message_content.id
-      };
-
-      this.message_queue.push(message);
-    });
-  }
-
-  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;
-
-    const deleteMessage = async () => {
-      const menu = await Actions.livechat(this.session, 'live_chat/get_item_context_menu', { params: { params: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.contextMenuEndpoint.liveChatItemContextMenuEndpoint.params, pbj: 1 } });
-      if (!menu.success) return menu;
-
-      const chat_item_menu = menu.data.liveChatItemContextMenuSupportedRenderers.menuRenderer.items[0];
-
-      const cmd = await Actions.livechat(this.session, 'live_chat/moderate', { cmd_params: chat_item_menu.menuServiceItemRenderer.serviceEndpoint.moderateLiveChatEndpoint.params });
-      if (!cmd.success) return cmd;
-
-      return { success: true, status_code: cmd.status_code };
-    };
-
-    return {
-      success: true,
-      status_code: message.status_code,
-      deleteMessage: deleteMessage,
-      message_data: {
-        text: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.message.runs.map((item) => item.text).join(' '),
-        author: {
-          name: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.authorName && message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.authorName.simpleText || 'N/',
-          channel_id: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.authorExternalChannelId,
-          profile_picture: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.authorPhoto.thumbnails
-        },
-        timestamp: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.timestampUsec,
-        id: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.id
-      }
-    };
-  }
-
-  async blockUser(msg_params) {
-    /* TODO: Implement this */
-    throw new Error('Not implemented');
-  }
-
-  stop() {
-    this.running = false;
-    clearTimeout(this.livechat_poller);
-  }
-}
-
-module.exports = Livechat;

lib/NToken.js

@@ -1,137 +0,0 @@
-'use strict';
-
-const Utils = require('./Utils');
-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;
-  }
-
-  /**
-   * 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();
-      transformations = transformations.map((el) => {
-        if (el != null && typeof el != 'number') {
-          const is_reverse_base64 = el.includes('case 65:');
-          (({ // 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
-      const null_placeholder_positions = [...this.raw_code.matchAll(this.null_placeholder_regex)].map((item) => parseInt(item[1]));
-      null_placeholder_positions.forEach((pos) => transformations[pos] = transformations);
-
-      // Parses and emulates calls to the functions of the transformations array
-      const 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 param_index = data.params.split(',').map((param) => param.match(/c\[(.*?)\]/)[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)
-      return n;
-    }
-    return n_token.join('');
-  }
-
-  #getFunc(el) {
-    return el.match(Constants.FUNCS_REGEX);
-  }
-
-  /**
-   * 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(Constants.formatNTransformData(data));
-  }
-
-  /**
-   * Gets a base64 alphabet and uses it as a lookup table to modify n.
-   */
-  #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]);
-    }, token.split(''));
-  }
-
-  #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(''));
-  }
-
-  /**
-   * Returns the requested base64 dialect, currently this is only used by 'translate2'.
-   */
-  #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.
-   */
-  #swap0(arr, index) {
-    const old_elem = arr[0];
-    index = (index % arr.length + arr.length) % arr.length;
-    arr[0] = arr[index];
-    arr[index] = old_elem;
-  }
-
-  /**
-   * Rotates elements of the array.
-   */
-  #rotate(arr, index) {
-    index = (index % arr.length + arr.length) % arr.length;
-    arr.splice(-index).reverse().forEach((el) => arr.unshift(el));
-  }
-
-  /**
-   * Deletes one element at the given index.
-   */
-  #splice(arr, index) {
-    index = (index % arr.length + arr.length) % arr.length;
-    arr.splice(index, 1);
-  }
-
-  #reverse(arr) {
-    arr.reverse();
-  }
-
-  #push(arr, item) {
-    arr.push(item);
-  }
-}
-
-module.exports = NToken;

lib/OAuth.js

@@ -1,198 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-const Constants = require('./Constants');
-const EventEmitter = require('events');
-const Uuid = require('uuid');
-
-class OAuth extends EventEmitter {
-  constructor(auth_info) {
-    super();
-    this.auth_info = auth_info;
-    this.refresh_interval = 5;
-
-    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`;
-
-    this.model_name = Constants.OAUTH.MODEL_NAME;
-    this.grant_type = Constants.OAUTH.GRANT_TYPE;
-    this.scope = Constants.OAUTH.SCOPE;
-
-    this.auth_script_regex = /<script id=\"base-js\" src=\"(.*?)\" nonce=".*?"><\/script>/;
-    this.identity_regex = /.+?={};var .+?={clientId:\"(?<id>.+?)\",si:\"(?<secret>.+?)\"},/;
-
-    if (auth_info.access_token) return;
-    this.#requestAuthCode();
-  }
-
-  /**
-   * Asks the OAuth server for an auth code.
-   */
-  async #requestAuthCode() {
-    const identity = await this.#getClientIdentity();
-
-    this.client_id = identity.id;
-    this.client_secret = identity.secret;
-
-    const data = {
-      client_id: this.client_id,
-      scope: this.scope,
-      device_id: Uuid.v4(),
-      model_name: this.model_name
-    };
-
-    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.',
-        status: 'FAILED'
-      });
-
-    this.emit('auth', {
-      code: response.data.user_code,
-      status: 'AUTHORIZATION_PENDING',
-      expires_in: response.data.expires_in,
-      verification_url: response.data.verification_url
-    });
-
-    this.refresh_interval = response.data.interval;
-
-    this.#waitForAuth(response.data.device_code);
-  }
-
-  /**
-   * Waits for sign-in authorization.
-   *
-   * @param {string} device_code Client's device code.
-   */
-  #waitForAuth(device_code) {
-    const data = {
-      client_id: this.client_id,
-      client_secret: this.client_secret,
-      code: device_code,
-      grant_type: this.grant_type
-    };
-
-    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'
-        });
-
-      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);
-  }
-
-  /**
-   * Gets a new access token using a refresh token.
-   * @returns {object} { credentials: { access_token: string, refresh_token: string, expires: string }, status: 'FAILED' | 'SUCCESS' }
-   */
-  async refreshAccessToken() {
-    const identity = await this.#getClientIdentity();
-
-    const data = {
-      client_id: identity.id,
-      client_secret: identity.secret,
-      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.HEADERS).catch((error) => error);
-    if (response instanceof Error) {
-      this.emit('auth', {
-        error: 'Could not refresh access token.',
-        status: 'FAILED'
-      });
-
-      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,
-      status: 'SUCCESS'
-    };
-  }
-
-  /**
-   * Gets client identity data.
-   * @returns {object} { 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}`);
-
-    // 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;
-  }
-}
-
-module.exports = OAuth;

lib/Parser.js

@@ -1,206 +0,0 @@
-'use strict';
-
-const Utils = require('./Utils');
-const Actions = require('./Actions');
-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(),
-      VIDEO_INFO: () => this.#parseVideoInfo()
-    })[this.args.data_type]() : ({
-      SEARCH: () => this.#parseMusicSearch(),
-      SONG_INFO: () => { }
-    })[this.args.data_type]();
-  }
-
-  #parseVideoSearch() {
-    const response = {};
-
-    const contents = this.data.contents.twoColumnSearchResultsRenderer
-      .primaryContents.sectionListRenderer.contents[0].itemSectionRenderer
-      .contents;
-
-    const continuation_token = this.data.contents.twoColumnSearchResultsRenderer
-      .primaryContents.sectionListRenderer.contents[1].continuationItemRenderer
-      .continuationEndpoint.continuationCommand.token;
-
-    response.search_metadata = {};
-    response.search_metadata.query = contents[0].showingResultsForRenderer && contents[0].showingResultsForRenderer.originalQuery.simpleText || this.args.query;
-    response.search_metadata.corrected_query = contents[0].showingResultsForRenderer && contents[0].showingResultsForRenderer.correctedQueryEndpoint.searchEndpoint.query || this.args.query;
-    response.search_metadata.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;
-  }
-
-  #parseMusicSearch() {
-    const tabs = this.data.contents.tabbedSearchResultsRenderer.tabs;
-    const contents = tabs[0].tabRenderer.content.sectionListRenderer.contents;
-
-    /**
-     * WIP
-     **/ 
-    const getLyrics = async (id) => {
-      // const data_continuation = await Actions.getContinuation(this.session, { video_id: id, ytmusic: true });
-      return undefined;
-    }
-
-    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;
-      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: () => getLyrics(list_item.playlistItemData.videoId)
-      };
-    });
-
-    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;
-      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: () => getLyrics(list_item.playlistItemData.videoId)
-      };
-    });
-
-    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,
-      };
-    });
-
-    return { songs, videos, albums };
-  }
-
-  #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,46 +0,0 @@
-'use strict';
-
-const Fs = require('fs');
-const Axios = require('axios');
-const Utils = require('./Utils');
-const Constants = require('./Constants');
-
-class Player {
-  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.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);
-      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) {}
-
-      this.sig_decipher_sc = this.#getSigDecipherCode(response.data);
-      this.ntoken_sc = this.#getNEncoder(response.data);
-    }
-  }
-
-  #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) {
-    return `var b=a.split("")${Utils.getStringBetweenStrings(data, 'b=a.split("")', '}return b.join("")}')}} return b.join("");`;
-  }
-}
-
-module.exports = Player;

lib/Sig.js

@@ -1,80 +0,0 @@
-'use strict';
-
-const NToken = require('./NToken');
-const QueryString = require('querystring');
-
-class SigDecipher {
-  constructor(url, cver, 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();
-
-    function splice(arr, end) {
-      arr.splice(0, end);
-    }
-
-    function swap(arr, index) {
-      let origArrI = arr[0];
-      arr[0] = arr[index % arr.length];
-      arr[index % arr.length] = origArrI;
-    }
-
-    function reverse(arr) {
-      arr.reverse();
-    }
-
-    let actions;
-    let signature = args.s.split('');
-
-    while ((actions = this.actions_regex.exec(this.player.sig_decipher_sc)) !== null) {
-      switch (actions[1]) {
-        case functions[0]:
-          reverse(signature, actions[2]);
-          break;
-        case functions[1]:
-          splice(signature, actions[2]);
-          break;
-        case functions[2]:
-          swap(signature, actions[2]);
-          break;
-        default:
-      }
-    }
-
-    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')));
-    return url_components.toString();
-  }
-
-  #getFunctions() {
-    let func;
-    let func_name = [];
-
-    while ((func = this.func_regex.exec(this.player.sig_decipher_sc)) !== null) {
-      if (func[0].includes('reverse()')) {
-        func_name[0] = func[1];
-      } else if (func[0].includes('splice')) {
-        func_name[1] = func[1];
-      } else {
-        func_name[2] = func[1];
-      }
-    }
-
-    return func_name;
-  }
-}
-
-module.exports = SigDecipher;

lib/Utils.js

@@ -1,174 +0,0 @@
-'use strict';
-
-const Fs = require('fs');
-const Proto = require('protons');
-const Crypto = require('crypto');
-const UserAgent = require('user-agents');
-
-/**
- * Returns a random user agent.
- *
- * @param {string} type mobile | desktop
- */
-function getRandomUserAgent(type) {
-  switch (type) {
-    case 'mobile':
-      return new UserAgent(/Android/).data;
-    case 'desktop':
-      return new UserAgent({ deviceCategory: 'desktop' }).data;
-    default:
-  }
-}
-
-/**
- * Generates an authentication token from a cookies' sid.
- *
- * @param {string} sid Sid extracted from cookies 
- */
-function generateSidAuth(sid) {
-  const youtube = 'https://www.youtube.com';
-  const timestamp = Math.floor(new Date().getTime() / 1000);
-  const input = [timestamp, sid, youtube].join(' ');
-
-  let hash = Crypto.createHash('sha1');
-  let data = hash.update(input, 'utf-8');
-  let gen_hash = data.digest('hex');
-
-  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);
-  return match ? match[1] : undefined;
-}
-
-function escapeStringRegexp(string) {
-  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
-}
-
-/**
- * Converts time (h:m:s) to seconds.
- * 
- * @param {string} time 
- * @returns {string} 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.
- */
-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
- */
-function encodeNotificationPref(channel_id, index) {
-  const youtube_proto = Proto(Fs.readFileSync(`${__dirname}/proto/youtube.proto`));
-
-  const buf = youtube_proto.NotificationPreferences.encode({
-    channel_id,
-    pref_id: {
-      index
-    },
-    number_0: 0,
-    number_1: 4
-  });
-
-  return encodeURIComponent(Buffer.from(buf).toString('base64'));
-}
-
-
-/**
- * Encodes livestream message protobuf.
- *
- * @param {string} channel_id
- * @param {string} video_id 
- */
-function encodeMessageParams(channel_id, video_id) {
-  const youtube_proto = Proto(Fs.readFileSync(`${__dirname}/proto/youtube.proto`));
-
-  const buf = youtube_proto.LiveMessageParams.encode({
-    params: {
-      ids: {
-        channel_id,
-        video_id
-      }
-    },
-    number_0: 1,
-    number_1: 4
-  });
-
-  return Buffer.from(encodeURIComponent(Buffer.from(buf).toString('base64'))).toString('base64');
-}
-
-
-/**
- * Encodes comment params protobuf.
- *
- * @param {string} video_id
- */
-function encodeCommentParams(video_id) {
-  const youtube_proto = Proto(Fs.readFileSync(`${__dirname}/proto/youtube.proto`));
-
-  const buf = youtube_proto.CreateCommentParams.encode({
-    video_id,
-    params: {
-      index: 0
-    },
-    number: 7
-  });
-
-  return encodeURIComponent(Buffer.from(buf).toString('base64'));
-}
-
-
-/**
- * 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
- */
-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'));
-}
-
-module.exports = { getRandomUserAgent, generateSidAuth, getStringBetweenStrings, camelToSnake, timeToSeconds, encodeMessageParams, encodeCommentParams, encodeNotificationPref, encodeFilter };

lib/proto/youtube.proto

@@ -1,44 +0,0 @@
-syntax = "proto2";
-package proto;
-
-message NotificationPreferences {
-  string channel_id = 1;
-  message Preference {
-    int32 index = 1;
-  }
-  Preference pref_id = 2;
-  int32 number_0 = 3;
-  int32 number_1 = 4;
-}
-
-message LiveMessageParams {
-  message Params {
-    message Ids {
-      string channel_id = 1;
-      string video_id = 2;
-    }
-    Ids ids = 5;
-  }
-  Params params = 1;
-  int32 number_0 = 2;
-  int32 number_1 = 3;
-}
-
-message CreateCommentParams {
-  string video_id = 2;
-  message Params {
-    int32 index = 1;
-  }
-  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.json

@@ -1,45 +1,86 @@
 {
   "name": "youtubei.js",
-  "version": "1.2.9",
-  "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": "node test"
-  },
-  "author": "LuanRT",
-  "license": "MIT",
+  "version": "2.0.2",
+  "description": "Full-featured wrapper around YouTube's private API.",
+  "main": "./dist/index.js",
+  "browser": "./bundle/browser.js",
+  "types": "./dist",
+  "author": "LuanRT <luan.lrt4@gmail.com> (https://github.com/LuanRT)",
+  "funding": [
+    "https://github.com/sponsors/LuanRT"
+  ],
+  "contributors": [
+    "Wykerd (https://github.com/wykerd/)",
+    "MasterOfBob777 (https://github.com/MasterOfBob777)",
+    "patrickkfkan (https://github.com/patrickkfkan)"
+  ],
   "directories": {
-    "example": "examples",
-    "lib": "lib"
+    "test": "./test",
+    "examples": "./examples",
+    "dist": "./dist"
   },
-  "dependencies": {
-    "axios": "^0.21.4",
-    "protons": "^2.0.3",
-    "user-agents": "^1.0.778",
-    "uuid": "^8.3.2"
+  "scripts": {
+    "test": "npx jest --verbose",
+    "lint": "npx eslint ./src",
+    "lint:fix": "npx eslint --fix ./src",
+    "build": "npm run build:parser-map && npm run build:proto && npm run bundle:browser && npm run bundle:browser:prod && npm run build:node",
+    "build:node": "npx tsc",
+    "bundle:browser": "npx tsc --module esnext && npx esbuild ./dist/browser.js --banner:js=\"/* eslint-disable */\" --bundle --target=chrome58 --keep-names --format=esm --sourcemap --define:global=globalThis --outfile=./bundle/browser.js --platform=browser",
+    "bundle:browser:prod": "npm run bundle:browser -- --outfile=./bundle/browser.min.js --minify",
+    "build:parser-map": "node ./scripts/build-parser-map.js",
+    "build:proto": "npx protoc --ts_out ./src/proto --proto_path ./src/proto ./src/proto/youtube.proto",
+    "prepare": "npm run build",
+    "watch": "npx tsc --watch"
   },
   "repository": {
     "type": "git",
-    "url": "git+https//github.com/LuanRT/YouTube.js.git"
+    "url": "git+https://github.com/LuanRT/YouTube.js.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@protobuf-ts/runtime": "^2.7.0",
+    "jintr": "^0.1.9",
+    "linkedom": "^0.14.12",
+    "undici": "^5.7.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.30.6",
+    "@typescript-eslint/parser": "^5.30.6",
+    "@protobuf-ts/plugin": "^2.7.0",
+    "@types/jest": "^28.1.7",
+    "@types/node": "^17.0.45",
+    "esbuild": "^0.14.49",
+    "eslint": "^8.19.0",
+    "eslint-plugin-tsdoc": "^0.2.16",
+    "glob": "^8.0.3",
+    "jest": "^28.1.3",
+    "ts-jest": "^28.0.8",
+    "typescript": "^4.7.4"
   },
-  "keywords": [
-    "youtube",
-    "youtube-dl",
-    "youtubedl",
-    "innertube",
-    "innertubeapi",
-    "livechat",
-    "api",
-    "search",
-    "like",
-    "dislike",
-    "comment",
-    "downloader",
-    "comments-section",
-    "youtube-downloader"
-  ],
   "bugs": {
     "url": "https://github.com/LuanRT/YouTube.js/issues"
   },
-  "homepage": "https://github.com/LuanRT/YouTube.js#readme"
+  "homepage": "https://github.com/LuanRT/YouTube.js#readme",
+  "keywords": [
+    "yt",
+    "dl",
+    "ytdl",
+    "youtube",
+    "youtubedl",
+    "youtube-dl",
+    "youtube-downloader",
+    "youtube-music",
+    "innertubeapi",
+    "innertube",
+    "unofficial",
+    "downloader",
+    "livechat",
+    "studio",
+    "upload",
+    "ytmusic",
+    "search",
+    "comment",
+    "music",
+    "api"
+  ]
 }

scripts/build-parser-map.js

@@ -0,0 +1,48 @@
+const glob = require('glob');
+const fs = require('fs');
+const path = require('path');
+
+const import_list = [];
+
+const json = [];
+
+glob.sync('../src/parser/classes/**/*.{js,ts}', { cwd: __dirname })
+  .forEach((file) => {
+    if (file.includes('/misc/')) return;
+    // Trim path
+    file = file.replace('../src/parser/classes/', '').replace('.js', '').replace('.ts', '');
+    const import_name = file.split('/').pop();
+    import_list.push(`import { default as ${import_name} } from './classes/${file}';`);
+    json.push(import_name);
+  });
+
+fs.writeFileSync(
+  path.resolve(__dirname, '../src/parser/map.ts'),
+  `// This file was auto generated, do not edit.
+// See ./scripts/build-parser-map.js
+import { YTNodeConstructor } from './helpers';
+
+${import_list.join('\n')}
+
+const map: Record<string, YTNodeConstructor> = {
+  ${json.join(',\n  ')}
+};
+
+export const YTNodes = map;
+
+/**
+ * @param name - Name of the node to be parsed
+ */
+export default function GetParserByName(name: string) {
+  const ParserConstructor = map[name];
+
+  if (!ParserConstructor) {
+    const error = new Error(\`Module not found: \${name}\`);
+    (error as any).code = 'MODULE_NOT_FOUND';
+    throw error;
+  }
+
+  return ParserConstructor;
+}
+`
+);

scripts/get-agents.mjs

@@ -0,0 +1,52 @@
+import { fetch } from "undici";
+import { gunzip } from "zlib";
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { writeFile } from "fs/promises";
+
+(async () => {
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const buf = await (await fetch('https://github.com/intoli/user-agents/blob/master/src/user-agents.json.gz?raw=true')).arrayBuffer();
+const bytes = new Uint8Array(buf);
+
+// Only get desktop and mobile agents
+const allowed_agents = new Set([
+    'desktop',
+    'mobile',
+])
+
+const decompressed = await new Promise((resolve, reject) => {
+    gunzip(bytes, (err, result) => {
+        if (err) {
+            reject(err);
+        } else {
+            resolve(result.buffer);
+        }
+    });
+});
+
+const contents = new TextDecoder().decode(decompressed);
+
+const agents = JSON.parse(contents);
+
+if (!Array.isArray(agents)) {
+    throw new Error('Invalid user-agents.json');
+}
+
+const agentsByDevice = agents.reduce((acc, agent) => {
+    const device = agent.deviceCategory;
+    if (!allowed_agents.has(device)) 
+        return acc;
+    if (!acc[device]) {
+        acc[device] = [];
+    }
+    // we dont want to massive of a list of agents for each device
+    if (acc[device].length <= 25) acc[device].push(agent.userAgent);
+    return acc;
+}, {});
+
+await writeFile(resolve(__dirname, '..', 'src', 'utils', 'user-agents.json'), JSON.stringify(agentsByDevice, null, 2));
+
+})();

src/Innertube.ts

@@ -0,0 +1,255 @@
+
+import Session, { SessionOptions } from './core/Session';
+
+import Search from './parser/youtube/Search';
+import Channel from './parser/youtube/Channel';
+import Playlist from './parser/youtube/Playlist';
+import Library from './parser/youtube/Library';
+import History from './parser/youtube/History';
+import Comments from './parser/youtube/Comments';
+import NotificationsMenu from './parser/youtube/NotificationsMenu';
+import VideoInfo, { DownloadOptions, FormatOptions } from './parser/youtube/VideoInfo';
+import NavigationEndpoint from './parser/classes/NavigationEndpoint';
+
+import { ParsedResponse } from './parser';
+import { ActionsResponse } from './core/Actions';
+
+import Feed from './core/Feed';
+import YTMusic from './core/Music';
+import Studio from './core/Studio';
+import AccountManager from './core/AccountManager';
+import PlaylistManager from './core/PlaylistManager';
+import InteractionManager from './core/InteractionManager';
+import FilterableFeed from './core/FilterableFeed';
+import TabbedFeed from './core/TabbedFeed';
+import Constants from './utils/Constants';
+import Proto from './proto/index';
+
+import { throwIfMissing, generateRandomString } from './utils/Utils';
+
+export type InnertubeConfig = SessionOptions
+
+export interface SearchFilters {
+  /**
+   * Filter videos by upload date, can be: any | last_hour | today | this_week | this_month | this_year
+   */
+  upload_date?: 'any' | 'last_hour' | 'today' | 'this_week' | 'this_month' | 'this_year';
+  /**
+   * Filter results by type, can be: any | video | channel | playlist | movie
+   */
+  type?: 'any' | 'video' | 'channel' | 'playlist' | 'movie';
+  /**
+   * Filter videos by duration, can be: any | short | medium | long
+   */
+  duration?: 'any' | 'short' | 'medium' | 'long';
+  /**
+   * Filter video results by order, can be: relevance | rating | upload_date | view_count
+   */
+  sort_by?: 'relevance' | 'rating' | 'upload_date' | 'view_count';
+}
+
+export type InnerTubeClient = 'ANDROID' | 'YTMUSIC_ANDROID' | 'WEB' | 'YTMUSIC';
+
+class Innertube {
+  session;
+  account;
+  playlist;
+  interact;
+  music;
+  studio;
+  actions;
+
+  constructor(session: Session) {
+    this.session = session;
+    this.account = new AccountManager(this.session.actions);
+    this.playlist = new PlaylistManager(this.session.actions);
+    this.interact = new InteractionManager(this.session.actions);
+    this.music = new YTMusic(this.session);
+    this.studio = new Studio(this.session);
+    this.actions = this.session.actions;
+  }
+
+  static async create(config: InnertubeConfig = {}) {
+    return new Innertube(await Session.create(config));
+  }
+
+  /**
+   * Retrieves video info.
+   */
+  async getInfo(video_id: string, client?: InnerTubeClient) {
+    const cpn = generateRandomString(16);
+
+    const initial_info = await this.actions.getVideoInfo(video_id, cpn, client);
+    const continuation = this.actions.next({ video_id });
+
+    const response = await Promise.all([ initial_info, continuation ]);
+    return new VideoInfo(response, this.actions, this.session.player, cpn);
+  }
+
+  /**
+   * Retrieves basic video info.
+   */
+  async getBasicInfo(video_id: string, client?: InnerTubeClient) {
+    const cpn = generateRandomString(16);
+    const response = await this.actions.getVideoInfo(video_id, cpn, client);
+
+    return new VideoInfo([ response ], this.actions, this.session.player, cpn);
+  }
+
+  /**
+   * Searches a given query.
+   * @param query - search query.
+   * @param filters - search filters.
+   */
+  async search(query: string, filters: SearchFilters = {}) {
+    throwIfMissing({ query });
+    const response = await this.actions.search({ query, filters });
+    return new Search(this.actions, response.data);
+  }
+
+  /**
+   * Retrieves search suggestions for a given query.
+   * @param query - the search query.
+   */
+  async getSearchSuggestions(query: string): Promise<string[]> {
+    throwIfMissing({ query });
+
+    const url = new URL(`${Constants.URLS.YT_SUGGESTIONS}search`);
+    url.searchParams.set('q', query);
+    url.searchParams.set('hl', this.session.context.client.hl);
+    url.searchParams.set('gl', this.session.context.client.gl);
+    url.searchParams.set('ds', 'yt');
+    url.searchParams.set('client', 'youtube');
+    url.searchParams.set('xssi', 't');
+    url.searchParams.set('oe', 'UTF');
+
+    const response = await this.session.http.fetch(url);
+    const response_data = await response.text();
+
+    const data = JSON.parse(response_data.replace(')]}\'', ''));
+    const suggestions = data[1].map((suggestion: any) => suggestion[0]);
+
+    return suggestions;
+  }
+
+  /**
+   * Retrieves comments for a video.
+   * @param video_id - the video id.
+   * @param sort_by - can be: `TOP_COMMENTS` or `NEWEST_FIRST`.
+   */
+  async getComments(video_id: string, sort_by?: 'TOP_COMMENTS' | 'NEWEST_FIRST') {
+    throwIfMissing({ video_id });
+
+    const payload = Proto.encodeCommentsSectionParams(video_id, {
+      sort_by: sort_by || 'TOP_COMMENTS'
+    });
+
+    const response = await this.actions.next({ ctoken: payload });
+    return new Comments(this.actions, response.data);
+  }
+
+  /**
+   * Retrieves YouTube's home feed (aka recommendations).
+   */
+  async getHomeFeed() {
+    const response = await this.actions.browse('FEwhat_to_watch');
+    return new FilterableFeed(this.actions, response.data);
+  }
+
+  /**
+   * Returns the account's library.
+   */
+  async getLibrary() {
+    const response = await this.actions.browse('FElibrary');
+    return new Library(response.data, this.actions);
+  }
+
+  /**
+   * Retrieves watch history.
+   * Which can also be achieved with {@link getLibrary}.
+   */
+  async getHistory() {
+    const response = await this.actions.browse('FEhistory');
+    return new History(this.actions, response.data);
+  }
+
+  /**
+   * Retrieves trending content.
+   */
+  async getTrending() {
+    const response = await this.actions.browse('FEtrending');
+    return new TabbedFeed(this.actions, response.data);
+  }
+
+  /**
+   * Retrieves subscriptions feed.
+   */
+  async getSubscriptionsFeed() {
+    const response = await this.actions.browse('FEsubscriptions');
+    return new Feed(this.actions, response.data);
+  }
+
+  /**
+   * Retrieves contents for a given channel.
+   * @param id - channel id
+   */
+  async getChannel(id: string) {
+    throwIfMissing({ id });
+    const response = await this.actions.browse(id);
+    return new Channel(this.actions, response.data);
+  }
+
+  /**
+   * Retrieves notifications.
+   */
+  async getNotifications() {
+    const response = await this.actions.notifications('get_notification_menu');
+    return new NotificationsMenu(this.actions, response);
+  }
+
+  /**
+   * Retrieves unseen notifications count.
+   */
+  async getUnseenNotificationsCount() {
+    const response = await this.actions.notifications('get_unseen_count');
+    return response.data.unseenCount;
+  }
+
+  /**
+   * Retrieves playlist contents.
+   */
+  async getPlaylist(id: string) {
+    throwIfMissing({ id });
+    const response = await this.actions.browse(`VL${id.replace(/VL/g, '')}`);
+    return new Playlist(this.actions, response.data);
+  }
+
+  /**
+   * An alternative to {@link download}.
+   * Returns deciphered streaming data.
+   *
+   * If you wish to retrieve the video info too, have a look at {@link getBasicInfo} or {@link getInfo}.
+   */
+  async getStreamingData(video_id: string, options: FormatOptions = {}) {
+    const info = await this.getBasicInfo(video_id);
+    return info.chooseFormat(options);
+  }
+
+  /**
+   * Downloads a given video. If you only need the direct download link see {@link getStreamingData}.
+   *
+   * If you wish to retrieve the video info too, have a look at {@link getBasicInfo} or {@link getInfo}.
+   */
+  async download(video_id: string, options?: DownloadOptions) {
+    const info = await this.getBasicInfo(video_id, options?.client);
+    return info.download(options);
+  }
+
+  call(endpoint: NavigationEndpoint, args: { [ key: string ]: any; parse: true }): Promise<ParsedResponse>;
+  call(endpoint: NavigationEndpoint, args?: { [ key: string ]: any; parse?: false }): Promise<ActionsResponse>;
+  call(endpoint: NavigationEndpoint, args?: object): Promise<ActionsResponse | ParsedResponse> {
+    return endpoint.callTest(this.actions, args);
+  }
+}
+
+export default Innertube;

src/core/AccountManager.ts

@@ -0,0 +1,77 @@
+import Proto from '../proto/index';
+import Actions from './Actions';
+
+import Analytics from '../parser/youtube/Analytics';
+import TimeWatched from '../parser/youtube/TimeWatched';
+import AccountInfo from '../parser/youtube/AccountInfo';
+import Settings from '../parser/youtube/Settings';
+
+class AccountManager {
+  #actions;
+  channel;
+
+  constructor(actions: Actions) {
+    this.#actions = actions;
+
+    this.channel = {
+      /**
+       * Edits channel name.
+       */
+      editName: (new_name: string) => this.#actions.channel('channel/edit_name', { new_name }),
+      /**
+       * Edits channel description.
+       *
+       */
+      editDescription: (new_description: string) => this.#actions.channel('channel/edit_description', { new_description }),
+      /**
+       * Retrieves basic channel analytics.
+       */
+      getBasicAnalytics: () => this.getAnalytics()
+    };
+  }
+
+  /**
+   * Retrieves channel info.
+   */
+  async getInfo() {
+    const response = await this.#actions.execute('/account/accounts_list', { client: 'ANDROID' });
+    return new AccountInfo(response);
+  }
+
+  /**
+   * Retrieves time watched statistics.
+   */
+  async getTimeWatched() {
+    const response = await this.#actions.execute('/browse', {
+      browseId: 'SPtime_watched',
+      client: 'ANDROID'
+    });
+
+    return new TimeWatched(response);
+  }
+
+  /**
+   * Opens YouTube settings.
+   */
+  async getSettings() {
+    const response = await this.#actions.execute('/browse', {
+      browseId: 'SPaccount_overview'
+    });
+
+    return new Settings(this.#actions, response);
+  }
+
+  /**
+   * Retrieves basic channel analytics.
+   */
+  async getAnalytics() {
+    const info = await this.getInfo();
+
+    const params = Proto.encodeChannelAnalyticsParams(info.footers?.endpoint.payload.browseId);
+    const response = await this.#actions.browse('FEanalytics_screen', { params, client: 'ANDROID' });
+
+    return new Analytics(response);
+  }
+}
+
+export default AccountManager;

src/core/Actions.ts

@@ -0,0 +1,783 @@
+import Proto from '../proto/index';
+import Session from './Session';
+
+import Parser, { ParsedResponse } from '../parser/index';
+
+import { hasKeys, InnertubeError, MissingParamError, uuidv4 } from '../utils/Utils';
+
+export interface BrowseArgs {
+  params?: string | null;
+  is_ytm?: boolean;
+  is_ctoken?: boolean;
+  form_data?: {};
+  client?: string;
+}
+
+export interface EngageArgs {
+  video_id?: string;
+  channel_id?: string;
+  comment_id?: string;
+  comment_action?: string;
+  params?: string;
+  text?: string;
+  target_language?: string;
+}
+
+export interface AccountArgs {
+  new_value?: string | boolean; // TODO: is this correct?
+  setting_item_id?: string;
+  client?: string;
+}
+
+export interface SearchArgs {
+  query?: string,
+  options?: {
+    period?: string,
+    duration?: string,
+    order?: string
+  },
+  client?: string,
+  ctoken?: string,
+  params?: string
+  filters?: any // TODO: what is this type??
+}
+
+export interface AxioslikeResponse {
+  success: boolean;
+  status_code: number;
+  data: any;
+}
+
+export type ActionsResponse = Promise<AxioslikeResponse>;
+
+class Actions {
+  #session;
+
+  constructor(session: Session) {
+    this.#session = session;
+  }
+
+  get session() {
+    return this.#session;
+  }
+
+  /**
+   * Mimmics the Axios API using Fetch's Response object.
+   */
+  async #wrap(response: Response, protobuf?: boolean) {
+    return {
+      success: response.ok,
+      status_code: response.status,
+      data: protobuf ? await response.text() : JSON.parse(await response.text())
+    };
+  }
+
+  /**
+   * Covers `/browse` endpoint, mostly used to access
+   * YouTube's sections such as the home feed, etc
+   * and sometimes to retrieve continuations.
+   *
+   * @param id - browseId or a continuation token
+   * @param args - additional arguments
+   */
+  async browse(id: string, args: BrowseArgs = {}) {
+    if (this.#needsLogin(id) && !this.#session.logged_in)
+      throw new InnertubeError('You are not signed in');
+
+    const data: Record<string, any> = {};
+
+    if (args.params)
+      data.params = args.params;
+
+    if (args.is_ctoken) {
+      data.continuation = id;
+    } else {
+      data.browseId = id;
+    }
+
+    if (args.form_data) {
+      data.formData = args.form_data;
+    }
+
+    if (args.client) {
+      data.client = args.client;
+    }
+
+    const response = await this.#session.http.fetch('/browse', {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Covers endpoints used to perform direct interactions
+   * on YouTube.
+   */
+  async engage(action: string, args: EngageArgs = {}) {
+    if (!this.#session.logged_in && !args.hasOwnProperty('text'))
+      throw new InnertubeError('You are not signed in');
+
+    const data: Record<string, any> = {};
+
+    switch (action) {
+      case 'like/like':
+      case 'like/dislike':
+      case 'like/removelike':
+        if (!hasKeys(args, 'video_id'))
+          throw new MissingParamError('Arguments lacks video_id');
+
+        data.target = {};
+        data.target.videoId = args.video_id;
+
+        if (args.params) {
+          data.params = args.params;
+        }
+        break;
+      case 'subscription/subscribe':
+      case 'subscription/unsubscribe':
+        if (!hasKeys(args, 'channel_id'))
+          throw new MissingParamError('Arguments lacks channel_id');
+
+        data.channelIds = [ args.channel_id ];
+        data.params = action === 'subscription/subscribe' ? 'EgIIAhgA' : 'CgIIAhgA';
+        break;
+      case 'comment/create_comment':
+        data.commentText = args.text;
+
+        if (!hasKeys(args, 'video_id'))
+          throw new MissingParamError('Arguments lacks video_id');
+
+        data.createCommentParams = Proto.encodeCommentParams(args.video_id);
+        break;
+      case 'comment/create_comment_reply':
+        if (!hasKeys(args, 'comment_id', 'video_id', 'text'))
+          throw new MissingParamError('Arguments lacks comment_id, video_id or text');
+
+        data.createReplyParams = Proto.encodeCommentReplyParams(args.comment_id, args.video_id);
+        data.commentText = args.text;
+        break;
+      case 'comment/perform_comment_action':
+        const target_action = (() => {
+          switch (args.comment_action) {
+            case 'like':
+              return Proto.encodeCommentActionParams(5, args);
+            case 'dislike':
+              return Proto.encodeCommentActionParams(4, args);
+            case 'translate':
+              return Proto.encodeCommentActionParams(22, args);
+            default:
+              break;
+          }
+        })();
+        data.actions = [ target_action ];
+        break;
+      default:
+        throw new InnertubeError('Action not implemented', action);
+    }
+
+    const response = await this.#session.http.fetch(`/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Covers endpoints related to account management.
+   */
+  async account(action: string, args: AccountArgs = {}) {
+    if (!this.#session.logged_in)
+      throw new InnertubeError('You are not signed in');
+
+    const data: Record<string, any> = { client: args.client };
+
+    switch (action) {
+      case 'account/set_setting':
+        data.newValue = {
+          boolValue: args.new_value
+        };
+        data.settingItemId = args.setting_item_id;
+        break;
+      case 'account/accounts_list':
+        break;
+      default:
+        throw new InnertubeError('Action not implemented', action);
+    }
+
+    const response = await this.#session.http.fetch(`/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Endpoint used for search.
+   */
+  async search(args: SearchArgs = {}) {
+    const data: Record<string, any> = { client: args.client };
+
+    if (args.query) {
+      data.query = args.query;
+    }
+
+    if (args.ctoken) {
+      data.continuation = args.ctoken;
+    }
+
+    if (args.params) {
+      data.params = args.params;
+    }
+
+    if (args.filters) {
+      if (args.client == 'YTMUSIC' && args.filters?.type && args.filters.type !== 'all') {
+        data.params = Proto.encodeMusicSearchFilters(args.filters);
+      } else {
+        data.params = Proto.encodeSearchFilters(args.filters);
+      }
+    }
+
+    const response = await this.#session.http.fetch('/search', {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Endpoint used fo Shorts' sound search.
+   */
+  async searchSound(args: { query: string; }) {
+    const data = {
+      query: args.query,
+      client: 'ANDROID'
+    };
+
+    const response = await this.#session.http.fetch('/sfv/search', {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Channel management endpoints.
+   */
+  async channel(action: string, args: { new_name?: string; new_description?: string; client?: string; } = {}) {
+    if (!this.#session.logged_in)
+      throw new InnertubeError('You are not signed in');
+
+    const data: Record<string, any> = { client: args.client || 'ANDROID' };
+
+    switch (action) {
+      case 'channel/edit_name':
+        data.givenName = args.new_name;
+        break;
+      case 'channel/edit_description':
+        data.description = args.new_description;
+        break;
+      case 'channel/get_profile_editor':
+        break;
+      default:
+        throw new InnertubeError('Action not implemented', action);
+    }
+
+    const response = await this.#session.http.fetch(`/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Covers endpoints used for playlist management.
+   */
+  async playlist(action: string, args: {
+    title?: string;
+    ids?: string[];
+    playlist_id?: string;
+    action?: string;
+  } = {}) {
+    if (!this.#session.logged_in)
+      throw new InnertubeError('You are not signed in');
+
+    const data: Record<string, any> = {};
+
+    switch (action) {
+      case 'playlist/create':
+        data.title = args.title;
+        data.videoIds = args.ids;
+        break;
+      case 'playlist/delete':
+        data.playlistId = args.playlist_id;
+        break;
+      case 'browse/edit_playlist':
+        if (!hasKeys(args, 'ids'))
+          throw new MissingParamError('Arguments lacks ids');
+        data.playlistId = args.playlist_id;
+        data.actions = args.ids.map((id) => {
+          switch (args.action) {
+            case 'ACTION_ADD_VIDEO':
+              return {
+                action: args.action,
+                addedVideoId: id
+              };
+            case 'ACTION_REMOVE_VIDEO':
+              return {
+                action: args.action,
+                setVideoId: id
+              };
+            default:
+              break;
+          }
+        });
+        break;
+      default:
+        throw new InnertubeError('Action not implemented', action);
+    }
+
+    const response = await this.#session.http.fetch(`/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Covers endpoints used for notifications management.
+   */
+  async notifications(action: string, args: {
+    pref?: string;
+    channel_id?: string;
+    ctoken?: string;
+    params?: string
+  } = {}) {
+    if (!this.#session.logged_in)
+      throw new InnertubeError('You are not signed in');
+
+    const data: Record<string, any> = {};
+
+    switch (action) {
+      case 'modify_channel_preference':
+        if (!hasKeys(args, 'channel_id', 'pref'))
+          throw new MissingParamError('Arguments lacks channel_id or pref');
+        const pref_types = {
+          PERSONALIZED: 1,
+          ALL: 2,
+          NONE: 3
+        };
+        if (!Object.keys(pref_types).includes(args.pref.toUpperCase()))
+          throw new InnertubeError('Invalid preference type', args.pref);
+        data.params = Proto.encodeNotificationPref(args.channel_id, pref_types[args.pref.toUpperCase() as keyof typeof pref_types]);
+        break;
+      case 'get_notification_menu':
+        data.notificationsMenuRequestType = 'NOTIFICATIONS_MENU_REQUEST_TYPE_INBOX';
+        if (args.ctoken)
+          data.ctoken = args.ctoken;
+        break;
+      case 'record_interactions':
+        data.serializedRecordNotificationInteractionsRequest = args.params;
+        break;
+      case 'get_unseen_count':
+        break;
+      default:
+        throw new InnertubeError('Action not implemented', action);
+    }
+
+    const response = await this.#session.http.fetch(`/notification/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Covers livechat endpoints.
+   */
+  async livechat(action: string, args: {
+    text?: string;
+    video_id?: string;
+    channel_id?: string;
+    ctoken?: string;
+    params?: string;
+    client?: string;
+  } = {}) {
+    // TODO: should client be required?
+    const data: Record<string, any> = { client: args.client };
+
+    switch (action) {
+      case 'live_chat/get_live_chat':
+      case 'live_chat/get_live_chat_replay':
+        data.continuation = args.ctoken;
+        break;
+      case 'live_chat/send_message':
+        if (!hasKeys(args, 'channel_id', 'video_id', 'text'))
+          throw new MissingParamError('Arguments lacks channel_id, video_id or text');
+        data.params = Proto.encodeMessageParams(args.channel_id, args.video_id);
+        data.clientMessageId = uuidv4();
+        data.richMessage = {
+          textSegments: [ {
+            text: args.text
+          } ]
+        };
+        break;
+      case 'live_chat/get_item_context_menu':
+        // Note: this is currently broken due to a recent refactor
+        // TODO: this should be implemented
+        break;
+      case 'live_chat/moderate':
+        data.params = args.params;
+        break;
+      case 'updated_metadata':
+        data.videoId = args.video_id;
+        if (args.ctoken)
+          data.continuation = args.ctoken;
+        break;
+      default:
+        throw new InnertubeError('Action not implemented', action);
+    }
+
+    const response = await this.#session.http.fetch(`/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Endpoint used to retrieve video thumbnails.
+   */
+  async thumbnails(args: { video_id: string; }) {
+    const data = {
+      client: 'ANDROID',
+      videoId: args.video_id
+    };
+
+    const response = await this.#session.http.fetch('/thumbnails', {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Place Autocomplete endpoint, found it in the APK but
+   * doesn't seem to be used anywhere on YouTube (maybe for ads?).
+   *
+   * Ex:
+   * ```js
+   * const places = await session.actions.geo('place_autocomplete', { input: 'San diego cafe' });
+   * console.info(places.data);
+   * ```
+   */
+  async geo(action: string, args: { input: string; }) {
+    if (!this.#session.logged_in)
+      throw new InnertubeError('You are not signed in');
+
+    const data = {
+      input: args.input,
+      client: 'ANDROID'
+    };
+
+    const response = await this.#session.http.fetch(`/geo/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Covers endpoints used to report content.
+   */
+  async flag(action: string, args: { action: string; params?: string; }) {
+    if (!this.#session.logged_in)
+      throw new InnertubeError('You are not signed in');
+
+    const data: Record<string, any> = {};
+
+    switch (action) {
+      case 'flag/flag':
+        data.action = args.action;
+        break;
+      case 'flag/get_form':
+        data.params = args.params;
+        break;
+      default:
+        throw new InnertubeError('Action not implemented', action);
+    }
+
+    const response = await this.#session.http.fetch(`/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Covers specific YouTube Music endpoints.
+   */
+  async music(action: string, args: { input?: string; }) {
+    const data = {
+      input: args.input || '',
+      client: 'YTMUSIC'
+    };
+
+    const response = await this.#session.http.fetch(`/music/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Mostly used for pagination and specific operations.
+   */
+  async next(args: { video_id?: string; ctoken?: string; client?: string; playlist_id?: string; params?: string } = {}) {
+    const data: Record<string, any> = { client: args.client };
+
+    if (args.ctoken) {
+      data.continuation = args.ctoken;
+    }
+
+    if (args.video_id) {
+      data.videoId = args.video_id;
+    }
+
+    if (args.playlist_id) {
+      data.playlistId = args.playlist_id;
+    }
+
+    if (args.params) {
+      data.params = args.params;
+    }
+
+    const response = await this.#session.http.fetch('/next', {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Used to retrieve video info.
+   */
+  async getVideoInfo(id: string, cpn?: string, client?: string) {
+    const data: Record<string, any> = {
+      playbackContext: {
+        contentPlaybackContext: {
+          vis: 0,
+          splay: false,
+          referer: 'https://www.youtube.com',
+          currentUrl: `/watch?v=${id}`,
+          autonavState: 'STATE_OFF',
+          signatureTimestamp: this.#session.player.sts,
+          autoCaptionsDefaultOn: false,
+          html5Preference: 'HTML5_PREF_WANTS',
+          lactMilliseconds: '-1'
+        }
+      },
+      attestationRequest: {
+        omitBotguardData: true
+      },
+      videoId: id
+    };
+
+    if (client) {
+      data.client = client;
+    }
+
+    if (cpn) {
+      data.cpn = cpn;
+    }
+
+    const response = await this.#session.http.fetch('/player', {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Endpoint used to retrieve user mention suggestions.
+   */
+  async getUserMentionSuggestions(args: { input: string; }) {
+    if (!this.#session.logged_in)
+      throw new InnertubeError('You are not signed in');
+
+    const data = {
+      input: args.input,
+      client: 'ANDROID'
+    };
+
+    const response = await this.#session.http.fetch('/get_user_mention_suggestions', {
+      method: 'POST',
+      body: JSON.stringify(data),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    return this.#wrap(response);
+  }
+
+  /**
+   * Makes calls to the playback tracking API.
+   */
+  async stats(url: string, client: { client_name: string; client_version: string }, params: { [key: string]: any }) {
+    const s_url = new URL(url);
+
+    s_url.searchParams.set('ver', '2');
+    s_url.searchParams.set('c', client.client_name.toLowerCase());
+    s_url.searchParams.set('cbrver', client.client_version);
+    s_url.searchParams.set('cver', client.client_version);
+
+    for (const key of Object.keys(params)) {
+      s_url.searchParams.set(key, params[key]);
+    }
+
+    const response = await this.#session.http.fetch(s_url);
+
+    return response;
+  }
+
+  /**
+   * Executes an API call.
+   * @param action - endpoint
+   * @param args - call arguments
+   */
+  async execute(action: string, args: { [key: string]: any; parse: true; protobuf?: false; serialized_data?: any }) : Promise<ParsedResponse>;
+  async execute(action: string, args: { [key: string]: any; parse?: false; protobuf?: true; serialized_data?: any }) : Promise<ActionsResponse>;
+  async execute(action: string, args: { [key: string]: any; parse?: boolean; protobuf?: boolean; serialized_data?: any }): Promise<ParsedResponse | ActionsResponse> {
+    let data;
+
+    if (!args.protobuf) {
+      data = { ...args };
+
+      if (Reflect.has(data, 'browseId')) {
+        if (this.#needsLogin(data.browseId) && !this.#session.logged_in)
+          throw new InnertubeError('You are not signed in');
+      }
+
+      if (Reflect.has(data, 'parse'))
+        delete data.parse;
+
+      if (Reflect.has(data, 'request'))
+        delete data.request;
+
+      if (Reflect.has(data, 'clientActions'))
+        delete data.clientActions;
+
+      if (Reflect.has(data, 'settingItemIdForClient'))
+        delete data.settingItemIdForClient;
+
+      if (Reflect.has(data, 'action')) {
+        data.actions = [ data.action ];
+        delete data.action;
+      }
+
+      if (Reflect.has(data, 'boolValue')) {
+        data.newValue = { boolValue: data.boolValue };
+        delete data.boolValue;
+      }
+
+      if (Reflect.has(data, 'token')) {
+        data.continuation = data.token;
+        delete data.token;
+      }
+    } else {
+      data = args.serialized_data;
+    }
+
+    const response = await this.#session.http.fetch(action, {
+      method: 'POST',
+      body: args.protobuf ? data : JSON.stringify(data),
+      headers: {
+        'Content-Type': args.protobuf ?
+          'application/x-protobuf' :
+          'application/json'
+      }
+    });
+
+    if (args.parse) {
+      return Parser.parseResponse(await response.json());
+    }
+
+    return this.#wrap(response, args.protobuf);
+  }
+
+  #needsLogin(id: string) {
+    return [
+      'FElibrary',
+      'FEhistory',
+      'FEsubscriptions',
+      'FEmusic_listening_review',
+      'SPaccount_notifications',
+      'SPaccount_privacy',
+      'SPtime_watched'
+    ].includes(id);
+  }
+}
+
+// TODO: maybe do this inferrance in a more elegant way
+export default Actions;

src/core/Feed.ts

@@ -0,0 +1,206 @@
+import Parser, { ParsedResponse, ReloadContinuationItemsCommand } from '../parser/index';
+import { Memo, ObservedArray } from '../parser/helpers';
+import { InnertubeError } from '../utils/Utils';
+import Actions from './Actions';
+
+import Post from '../parser/classes/Post';
+import BackstagePost from '../parser/classes/BackstagePost';
+
+import Channel from '../parser/classes/Channel';
+import CompactVideo from '../parser/classes/CompactVideo';
+
+import GridChannel from '../parser/classes/GridChannel';
+import GridPlaylist from '../parser/classes/GridPlaylist';
+import GridVideo from '../parser/classes/GridVideo';
+
+import Playlist from '../parser/classes/Playlist';
+import PlaylistPanelVideo from '../parser/classes/PlaylistPanelVideo';
+import PlaylistVideo from '../parser/classes/PlaylistVideo';
+
+import Tab from '../parser/classes/Tab';
+import ReelShelf from '../parser/classes/ReelShelf';
+import RichShelf from '../parser/classes/RichShelf';
+import Shelf from '../parser/classes/Shelf';
+
+import TwoColumnBrowseResults from '../parser/classes/TwoColumnBrowseResults';
+import TwoColumnSearchResults from '../parser/classes/TwoColumnSearchResults';
+import WatchCardCompactVideo from '../parser/classes/WatchCardCompactVideo';
+import AppendContinuationItemsAction from '../parser/classes/actions/AppendContinuationItemsAction';
+import ContinuationItem from '../parser/classes/ContinuationItem';
+
+import Video from '../parser/classes/Video';
+
+// TODO: add a way subdivide into sections and return subfeeds?
+class Feed {
+  #page: ParsedResponse;
+  #continuation?: ObservedArray<ContinuationItem>;
+  #actions;
+  #memo;
+
+  constructor(actions: Actions, data: any, already_parsed = false) {
+    if (data.on_response_received_actions || data.on_response_received_endpoints || already_parsed) {
+      this.#page = data;
+    } else {
+      this.#page = Parser.parseResponse(data);
+    }
+
+    // Xxx: this can be extremely confusing — maybe refactor?
+    const memo =
+            this.#page.on_response_received_commands ?
+              this.#page.on_response_received_commands_memo :
+              this.#page.on_response_received_endpoints ?
+                this.#page.on_response_received_endpoints_memo :
+                this.#page.contents ?
+                  this.#page.contents_memo :
+                  this.#page.on_response_received_actions ?
+                    this.#page.on_response_received_actions_memo : undefined;
+
+    if (!memo)
+      throw new InnertubeError('No memo found in feed');
+
+    this.#memo = memo;
+    this.#actions = actions;
+  }
+
+  /**
+   * Get all videos on a given page via memo
+   */
+  static getVideosFromMemo(memo: Memo) {
+    return memo.getType<Video | GridVideo | CompactVideo | PlaylistVideo | PlaylistPanelVideo | WatchCardCompactVideo>([
+      Video,
+      GridVideo,
+      CompactVideo,
+      PlaylistVideo,
+      PlaylistPanelVideo,
+      WatchCardCompactVideo
+    ]);
+  }
+
+  /**
+   * Get all playlists on a given page via memo
+   */
+  static getPlaylistsFromMemo(memo: Memo) {
+    return memo.getType<Playlist | GridPlaylist>([ Playlist, GridPlaylist ]);
+  }
+
+  /**
+   * Get all the videos in the feed
+   */
+  get videos() {
+    return Feed.getVideosFromMemo(this.#memo);
+  }
+
+  /**
+   * Get all the community posts in the feed
+   */
+  get posts() {
+    return this.#memo.getType<Post | BackstagePost>([ BackstagePost, Post ]);
+  }
+
+  /**
+   * Get all the channels in the feed
+   */
+  get channels() {
+    return this.#memo.getType<Channel | GridChannel>([ Channel, GridChannel ]);
+  }
+
+  /**
+   * Get all playlists in the feed
+   */
+  get playlists() {
+    return Feed.getPlaylistsFromMemo(this.#memo);
+  }
+
+  get memo() {
+    return this.#memo;
+  }
+
+  /**
+   * Returns contents from the page.
+   */
+  get contents() {
+    const tab_content = this.#memo.getType(Tab)?.[0]?.content;
+    const reload_continuation_items = this.#memo.getType(ReloadContinuationItemsCommand)?.[0];
+    const append_continuation_items = this.#memo.getType(AppendContinuationItemsAction)?.[0];
+
+    return tab_content || reload_continuation_items || append_continuation_items;
+  }
+
+  /**
+   * Returns all segments/sections from the page.
+   */
+  get shelves() {
+    return this.#memo.getType<Shelf | RichShelf | ReelShelf>([ Shelf, RichShelf, ReelShelf ]);
+  }
+
+  /**
+   * Finds shelf by title.
+   */
+  getShelf(title: string) {
+    return this.shelves.find((shelf) => shelf.title.toString() === title);
+  }
+
+  /**
+   * Returns secondary contents from the page.
+   */
+  get secondary_contents() {
+    if (!this.#page.contents.is_node)
+      return undefined;
+
+    const node = this.#page.contents.item();
+
+    if (!node.is(TwoColumnBrowseResults, TwoColumnSearchResults))
+      return undefined;
+
+    return node.secondary_contents;
+  }
+
+  get actions() {
+    return this.#actions;
+  }
+
+  /**
+   * Get the original page data
+   */
+  get page() {
+    return this.#page;
+  }
+
+  /**
+   * Checks if the feed has continuation.
+   */
+  get has_continuation() {
+    return (this.#memo.get('ContinuationItem') || []).length > 0;
+  }
+
+  /**
+   * Retrieves continuation data as it is.
+   */
+  async getContinuationData(): Promise<ParsedResponse | undefined> {
+    if (this.#continuation) {
+      if (this.#continuation.length > 1)
+        throw new InnertubeError('There are too many continuations, you\'ll need to find the correct one yourself in this.page');
+      if (this.#continuation.length === 0)
+        throw new InnertubeError('There are no continuations');
+
+      const response = await this.#continuation[0].endpoint.call(this.#actions, undefined, true);
+
+      return response;
+    }
+
+    this.#continuation = this.#memo.getType(ContinuationItem);
+
+    if (this.#continuation)
+      return this.getContinuationData();
+  }
+
+  /**
+   * Retrieves next batch of contents and returns a new {@link Feed} object.
+   */
+  async getContinuation() {
+    const continuation_data = await this.getContinuationData();
+    return new Feed(this.actions, continuation_data, true);
+  }
+}
+
+export default Feed;

src/core/FilterableFeed.ts

@@ -0,0 +1,65 @@
+import ChipCloudChip from '../parser/classes/ChipCloudChip';
+import FeedFilterChipBar from '../parser/classes/FeedFilterChipBar';
+import { ObservedArray } from '../parser/helpers';
+import { InnertubeError } from '../utils/Utils';
+import Actions from './Actions';
+import Feed from './Feed';
+
+class FilterableFeed extends Feed {
+  #chips?: ObservedArray<ChipCloudChip>;
+
+  constructor(actions: Actions, data: any, already_parsed = false) {
+    super(actions, data, already_parsed);
+  }
+
+  /**
+   * Get filters for the feed
+   */
+  get filter_chips() {
+    if (this.#chips)
+      return this.#chips || [];
+
+    if (this.memo.getType(FeedFilterChipBar)?.length > 1)
+      throw new InnertubeError('There are too many feed filter chipbars, you\'ll need to find the correct one yourself in this.page');
+
+    if (this.memo.getType(FeedFilterChipBar)?.length === 0)
+      throw new InnertubeError('There are no feed filter chipbars');
+
+    this.#chips = this.memo.getType(ChipCloudChip);
+
+    return this.#chips || [];
+  }
+
+  get filters() {
+    return this.filter_chips.map((chip) => chip.text.toString()) || [];
+  }
+
+  /**
+   * Applies given filter and returns a new {@link Feed} object.
+   */
+  async getFilteredFeed(filter: string | ChipCloudChip) {
+    let target_filter: ChipCloudChip | undefined;
+
+    if (typeof filter === 'string') {
+      if (!this.filters.includes(filter))
+        throw new InnertubeError('Filter not found', {
+          available_filters: this.filters
+        });
+      target_filter = this.filter_chips.find((chip) => chip.text.toString() === filter);
+    } else if (filter.type === 'ChipCloudChip') {
+      target_filter = filter;
+    } else {
+      throw new InnertubeError('Invalid filter');
+    }
+
+    if (!target_filter)
+      throw new InnertubeError('Filter not found');
+    if (target_filter.is_selected)
+      return this;
+
+    const response = await target_filter.endpoint?.call(this.actions, undefined, true);
+    return new Feed(this.actions, response, true);
+  }
+}
+
+export default FilterableFeed;

src/core/InteractionManager.ts

@@ -0,0 +1,103 @@
+import { throwIfMissing } from '../utils/Utils';
+import Actions from './Actions';
+
+class InteractionManager {
+  #actions;
+
+  constructor(actions: Actions) {
+    this.#actions = actions;
+  }
+
+  /**
+   * Likes a given video.
+   */
+  async like(video_id: string) {
+    throwIfMissing({ video_id });
+    const action = await this.#actions.engage('like/like', { video_id });
+    return action;
+  }
+
+  /**
+   * Dislikes a given video.
+   */
+  async dislike(video_id: string) {
+    throwIfMissing({ video_id });
+    const action = await this.#actions.engage('like/dislike', { video_id });
+    return action;
+  }
+
+  /**
+   * Removes a like/dislike.
+   */
+  async removeLike(video_id: string) {
+    throwIfMissing({ video_id });
+    const action = await this.#actions.engage('like/removelike', { video_id });
+    return action;
+  }
+
+  /**
+   * Subscribes to a given channel.
+   */
+  async subscribe(channel_id: string) {
+    throwIfMissing({ channel_id });
+    const action = await this.#actions.engage('subscription/subscribe', { channel_id });
+    return action;
+  }
+
+  /**
+   * Unsubscribes from a given channel.
+   */
+  async unsubscribe(channel_id: string) {
+    throwIfMissing({ channel_id });
+    const action = await this.#actions.engage('subscription/unsubscribe', { channel_id });
+    return action;
+  }
+
+  /**
+   * Posts a comment on a given video.
+   */
+  async comment(video_id: string, text: string) {
+    throwIfMissing({ video_id, text });
+    const action = await this.#actions.engage('comment/create_comment', { video_id, text });
+    return action;
+  }
+
+  /**
+   * Translates a given text using YouTube's comment translate feature.
+   *
+   * @param target_language - an ISO language code
+   * @param args - optional arguments
+   */
+  async translate(text: string, target_language: string, args: { video_id?: string; comment_id?: string; } = {}) {
+    throwIfMissing({ text, target_language });
+
+    const response = await await this.#actions.engage('comment/perform_comment_action', {
+      video_id: args.video_id,
+      comment_id: args.comment_id,
+      target_language: target_language,
+      comment_action: 'translate',
+      text
+    });
+
+    const mutation = response.data.frameworkUpdates.entityBatchUpdate.mutations[0].payload.commentEntityPayload;
+
+    return {
+      success: response.success,
+      status_code: response.status_code,
+      translated_content: mutation.translatedContent.content,
+      data: response.data
+    };
+  }
+
+  /**
+   * Changes notification preferences for a given channel.
+   * Only works with channels you are subscribed to.
+   */
+  async setNotificationPreferences(channel_id: string, type: 'PERSONALIZED' | 'ALL' | 'NONE') {
+    throwIfMissing({ channel_id, type });
+    const action = await this.#actions.notifications('modify_channel_preference', { channel_id, pref: type || 'NONE' });
+    return action;
+  }
+}
+
+export default InteractionManager;

src/core/Music.ts

@@ -0,0 +1,255 @@
+import Session from './Session';
+
+import TrackInfo from '../parser/ytmusic/TrackInfo';
+
+import Search from '../parser/ytmusic/Search';
+import HomeFeed from '../parser/ytmusic/HomeFeed';
+import Explore from '../parser/ytmusic/Explore';
+import Library from '../parser/ytmusic/Library';
+import Artist from '../parser/ytmusic/Artist';
+import Album from '../parser/ytmusic/Album';
+import Playlist from '../parser/ytmusic/Playlist';
+import Recap from '../parser/ytmusic/Recap';
+
+import Parser from '../parser/index';
+import { observe, YTNode } from '../parser/helpers';
+
+import Tab from '../parser/classes/Tab';
+import Tabbed from '../parser/classes/Tabbed';
+import SingleColumnMusicWatchNextResults from '../parser/classes/SingleColumnMusicWatchNextResults';
+import WatchNextTabbedResults from '../parser/classes/WatchNextTabbedResults';
+import SectionList from '../parser/classes/SectionList';
+
+import MusicQueue from '../parser/classes/MusicQueue';
+import PlaylistPanel from '../parser/classes/PlaylistPanel';
+import Message from '../parser/classes/Message';
+import MusicDescriptionShelf from '../parser/classes/MusicDescriptionShelf';
+import MusicCarouselShelf from '../parser/classes/MusicCarouselShelf';
+import SearchSuggestionsSection from '../parser/classes/SearchSuggestionsSection';
+
+import { InnertubeError, throwIfMissing, generateRandomString } from '../utils/Utils';
+
+class Music {
+  #actions;
+
+  constructor(session: Session) {
+    this.#actions = session.actions;
+  }
+
+  /**
+   * Retrieves track info.
+   */
+  async getInfo(video_id: string) {
+    const cpn = generateRandomString(16);
+
+    const initial_info = await this.#actions.getVideoInfo(video_id, cpn, 'YTMUSIC');
+    const continuation = this.#actions.execute('/next', { client: 'YTMUSIC', videoId: video_id });
+
+    const response = await Promise.all([ initial_info, continuation ]);
+    return new TrackInfo(response, this.#actions, cpn);
+  }
+
+  /**
+   * Searches on YouTube Music.
+   */
+  async search(query: string, filters: {
+    type?: 'all' | 'song' | 'video' | 'album' | 'playlist' | 'artist';
+  } = {}) {
+    throwIfMissing({ query });
+    const response = await this.#actions.search({ query, filters, client: 'YTMUSIC' });
+    return new Search(response, this.#actions, { is_filtered: Reflect.has(filters, 'type') && filters.type !== 'all' });
+  }
+
+  /**
+   * Retrieves the home feed.
+   */
+  async getHomeFeed() {
+    const response = await this.#actions.browse('FEmusic_home', { client: 'YTMUSIC' });
+    return new HomeFeed(response, this.#actions);
+  }
+
+  /**
+   * Retrieves the Explore feed.
+   */
+  async getExplore() {
+    const response = await this.#actions.browse('FEmusic_explore', { client: 'YTMUSIC' });
+    return new Explore(response);
+    // TODO: return new Explore(response, this.#actions);
+  }
+
+  /**
+   * Retrieves the Library.
+   */
+  getLibrary() {
+    return new Library(this.#actions);
+  }
+
+  /**
+   * Retrieves artist's info & content.
+   */
+  async getArtist(artist_id: string) {
+    throwIfMissing({ artist_id });
+
+    if (!artist_id.startsWith('UC') && !artist_id.startsWith('FEmusic_library_privately_owned_artist'))
+      throw new InnertubeError('Invalid artist id', artist_id);
+
+    const response = await this.#actions.browse(artist_id, { client: 'YTMUSIC' });
+    return new Artist(response, this.#actions);
+  }
+
+  /**
+   * Retrieves album.
+   */
+  async getAlbum(album_id: string) {
+    throwIfMissing({ album_id });
+
+    if (!album_id.startsWith('MPR') && !album_id.startsWith('FEmusic_library_privately_owned_release'))
+      throw new InnertubeError('Invalid album id', album_id);
+
+    const response = await this.#actions.browse(album_id, { client: 'YTMUSIC' });
+    return new Album(response, this.#actions);
+  }
+
+  /**
+   * Retrieves playlist.
+   */
+  async getPlaylist(playlist_id: string) {
+    throwIfMissing({ playlist_id });
+
+    if (!playlist_id.startsWith('VL')) {
+      playlist_id = `VL${playlist_id}`;
+    }
+
+    const response = await this.#actions.browse(playlist_id, { client: 'YTMUSIC' });
+    return new Playlist(response, this.#actions);
+  }
+
+  /**
+   * Retrieves song lyrics.
+   */
+  async getLyrics(video_id: string) {
+    throwIfMissing({ video_id });
+
+    const response = await this.#actions.next({ video_id, client: 'YTMUSIC' });
+
+    const data = Parser.parseResponse(response.data);
+
+    const tabs = data.contents.item()
+      .as(SingleColumnMusicWatchNextResults).contents.item()
+      .as(Tabbed).contents.item()
+      .as(WatchNextTabbedResults)
+      .tabs.array().as(Tab);
+
+    const tab = tabs.get({ title: 'Lyrics' });
+
+    if (!tab)
+      throw new InnertubeError('Could not find target tab.');
+
+    const page = await tab.endpoint.call(this.#actions, 'YTMUSIC', true);
+
+    if (!page)
+      throw new InnertubeError('Could not retrieve tab contents, the given id may be invalid or is not a song.');
+
+    if (page.contents.item().key('type').string() === 'Message')
+      throw new InnertubeError(page.contents.item().as(Message).text, video_id);
+
+    const section_list = page.contents.item().as(SectionList).contents.array();
+    const description_shelf = section_list.firstOfType(MusicDescriptionShelf);
+
+    return {
+      text: description_shelf?.description.toString(),
+      footer: description_shelf?.footer
+    };
+  }
+
+  /**
+   * Retrieves up next.
+   */
+  async getUpNext(video_id: string) {
+    throwIfMissing({ video_id });
+
+    const response = await this.#actions.next({ video_id, client: 'YTMUSIC' });
+
+    const data = Parser.parseResponse(response.data);
+
+    const tabs = data.contents.item()
+      .as(SingleColumnMusicWatchNextResults).contents.item()
+      .as(Tabbed).contents.item()
+      .as(WatchNextTabbedResults)
+      .tabs.array().as(Tab);
+
+    const tab = tabs.get({ title: 'Up next' });
+
+    if (!tab)
+      throw new InnertubeError('Could not find target tab.');
+
+    const music_queue = tab.content?.as(MusicQueue);
+
+    if (!music_queue || !music_queue.content)
+      throw new InnertubeError('Music queue was empty, the given id is probably invalid.', music_queue);
+
+    const playlist_panel = music_queue.content.item().as(PlaylistPanel);
+
+    return playlist_panel;
+  }
+
+  /**
+   * Retrieves related content.
+   */
+  async getRelated(video_id: string) {
+    throwIfMissing({ video_id });
+
+    const response = await this.#actions.next({ video_id, client: 'YTMUSIC' });
+
+    const data = Parser.parseResponse(response.data);
+
+    const tabs = data.contents.item()
+      .as(SingleColumnMusicWatchNextResults).contents.item()
+      .as(Tabbed).contents.item()
+      .as(WatchNextTabbedResults)
+      .tabs.array().as(Tab);
+
+    const tab = tabs.get({ title: 'Related' });
+
+    if (!tab)
+      throw new InnertubeError('Could not find target tab.');
+
+    const page = await tab.endpoint.call(this.#actions, 'YTMUSIC', true);
+
+    if (!page)
+      throw new InnertubeError('Could not retrieve tab contents, the given id may be invalid or is not a song.');
+
+    const shelves = page.contents.item().as(SectionList).contents.array().as(MusicCarouselShelf, MusicDescriptionShelf);
+
+    return shelves;
+  }
+
+  async getRecap() {
+    const response = await this.#actions.execute('/browse', {
+      browseId: 'FEmusic_listening_review',
+      client: 'YTMUSIC_ANDROID'
+    });
+
+    return new Recap(response, this.#actions);
+  }
+
+  /**
+   * Retrieves search suggestions for the given query.
+   */
+  async getSearchSuggestions(query: string) {
+    const response = await this.#actions.execute('/music/get_search_suggestions', {
+      parse: true,
+      input: query,
+      client: 'YTMUSIC'
+    });
+
+    const search_suggestions_section = response.contents_memo.getType(SearchSuggestionsSection)?.[0];
+
+    if (!search_suggestions_section.contents.is_array)
+      return observe([] as YTNode[]);
+
+    return search_suggestions_section?.contents.array();
+  }
+}
+
+export default Music;

src/core/OAuth.ts

@@ -0,0 +1,270 @@
+import Session from './Session';
+import Constants from '../utils/Constants';
+import { OAuthError, uuidv4 } from '../utils/Utils';
+
+export interface Credentials {
+  /**
+   * Token used to sign in.
+   */
+  access_token: string;
+  /**
+   * Token used to get a new access token.
+   */
+  refresh_token: string;
+  /**
+   * Access token's expiration date, which is usually 24hrs-ish.
+   */
+  expires: Date;
+}
+
+// TODO: actual type info for this.
+export type OAuthAuthPendingData = any;
+
+export type OAuthAuthEventHandler = (data: {
+  credentials: Credentials;
+  status: 'SUCCESS';
+}) => any;
+
+export type OAuthAuthPendingEventHandler = (data: OAuthAuthPendingData) => any;
+export type OAuthAuthErrorEventHandler = (err: OAuthError) => any;
+
+class OAuth {
+  #identity?: Record<string, string>;
+  #session: Session;
+  #credentials?: Credentials;
+  #polling_interval = 5;
+
+  constructor(session: Session) {
+    this.#session = session;
+  }
+
+  /**
+   * Starts the auth flow in case no valid credentials are available.
+   */
+  async init(credentials?: Credentials) {
+    this.#credentials = credentials;
+
+    if (this.validateCredentials()) {
+      if (!this.has_access_token_expired)
+        this.#session.emit('auth', {
+          credentials: this.#credentials,
+          status: 'SUCCESS'
+        });
+    } else if (!(await this.#loadCachedCredentials())) {
+      await this.#getUserCode();
+    }
+  }
+
+  async cacheCredentials() {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(JSON.stringify(this.#credentials));
+    await this.#session.cache?.set('youtubei_oauth_credentials', data.buffer);
+  }
+
+  async #loadCachedCredentials() {
+    const data = await this.#session.cache?.get('youtubei_oauth_credentials');
+    if (!data) return false;
+
+    const decoder = new TextDecoder();
+    const credentials = JSON.parse(decoder.decode(data));
+
+    this.#credentials = {
+      access_token: credentials.access_token,
+      refresh_token: credentials.refresh_token,
+      expires: new Date(credentials.expires)
+    };
+
+    this.#session.emit('auth', {
+      credentials: this.#credentials,
+      status: 'SUCCESS'
+    });
+
+    return true;
+  }
+
+  async removeCache() {
+    await this.#session.cache?.remove('youtubei_oauth_credentials');
+  }
+
+  /**
+   * Asks the server for a user code and verification URL.
+   */
+  async #getUserCode() {
+    this.#identity = await this.#getClientIdentity();
+
+    const data = {
+      client_id: this.#identity.client_id,
+      scope: Constants.OAUTH.SCOPE,
+      device_id: uuidv4(),
+      model_name: Constants.OAUTH.MODEL_NAME
+    };
+
+    const response = await this.#session.http.fetch_function(new URL('/o/oauth2/device/code', Constants.URLS.YT_BASE), {
+      body: JSON.stringify(data),
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    const response_data = await response.json();
+
+    this.#session.emit('auth-pending', response_data);
+    this.#polling_interval = response_data.interval;
+    this.#startPolling(response_data.device_code);
+  }
+
+  /**
+   * Polls the authorization server until access is granted by the user.
+   */
+  #startPolling(device_code: string) {
+    const poller = setInterval(async () => {
+      const data = {
+        ...this.#identity,
+        code: device_code,
+        grant_type: Constants.OAUTH.GRANT_TYPE
+      };
+
+      try {
+        const response = await this.#session.http.fetch_function(new URL('/o/oauth2/token', Constants.URLS.YT_BASE), {
+          body: JSON.stringify(data),
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        });
+
+        const response_data = await response.json();
+
+        if (response_data.error) {
+          switch (response_data.error) {
+            case 'access_denied':
+              this.#session.emit('auth-error', new OAuthError('Access was denied.', { status: 'ACCESS_DENIED' }));
+              break;
+            case 'expired_token':
+              this.#session.emit('auth-error', new OAuthError('The device code has expired, restarting auth flow.', { status: 'DEVICE_CODE_EXPIRED' }));
+              clearInterval(poller);
+              this.#getUserCode();
+              break;
+            default:
+              break;
+          }
+          return;
+        }
+
+        const expiration_date = new Date(new Date().getTime() + response_data.expires_in * 1000);
+
+        this.#credentials = {
+          access_token: response_data.access_token,
+          refresh_token: response_data.refresh_token,
+          expires: expiration_date
+        };
+
+        this.#session.emit('auth', {
+          credentials: this.#credentials,
+          status: 'SUCCESS'
+        });
+
+        clearInterval(poller);
+      } catch (err) {
+        clearInterval(poller);
+        return this.#session.emit('auth-error', new OAuthError('Could not obtain user code.', { status: 'FAILED', error: err }));
+      }
+    }, this.#polling_interval * 1000);
+  }
+
+  /**
+   * Refresh access token if the same has expired.
+   */
+  async refreshIfRequired() {
+    if (this.has_access_token_expired) {
+      await this.#refreshAccessToken();
+    }
+  }
+
+  async #refreshAccessToken() {
+    if (!this.#credentials) return;
+    this.#identity = await this.#getClientIdentity();
+
+    const data = {
+      ...this.#identity,
+      refresh_token: this.#credentials.refresh_token,
+      grant_type: 'refresh_token'
+    };
+
+    const response = await this.#session.http.fetch_function(new URL('/o/oauth2/token', Constants.URLS.YT_BASE), {
+      body: JSON.stringify(data),
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    const response_data = await response.json();
+    const expiration_date = new Date(new Date().getTime() + response_data.expires_in * 1000);
+
+    this.#credentials = {
+      access_token: response_data.access_token,
+      refresh_token: response_data.refresh_token || this.#credentials.refresh_token,
+      expires: expiration_date
+    };
+
+    this.#session.emit('update-credentials', {
+      credentials: this.#credentials,
+      status: 'SUCCESS'
+    });
+  }
+
+  async revokeCredentials() {
+    if (!this.#credentials) return;
+    await this.removeCache();
+    return this.#session.http.fetch_function(new URL(`/o/oauth2/revoke?token=${encodeURIComponent(this.#credentials.access_token)}`, Constants.URLS.YT_BASE), {
+      method: 'post'
+    });
+  }
+
+  /**
+   * Retrieves client identity from YouTube TV.
+   */
+  async #getClientIdentity() {
+    const response = await this.#session.http.fetch_function(new URL('/tv', Constants.URLS.YT_BASE), { headers: Constants.OAUTH.HEADERS });
+
+    const response_data = await response.text();
+    const url_body = Constants.OAUTH.REGEX.AUTH_SCRIPT.exec(response_data)?.[1];
+
+    if (!url_body)
+      throw new OAuthError('Could not obtain script url.', { status: 'FAILED' });
+
+    const script = await this.#session.http.fetch(url_body, { baseURL: Constants.URLS.YT_BASE });
+
+    const client_identity = (await script.text())
+      .replace(/\n/g, '')
+      .match(Constants.OAUTH.REGEX.CLIENT_IDENTITY);
+
+    // TODO: check this.
+    const groups = client_identity?.groups;
+
+    if (!groups)
+      throw new OAuthError('Could not obtain client identity.', { status: 'FAILED' });
+
+    return groups;
+  }
+
+  get credentials() {
+    return this.#credentials;
+  }
+
+  get has_access_token_expired(): boolean {
+    const timestamp = this.#credentials ? new Date(this.#credentials.expires).getTime() : -Infinity;
+    return new Date().getTime() > timestamp;
+  }
+
+  validateCredentials(): this is this & { credentials: Credentials } {
+    return this.#credentials &&
+      Reflect.has(this.#credentials, 'access_token') &&
+      Reflect.has(this.#credentials, 'refresh_token') &&
+      Reflect.has(this.#credentials, 'expires') || false;
+  }
+}
+
+export default OAuth;

src/core/Player.ts

@@ -0,0 +1,206 @@
+
+import { FetchFunction } from '../utils/HTTPClient';
+import { getRandomUserAgent, getStringBetweenStrings, PlayerError } from '../utils/Utils';
+
+import Constants from '../utils/Constants';
+import UniversalCache from '../utils/Cache';
+
+// See https://github.com/LuanRT/Jinter
+import Jinter from 'jintr';
+
+export default class Player {
+  #nsig_sc;
+  #sig_sc;
+  #sig_sc_timestamp;
+  #player_id;
+
+  constructor(signature_timestamp: number, sig_sc: string, nsig_sc: string, player_id: string) {
+    this.#nsig_sc = nsig_sc;
+    this.#sig_sc = sig_sc;
+
+    this.#sig_sc_timestamp = signature_timestamp;
+
+    this.#player_id = player_id;
+  }
+
+  static async create(cache: UniversalCache | undefined, fetch: FetchFunction = globalThis.fetch) {
+    const url = new URL('/iframe_api', Constants.URLS.YT_BASE);
+    const res = await fetch(url);
+
+    if (res.status !== 200)
+      throw new PlayerError('Failed to request player id');
+
+    const js = await res.text();
+
+    const player_id = getStringBetweenStrings(js, 'player\\/', '\\/');
+
+    if (!player_id)
+      throw new PlayerError('Failed to get player id');
+
+    // We have the playerID now we can check if we have a cached player
+    if (cache) {
+      const cached_player = await Player.fromCache(cache, player_id);
+      if (cached_player)
+        return cached_player;
+    }
+
+    const player_url = new URL(`/s/player/${player_id}/player_ias.vflset/en_US/base.js`, Constants.URLS.YT_BASE);
+
+    const player_res = await fetch(player_url, {
+      headers: {
+        'user-agent': getRandomUserAgent('desktop')
+      }
+    });
+
+    if (!player_res.ok) {
+      throw new PlayerError(`Failed to get player data: ${player_res.status}`);
+    }
+
+    const player_js = await player_res.text();
+
+    const sig_timestamp = this.extractSigTimestamp(player_js);
+
+    const sig_sc = this.extractSigSourceCode(player_js);
+    const nsig_sc = this.extractNSigSourceCode(player_js);
+
+    return await Player.fromSource(cache, sig_timestamp, sig_sc, nsig_sc, player_id);
+  }
+
+  decipher(url?: string, signature_cipher?: string, cipher?: string) {
+    url = url || signature_cipher || cipher;
+
+    if (!url)
+      throw new PlayerError('No valid URL to decipher');
+
+    const args = new URLSearchParams(url);
+    const url_components = new URL(args.get('url') || url);
+
+    url_components.searchParams.set('ratebypass', 'yes');
+
+    if (signature_cipher || cipher) {
+      const sig_decipher = new Jinter(this.#sig_sc);
+      sig_decipher.scope.set('sig', args.get('s'));
+
+      const signature = sig_decipher.interpret();
+
+      const sp = args.get('sp');
+
+      sp ?
+        url_components.searchParams.set(sp, signature) :
+        url_components.searchParams.set('signature', signature);
+    }
+
+    const n = url_components.searchParams.get('n');
+
+    if (n) {
+      const nsig_decipher = new Jinter(this.#nsig_sc);
+      nsig_decipher.scope.set('nsig', n);
+
+      const nsig = nsig_decipher.interpret();
+
+      if (nsig.startsWith('enhanced_except_')) {
+        console.warn('Warning:\nCould not transform nsig, download may be throttled.\nChanging the InnerTube client to "ANDROID" might help!');
+      }
+
+      url_components.searchParams.set('n', nsig);
+    }
+
+    return url_components.toString();
+  }
+
+  static async fromCache(cache: UniversalCache, player_id: string) {
+    const buffer = await cache.get(player_id);
+
+    if (!buffer)
+      return null;
+
+    const view = new DataView(buffer);
+    const version = view.getUint32(0, true);
+
+    if (version !== Player.LIBRARY_VERSION)
+      return null;
+
+    const sig_timestamp = view.getUint32(4, true);
+
+    const sig_len = view.getUint32(8, true);
+    const sig_buf = buffer.slice(12, 12 + sig_len);
+    const nsig_buf = buffer.slice(12 + sig_len);
+
+    const decoder = new TextDecoder();
+
+    const sig_sc = decoder.decode(sig_buf);
+    const nsig_sc = decoder.decode(nsig_buf);
+
+    return new Player(sig_timestamp, sig_sc, nsig_sc, player_id);
+  }
+
+  static async fromSource(cache: UniversalCache | undefined, sig_timestamp: number, sig_sc: string, nsig_sc: string, player_id: string) {
+    const player = new Player(sig_timestamp, sig_sc, nsig_sc, player_id);
+    await player.cache(cache);
+    return player;
+  }
+
+  async cache(cache?: UniversalCache) {
+    if (!cache) return;
+
+    const encoder = new TextEncoder();
+
+    const sig_buf = encoder.encode(this.#sig_sc);
+    const nsig_buf = encoder.encode(this.#nsig_sc);
+
+    const buffer = new ArrayBuffer(12 + sig_buf.byteLength + nsig_buf.byteLength);
+    const view = new DataView(buffer);
+
+    view.setUint32(0, Player.LIBRARY_VERSION, true);
+    view.setUint32(4, this.#sig_sc_timestamp, true);
+    view.setUint32(8, sig_buf.byteLength, true);
+
+    new Uint8Array(buffer).set(sig_buf, 12);
+    new Uint8Array(buffer).set(nsig_buf, 12 + sig_buf.byteLength);
+
+    await cache.set(this.#player_id, new Uint8Array(buffer));
+  }
+
+  static extractSigTimestamp(data: string) {
+    return parseInt(getStringBetweenStrings(data, 'signatureTimestamp:', ',') || '0');
+  }
+
+  static extractSigSourceCode(data: string) {
+    const funcs = getStringBetweenStrings(data, 'this.audioTracks};var', '};');
+    const calls = getStringBetweenStrings(data, 'function(a){a=a.split("")', 'return a.join("")}');
+
+    if (!funcs || !calls)
+      throw new PlayerError('Failed to extract signature decipher algorithm');
+
+    return `function descramble_sig(a) { a = a.split(""); ${funcs}}${calls} return a.join("") } descramble_sig(sig);`;
+  }
+
+  static extractNSigSourceCode(data: string) {
+    const sc = `function descramble_nsig(a) { let b=a.split("")${getStringBetweenStrings(data, 'b=a.split("")', '}return b.join("")}')}} return b.join(""); } descramble_nsig(nsig)`;
+
+    if (!sc)
+      throw new PlayerError('Failed to extract n-token decipher algorithm');
+
+    return sc;
+  }
+
+  get url() {
+    return new URL(`/s/player/${this.#player_id}/player_ias.vflset/en_US/base.js`, Constants.URLS.YT_BASE).toString();
+  }
+
+  get sts() {
+    return this.#sig_sc_timestamp;
+  }
+
+  get nsig_sc() {
+    return this.#nsig_sc;
+  }
+
+  get sig_sc() {
+    return this.#sig_sc;
+  }
+
+  static get LIBRARY_VERSION() {
+    return 2;
+  }
+}

src/core/PlaylistManager.ts

@@ -0,0 +1,169 @@
+import Playlist from '../parser/youtube/Playlist';
+import Actions from './Actions';
+import Feed from './Feed';
+
+import { InnertubeError, throwIfMissing } from '../utils/Utils';
+
+class PlaylistManager {
+  #actions;
+
+  constructor(actions: Actions) {
+    this.#actions = actions;
+  }
+
+  /**
+   * Creates a playlist.
+   */
+  async create(title: string, video_ids: string[]) {
+    throwIfMissing({ title, video_ids });
+
+    const response = await this.#actions.execute('/playlist/create', { title, ids: video_ids, parse: false });
+
+    return {
+      success: response.success,
+      status_code: response.status_code,
+      playlist_id: response.data.playlistId,
+      data: response.data
+    };
+  }
+
+  /**
+   * Deletes a given playlist.
+   */
+  async delete(playlist_id: string) {
+    throwIfMissing({ playlist_id });
+
+    const response = await this.#actions.execute('playlist/delete', { playlistId: playlist_id });
+
+    return {
+      playlist_id,
+      success: response.success,
+      status_code: response.status_code,
+      data: response.data
+    };
+  }
+
+  /**
+   * Adds videos to a given playlist.
+   */
+  async addVideos(playlist_id: string, video_ids: string[]) {
+    throwIfMissing({ playlist_id, video_ids });
+
+    const response = await this.#actions.execute('/browse/edit_playlist', {
+      playlistId: playlist_id,
+      actions: video_ids.map((id) => ({
+        action: 'ACTION_ADD_VIDEO',
+        addedVideoId: id
+      })),
+      parse: false
+    });
+
+    return {
+      playlist_id,
+      action_result: response.data.actions // TODO: implement actions in the parser
+    };
+  }
+
+  /**
+   * Removes videos from a given playlist.
+   */
+  async removeVideos(playlist_id: string, video_ids: string[]) {
+    throwIfMissing({ playlist_id, video_ids });
+
+    const info = await this.#actions.execute('/browse', { browseId: `VL${playlist_id}`, parse: true });
+    const playlist = new Playlist(this.#actions, info, true);
+
+    if (!playlist.info.is_editable)
+      throw new InnertubeError('This playlist cannot be edited.', playlist_id);
+
+    const payload = {
+      playlistId: playlist_id,
+      actions: [] as {
+        action: string;
+        setVideoId: string;
+      }[]
+    };
+
+    const getSetVideoIds = async (pl: Feed): Promise<void> => {
+      const videos = pl.videos.filter((video) => video_ids.includes(video.key('id').string()));
+
+      videos.forEach((video) =>
+        payload.actions.push({
+          action: 'ACTION_REMOVE_VIDEO',
+          setVideoId: video.key('set_video_id').string()
+        })
+      );
+
+      if (payload.actions.length < video_ids.length) {
+        const next = await pl.getContinuation();
+        return getSetVideoIds(next);
+      }
+    };
+
+    await getSetVideoIds(playlist);
+
+    if (!payload.actions.length)
+      throw new InnertubeError('Given video ids were not found in this playlist.', video_ids);
+
+    const response = await this.#actions.execute('/browse/edit_playlist', { ...payload, parse: false });
+
+    return {
+      playlist_id,
+      action_result: response.data.actions // TODO: implement actions in the parser
+    };
+  }
+
+  /**
+   * Moves a video to a new position within a given playlist.
+   */
+  async moveVideo(playlist_id: string, moved_video_id: string, predecessor_video_id: string) {
+    throwIfMissing({ playlist_id, moved_video_id, predecessor_video_id });
+
+    const info = await this.#actions.execute('/browse', { browseId: `VL${playlist_id}`, parse: true });
+    const playlist = new Playlist(this.#actions, info, true);
+
+    if (!playlist.info.is_editable)
+      throw new InnertubeError('This playlist cannot be edited.', playlist_id);
+
+    const payload = {
+      playlistId: playlist_id,
+      actions: [] as {
+        action: string,
+        setVideoId?: string,
+        movedSetVideoIdPredecessor?: string
+      }[]
+    };
+
+    let set_video_id_0: string | undefined, set_video_id_1: string | undefined;
+
+    const getSetVideoIds = async (pl: Feed): Promise<void> => {
+      const video_0 = pl.videos.find((video) => moved_video_id === video.key('id').string());
+      const video_1 = pl.videos.find((video) => predecessor_video_id === video.key('id').string());
+
+      set_video_id_0 = set_video_id_0 || video_0?.key('set_video_id').string();
+      set_video_id_1 = set_video_id_1 || video_1?.key('set_video_id').string();
+
+      if (!set_video_id_0 || !set_video_id_1) {
+        const next = await pl.getContinuation();
+        return getSetVideoIds(next);
+      }
+    };
+
+    await getSetVideoIds(playlist);
+
+    payload.actions.push({
+      action: 'ACTION_MOVE_VIDEO_AFTER',
+      setVideoId: set_video_id_0,
+      movedSetVideoIdPredecessor: set_video_id_1
+    });
+
+    const response = await this.#actions.execute('/browse/edit_playlist', { ...payload, parse: false });
+
+    return {
+      playlist_id,
+      action_result: response.data.actions // TODO: implement actions in the parser
+    };
+  }
+}
+
+export default PlaylistManager;

src/core/Session.ts

@@ -0,0 +1,244 @@
+import Player from './Player';
+import Proto from '../proto/index';
+import Actions from './Actions';
+import Constants from '../utils/Constants';
+import UniversalCache from '../utils/Cache';
+import EventEmitterLike from '../utils/EventEmitterLike';
+
+import HTTPClient, { FetchFunction } from '../utils/HTTPClient';
+import { DeviceCategory, generateRandomString, getRandomUserAgent, InnertubeError, SessionError } from '../utils/Utils';
+import OAuth, { Credentials, OAuthAuthErrorEventHandler, OAuthAuthEventHandler, OAuthAuthPendingEventHandler } from './OAuth';
+
+export enum ClientType {
+  WEB = 'WEB',
+  MUSIC = 'WEB_REMIX',
+  ANDROID = 'ANDROID',
+  ANDROID_MUSIC = 'ANDROID_MUSIC'
+}
+
+export interface Context {
+  client: {
+    hl: string;
+    gl: string;
+    remoteHost: string;
+    visitorData: string;
+    userAgent: string;
+    clientName: string;
+    clientVersion: string;
+    androidSdkVersion?: string;
+    osName: string;
+    osVersion: string;
+    platform: string;
+    clientFormFactor: string;
+    userInterfaceTheme: string;
+    timeZone: string;
+    browserName: string;
+    browserVersion: string;
+    originalUrl: string;
+    deviceMake: string;
+    deviceModel: string;
+    utcOffsetMinutes: number;
+  };
+  user: {
+    lockedSafetyMode: false;
+  };
+  request: {
+    useSsl: true;
+  };
+}
+
+export interface SessionOptions {
+  lang?: string;
+  device_category?: DeviceCategory;
+  client_type?: ClientType;
+  timezone?: string;
+  cache?: UniversalCache;
+  cookie?: string;
+  fetch?: FetchFunction;
+}
+
+export default class Session extends EventEmitterLike {
+  #api_version;
+  #key;
+  #context;
+  #player;
+
+  oauth;
+  http;
+  logged_in;
+  actions;
+  cache;
+
+  constructor(context: Context, api_key: string, api_version: string, player: Player, cookie?: string, fetch?: FetchFunction, cache?: UniversalCache) {
+    super();
+    this.#context = context;
+    this.#key = api_key;
+    this.#api_version = api_version;
+    this.#player = player;
+    this.http = new HTTPClient(this, cookie, fetch);
+    this.actions = new Actions(this);
+    this.oauth = new OAuth(this);
+    this.logged_in = !!cookie;
+    this.cache = cache;
+  }
+
+  on(type: 'auth', listener: OAuthAuthEventHandler): void;
+  on(type: 'auth-pending', listener: OAuthAuthPendingEventHandler): void;
+  on(type: 'auth-error', listener: OAuthAuthErrorEventHandler): void;
+  on(type: 'update-credentials', listener: OAuthAuthEventHandler): void;
+
+  on(type: string, listener: (...args: any[]) => void): void {
+    super.on(type, listener);
+  }
+
+  once(type: 'auth', listener: OAuthAuthEventHandler): void;
+  once(type: 'auth-pending', listener: OAuthAuthPendingEventHandler): void;
+  once(type: 'auth-error', listener: OAuthAuthErrorEventHandler): void;
+
+  once(type: string, listener: (...args: any[]) => void): void {
+    super.once(type, listener);
+  }
+
+  static async create(options: SessionOptions = {}) {
+    const { context, api_key, api_version } = await Session.getSessionData(options.lang, options.device_category, options.client_type, options.timezone, options.fetch);
+    return new Session(context, api_key, api_version, await Player.create(options.cache, options.fetch), options.cookie, options.fetch, options.cache);
+  }
+
+  static async getSessionData(
+    lang = 'en-US',
+    device_category: DeviceCategory = 'desktop',
+    client_name: ClientType = ClientType.WEB,
+    tz: string = Intl.DateTimeFormat().resolvedOptions().timeZone,
+    fetch: FetchFunction = globalThis.fetch
+  ) {
+    const url = new URL('/sw.js_data', Constants.URLS.YT_BASE);
+
+    const res = await fetch(url, {
+      headers: {
+        'accept-language': lang,
+        'user-agent': getRandomUserAgent('desktop'),
+        'accept': '*/*',
+        'referer': 'https://www.youtube.com/sw.js',
+        'cookie': `PREF=tz=${tz.replace('/', '.')}`
+      }
+    });
+
+    if (!res.ok) {
+      throw new SessionError(`Failed to get session data: ${res.status}`);
+    }
+
+    const text = await res.text();
+    const data = JSON.parse(text.replace(/^\)\]\}'/, ''));
+
+    const ytcfg = data[0][2];
+
+    const api_version = `v${ytcfg[0][0][6]}`;
+
+    const [ [ device_info ], api_key ] = ytcfg;
+
+    const id = generateRandomString(11);
+    const timestamp = Math.floor(Date.now() / 1000);
+    const visitor_data = Proto.encodeVisitorData(id, timestamp);
+
+    const context: Context = {
+      client: {
+        hl: device_info[0],
+        gl: device_info[2],
+        remoteHost: device_info[3],
+        visitorData: visitor_data,
+        userAgent: device_info[14],
+        clientName: client_name,
+        clientVersion: device_info[16],
+        osName: device_info[17],
+        osVersion: device_info[18],
+        platform: device_category.toUpperCase(),
+        clientFormFactor: 'UNKNOWN_FORM_FACTOR',
+        userInterfaceTheme: 'USER_INTERFACE_THEME_LIGHT',
+        timeZone: device_info[79],
+        browserName: device_info[86],
+        browserVersion: device_info[87],
+        originalUrl: Constants.URLS.API.BASE,
+        deviceMake: device_info[11],
+        deviceModel: device_info[12],
+        utcOffsetMinutes: new Date().getTimezoneOffset()
+      },
+      user: {
+        lockedSafetyMode: false
+      },
+      request: {
+        useSsl: true
+      }
+    };
+
+    return { context, api_key, api_version };
+  }
+
+  async signIn(credentials?: Credentials): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      const error_handler: OAuthAuthErrorEventHandler = (err) => reject(err);
+
+      this.once('auth', (data) => {
+        this.off('auth-error', error_handler);
+
+        if (data.status === 'SUCCESS') {
+          this.logged_in = true;
+          resolve();
+        }
+
+        reject(data);
+      });
+
+      this.once('auth-error', error_handler);
+
+      try {
+        await this.oauth.init(credentials);
+
+        if (this.oauth.validateCredentials()) {
+          await this.oauth.refreshIfRequired();
+          this.logged_in = true;
+          resolve();
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  async signOut() {
+    if (!this.logged_in)
+      throw new InnertubeError('You are not signed in');
+
+    const response = await this.oauth.revokeCredentials();
+    this.logged_in = false;
+
+    return response;
+  }
+
+  get key() {
+    return this.#key;
+  }
+
+  get api_version() {
+    return this.#api_version;
+  }
+
+  get client_version() {
+    return this.#context.client.clientVersion;
+  }
+
+  get client_name() {
+    return this.#context.client.clientName;
+  }
+
+  get context() {
+    return this.#context;
+  }
+
+  get player() {
+    return this.#player;
+  }
+
+  get lang() {
+    return this.#context.client.hl;
+  }
+}

src/core/Studio.ts

@@ -0,0 +1,165 @@
+import Proto from '../proto';
+import Session from './Session';
+import { AxioslikeResponse } from './Actions';
+import { InnertubeError, MissingParamError, uuidv4 } from '../utils/Utils';
+import { Constants } from '../utils';
+
+export interface UploadResult {
+  status: string;
+  scottyResourceId: string;
+}
+
+export interface InitialUploadData {
+  frontend_upload_id: string;
+  upload_id: string;
+  upload_url: string;
+  scotty_resource_id: string;
+  chunk_granularity: string;
+}
+
+export interface VideoMetadata {
+  title?: string;
+  description?: string;
+  privacy?: 'PUBLIC' | 'PRIVATE' | 'UNLISTED';
+  is_draft?: boolean;
+}
+
+class Studio {
+  #session;
+
+  constructor(session: Session) {
+    this.#session = session;
+  }
+
+  /**
+   * Uploads a custom thumbnail and sets it for a video.
+   * @example
+   * ```ts
+   * const buffer = fs.readFileSync('./my_awesome_thumbnail.jpg');
+   * const response = await yt.studio.setThumbnail(video_id, buffer);
+   * ```
+   */
+  async setThumbnail(video_id: string, buffer: Uint8Array): Promise<AxioslikeResponse> {
+    if (!video_id || !buffer)
+      throw new MissingParamError('One or more parameters are missing.');
+
+    const payload = Proto.encodeCustomThumbnailPayload(video_id, buffer);
+
+    const response = await this.#session.actions.execute('/video_manager/metadata_update', {
+      protobuf: true,
+      serialized_data: payload
+    });
+
+    return response;
+  }
+
+  /**
+   * Uploads a video to YouTube.
+   * @example
+   * ```ts
+   * const file = fs.readFileSync('./my_awesome_video.mp4');
+   * const response = await yt.studio.upload(file.buffer, { title: 'Wow!' });
+   * ```
+   */
+  async upload(file: BodyInit, metadata: VideoMetadata = {}): Promise<AxioslikeResponse> {
+    const initial_data = await this.#getInitialUploadData();
+    const upload_result = await this.#uploadVideo(initial_data.upload_url, file);
+
+    if (upload_result.status !== 'STATUS_SUCCESS')
+      throw new InnertubeError('Could not process video.');
+
+    const response = await this.#setVideoMetadata(initial_data, upload_result, metadata);
+
+    return response;
+  }
+
+  async #getInitialUploadData(): Promise<InitialUploadData> {
+    const frontend_upload_id = `innertube_android:${uuidv4()}:0:v=3,api=1,cf=3`;
+
+    const payload = {
+      frontendUploadId: frontend_upload_id,
+      deviceDisplayName: 'Pixel 6 Pro',
+      fileId: `goog-edited-video://generated?videoFileUri=content://media/external/video/media/${uuidv4()}`,
+      mp4MoovAtomRelocationStatus: 'UNSUPPORTED',
+      transcodeResult: 'DISABLED',
+      connectionType: 'WIFI'
+    };
+
+    const response = await this.#session.http.fetch('/upload/youtubei', {
+      baseURL: Constants.URLS.YT_UPLOAD,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'x-goog-upload-command': 'start',
+        'x-goog-upload-protocol': 'resumable'
+      },
+      body: JSON.stringify(payload)
+    });
+
+    if (!response.ok)
+      throw new InnertubeError('Could not get initial upload data');
+
+    return {
+      frontend_upload_id,
+      upload_id: response.headers.get('x-guploader-uploadid') as string,
+      upload_url: response.headers.get('x-goog-upload-url') as string,
+      scotty_resource_id: response.headers.get('x-goog-upload-header-scotty-resource-id') as string,
+      chunk_granularity: response.headers.get('x-goog-upload-chunk-granularity') as string
+    };
+  }
+
+  async #uploadVideo(upload_url: string, file: BodyInit): Promise<UploadResult> {
+    const response = await this.#session.http.fetch_function(upload_url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'x-goog-upload-command': 'upload, finalize',
+        'x-goog-upload-file-name': `file-${Date.now()}`,
+        'x-goog-upload-offset': '0'
+      },
+      body: file
+    });
+
+    if (!response.ok)
+      throw new InnertubeError('Could not upload video');
+
+    const data = await response.json();
+
+    return data;
+  }
+
+  async #setVideoMetadata(initial_data: InitialUploadData, upload_result: UploadResult, metadata: VideoMetadata) {
+    const metadata_payload = {
+      resourceId: {
+        scottyResourceId: {
+          id: upload_result.scottyResourceId
+        }
+      },
+      frontendUploadId: initial_data.frontend_upload_id,
+      initialMetadata: {
+        title: {
+          newTitle: metadata.title || new Date().toDateString()
+        },
+        description: {
+          newDescription: metadata.description || '',
+          shouldSegment: true
+        },
+        privacy: {
+          newPrivacy: metadata.privacy || 'PRIVATE'
+        },
+        draftState: {
+          isDraft: metadata.is_draft || false
+        }
+      }
+    };
+
+    const response = await this.#session.actions.execute('/upload/createvideo', {
+      client: 'ANDROID',
+      ...metadata_payload
+    });
+
+    return response;
+  }
+}
+
+export default Studio;

src/core/TabbedFeed.ts

@@ -0,0 +1,42 @@
+import Tab from '../parser/classes/Tab';
+import { InnertubeError } from '../utils/Utils';
+import Actions from './Actions';
+import Feed from './Feed';
+
+class TabbedFeed extends Feed {
+  #tabs;
+  #actions;
+
+  constructor(actions: Actions, data: any, already_parsed = false) {
+    super(actions, data, already_parsed);
+    this.#actions = actions;
+    this.#tabs = this.page.contents_memo.getType(Tab);
+  }
+
+  get tabs() {
+    return this.#tabs.map((tab) => tab.title.toString());
+  }
+
+  async getTab(title: string) {
+    const tab = this.#tabs.find((tab) => tab.title.toLowerCase() === title.toLowerCase());
+
+    if (!tab)
+      throw new InnertubeError(`Tab "${title}" not found`);
+
+    if (tab.selected)
+      return this;
+
+    const response = await tab.endpoint.call(this.#actions);
+
+    if (!response)
+      throw new InnertubeError('Failed to call endpoint');
+
+    return new TabbedFeed(this.#actions, response.data, false);
+  }
+
+  get title() {
+    return this.page.contents_memo.getType(Tab)?.find((tab) => tab.selected)?.title.toString();
+  }
+}
+
+export default TabbedFeed;

src/parser/README.md

@@ -0,0 +1,307 @@
+# Parser
+
+Sanitizes and standardizes InnerTube responses while maintaining the integrity of the data. Also [drastically improves](https://github.com/LuanRT/YouTube.js/blob/main/lib/parser/youtube/Library.js#L44) how API calls are made and handled. 
+
+## API
+
+* Parser
+  * [.parse](#parse)
+  * [.parseItem](#parse)
+  * [.parseArray](#parse)
+  * [.parseResponse](#parseresponse) 
+
+<a name="parse"></a>
+
+#### parse(data, requireArray, validTypes)
+
+Responsible for parsing individual nodes.
+
+| Param | Type | Description |
+| --- | --- | --- |
+| data | `any` | The data |
+| requireArray | `?boolean` | Whether the response should be an array |
+| validTypes | `YTNodeConstructor<T> | YTNodeConstructor<T>[] | undefined` | The types of YTNodes are allowed |
+
+When `requireArray` is `true`, the response will be an `ObservedArray<YTNodes>`.
+
+When `validTypes` is `undefined`, the response will be an array of YTNodes.
+
+When `validTypes` is an array, the response will be an array of YTNodes that are of the types specified in the array.
+
+When `validTypes` is a single type, the response will be an array of YTNodes that are of the type specified.
+
+If you do not specify `requireArray`, the return type of the function will not be known at runtime, and therefore we return the response wrapped in a helper, `SuperParsedResponse`, to gain access to the response.
+
+You may use the `Parser#parseArray` and `Parser#parseItem` methods to parse the response in a deterministic way.
+
+<a name="parseresponse"></a>
+#### parseResponse(data)
+
+Unlike `parse`, this can be used to parse the entire response object.
+
+| Param | Type | Description |
+| --- | --- | --- |
+| data | `object` | Raw InnerTube response |
+
+## ObservedArray
+You may use `ObservedArray<T extends YTNode>` as a normal array, but it provides additional methods for typesafe access and casting.
+
+```ts
+// For example, we have a feed, and want all the videos:
+const feed = new ObservedArray<YTNode>([...feed.contents]);
+const videos = feed.filterType(GridVideo);
+// This is now a GridVideo[]
+
+// Or we want only the first video:
+const firstVideo = feed.firstOfType(GridVideo);
+
+// We may cast the whole array to a GridVideo[] and throw if we have any non-GridVideo elements:
+const allVideos = feed.as(GridVideo);
+
+// There's some extra methods for ObservedArray<T extends YTNode>
+// which we use internally but not documented here (yet).
+// see the source code for more details.
+```
+
+## SuperParsedResponse
+Represents a parsed response in an unknown state. Either a `YTNode` or a `ObservedArray<YTNode>` or `null`.
+
+You will need to assert the type and unwrap the response to get the actual value.
+
+```ts
+// We can assert we have a YTNode:
+const response = Parser.parse(data);
+if (response.is_item) {
+  const node = response.item();
+}
+
+// We can assert we have an ObservedArray<YTNode>:
+const response = Parser.parse(data);
+if (response.is_array) {
+  const nodes = response.array();
+}
+
+// Or lastly a null response:
+const response = Parser.parse(data);
+const is_null = response.is_null;
+```
+
+## YTNode
+All renderers returned by InnerTube are converted to this generic class and then extended for the specific renderers.
+
+This class is allows us a typesafe way to use data returned by the InnerTube API.
+
+Here's how to use this class to access returned data:
+
+### Type Casting
+```ts
+// We can cast a YTNode to a child class of YTNode
+const results = node.as(TwoColumnSearchResults);
+// This will throw if the node is not a TwoColumnSearchResults
+// We thus may want to check for the type of the node before casting
+if (node.is(TwoColumnSearchResults)) {
+  // We do not need to recast the node, it is already a TwoColumnSearchResults after calling is() and using it in the branch where is() returns true
+  const results = node;
+}
+
+// Sometimes we can expect multiple types of nodes, we can just pass all possible types as params.
+const results = node.as(TwoColumnSearchResults, VideoList);
+// The type of `results` will now be `TwoColumnSearchResults | VideoList`
+
+// Similarly, we can check if the node is of a certain type.
+if (node.is(TwoColumnSearchResults, VideoList)) {
+  // Again no casting is needed, the node is already of the correct type.
+  const results = node;
+}
+```
+
+### Accessing properties without casting
+Sometimes multiple nodes have the same properties and we don't want to check the type of the node before accessing the property, for example the property "contents" is used by many node types, and we may add more in the future, as such we want to only assert the property instead of casting to a specific type.
+
+```ts
+// Accesing a property on a node which you aren't sure if it exists.
+const prop = node.key("contents");
+// This returns the value wrapped into a `Maybe` type
+// which you can use to find the type of the value
+// note however, this throws an error if the key doesn't exist
+// we may want to check for the key before accessing it.
+if (node.hasKey("contents")) {
+  const prop = node.key("contents");
+}
+
+// We can assert the type of the value.
+const prop = node.key("contents");
+if (prop.isString()) {
+  const value = prop.string();
+}
+
+// We can do more complex assertions too,
+// like checking for instanceof.
+const prop = node.key("contents");
+if (prop.isInstanceof(Text)) {
+  const text = prop.instanceof(Text);
+  // and then use the value as the given type
+  text.runs.forEach(run => {
+    console.log(run.text);
+  });
+}
+
+// There's some special methods for using with the parser —
+// such as getting the value as a YTNode.
+const prop = node.key("contents");
+if (prop.isNode()) {
+  const node = prop.node();
+}
+
+// Like with YTNode, keys can also be checked for YTNode child class types.
+const prop = node.key("contents");
+if (prop.isNodeOfType(TwoColumnSearchResults)) {
+  const results = prop.nodeOfType(TwoColumnSearchResults);
+}
+
+// Or we can check for multiple types of nodes.
+const prop = node.key("contents");
+if (prop.isNodeOfType([TwoColumnSearchResults, VideoList])) {
+  const results = prop.nodeOfType<TwoColumnSearchResults | VideoList>([TwoColumnSearchResults, VideoList]);
+}
+
+// Sometimes an ObservedArray is returned when working with parsed data.
+// We've got a helper for that too;
+const prop = node.key("contents");
+if (prop.isObserved()) {
+  const array = prop.observed();
+
+  // Now we may use the all the ObservedArray methods as normal,
+  // like finding nodes of a certain type for example.
+  const results = array.filterType(GridVideo);
+}
+
+// Other times a SuperParsedResult is returned, like when using the `Parser#parse` method.
+const prop = node.key("contents");
+if (prop.isParsed()) {
+  const result = prop.parsed();
+
+  // SuperParsedResult is another helper for typesafe access to the parsed data,
+  // it is explained above with the `Parser#parse` method.
+  const results = results.array();
+  const videos = results.filterType(Video);
+}
+
+// Sometimes we just want to debug something and not interested in finding the type.
+// This will, however, warn you when being used.
+const prop = node.key("contents");
+const value = prop.any();
+
+// Arrays are also a special case as every element may be of a different type,
+// the `arrayOfMaybe` method will return an array of `Maybe`s.
+const prop = node.key("contents");
+if (prop.isArray()) {
+  const array = prop.arrayOfMaybe(); 
+  // This will return Maybe[]
+}
+
+// Or if you want zero typesafety you can use the `array` method.
+const prop = node.key("contents");
+if (prop.isArray()) {
+  const array = prop.array();
+  // This will return any[]
+}
+```
+
+## Memo
+The `Memo` class is a helper class for memoizing values in the `Parser#parseResponse` method. It is useful for finding nodes after parsing the response.
+
+Say we want all of the videos in a search result. We can use the `Memo` to find all of them quickly without recursing through the response.
+
+```ts
+const response = Parser.parseResponse(data);
+const videos = response.contents_memo.getType(Video);
+// This returns the nodes as a ObservedArray<Video>.
+```
+
+`Memo` extends `Map<string, YTNode[]>` and can be used as a normal `Map` too if you want.
+
+## How it works
+
+If you decompile a YouTube client and analize it for a while you will notice that it has classes named `protos/youtube/api/innertube/MusicItemRenderer`, `protos/youtube/api/innertube/SectionListRenderer`, etc. 
+
+These classes are used to parse objects from the response, map them into models and generate the UI. The website works in a similar way, the difference is that it uses plain JSON (likely converted from protobuf server-side, hence the weird structure of the response).
+
+Here we're taking a similar approach, the parser goes through all the renderers and parses their inner element(s). The final result is a nicely structured JSON, and on top of that it also parses navigation endpoints which allows us to make an API call with all required parameters in one line and even emulate client actions (eg; clicking a button).
+
+Here is your average, arguably ugly InnerTube response:
+<details>
+<summary>Click to see</summary>
+<p>
+
+```js
+{
+  sidebar: {
+    playlistSidebarRenderer: {
+      items: [
+        {
+          playlistSidebarPrimaryInfoRenderer: {
+            title: {
+              simpleText: '..'
+            },
+            description: {
+              runs: [
+                {
+                  text: '..'
+                },
+                //....
+              ]
+            },
+            stats: [
+              {
+                simpleText: '..'
+              },
+              {
+                runs: [
+                  {
+                    text: '..'
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+    }
+  }
+}
+```
+
+</p>
+</details> 
+
+And what we get after parsing it:
+<details>
+<summary>Click to see</summary>
+<p>
+
+```js
+{
+  sidebar: {
+    type: 'PlaylistSidebar',
+    contents: [
+      {
+        type: 'PlaylistSidebarPrimaryInfo',
+        title: { text: '..' },
+        description: { text: '..' },
+        stats: [
+          {
+            text: '..'
+          },
+          {
+            text: '..'
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+</p>
+</details> 

src/parser/classes/AccountChannel.ts

@@ -0,0 +1,18 @@
+import Text from './misc/Text';
+import NavigationEndpoint from './NavigationEndpoint';
+import { YTNode } from '../helpers';
+
+class AccountChannel extends YTNode {
+  static type = 'AccountChannel';
+
+  title: Text;
+  endpoint: NavigationEndpoint;
+
+  constructor(data: any) {
+    super();
+    this.title = new Text(data.title);
+    this.endpoint = new NavigationEndpoint(data.navigationEndpoint);
+  }
+}
+
+export default AccountChannel;

src/parser/classes/AccountItemSection.ts

@@ -0,0 +1,45 @@
+import Parser from '..';
+
+import Text from './misc/Text';
+import Thumbnail from './misc/Thumbnail';
+import NavigationEndpoint from './NavigationEndpoint';
+import AccountItemSectionHeader from './AccountItemSectionHeader';
+
+import { YTNode } from '../helpers';
+
+class AccountItem {
+  static type = 'AccountItem';
+
+  account_name: Text;
+  account_photo: Thumbnail[];
+  is_selected: boolean;
+  is_disabled: boolean;
+  has_channel: boolean;
+  endpoint: NavigationEndpoint;
+  account_byline: Text;
+
+  constructor(data: any) {
+    this.account_name = new Text(data.accountName);
+    this.account_photo = Thumbnail.fromResponse(data.accountPhoto);
+    this.is_selected = data.isSelected;
+    this.is_disabled = data.isDisabled;
+    this.has_channel = data.hasChannel;
+    this.endpoint = new NavigationEndpoint(data.serviceEndpoint);
+    this.account_byline = new Text(data.accountByline);
+  }
+}
+
+class AccountItemSection extends YTNode {
+  static type = 'AccountItemSection';
+
+  contents;
+  header;
+
+  constructor(data: any) {
+    super();
+    this.contents = data.contents.map((ac: any) => new AccountItem(ac.accountItem));
+    this.header = Parser.parseItem<AccountItemSectionHeader>(data.header, AccountItemSectionHeader);
+  }
+}
+
+export default AccountItemSection;

src/parser/classes/AccountItemSectionHeader.ts

@@ -0,0 +1,15 @@
+import Text from './misc/Text';
+import { YTNode } from '../helpers';
+
+class AccountItemSectionHeader extends YTNode {
+  static type = 'AccountItemSectionHeader';
+
+  title: Text;
+
+  constructor(data: any) {
+    super();
+    this.title = new Text(data.title);
+  }
+}
+
+export default AccountItemSectionHeader;

src/parser/classes/AccountSectionList.ts

@@ -0,0 +1,20 @@
+import Parser from '..';
+import AccountChannel from './AccountChannel';
+import AccountItemSection from './AccountItemSection';
+
+import { YTNode } from '../helpers';
+
+class AccountSectionList extends YTNode {
+  static type = 'AccountSectionList';
+
+  contents;
+  footers;
+
+  constructor(data: any) {
+    super();
+    this.contents = Parser.parseItem<AccountItemSection>(data.contents[0], AccountItemSection);
+    this.footers = Parser.parseItem<AccountChannel>(data.footers[0], AccountChannel);
+  }
+}
+
+export default AccountSectionList;

src/parser/classes/AutomixPreviewVideo.ts

@@ -0,0 +1,19 @@
+import { YTNode } from '../helpers';
+import NavigationEndpoint from './NavigationEndpoint';
+
+class AutomixPreviewVideo extends YTNode {
+  static type = 'AutomixPreviewVideo';
+
+  playlist_video?: { endpoint: NavigationEndpoint };
+
+  constructor(data: any) {
+    super();
+    if (data?.content?.automixPlaylistVideoRenderer?.navigationEndpoint) {
+      this.playlist_video = {
+        endpoint: new NavigationEndpoint(data.content.automixPlaylistVideoRenderer.navigationEndpoint)
+      };
+    }
+  }
+}
+
+export default AutomixPreviewVideo;

src/parser/classes/BackstageImage.ts

@@ -0,0 +1,15 @@
+import Thumbnail from './misc/Thumbnail';
+import { YTNode } from '../helpers';
+
+class BackstageImage extends YTNode {
+  static type = 'BackstageImage';
+
+  image: Thumbnail[];
+
+  constructor(data: any) {
+    super();
+    this.image = Thumbnail.fromResponse(data.image);
+  }
+}
+
+export default BackstageImage;

src/parser/classes/BackstagePost.ts

@@ -0,0 +1,49 @@
+import Parser from '../index';
+import Author from './misc/Author';
+import Text from './misc/Text';
+import NavigationEndpoint from './NavigationEndpoint';
+
+import { YTNode } from '../helpers';
+
+class BackstagePost extends YTNode {
+  static type = 'BackstagePost';
+
+  id: string;
+  author: Author;
+  content: Text;
+  published: Text;
+  poll_status: string;
+  vote_status: string;
+  likes: Text;
+  menu;
+  actions;
+  vote_button;
+  surface: string;
+  endpoint: NavigationEndpoint;
+  attachment;
+
+  constructor(data: any) {
+    super();
+
+    this.id = data.postId;
+
+    this.author = new Author({
+      ...data.authorText,
+      navigationEndpoint: data.authorEndpoint
+    }, null, data.authorThumbnail);
+
+    this.content = new Text(data.contentText);
+    this.published = new Text(data.publishedTimeText);
+    this.poll_status = data.pollStatus;
+    this.vote_status = data.voteStatus;
+    this.likes = new Text(data.voteCount);
+    this.menu = Parser.parse(data.actionMenu) || null;
+    this.actions = Parser.parse(data.actionButtons);
+    this.vote_button = Parser.parse(data.voteButton);
+    this.surface = data.surface;
+    this.endpoint = new NavigationEndpoint(data.navigationEndpoint);
+    this.attachment = Parser.parse(data.backstageAttachment) || null;
+  }
+}
+
+export default BackstagePost;

src/parser/classes/BackstagePostThread.ts

@@ -0,0 +1,15 @@
+import Parser from '../index';
+import { YTNode } from '../helpers';
+
+class BackstagePostThread extends YTNode {
+  static type = 'BackstagePostThread';
+
+  post;
+
+  constructor(data: any) {
+    super();
+    this.post = Parser.parse(data.post);
+  }
+}
+
+export default BackstagePostThread;

src/parser/classes/BrowseFeedActions.ts

@@ -0,0 +1,15 @@
+import Parser from '../index';
+import { YTNode } from '../helpers';
+
+class BrowseFeedActions extends YTNode {
+  static type = 'BrowseFeedActions';
+
+  contents;
+
+  constructor(data: any) {
+    super();
+    this.contents = Parser.parseArray(data.contents);
+  }
+}
+
+export default BrowseFeedActions;

src/parser/classes/Button.ts

@@ -0,0 +1,37 @@
+import Text from './misc/Text';
+import NavigationEndpoint from './NavigationEndpoint';
+
+import { YTNode } from '../helpers';
+
+class Button extends YTNode {
+  static type = 'Button';
+
+  text: string;
+
+  label;
+  tooltip;
+  icon_type;
+
+  endpoint: NavigationEndpoint;
+
+  constructor(data: any) {
+    super();
+    this.text = new Text(data.text).toString();
+
+    if (data.accessibility?.label) {
+      this.label = data.accessibility?.label;
+    }
+
+    if (data.tooltip) {
+      this.tooltip = data.tooltip;
+    }
+
+    if (data.icon?.iconType) {
+      this.icon_type = data.icon?.iconType;
+    }
+
+    this.endpoint = new NavigationEndpoint(data.navigationEndpoint || data.serviceEndpoint || data.command);
+  }
+}
+
+export default Button;

src/parser/classes/C4TabbedHeader.ts

@@ -0,0 +1,36 @@
+import Parser from '../index';
+import Author from './misc/Author';
+import Thumbnail from './misc/Thumbnail';
+import Text from './misc/Text';
+import { YTNode } from '../helpers';
+
+class C4TabbedHeader extends YTNode {
+  static type = 'C4TabbedHeader';
+
+  author;
+  banner;
+  tv_banner;
+  mobile_banner;
+  subscribers;
+  sponsor_button;
+  subscribe_button;
+  header_links;
+
+  constructor(data: any) {
+    super();
+    this.author = new Author({
+      simpleText: data.title,
+      navigationEndpoint: data.navigationEndpoint
+    }, data.badges, data.avatar);
+
+    this.banner = data.banner ? Thumbnail.fromResponse(data.banner) : [];
+    this.tv_banner = data.tvBanner ? Thumbnail.fromResponse(data.tvBanner) : [];
+    this.mobile_banner = data.mobileBanner ? Thumbnail.fromResponse(data.mobileBanner) : [];
+    this.subscribers = new Text(data.subscriberCountText);
+    this.sponsor_button = data.sponsorButton ? Parser.parseItem(data.sponsorButton) : undefined;
+    this.subscribe_button = data.subscribeButton ? Parser.parseItem(data.subscribeButton) : undefined;
+    this.header_links = data.headerLinks ? Parser.parse(data.headerLinks) : undefined;
+  }
+}
+
+export default C4TabbedHeader;