chore(release): v2.6.0

* Allow overriding geolocation

* Fix some inconsistencies (unrelated)

.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/FEATURE.md

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

.github/ISSUE_TEMPLATE/ISSUE.md

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

.github/ISSUE_TEMPLATE/QUESTION.md

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

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +1 @@
-blank_issues_enabled: false
+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/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,81 @@
+# 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](#build)
+  
+## 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. Documentation updates and grammar fixes are also appreciated!
+
+<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
+npm run lint:fix
+```
+
+<a id="build"></a>
+#### Build
+
+```bash
+# Node
+npm run build:node
+
+# Browser
+npm run build:browser
+npm run build:browser:prod
+
+# Protobuf
+npm run build:proto
+
+# Parser map
+npm run build:parser-map
+```

browser.ts

@@ -0,0 +1,11 @@
+// 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 as Session } from './src/core/Session';
+export { default as Player } from './src/core/Player';
+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,320 @@
+# Music
+
+YouTube Music class.
+
+## API
+
+* Music 
+  * [.getInfo(target)](#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, automix?)](#getupnext)
+  * [.getRelated(video_id)](#getrelated)
+  * [.getRecap()](#getrecap)
+  * [.getSearchSuggestions(query)](#getsearchsuggestions)
+
+<a name="getinfo"></a>
+### getInfo(target)
+
+Retrieves track info.
+
+**Returns:** `Promise.<TrackInfo>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| target | `string` or `MusicTwoRowItem` | video id or list item |
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<info>#getTab(title)`
+  - Retrieves contents of the given tab.
+
+- `<info>#getUpNext(automix?)`
+  - Retrieves up next.
+
+- `<info>#getRelated()`
+  - Retrieves related content.
+
+- `<info>#getLyrics()`
+  - Retrieves song lyrics.
+
+- `<info>#available_tabs`
+  - Returns available tabs.
+
+</p>
+</details> 
+
+<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:** `Library`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<library>#applyFilter(filter)`
+  - Applies given filter to the library.
+
+- `<library>#applySortFilter(filter)`
+  - Applies given sort filter to the library items.
+
+- `<library>#getContinuation()`
+  - Retrieves continuation of the library items.
+
+- `<library>#has_continuation`
+  - Checks if continuation is available.
+
+- `<library>#filters`
+  - Returns available filters.
+
+- `<library>#sort_filters`
+  - Returns available sort filters.
+
+- `<library>#page`
+  - Returns original InnerTube response (sanitized).
+
+</p>
+</details> 
+
+<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.<MusicDescriptionShelf | undefined>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="getupnext"></a>
+### getUpNext(video_id, automix?)
+
+Retrieves up next content.
+
+**Returns:** `Promise.<PlaylistPanel>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+| automix? | `boolean` | if automix should be fetched |
+
+<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>
+### api_version
+
+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,46 @@
+# Studio
+
+YouTube Studio class (WIP).
+
+## API
+
+* Studio 
+  * [.setThumbnail(video_id, buffer)](#setthumbnail)
+  * [.updateVideoMetadata(video_id, metadata)](#updatemetadata)
+  * [.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="updatemetadata"></a>
+### updateVideoMetadata(video_id, metadata)
+
+Updates given video's metadata.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+| metadata | `VideoMetadata` | Video metadata |
+
+<a name="upload"></a>
+### upload(file, metadata)
+
+Uploads a video to YouTube.
+
+**Returns:** `Promise.<ActionsResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| file | `BodyInit` | Video file |
+| metadata | `UploadedVideoMetadata` | Video metadata |

docs/updating-the-parser.md

@@ -0,0 +1,54 @@
+# Updating the parser
+
+YouTube is constantly changing, so it is not rare to see YouTube crawlers/scrapers breaking every now and then. 
+
+Our parser, on the other hand, was written so that it behaves similarly to an official client, parsing and mapping renderers (a.k.a YTNodes) dynamically without hard-coding their path in the response.  This way, whenever a new renderer pops up (e.g; YouTube adds a new feature / minor UI changes) the library will print a warning like this in the console:
+```
+InnertubeError: SomeRenderer not found!
+This is a bug, want to help us fix it? Follow the instructions at https://github.com/LuanRT/YouTube.js/blob/main/docs/updating-the-parser.md or report it at https://github.com/LuanRT/YouTube.js/issues!
+    at Parser.printError (...)
+    at Parser.parseItem (...)
+    at Parser.parseArray (...) {
+  info: {
+    // renderer data, can be used as a reference to implement the renderer parser
+  },
+  date: 2022-05-22T22:16:06.831Z,
+  version: '2.2.3'
+}
+```
+
+This warning, however, **does not** throw an error. The parser itself will continue working normally, even if a parsing error occurs in an existing renderer parser.
+
+## Adding a new renderer parser
+
+Thanks to the modularity of the parser, a renderer can be implemented by simply adding a new file anywhere in the [classes directory](../src/parser/classes)!
+
+For example, say we found a new renderer named `verticalListRenderer`, to let the parser know it exists we would have to create a file with the following structure:
+
+> `../classes/VerticalList.ts`
+```ts
+import Parser from '..';
+import { YTNode } from '../helpers';
+
+class VerticalList extends YTNode {
+  static type = 'VerticalList';
+  
+  header;
+  contents;
+
+  constructor(data: any) {
+    // parse the data here, ex;
+    this.header = Parser.parseItem(data.header);
+    this.contents = Parser.parseArray(data.contents);
+  }
+}
+
+export default VerticalList;
+```
+
+Then update the parser map:
+```bash
+npm run build:parser-map
+```
+
+And that's it!

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,61 @@
+# 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`.
+
+We'll use our own fetch implementation to proxy requests through our server. This is a simple example, but you can use any fetch implementation you want.
+
+```ts
+import { Innertube } from "youtubei.js/build/browser";
+
+const yt = await Innertube.create({
+    fetch: async (input, init) => {
+        // 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(),
+});
+```
+
+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,84 @@
+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, Referer',
+        '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);
+  !request_headers.has('user-agent') && 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);
+  copyHeader('accept-ranges', headers, fetchRes.headers);
+  copyHeader('content-range', 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,44 @@
+import { Innertube, UniversalCache, YTNodes } from 'youtubei.js';
+
+(async () => {
+  const yt = await Innertube.create({ cache: new UniversalCache() });
+
+  const channel = await yt.getChannel('UCX6OQ3DkcsbYNE6H8uQQuVA');
+
+  if (channel.header?.is(YTNodes.C4TabbedHeader)) {
+    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);
-  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,83 @@
+## 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`
+  * [.getItemMenu](#getitemmenu) ⇒ `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="getitemmenu"></a>
+### getItemMenu(item)
+Retrieves given chat item's menu.
+
+| Param | Type | Description |
+| --- | --- | --- |
+| item | `object` | Chat item |
+
+**Returns:** `Promise<ItemMenu>`
+
+<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,76 @@
+import { Innertube, UniversalCache, YTNodes } from 'youtubei.js';
+
+import { LiveChatContinuation } from 'youtubei.js/dist/src/parser';
+import { ChatAction, LiveMetadata } from 'youtubei.js/dist/src/parser/youtube/LiveChat';
+
+(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(YTNodes.Video).id);
+
+  const livechat = 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(YTNodes.AddChatItemAction)) {
+      const item = action.as(YTNodes.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(YTNodes.LiveChatTextMessage).author?.name.toString()}:\n` +
+            `${item.as(YTNodes.LiveChatTextMessage).message.toString()}\n`
+          );
+          break;
+        case 'LiveChatPaidMessage':
+          console.info(
+            `${hours} - ${item.as(YTNodes.LiveChatPaidMessage).author.name.toString()}:\n` +
+            `${item.as(YTNodes.LiveChatPaidMessage).purchase_amount}\n`
+          );
+          break;
+        default:
+          console.debug(action);
+          break;
+      }
+    }
+
+    if (action.is(YTNodes.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,26 @@
+import { Parser, YTNodes } from 'youtubei.js';
+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(YTNodes.MusicImmersiveHeader, YTNodes.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(YTNodes.SingleColumnBrowseResults).tabs.firstOfType(YTNodes.Tab);
+
+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(YTNodes.SectionList).contents.array().as(YTNodes.MusicCarouselShelf, YTNodes.MusicDescriptionShelf, YTNodes.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,28 @@
+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);
+  try {
+    // eslint-disable-next-line
+    const { ReadableStream } = require('node:stream/web');
+    Reflect.set(globalThis, 'ReadableStream', ReadableStream);
+  } catch { /* do nothing */ }
+}
+
+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 as Session } from './src/core/Session';
+export { default as Player } from './src/core/Player';
+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/Innertube.js

@@ -1,839 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-const Stream = require('stream');
-const Parser = require('./parser');
-const CancelToken = Axios.CancelToken;
-const EventEmitter = require('events');
-
-const OAuth = require('./core/OAuth');
-const Player = require('./core/Player');
-const Actions = require('./core/Actions');
-const Livechat = require('./core/Livechat');
-
-const Utils = require('./utils/Utils');
-const Request = require('./utils/Request');
-const Constants = require('./utils/Constants');
-
-const Proto = require('./proto');
-const NToken = require('./deciphers/NToken');
-const Signature = require('./deciphers/Signature');
-
-class Innertube {
-  #oauth;
-  #player;
-  #retry_count;
-  
-  /**
-   * ```js
-   * const Innertube = require('youtubei.js');
-   * const youtube = await new Innertube();
-   * ```
-   * @param {object} [config]
-   * @param {string} [config.gl]
-   * @param {string} [config.cookie]
-   * @returns {Innertube}
-   * @constructor
-   */
-  constructor(config) {
-    this.config = config || {};
-    this.#retry_count = 0;
-    return this.#init();
-  }
-
-  async #init() {
-    const response = await Axios.get(Constants.URLS.YT_BASE, Constants.DEFAULT_HEADERS(this.config)).catch((error) => error);
-    if (response instanceof Error) throw new Utils.InnertubeError('Could not retrieve Innertube session', { message: response.message, status_code: response.status || 0 });
-
-    const data = JSON.parse(`{${Utils.getStringBetweenStrings(response.data, 'ytcfg.set({', '});') || ''}}`);
-    if (data.INNERTUBE_CONTEXT) {
-      this.key = data.INNERTUBE_API_KEY;
-      this.version = data.INNERTUBE_API_VERSION;
-      this.context = data.INNERTUBE_CONTEXT;
-
-      this.player_url = data.PLAYER_JS_URL;
-      this.logged_in = data.LOGGED_IN;
-      this.sts = data.STS;
-
-      this.context.client.hl = 'en';
-      this.context.client.gl = this.config.gl || 'US';
-
-      /**
-       * @event Innertube#auth - Fired when signing in to an account.
-       * @event Innertube#update-credentials - Fired when the access token is no longer valid.
-       * @type {EventEmitter}
-       */
-      this.ev = new EventEmitter();
-      this.#oauth = new OAuth(this.ev);
-      
-      this.#player = new Player(this);
-      await this.#player.init();
-
-      if (this.logged_in && this.config.cookie) {
-        this.auth_apisid = Utils.getStringBetweenStrings(this.config.cookie, 'PAPISID=', ';');
-        this.auth_apisid = Utils.generateSidAuth(this.auth_apisid);
-      }
-      
-      this.request = new Request(this);
-      
-      this.#initMethods();
-    } else {
-      this.#retry_count += 1;
-      if (this.#retry_count >= 10)
-        throw new Utils.ParsingError('No InnerTubeContext shell provided in ytconfig.', {
-          data_snippet: response.data.slice(0, 300),
-          status_code: response.status || 0
-        });
-      return this.#init();
-    }
-    return this;
-  }
-
-  #initMethods() {
-    this.account = {
-      info: () => this.getAccountInfo(),
-      settings: {
-        notifications: {
-          /**
-           * Notify about activity from the channels you're subscribed to.
-           * 
-           * @param {boolean} new_value 
-           * @returns {Promise.<{ success: boolean; status_code: string; }>}
-           */
-          setSubscriptions: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.SUBSCRIPTIONS, 'account_notifications', new_value),
-
-          /**
-           * Recommended content notifications.
-           * 
-           * @param {boolean} new_value 
-           * @returns {Promise.<{ success: boolean; status_code: string; }>}
-           */
-          setRecommendedVideos: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.RECOMMENDED_VIDEOS, 'account_notifications', new_value),
-
-          /**
-           * Notify about activity on your channel.
-           * 
-           * @param {boolean} new_value 
-           * @returns {Promise.<{ success: boolean; status_code: string; }>}
-           */
-          setChannelActivity: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.CHANNEL_ACTIVITY, 'account_notifications', new_value),
-
-          /**
-           * Notify about replies to your comments.
-           * 
-           * @param {boolean} new_value 
-           * @returns {Promise.<{ success: boolean; status_code: string; }>}
-           */
-          setCommentReplies: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.COMMENT_REPLIES, 'account_notifications', new_value),
-
-          /**
-           * Notify when others mention your channel.
-           * 
-           * @param {boolean} new_value 
-           * @returns {Promise.<{ success: boolean; status_code: string; }>}
-           */
-          setMentions: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.USER_MENTION, 'account_notifications', new_value),
-
-          /**
-           * Notify when others share your content on their channels.
-           * 
-           * @param {boolean} new_value 
-           * @returns {Promise.<{ success: boolean; status_code: string; }>}
-           */
-          setSharedContent: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.SHARED_CONTENT, 'account_notifications', new_value)
-        },
-        privacy: {
-          /**
-           * If set to true, your subscriptions won't be visible to others.
-           * 
-           * @param {boolean} new_value 
-           * @returns {Promise.<{ success: boolean; status_code: string; }>}
-           */
-          setSubscriptionsPrivate: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.SUBSCRIPTIONS_PRIVACY, 'account_privacy', new_value),
-
-          /**
-           * If set to true, saved playlists won't appear on your channel.
-           * 
-           * @param {boolean} new_value 
-           * @returns {Promise.<{ success: boolean; status_code: string; }>}
-           */
-          setSavedPlaylistsPrivate: (new_value) => this.#setSetting(Constants.ACCOUNT_SETTINGS.PLAYLISTS_PRIVACY, 'account_privacy', new_value)
-        }
-      }
-    }
-
-    this.interact = {
-      /**
-       * Likes a given video.
-       * 
-       * @param {string} video_id
-       * @returns {Promise.<{ success: boolean; status_code: string; }>}
-       */
-      like: (video_id) => Actions.engage(this, 'like/like', { video_id }),
-
-      /**
-       * Diskes a given video.
-       * 
-       * @param {string} video_id
-       * @returns {Promise.<{ success: boolean; status_code: string; }>}
-       */
-      dislike: (video_id) => Actions.engage(this, 'like/dislike', { video_id }),
-
-      /**
-       * Removes a like/dislike.
-       * 
-       * @param {string} video_id 
-       * @returns {Promise.<{ success: boolean; status_code: string; }>} 
-       */
-      removeLike: (video_id) => Actions.engage(this, 'like/removelike', { video_id }),
-
-      /**
-       * Posts a comment on a given video.
-       * 
-       * @param {string} video_id 
-       * @param {string} text 
-       * @returns {Promise.<{ success: boolean; status_code: string; }>}
-       */
-      comment: (video_id, text) => Actions.engage(this, 'comment/create_comment', { video_id, text }),
-
-      /**
-       * Subscribes to a given channel.
-       * 
-       * @param {string} channel_id 
-       * @returns {Promise.<{ success: boolean; status_code: string; }>}
-       */
-      subscribe: (channel_id) => Actions.engage(this, 'subscription/subscribe', { channel_id }),
-
-      /**
-       * Unsubscribes from a given channel.
-       * 
-       * @param {string} channel_id 
-       * @returns {Promise.<{ success: boolean; status_code: string; }>}
-       */
-      unsubscribe: (channel_id) => Actions.engage(this, 'subscription/unsubscribe', { channel_id }),
-
-      /**
-       * Changes notification preferences for a given channel.
-       * Only works with channels you are subscribed to.
-       * 
-       * @param {string} channel_id 
-       * @param {string} type PERSONALIZED | ALL | NONE
-       * @returns {Promise.<{ success: boolean; status_code: string; }>} 
-       */
-      setNotificationPreferences: (channel_id, type) => Actions.notifications(this, 'modify_channel_preference', { channel_id, pref: type || 'NONE' }),
-    };
-
-    this.playlist = {
-      /**
-       * Creates a playlist.
-       * 
-       * @param {string} title 
-       * @param {string} video_id - Note that a video must be supplied, empty playlists cannot be created.
-       * @returns {Promise.<{ success: boolean; status_code: string; }>} 
-       */
-      create: (title, video_id) => Actions.engage(this, 'playlist/create', { title, video_id }),
-
-      /**
-       * Deletes a given playlist.
-       * 
-       * @param {string} playlist_id
-       * @returns {Promise.<{ success: boolean; status_code: string; }>} 
-       */
-      delete: (playlist_id) => Actions.engage(this, 'playlist/delete', { playlist_id }),
-
-      /**
-       * Adds an array of videos to a given playlist.
-       * 
-       * @param {string} playlist_id
-       * @param {Array.<string>} video_ids
-       * @returns {Promise.<{ success: boolean; status_code: string; }>} 
-       */
-      addVideos: (playlist_id, video_ids) => Actions.engage(this, 'browse/edit_playlist', { action: 'ACTION_ADD_VIDEO', playlist_id, video_ids })
-    };
-  }
-
-  /**
-   * Internal method to perform changes on an account's settings.
-   * 
-   * @param {string} setting_id 
-   * @param {string} type 
-   * @param {string} new_value 
-   * @returns {Promise.<{ success: boolean; status_code: string; }>}
-   */
-  async #setSetting(setting_id, type, new_value) {
-    const response = await Actions.browse(this, type);
-    if (!response.success) return response;
-    
-    const contents = ({
-      account_notifications: () => Utils.findNode(response.data, 'contents', 'Your preferences', 13, false).options,
-      account_privacy: () => Utils.findNode(response.data, 'contents', 'settingsSwitchRenderer', 13, false).options
-    })[type.trim()]();
-
-    const option = contents.find((option) => option.settingsSwitchRenderer.enableServiceEndpoint.setSettingEndpoint.settingItemIdForClient == setting_id);
-
-    const setting_item_id = option.settingsSwitchRenderer.enableServiceEndpoint.setSettingEndpoint.settingItemId;
-    const set_setting = await Actions.account(this, 'account/set_setting', { new_value: type == 'account_privacy' ? !new_value : new_value, setting_item_id });
-
-    return {
-      success: set_setting.success,
-      status_code: set_setting.status_code,
-    }
-  }
-
-  /**
-   * Signs-in to a google account.
-   *
-   * @param {object} auth_info
-   * @param {string} auth_info.access_token - Token used to sign in.
-   * @param {string} auth_info.refresh_token - Token used to get a new access token.
-   * @param {Date} auth_info.expires - Access token's expiration date, which is usually 24hrs-ish
-   * @returns {Promise.<void>}
-   */
-  signIn(auth_info = {}) {
-    return new Promise(async (resolve) => {
-      this.#oauth.init(auth_info);
-
-      if (this.#oauth.isValidAuthInfo()) {
-        await this.#oauth.checkTokenValidity();
-        this.#updateCredentials();
-        return resolve();
-      }
-  
-      this.ev.on('auth', (data) => {
-        if (data.status === 'SUCCESS') {
-          this.#updateCredentials();
-          resolve();
-        }
-      });
-    });
-  }
-  
-  #updateCredentials() {
-    this.access_token = this.#oauth.getAccessToken();
-    this.refresh_token = this.#oauth.getRefreshToken();
-    this.logged_in = true;
-  }
-  
-  /**
-   * Signs out of your account.
-   * @returns {Promise.<{ success: boolean; status_code: number }>}
-   */
-  async signOut() {
-    if (!this.logged_in) throw new Utils.InnertubeError('You are not signed in');
-    const response = await this.#oauth.revokeAccessToken();
-    response.success && (this.logged_in = false);
-    return response;
-  }
-
-  /**
-   * Retrieves account details.
-   * @returns {Promise.<{ name: string; photo: Array<object>; country: string; language: string; }>}
-   */
-  async getAccountInfo() {
-    const response = await Actions.account(this, 'account/account_menu');
-    if (!response.success) throw new Utils.InnertubeError('Could not get account info', response);
-
-    const menu = Utils.findNode(response, 'actions', 'multiPageMenuRenderer', 6, false);
-
-    return {
-      name: menu.header.activeAccountHeaderRenderer.accountName.simpleText,
-      photo: menu.header.activeAccountHeaderRenderer.accountPhoto.thumbnails,
-      country: menu.sections[1].multiPageMenuSectionRenderer.items[2].compactLinkRenderer.subtitle.simpleText,
-      language: menu.sections[1].multiPageMenuSectionRenderer.items[1].compactLinkRenderer.subtitle.simpleText
-    }
-  }
-
-  /**
-   * Searches on YouTube.
-   *
-   * @param {string} query - Search query.
-   * @param {object} options - Search options.
-   * @param {string} options.client - Client used to perform the search, can be: `YTMUSIC` or `YOUTUBE`. 
-   * @param {string} options.period - Filter videos uploaded within a period, can be: any | hour | day | week | month | year
-   * @param {string} options.order - Filter results by order, can be: relevance | rating | age | views
-   * @param {string} options.duration - Filter video results by duration, can be: any | short | long
-   * @returns {Promise.<{ query: string; corrected_query: string; estimated_results: number; videos: [] } |
-   * { results: { songs: []; videos: []; albums: []; community_playlists: [] } }>} 
-   */
-  async search(query, options = { client: 'YOUTUBE', period: 'any', order: 'relevance', duration: 'any' }) {
-    const response = await Actions.search(this, options.client, { query, options });
-    if (!response.success) throw new Utils.InnertubeError('Could not search on YouTube', response);
-    
-    const results = new Parser(this, response.data, {
-      query, client: options.client,
-      data_type: 'SEARCH'
-    }).parse();
-
-    return results;
-  }
-
-  /**
-   * Retrieves search suggestions.
-   * 
-   * @param {string} input - The search query.
-   * @param {object} [options] - Search options.
-   * @param {string} [options.client='YOUTUBE'] - Client used to retrieve search suggestions, can be: `YOUTUBE` or `YTMUSIC`.
-   * @returns {Promise.<[{ text: string; bold_text: string }]>}
-   */
-  async getSearchSuggestions(input, options = { client: 'YOUTUBE' }) {
-    const response = await Actions.getSearchSuggestions(this, options.client, input);
-    if (!response.success) throw new Utils.InnertubeError('Could not get search suggestions', response);
-    if (options.client === 'YTMUSIC' && !response.data.contents) return [];
-
-    const suggestions = new Parser(this, response.data, {
-      input, client: options.client, 
-      data_type: 'SEARCH_SUGGESTIONS'
-    }).parse();
-    
-    return suggestions;
-  }
-
-  /**
-   * Retrieves video info.
-   *
-   * @param {string} video_id - Video id
-   * @return {Promise.<{ title: string; description: string; thumbnail: []; metadata: object }>}
-   */
-  async getDetails(video_id) {
-    if (!video_id) throw new Utils.MissingParamError('Video id is missing');
-
-    const response = await Actions.getVideoInfo(this, { id: video_id });
-    const continuation = await Actions.next(this, { video_id });
-    continuation.success && (response.continuation = continuation.data);
-
-    const details = new Parser(this, response, {
-      client: 'YOUTUBE', 
-      data_type: 'VIDEO_INFO'
-    }).parse();
-    
-    details.like = () => Actions.engage(this, 'like/like', { video_id });
-    details.dislike = () => Actions.engage(this, 'like/dislike', { video_id });
-    details.removeLike = () => Actions.engage(this, 'like/removelike', { video_id });
-    details.subscribe = () => Actions.engage(this, 'subscription/subscribe', { channel_id: details.metadata.channel_id });
-    details.unsubscribe = () => Actions.engage(this, 'subscription/unsubscribe', { channel_id: details.metadata.channel_id });
-    details.comment = (text) => Actions.engage(this, 'comment/create_comment', { video_id, text });
-    details.getComments = (sort_by) => this.getComments(video_id, sort_by);
-    details.getLivechat = () => new Livechat(this, continuation.data.contents?.twoColumnWatchNextResults?.conversationBar?.liveChatRenderer?.continuations?.find((continuation) => continuation.reloadContinuationData).reloadContinuationData.continuation, details.metadata.channel_id, video_id);
-    details.setNotificationPreferences = (type) => Actions.notifications(this, 'modify_channel_preference', { channel_id: details.metadata.channel_id, pref: type || 'NONE' });
-
-    return details;
-  }
-  
-  /**
-   * Retrieves comments for a video.
-   *
-   * @param {string} video_id - Video id
-   * @param {string} [sort_by] - Can be: `TOP_COMMENTS` or `NEWEST_FIRST`.
-   * @return {Promise.<{ page_count: number; comment_count: number; items: []; }>}
-   */
-  async getComments(video_id, sort_by) {
-    const payload = Proto.encodeCommentsSectionParams(video_id, {
-      sort_by: sort_by || 'TOP_COMMENTS'
-    });
-   
-    const response = await Actions.next(this, { continuation_token: payload });
-    if (!response.success) throw new Utils.InnertubeError('Could not retrieve comments', response);
-
-    const comments = new Parser(this, response.data, {
-      video_id,
-      client: 'YOUTUBE', 
-      data_type: 'COMMENTS'
-    }).parse();
-    
-    return comments;
-  }
-
-  /**
-   * Retrieves contents for a given channel. (WIP)
-   * 
-   * @param {string} id - The id of the channel.
-   * @return {Promise.<{ title: string; description: string; metadata: object; content: object }>}
-   */
-  async getChannel(id) {
-    const response = await Actions.browse(this, 'channel', { browse_id: id });
-    if (!response.success) throw new Utils.InnertubeError('Could not retrieve channel info.', response);
-    
-    const channel_info = new Parser(this, response.data, {
-      client: 'YOUTUBE', 
-      data_type: 'CHANNEL'
-    }).parse();
-    
-    return channel_info;
-  }
-  
-  /**
-   * Retrieves your watch history.
-   * @returns {Promise.<{ items: [{ date: string; videos: [] }] }>}
-   */
-  async getHistory() {
-    const response = await Actions.browse(this, 'history');
-    if (!response.success) throw new Utils.InnertubeError('Could not retrieve watch history', response);
-
-    const history = new Parser(this, response, {
-      client: 'YOUTUBE', 
-      data_type: 'HISTORY'
-    }).parse();
-    
-    return history;
-  }
-
-  /**
-   * Retrieves YouTube's home feed (aka recommendations).
-   * @returns {Promise.<{ videos: [{ id: string; title: string; description: string; channel: string; metadata: object }] }>}
-   */
-  async getHomeFeed() {
-    const response = await Actions.browse(this, 'home_feed');
-    if (!response.success) throw new Utils.InnertubeError('Could not retrieve home feed', response);
-
-    const homefeed = new Parser(this, response, {
-      client: 'YOUTUBE', 
-      data_type: 'HOMEFEED'
-    }).parse();
-    
-    return homefeed;
-  }
-  
-  /**
-   * Retrieves trending content.
-   * @returns {Promise.<{ now: { content: [{ title: string; videos: []; }] };
-   * music: { getVideos: Promise.<Array>; }; gaming: { getVideos: Promise.<Array>; };
-   * gaming: { getVideos: Promise.<Array>; }; }>}
-   */
-  async getTrending() {
-    const response = await Actions.browse(this, 'trending');
-    if (!response.success) throw new Utils.InnertubeError('Could not retrieve trending content', response);
-    
-    const trending = new Parser(this, response, {
-      client: 'YOUTUBE',
-      data_type: 'TRENDING'
-    }).parse();
-    
-    return trending;
-  }
-
-  /**
-   * Retrieves your subscriptions feed.
-   * @returns {Promise.<{ items: [{ date: string; videos: [] }] }>}
-   */
-  async getSubscriptionsFeed() {
-    const response = await Actions.browse(this, 'subscriptions_feed');
-    if (!response.success) throw new Utils.InnertubeError('Could not retrieve subscriptions feed', response);
-
-    const subsfeed = new Parser(this, response, {
-      client: 'YOUTUBE', 
-      data_type: 'SUBSFEED'
-    }).parse();
-
-    return subsfeed;
-  }
-
-  /**
-   * Retrieves your notifications.
-   * @returns {Promise.<{ items: [{ title: string; sent_time: string; channel_name: string; channel_thumbnail: {}; video_thumbnail: {}; video_url: string; read: boolean; notification_id: string }] }>}
-   */
-  async getNotifications() {
-    const response = await Actions.notifications(this, 'get_notification_menu');
-    if (!response.success) throw new Utils.InnertubeError('Could not fetch notifications', response);
-    
-    const notifications = new Parser(this, response.data, {
-      client: 'YOUTUBE', 
-      data_type: 'NOTIFICATIONS'
-    }).parse();
-    
-    return notifications;
-  }
-
-  /**
-   * Retrieves unseen notifications count.
-   * @returns {Promise.<number>} unseen notifications count.
-   */
-  async getUnseenNotificationsCount() {
-    const response = await Actions.notifications(this, 'get_unseen_count');
-    if (!response.success) throw new Utils.InnertubeError('Could not get unseen notifications count', response);
-    return response.data.unseenCount;
-  }
-
-  /**
-   * Retrieves lyrics for a given song if available.
-   * 
-   * @param {string} video_id 
-   * @returns {Promise.<string>} Song lyrics
-   */
-  async getLyrics(video_id) {
-    const continuation = await Actions.next(this, { video_id: video_id, ytmusic: true });
-    if (!continuation.success) throw new Utils.InnertubeError('Could not retrieve lyrics', continuation);
-
-    const lyrics_tab = Utils.findNode(continuation, 'contents',  'Lyrics', 8, false);
-    
-    const response = await Actions.browse(this, 'lyrics', { ytmusic: true, browse_id: lyrics_tab.endpoint?.browseEndpoint.browseId });
-    if (!response.success || !response.data?.contents?.sectionListRenderer) throw new Utils.UnavailableContentError('Lyrics not available', { video_id });
-    
-    const lyrics = Utils.findNode(response.data, 'contents', 'runs', 6, false);
-    return lyrics.runs[0].text;
-  }
-
-  /**
-   * Parses a given playlist.
-   * 
-   * @param {string} playlist_id - The id of the playlist.
-   * @param {object} options - { client: YOUTUBE | YTMUSIC }
-   * @param {string} options.client - Client used to parse the playlist, can be: `YTMUSIC` | `YOUTUBE`
-   * @returns {Promise.<
-   *  { title: string; description: string; total_items: string; last_updated: string; views: string; items: [] } |
-   *  { title: string; description: string; total_items: number; duration: string; year: string; items: [] }>}
-   */
-  async getPlaylist(playlist_id, options = { client: 'YOUTUBE' }) {
-    const response = await Actions.browse(this, options.client == 'YTMUSIC' ? 'music_playlist' : 'playlist', { ytmusic: options.client == 'YTMUSIC', browse_id: `VL${playlist_id}` });
-    if (!response.success) throw new Utils.InnertubeError('Could not get playlist', response);
-    
-    const playlist = new Parser(this, response.data, {
-      client: options.client, 
-      data_type: 'PLAYLIST'
-    }).parse();
-    
-    return playlist;
-  }
-
-  /**
-   * Internal method to process and filter formats.
-   * 
-   * @param {object} options 
-   * @param {object} video_data 
-   * @returns {object.<{ selected_format: {}; formats: [] }>}
-   */
-  #chooseFormat(options, video_data) {
-    let formats = [];
-
-    formats = formats
-      .concat(video_data.streamingData.formats || [])
-      .concat(video_data.streamingData.adaptiveFormats || []);
-
-    formats.forEach((format) => {
-      format.url = format.url || format.signatureCipher || format.cipher;
-
-      if (format.signatureCipher || format.cipher) {
-        format.url = new Signature(format.url, this.#player).decipher();
-      }
-
-      const url_components = new URL(format.url);
-      url_components.searchParams.set('cver', this.context.client.clientVersion);
-      url_components.searchParams.set('ratebypass', 'yes');
-
-      if (url_components.searchParams.get('n')) {
-        url_components.searchParams.set('n', new NToken(this.#player.ntoken_sc, url_components.searchParams.get('n')).transform());
-      }
-
-      format.url = url_components.toString();
-      format.has_audio = !!format.audioBitrate || !!format.audioQuality;
-      format.has_video = !!format.qualityLabel;
-
-      delete format.cipher;
-      delete format.signatureCipher;
-    });
-
-    formats.hls_manifest_url = video_data.streamingData.hlsManifestUrl || undefined;
-    formats.dash_manifest_url = video_data.streamingData.dashManifestUrl || undefined;
-
-    let format;
-    let bitrates;
-    let filtered_formats;
-
-    filtered_formats = ({
-      'video': formats.filter((format) => format.has_video && !format.has_audio),
-      'audio': formats.filter((format) => format.has_audio && !format.has_video),
-      'videoandaudio': formats.filter((format) => format.has_video && format.has_audio)
-    })[options.type] || formats.filter((format) => format.has_video && format.has_audio);
-
-    if (options.type != 'videoandaudio') {
-      let streams;
-
-      options.type != 'audio' &&
-        (streams = filtered_formats.filter((format) => format.mimeType.includes(options.format || 'mp4') && format.qualityLabel == options.quality)) ||
-        (streams = filtered_formats.filter((format) => format.mimeType.includes(options.format || 'mp4')));
-
-      streams == undefined || streams.length == 0 &&
-        (streams = filtered_formats.filter((format) => format.quality == 'medium'));
-
-      bitrates = streams.map((format) => format.bitrate);
-      format = streams.filter((format) => format.bitrate === Math.max(...bitrates))[0];
-    } else {
-      format = filtered_formats[0];
-    }
-
-    return { selected_format: format, formats };
-  }
-
-  /**
-   * An alternative to {@link download}.
-   * Returns deciphered streaming data.
-   * 
-   * @param {string} id - Video id
-   * @param {object} options - Download options.
-   * @param {string} options.quality - Video quality; 360p, 720p, 1080p, etc....
-   * @param {string} options.type - Download type, can be: video, audio or videoandaudio
-   * @param {string} options.format - File format
-   * @returns {Promise.<{ selected_format: {}; formats: [] }>}
-   */
-  async getStreamingData(id, options = {}) {
-    options.quality = options.quality || '360p';
-    options.type = options.type || 'videoandaudio';
-    options.format = options.format || 'mp4';
-
-    const data = await Actions.getVideoInfo(this, { id });
-    const streaming_data = this.#chooseFormat(options, data);
-    if (!streaming_data.selected_format) throw new Utils.NoStreamingDataError('Could not find any suitable format.', { id, options });
-
-    return streaming_data;
-  }
-
-  /**
-   * Downloads a given video. If you only need the direct download link take a look at {@link getStreamingData}.
-   * 
-   * @param {string} id - Video id
-   * @param {object} options - Download options.
-   * @param {string} options.quality - Video quality; 360p, 720p, 1080p, etc....
-   * @param {string} options.type - Download type, can be: video, audio or videoandaudio
-   * @param {string} options.format - File format
-   * @return {ReadableStream}
-   */
-  download(id, options = {}) {
-    if (!id) throw new Utils.MissingParamError('Video id is missing');
-
-    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 }).then(async (video_data) => {
-      if (video_data.playabilityStatus.status === 'LOGIN_REQUIRED')
-        return stream.emit('error', { message: 'You must login to download age-restricted videos.', error_type: 'LOGIN_REQUIRED', playability_status: video_data.playabilityStatus.status });
-      if (!video_data.streamingData)
-        return stream.emit('error', { message: 'Streaming data not available.', error_type: 'NO_STREAMING_DATA', playability_status: video_data.playabilityStatus.status });
-
-      const { selected_format: format, formats } = this.#chooseFormat(options, video_data);
-
-      if (!format)
-        return stream.emit('error', { message: 'Could not find any suitable format.', type: 'FORMAT_UNAVAILABLE' });
-
-      const video_details = new Parser(this, video_data, { client: 'YOUTUBE', data_type: 'VIDEO_INFO' }).parse();
-      stream.emit('info', { video_details, selected_format: format, formats });
-
-      if (options.type == 'videoandaudio' && !options.range) {
-        const response = await Axios.get(format.url, {
-          responseType: 'stream',
-          cancelToken: new CancelToken(function executor(c) { cancel = c; }),
-          headers: Constants.STREAM_HEADERS
-        }).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', {
-            size,
-            percentage,
-            chunk_size: chunk.length,
-            downloaded_size: (downloaded_size / 1024 / 1024).toFixed(2),
-            raw_data: {
-              chunk_size: chunk.length,
-              downloaded: downloaded_size,
-              size: response.headers['content-length']
-            }
-          });
-        });
-
-        response.data.on('error', (err) => {
-          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 >= format.contentLength || options.range) && (must_end = true);
-          options.range && (format.contentLength = options.range.end);
-
-          const response = await Axios.get(`${format.url}&range=${chunk_start}-${chunk_end || ''}`, {
-            responseType: 'stream',
-            cancelToken: new CancelToken(function executor(c) { cancel = c; }),
-            headers: Constants.STREAM_HEADERS
-          }).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 = (format.contentLength / 1024 / 1024).toFixed(2);
-            let percentage = Math.floor((downloaded_size / format.contentLength) * 100);
-
-            stream.emit('progress', {
-              size,
-              percentage,
-              chunk_size: chunk.length,
-              downloaded_size: (downloaded_size / 1024 / 1024).toFixed(2),
-              raw_data: {
-                chunk_size: chunk.length,
-                downloaded: downloaded_size,
-                size: response.headers['content-length']
-              }
-            });
-          });
-
-          response.data.on('error', (err) => {
-            cancelled &&
-              stream.emit('error', { message: 'The download was cancelled.', type: 'DOWNLOAD_CANCELLED' }) ||
-              stream.emit('error', { message: err.message, type: 'DOWNLOAD_ABORTED' });
-          });
-
-          response.data.on('end', () => {
-            if (!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/core/Actions.js

@@ -1,461 +0,0 @@
-'use strict';
-
-const Uuid = require('uuid');
-const Axios = require('axios');
-const Proto = require('../proto');
-const Utils = require('../utils/Utils');
-const Constants = require('../utils/Constants');
-
-/**
- * Performs direct interactions on YouTube.
- *
- * @param {Innertube} session 
- * @param {string} engagement_type
- * @param {object} args
- * @returns {Promise.<{ success: boolean; status_code: number; data: object; message?: string }>}
- */
-async function engage(session, engagement_type, args = {}) {
-  if (!session.logged_in) throw new Utils.InnertubeError('You are not signed in');
-
-  const data = { context: session.context };
-  switch (engagement_type) {
-    case 'like/like':
-    case 'like/dislike':
-    case 'like/removelike':
-      data.target = {
-        videoId: args.video_id
-      }
-      break;
-    case 'subscription/subscribe':
-    case 'subscription/unsubscribe':
-      data.channelIds = [args.channel_id];
-      data.params = engagement_type == 'subscription/subscribe' ? 'EgIIAhgA' : 'CgIIAhgA';
-      break;
-    case 'comment/create_comment':
-      data.commentText = args.text;
-      data.createCommentParams = Proto.encodeCommentParams(args.video_id);
-      break;
-    case 'comment/create_comment_reply':
-      data.createReplyParams = Proto.encodeCommentReplyParams(args.comment_id, args.video_id);
-      data.commentText = args.text;
-      break;
-    case 'comment/perform_comment_action':
-      const action = ({
-        like: () => Proto.encodeCommentActionParams(5, args.comment_id, args.video_id),
-        dislike: () => Proto.encodeCommentActionParams(4, args.comment_id, args.video_id),
-      })[args.comment_action]();
-      data.actions = [ action ];
-      break;
-    case 'playlist/create':
-      data.title = args.title;
-      data.videoIds = [args.video_id]; 
-      break;
-    case 'playlist/delete':
-      data.playlistId = args.playlist_id;
-      break;
-    case 'browse/edit_playlist':
-      data.playlistId = args.playlist_id;
-      data.actions = args.video_ids.map((id) => ({
-        action: args.action, 
-        addedVideoId: id
-      }));
-      break;
-    default:
-      throw new Utils.InnertubeError('Invalid action', engagement_type);
-  }
-  
-  const response = await session.request.post(`/${engagement_type}`, JSON.stringify(data)).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response?.status || 0, message: response.message };
-
-  return {
-    success: true,
-    status_code: response.status
-  };
-}
-
-/**
- * Accesses YouTube's various sections.
- *
- * @param {Innertube} session 
- * @param {string} action 
- * @param {object} args 
- * @returns {Promise.<{ success: boolean; status_code: number; data: object; message?: string }>}
- */
-async function browse(session, action, args = {}) {
-  if (!session.logged_in && ![ 'home_feed', 'lyrics',
-    'music_playlist', 'playlist', 'trending' ].includes(action))
-      throw new Utils.InnertubeError('You are not signed in');
-
-  const data = { context: session.context };
-  switch (action) {
-    case 'account_notifications':
-      data.browseId = 'SPaccount_notifications';
-      break;
-    case 'account_privacy':
-      data.browseId = 'SPaccount_privacy';
-      break;
-    case 'history':
-      data.browseId = 'FEhistory';
-      break;
-    case 'home_feed':
-      data.browseId = 'FEwhat_to_watch';
-      break;
-    case 'trending':
-      data.browseId = 'FEtrending';
-      args.params && (data.params = args.params);
-      break;
-    case 'subscriptions_feed':
-      data.browseId = 'FEsubscriptions';
-      break;
-    case 'lyrics':
-    case 'music_playlist':
-      const context = JSON.parse(JSON.stringify(session.context)); // deep copy the context obj so we don't accidentally change it
-
-      context.client.originalUrl = Constants.URLS.YT_MUSIC;
-      context.client.clientVersion = Constants.YTMUSIC_VERSION;
-      context.client.clientName = 'WEB_REMIX';
-      
-      data.context = context;
-      data.browseId = args.browse_id;
-      break;
-    case 'channel':
-    case 'playlist':
-      data.browseId = args.browse_id;
-      break;
-    case 'continuation':
-      data.continuation = args.ctoken;
-      break;
-    default:
-      throw new Utils.InnertubeError('Invalid action', action);
-  }
-  
-  const response = await session.request.post('/browse', JSON.stringify(data)).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response?.status || 0, message: response.message };
-
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
-}
-
-/**
- * Endpoints used to report content.
- *
- * @param {Innertube} session 
- * @param {string} action 
- * @param {object} args 
- * @returns {Promise.<{ success: boolean; status_code: number; data: object; message?: string }>}
- */
-async function flag(session, action, args = {}) {
-  if (!session.logged_in) throw new Utils.InnertubeError('You are not signed in');
-  const data = { context: session.context };
- 
-  switch (action) {
-    case 'flag/flag':
-      data.action = args.action;
-      break;
-    case 'flag/get_form':
-      data.params = args.params;
-      break;
-    default:
-      throw new Utils.InnertubeError('Invalid action', action);
-  }
-  
-  const response = await session.request.post(`/${action}`, JSON.stringify(data)).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response?.status || 0, message: response.message };
-
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
-}
-
-/**
- * Account settings endpoints.
- *
- * @param {Innertube} session 
- * @param {string} action 
- * @param {object} args 
- * @returns {Promise.<{ success: boolean; status_code: number; data: object; message?: string }>}
- */
-async function account(session, action, args = {}) {
-  if (!session.logged_in) throw new Utils.InnertubeError('You are not signed in');
-
-  const data = {};
-  switch (action) {
-    case 'account/account_menu':
-      data.context = session.context;
-      break;
-    case 'account/set_setting':
-      data.context = session.context;
-      data.newValue = { boolValue: args.new_value };
-      data.settingItemId = args.setting_item_id;
-      break;
-    default:
-      throw new Utils.InnertubeError('Invalid action', action);
-  }
-  
-  const response = await session.request.post(`/${action}`, JSON.stringify(data)).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response?.status || 0, message: response.message };
- 
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
-}
-
-/**
- * Accesses YouTube Music endpoints (/youtubei/v1/music/).
- * 
- * @param {Innertube} session 
- * @param {string} action 
- * @param {object} args 
- * @todo Implement more endpoints.
- * @returns {Promise.<{ success: boolean; status_code: number; data: object; message?: string }>}
- */
-async function music(session, action, args) {
-  const context = JSON.parse(JSON.stringify(session.context)); // deep copy the context obj so we don't accidentally change it
-
-  context.client.originalUrl = Constants.URLS.YT_MUSIC;
-  context.client.clientVersion = Constants.YTMUSIC_VERSION;
-  context.client.clientName = 'WEB_REMIX';
-
-  let data = {};
-  switch (action) {
-    case 'get_search_suggestions':
-      data.context = context;
-      data.input = args.input || '';
-      break;
-    default:
-      throw new Utils.InnertubeError('Invalid action', action);
-  }
-  
-  const response = await session.request.post(`/music/${action}`, JSON.stringify(data)).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response?.status || 0, message: response.message };
-
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
-}
-
-/**
- * Searches a given query on YouTube/YTMusic.
- *
- * @param {Innertube} session 
- * @param {string} client - YouTube client: YOUTUBE | YTMUSIC
- * @param {object} args - Search arguments.
- * @returns {Promise.<{ success: boolean; status_code: number; data: object; message?: string }>}
- */
-async function search(session, client, args = {}) {
-  const data = { context: session.context };
-  switch (client) {
-    case 'YOUTUBE':
-      if (args.query) {
-        data.params = Proto.encodeSearchFilter(args.options.period, args.options.duration, args.options.order);
-        data.query = args.query;
-      } else {
-        data.continuation = args.ctoken;
-      }
-      break;
-    case 'YTMUSIC':
-      const context = JSON.parse(JSON.stringify(session.context)); // deep copy the context obj so we don't accidentally change it
-
-      context.client.originalUrl = Constants.URLS.YT_MUSIC;
-      context.client.clientVersion = Constants.YTMUSIC_VERSION;
-      context.client.clientName = 'WEB_REMIX';
-      
-      data.context = context;
-      data.query = args.query;
-      break;
-    default:
-      throw new Utils.InnertubeError('Invalid client', client);
-  }
-  
-  const response = await session.request.post('/search', JSON.stringify(data)).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response?.status || 0, message: response.message };
-
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
-}
-
-/**
- * Interacts with YouTube's notification system.
- *
- * @param {Innertube} session 
- * @param {string} action 
- * @param {object} args
- * @returns {Promise.<{ success: boolean; status_code: number; data: object; message?: string }>}
- */
-async function notifications(session, action, args = {}) {
-  if (!session.logged_in) throw new Utils.InnertubeError('You are not signed in');
-
-  const data = {};
-  switch (action) {
-    case 'modify_channel_preference':
-      const pref_types = { PERSONALIZED: 1, ALL: 2, NONE: 3 };
-      data.context = session.context;
-      data.params = Proto.encodeNotificationPref(args.channel_id, pref_types[args.pref.toUpperCase()]);
-      break;
-    case 'get_notification_menu':
-      data.context = session.context;
-      data.notificationsMenuRequestType = 'NOTIFICATIONS_MENU_REQUEST_TYPE_INBOX';
-      args.ctoken && (data.ctoken = args.ctoken);
-      break;
-    case 'get_unseen_count':
-      data.context = session.context;
-      break;
-    default:
-      throw new Utils.InnertubeError('Invalid action', action);
-  }
-  
-  const response = await session.request.post(`/notification/${action}`, JSON.stringify(data)).catch((err) => err);
-  if (response instanceof Error) return { success: false, status_code: response.response?.status || 0, message: response.message };
-  if (action === '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 {Innertube} session 
- * @param {string} action 
- * @param {object} args
- * @returns {Promise.<{ success: boolean; data: object; message?: string }>}
- */
-async function livechat(session, action, args = {}) {
-  const data = {};
-  switch (action) {
-    case 'live_chat/get_live_chat':
-      data.context = session.context;
-      data.continuation = args.ctoken;
-      break;
-    case 'live_chat/send_message':
-      data.context = session.context;
-      data.params = Proto.encodeMessageParams(args.channel_id, args.video_id);
-      data.clientMessageId = Uuid.v4();
-      data.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;
-      data.params = args.cmd_params;
-      break;
-    case 'updated_metadata':
-      data.context = session.context;
-      data.videoId = args.video_id;
-      args.continuation && (data.continuation = args.continuation);
-      break;
-    default:
-      throw new Utils.InnertubeError('Invalid action', action);
-  }
-  
-  const response = await session.request.post(`/${action}`, JSON.stringify(data)).catch((err) => err);
-  if (response instanceof Error) return { success: false, message: response.message };
-  
-  return { success: true, data: response.data };
-}
-
-/**
- * Requests continuation for previously performed actions.
- *
- * @param {Innertube} session 
- * @param {object} args
- * @returns {Promise.<{ success: boolean; status_code: number; data: object; message?: string }>} 
- */
-async function next(session, args = {}) {
-  let data = { context: session.context };
-  args.continuation_token && (data.continuation = args.continuation_token);
-
-  if (args.video_id) {
-    data.videoId = args.video_id;
-    if (args.ytmusic) {
-      const context = JSON.parse(JSON.stringify(session.context)); // deep copy the context obj so we don't accidentally change it
-
-      context.client.originalUrl = Constants.URLS.YT_MUSIC;
-      context.client.clientVersion = Constants.YTMUSIC_VERSION;
-      context.client.clientName = 'WEB_REMIX';
-
-      data.context = context;
-      data.isAudioOnly = true;
-      data.tunerSettingValue = 'AUTOMIX_SETTING_NORMAL';
-    } else {
-      data.racyCheckOk = true;
-      data.contentCheckOk = false;
-      data.autonavState = 'STATE_NONE';
-      data.playbackContext = { vis: 0, lactMilliseconds: '-1' };
-      data.captionsRequested = false;
-    }
-  }
-  
-  const response = await session.request.post('/next', JSON.stringify(data)).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response?.status || 0, message: response.message  };
-
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
-}
-
-/**
- * Retrieves video data.
- *
- * @param {Innertube} session 
- * @param {object} args
- * @returns {Promise.<object>} - Video data.
- */
-async function getVideoInfo(session, args = {}) {
-  const response = await session.request.post(`/player`, JSON.stringify(Constants.VIDEO_INFO_REQBODY(args.id, session.sts, session.context))).catch((err) => err);
-  if (response instanceof Error) throw new Utils.InnertubeError(`Could not get video info: ${response.message}`);
-  return response.data;
-}
-
-/**
- * Gets search suggestions.
- * 
- * @param {Innertube} session
- * @param {string} query
- * @returns {Promise.<{ success: boolean; status_code: number; data: object; message?: string }>}
- */
-async function getSearchSuggestions(session, client, input) {
-  if (!['YOUTUBE', 'YTMUSIC'].includes(client))
-    throw new Utils.InnertubeError('Invalid client', client);
-  
-  const response = await ({
-    'YOUTUBE': async () => {
-      const response = await Axios.get(`${Constants.URLS.YT_SUGGESTIONS}search?client=firefox&ds=yt&q=${encodeURIComponent(input)}`,
-      Constants.DEFAULT_HEADERS(session.config)).catch((error) => error);
-      
-      return {
-        success: !(response instanceof Error),
-        status_code: response.status,
-        data: response?.data
-      };
-    },
-    'YTMUSIC': async () => {
-      const response = await music(session, 'get_search_suggestions', { input });
-      return response;
-    }
-  }[client])();
-  
-  return response;
-}
-
-module.exports = { engage, browse, account, flag, music, search, notifications, livechat, getVideoInfo, next, getSearchSuggestions };

lib/core/Livechat.js

@@ -1,139 +0,0 @@
-'use strict';
-
-const Actions = require('./Actions');
-const EventEmitter = require('events');
-
-class Livechat extends EventEmitter {
-  constructor(session, token, channel_id, video_id) {
-    super(session);
-
-    if (!token)
-      throw new Error('Could not retrieve livechat data');
-
-    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
-      }
-    };
-  }
-
-  /**
-   * Blocks a user.
-   * @todo Implement this method.
-   * @param {object} msg_params 
-   */
-  async blockUser(msg_params) {
-    throw new Error('Not implemented');
-  }
-
-  stop() {
-    this.running = false;
-    clearTimeout(this.livechat_poller);
-  }
-}
-
-module.exports = Livechat;

lib/core/OAuth.js

@@ -1,235 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-const Constants = require('../utils/Constants');
-const Uuid = require('uuid');
-
-class OAuth {
-  #scope = Constants.OAUTH.SCOPE;
-  #model_name = Constants.OAUTH.MODEL_NAME;
-  #grant_type = Constants.OAUTH.GRANT_TYPE;
-  
-  #oauth_code_url = `${Constants.URLS.YT_BASE}/o/oauth2/device/code`;
-  #oauth_token_url = `${Constants.URLS.YT_BASE}/o/oauth2/token`;
-  #oauth_revoke_url = `${Constants.URLS.YT_BASE}/o/oauth2/revoke`;
-  
-  #auth_info = {};
-  #refresh_interval = 5;
-  #ev = null;
-  
-  constructor(ev) {
-    this.#ev = ev;
-  }
-  
-  /**
-   * Starts the auth flow in case no valid credentials are available.
-   * @returns {Promise.<void>}
-   */
-  async init(auth_info) {
-    this.#auth_info = auth_info;
-    if (!auth_info.access_token) {
-      this.#requestUserCode();
-    }
-  }
-
-  /**
-   * Asks the OAuth server for a user code
-   * and verification URL.
-   * 
-   * @returns {Promise.<void>}
-   */
-  async #requestUserCode() {
-    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.#ev.emit('auth', { error: 'Could not obtain user code.', status: 'FAILED' });
-
-    this.#ev.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.
-   * @returns 
-   */
-  #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.#ev.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.#ev.emit('auth', {
-              error: 'Access was denied.',
-              status: 'ACCESS_DENIED'
-            });
-            break;
-          case 'expired_token':
-            this.#ev.emit('auth', {
-              error: 'The user code has expired, requesting a new one.',
-              status: 'DEVICE_CODE_EXPIRED'
-            });
-            this.#requestUserCode();
-            break;
-          default:
-        }
-      } else {
-        const expiration_date = new Date(new Date().getTime() + response.data.expires_in * 1000);
-
-        const credentials = {
-          access_token: response.data.access_token,
-          refresh_token: response.data.refresh_token,
-          expires: expiration_date,
-        };
-
-        this.#auth_info = credentials;
-
-        this.#ev.emit('auth', {
-          credentials,
-          status: 'SUCCESS'
-        });
-      }
-    }, 1000 * this.#refresh_interval);
-  }
-  
-  /**
-   * Refreshes the access token if necessary.
-   * @returns {Promise.<void>}
-   */
-  async checkTokenValidity() {
-    if (this.shouldRefreshToken()) {
-      await this.#refreshAccessToken();
-    }
-  }
-  
-  /**
-   * Gets a new access token using a refresh token.
-   * @returns {Promise.<void>}
-   */
-  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) 
-      return this.#ev.emit('update-credentials', {
-        error: 'Could not refresh access token.',
-        status: 'FAILED'
-      });
-
-    const expiration_date = new Date(new Date().getTime() + response.data.expires_in * 1000);
-
-    const credentials = {
-      access_token: response.data.access_token,
-      refresh_token: response.data.refresh_token || this.#auth_info.refresh_token,
-      expires: expiration_date,
-    };
-
-    this.#auth_info = credentials;
-    
-    this.#ev.emit('update-credentials', {
-      credentials,
-      status: 'SUCCESS'
-    });
-  }
-  
-  /**
-   * Revokes access token (note that the refresh token will also be revoked).
-   * @returns {Promise.<void>}
-   */
-  async revokeAccessToken() {
-    const response = await Axios.post(`${this.#oauth_revoke_url}?token=${this.getAccessToken()}`, Constants.OAUTH.HEADERS).catch((error) => error);
-    return {
-      success: !(response instanceof Error),
-      status_code: response.status || 0
-    }
-  }
-
-  /**
-   * Gets client identity data.
-   * @returns {Promise.<{ id: string; secret: string }>} 
-   */
-  async #getClientIdentity() {
-    // This request is made to get the auth script url, hard-coding it isn't viable as it changes overtime.
-    const yttv_response = await Axios.get(`${Constants.URLS.YT_BASE}/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 = Constants.OAUTH.REGEX.AUTH_SCRIPT.exec(yttv_response.data)[1];
-    const script_url = `${Constants.URLS.YT_BASE}/${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(Constants.OAUTH.REGEX.CLIENT_IDENTITY);
-    return client_identity.groups;
-  }
-  
-  getAccessToken() {
-    return this.#auth_info.access_token;
-  }
-  
-  getRefreshToken() {
-    return this.#auth_info.refresh_token;
-  }
-  
-  /**
-   * Checks if the auth info is valid.
-   * @returns {boolean} true | false
-   */
-  isValidAuthInfo() {
-    return this.#auth_info.hasOwnProperty('access_token')
-      && this.#auth_info.hasOwnProperty('refresh_token')
-      && this.#auth_info.hasOwnProperty('expires');
-  }
-
-  /**
-   * Checks access token validity.
-   * @returns {boolean} true | false
-   */
-  shouldRefreshToken() {
-    const timestamp = new Date(this.#auth_info.expires).getTime();
-    return new Date().getTime() > timestamp;
-  }
-}
-
-module.exports = OAuth;

lib/core/Player.js

@@ -1,49 +0,0 @@
-'use strict';
-
-const Fs = require('fs');
-const Axios = require('axios');
-const Utils = require('../utils/Utils');
-const Constants = require('../utils/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, -8) + '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}${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 {
-        // Deletes old players
-        Fs.existsSync(this.tmp_cache_dir) && Fs.rmSync(this.tmp_cache_dir, { recursive: true });
-
-        // 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/deciphers/NToken.js

@@ -1,139 +0,0 @@
-'use strict';
-
-const Utils = require('../utils/Utils');
-const Constants = require('../utils/Constants');
-
-class NToken {
-  constructor(raw_code, n) {
-    this.n = n;
-    this.raw_code = raw_code;
-  }
-
-  /**
-   * Solves throttling challange by transforming the n token.
-   * @returns {string} transformed token.
-   */
-  transform() {
-    let n_token = this.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 all placeholders with the transformations array
-      const placeholder_indexes = [...this.raw_code.matchAll(Constants.NTOKEN_REGEX.PLACEHOLDERS)].map((item) => parseInt(item[1]));
-      placeholder_indexes.forEach((i) => transformations[i] = transformations);
-
-      // Parses and emulates calls to the functions of the transformations array
-      const function_calls = [...Utils.getStringBetweenStrings(this.raw_code.replace(/\n/g, ''), 'try{', '}catch')
-        .matchAll(Constants.NTOKEN_REGEX.CALLS)].map((params) => ({ index: params[1], params: params[2] }));
-
-      function_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 (${this.n}), download may be throttled:`, err.message);
-      return this.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(Utils.refineNTokenData(data));
-  }
-
-  /**
-   * Gets a base64 alphabet and uses it as a lookup table to modify n.
-   * @returns
-   */
-  #translate1(arr, token, is_reverse_base64) {
-    const characters = is_reverse_base64 && Constants.BASE64_DIALECT.REVERSE || Constants.BASE64_DIALECT.NORMAL;
-    arr.forEach(function(char, index, loc) {
-      this.push(loc[index] = characters[(characters.indexOf(char) - characters.indexOf(this[index]) + 64) % characters.length]);
-    }, 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'.
-   * @returns {string[]}
-   */
-  #getBase64Dia(is_reverse_base64) {
-    const characters = is_reverse_base64 && Constants.BASE64_DIALECT.REVERSE || Constants.BASE64_DIALECT.NORMAL;
-    return characters;
-  }
-
-  /**
-   * Swaps the first element with the one at the given index.
-   * @returns
-   */
-  #swap0(arr, index) {
-    const old_elem = arr[0];
-    index = (index % arr.length + arr.length) % arr.length;
-    arr[0] = arr[index];
-    arr[index] = old_elem;
-  }
-
-  /**
-   * Rotates elements of the array.
-   * @returns
-   */
-  #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.
-   * @returns
-   */
-  #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/deciphers/Signature.js

@@ -1,75 +0,0 @@
-'use strict';
-
-const QueryString = require('querystring');
-
-class Signature {
-  constructor(url, player) {
-    this.url = url;
-    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 ? url_components.searchParams.set(args.sp, signature.join('')) : url_components.searchParams.set('signature', signature.join(''));
-    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 = Signature;

lib/parser/index.js

@@ -1,548 +0,0 @@
-'use strict';
-
-const Utils = require('../utils/Utils');
-const Actions = require('../core/Actions');
-const Constants = require('../utils/Constants');
-const YTDataItems = require('./youtube');
-const YTMusicDataItems = require('./ytmusic');
-const Proto = require('../proto');
-
-class Parser {
-  constructor(session, data, args = {}) {
-    this.data = data;
-    this.session = session;
-    this.args = args;
-  }
-
-  parse() {
-    const client = this.args.client;
-    const data_type = this.args.data_type
-
-    let processed_data;
-
-    switch (client) {
-      case 'YOUTUBE':
-        processed_data = ({
-          SEARCH: () => this.#processSearch(),
-          CHANNEL: () => this.#processChannel(),
-          PLAYLIST: () => this.#processPlaylist(),
-          SUBSFEED: () => this.#processSubscriptionFeed(),
-          HOMEFEED: () => this.#processHomeFeed(),
-          TRENDING: () => this.#processTrending(),
-          HISTORY: () => this.#processHistory(),
-          COMMENTS: () => this.#processComments(),
-          VIDEO_INFO: () => this.#processVideoInfo(),
-          NOTIFICATIONS: () => this.#processNotifications(),
-          SEARCH_SUGGESTIONS: () => this.#processSearchSuggestions(),
-        })[data_type]()
-        break;
-      case 'YTMUSIC':
-        processed_data = ({
-          SEARCH: () => this.#processMusicSearch(),
-          PLAYLIST: () => this.#processMusicPlaylist(),
-          SEARCH_SUGGESTIONS: () => this.#processMusicSearchSuggestions(),
-        })[data_type]();
-        break;
-      default:
-        throw new Utils.InnertubeError('Invalid client');
-    }
-
-    return processed_data;
-  }
-
-  #processSearch() {
-    const contents = Utils.findNode(this.data, 'contents', 'contents', 5);
-
-    const processed_data = {};
-
-    const parseItems = (contents) => {
-      const content = contents[0].itemSectionRenderer.contents;
-      
-      processed_data.query = content[0]?.showingResultsForRenderer?.originalQuery?.simpleText || this.args.query;
-      processed_data.corrected_query = content[0]?.showingResultsForRenderer?.correctedQueryEndpoint?.searchEndpoint?.query || 'N/A';
-      processed_data.estimated_results = parseInt(this.data.estimatedResults);
-
-      processed_data.videos = YTDataItems.VideoResultItem.parse(content);
-      
-      processed_data.getContinuation = async () => {
-        const citem = contents.find((item) => item.continuationItemRenderer);
-        const ctoken = citem.continuationItemRenderer.continuationEndpoint.continuationCommand.token;
-
-        const response = await Actions.search(this.session, 'YOUTUBE', { ctoken });
-        if (!response.success) throw new Utils.InnertubeError('Could not get continuation', response);
-
-        const continuation_items = Utils.findNode(response.data, 'onResponseReceivedCommands', 'itemSectionRenderer', 4, false);
-        return parseItems(continuation_items);
-      };
-
-      return processed_data;
-    }
-
-    return parseItems(contents);
-  }
-  
-  #processMusicSearch() {
-    const tabs = Utils.findNode(this.data, 'contents', 'tabs').tabs;
-    const contents = Utils.findNode(tabs, '0', 'contents', 5);
-
-    const did_you_mean_item = contents.find((content) => content.itemSectionRenderer);
-    const did_you_mean_renderer = did_you_mean_item?.itemSectionRenderer.contents[0].didYouMeanRenderer;
-
-    const processed_data = {
-      query: '',
-      corrected_query: '',
-      results: {}
-    };
-
-    processed_data.query = this.args.query;
-    processed_data.corrected_query = did_you_mean_renderer?.correctedQuery.runs.map((run) => run.text).join('') || 'N/A';
-
-    contents.forEach((content) => {
-      const section = content?.musicShelfRenderer;
-      if (section) {
-        const section_title = section.title.runs[0].text;
-
-        const section_items = ({
-          ['Top result']: () => YTMusicDataItems.TopResultItem.parse(section.contents),
-          ['Songs']: () => YTMusicDataItems.SongResultItem.parse(section.contents),
-          ['Videos']: () => YTMusicDataItems.VideoResultItem.parse(section.contents),
-          ['Featured playlists']: () => YTMusicDataItems.PlaylistResultItem.parse(section.contents),
-          ['Community playlists']: () => YTMusicDataItems.PlaylistResultItem.parse(section.contents),
-          ['Artists']: () => YTMusicDataItems.ArtistResultItem.parse(section.contents),
-          ['Albums']: () => YTMusicDataItems.AlbumResultItem.parse(section.contents)
-        })[section_title]();
-
-        processed_data.results[section_title.replace(/ /g, '_').toLowerCase()] = section_items;
-      }
-    });
-
-    return processed_data;
-  }
-  
-  #processSearchSuggestions() {
-    return YTDataItems.SearchSuggestionItem.parse(this.data[1], this.data[0]);
-  }
-  
-  #processMusicSearchSuggestions() {
-    const contents = this.data.contents[0].searchSuggestionsSectionRenderer.contents;
-    return YTMusicDataItems.MusicSearchSuggestionItem.parse(contents);
-  }
-  
-  #processPlaylist() {
-    const details = this.data.sidebar.playlistSidebarRenderer.items[0];
-
-    const metadata = {
-      title: this.data.metadata.playlistMetadataRenderer.title,
-      description: details.playlistSidebarPrimaryInfoRenderer.description.simpleText || 'N/A',
-      total_items: details.playlistSidebarPrimaryInfoRenderer.stats[0].runs[0].text,
-      last_updated: details.playlistSidebarPrimaryInfoRenderer.stats[2].runs[1].text,
-      views: details.playlistSidebarPrimaryInfoRenderer.stats[1].simpleText
-    }
-
-    const list = Utils.findNode(this.data, 'contents', 'contents', 13, false);
-    const items = YTDataItems.PlaylistItem.parse(list.contents);
-
-    return {
-      ...metadata,
-      items
-    }
-  }
-
-  #processMusicPlaylist() {
-    const details = this.data.header.musicDetailHeaderRenderer;
-
-    const metadata = {
-      title: details?.title?.runs[0].text,
-      description: details?.description?.runs?.map((run) => run.text).join('') || 'N/A',
-      total_items: parseInt(details?.secondSubtitle?.runs[0].text.match(/\d+/g)),
-      duration: details?.secondSubtitle?.runs[2].text,
-      year: details?.subtitle?.runs[4].text
-    };
-
-    const contents = this.data.contents.singleColumnBrowseResultsRenderer.tabs[0].tabRenderer.content.sectionListRenderer.contents;
-    const playlist_content = contents[0].musicPlaylistShelfRenderer.contents;
-
-    const items = YTMusicDataItems.PlaylistItem.parse(playlist_content);
-
-    return {
-      ...metadata,
-      items
-    }
-  }
-
-  /**
-   * Video data is parsed dynamically, so if youtube decides to add something new we won't have to change anything here.
-   */
-  #processVideoInfo() {
-    const playability_status = this.data.playabilityStatus;
-
-    if (playability_status.status == 'ERROR')
-      throw new Error(`Could not retrieve video details: ${playability_status.status} - ${playability_status.reason}`);
-
-    const details = this.data.videoDetails;
-    const microformat = this.data.microformat.playerMicroformatRenderer;
-    const streaming_data = this.data.streamingData;
-
-    const mf_raw_data = Object.entries(microformat);
-    const dt_raw_data = Object.entries(details);
-
-    const processed_data = {
-      id: '',
-      title: '',
-      description: '',
-      thumbnail: [],
-      metadata: {}
-    };
-
-    // Extracts most of the metadata
-    mf_raw_data.forEach((entry) => {
-      const key = Utils.camelToSnake(entry[0]);
-      if (Constants.METADATA_KEYS.includes(key)) {
-        key == 'view_count' && (processed_data.metadata[key] = parseInt(entry[1])) ||
-          key == 'owner_profile_url' && (processed_data.metadata.channel_url = entry[1]) ||
-          key == 'owner_channel_name' && (processed_data.metadata.channel_name = entry[1]) ||
-          (processed_data.metadata[key] = entry[1]);
-      } else {
-        processed_data[key] = entry[1];
-      }
-    });
-
-    // Extracts extra details 
-    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' && (processed_data.metadata[key] = parseInt(entry[1])) ||
-          (processed_data.metadata[key] = entry[1]);
-      } else {
-        key == 'short_description' && (processed_data.description = entry[1]) ||
-          key == 'thumbnail' && (processed_data.thumbnail = entry[1].thumbnails.slice(-1)[0]) ||
-          key == 'video_id' && (processed_data.id = entry[1]) ||
-          (processed_data[key] = entry[1]);
-      }
-    });
-
-    // Data continuation is only required for getDetails()
-    if (this.data.continuation) {
-      const primary_info_renderer = this.data.continuation.contents.twoColumnWatchNextResults
-        .results.results.contents.find((item) => item.videoPrimaryInfoRenderer).videoPrimaryInfoRenderer;
-
-      const secondary_info_renderer = this.data.continuation.contents.twoColumnWatchNextResults
-        .results.results.contents.find((item) => item.videoSecondaryInfoRenderer).videoSecondaryInfoRenderer;
-
-      const like_btn = primary_info_renderer.videoActions.menuRenderer
-        .topLevelButtons.find((item) => item.toggleButtonRenderer.defaultIcon.iconType == 'LIKE');
-
-      const dislike_btn = primary_info_renderer.videoActions.menuRenderer
-        .topLevelButtons.find((item) => item.toggleButtonRenderer.defaultIcon.iconType == 'DISLIKE');
-
-      const notification_toggle_btn = secondary_info_renderer.subscribeButton.subscribeButtonRenderer
-        ?.notificationPreferenceButton?.subscriptionNotificationToggleButtonRenderer;
-
-      // These will always be false if logged out.
-      processed_data.metadata.is_liked = like_btn.toggleButtonRenderer.isToggled;
-      processed_data.metadata.is_disliked = dislike_btn.toggleButtonRenderer.isToggled;
-      processed_data.metadata.is_subscribed = secondary_info_renderer.subscribeButton.subscribeButtonRenderer?.subscribed || false;
-
-      processed_data.metadata.subscriber_count = secondary_info_renderer.owner.videoOwnerRenderer?.subscriberCountText?.simpleText || 'N/A';
-      processed_data.metadata.current_notification_preference = notification_toggle_btn?.states.find((state) => state.stateId == notification_toggle_btn.currentStateId)
-        .state.buttonRenderer.icon.iconType || 'N/A';
-
-      // Simpler version of publish_date
-      processed_data.metadata.publish_date_text = primary_info_renderer.dateText.simpleText;
-
-      // Only parse like count if it's enabled
-      if (processed_data.metadata.allow_ratings) {
-        processed_data.metadata.likes = {
-          count: parseInt(like_btn.toggleButtonRenderer.defaultText.accessibility.accessibilityData.label.replace(/\D/g, '')),
-          short_count_text: like_btn.toggleButtonRenderer.defaultText.simpleText
-        };
-      }
-
-      processed_data.metadata.owner_badges = secondary_info_renderer.owner.videoOwnerRenderer?.badges?.map((badge) => badge.metadataBadgeRenderer.tooltip) || [];
-    }
-
-    streaming_data && streaming_data.adaptiveFormats &&
-      (processed_data.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, '')))]) ||
-      (processed_data.metadata.available_qualities = []);
-
-    return processed_data;
-  }
-  
-  #processComments() {
-    if (!this.data.onResponseReceivedEndpoints) 
-      throw new Utils.UnavailableContentError('Comments section not available', this.args);
-    
-    const header = Utils.findNode(this.data, 'onResponseReceivedEndpoints', 'commentsHeaderRenderer', 5, false);
-    const comment_count = parseInt(header.commentsHeaderRenderer.countText.runs[0].text.replace(/,/g, ''));
-    const page_count = parseInt(comment_count / 20);
-    
-    const parseComments = (data) => {
-      const items = Utils.findNode(data, 'onResponseReceivedEndpoints', 'commentRenderer', 4, false);
-     
-      const response = {
-        page_count,
-        comment_count,
-        items: [] 
-      };
-    
-      response.items = items.map((item) => {
-        const comment = YTDataItems.CommentThread.parseItem(item);
-        if (comment) {
-          comment.like = () => Actions.engage(this.session, 'comment/perform_comment_action', { comment_action: 'like', comment_id: comment.metadata.id, video_id: this.args.video_id }),
-          comment.dislike = () => Actions.engage(this.session, 'comment/perform_comment_action', { comment_action: 'dislike', comment_id: comment.metadata.id, video_id: this.args.video_id }),
-          comment.reply = (text) => Actions.engage(this.session, 'comment/create_comment_reply', { text, comment_id: comment.metadata.id, video_id: this.args.video_id });
-         
-          comment.report = async () => {
-            const payload = Utils.findNode(item, 'commentThreadRenderer', 'params', 10, false);
-            const form = await Actions.flag(this.session, 'flag/get_form', { params: payload.params });
-           
-            const action = Utils.findNode(form, 'actions', 'flagAction', 13, false);
-            const flag = await Actions.flag(this.session, 'flag/flag', { action: action.flagAction });
-            
-            return flag;
-          };
-          
-          comment.getReplies = async () => {
-            if (comment.metadata.reply_count === 0) throw new Utils.InnertubeError('This comment has no replies', comment);
-            const payload = Proto.encodeCommentRepliesParams(this.args.video_id, comment.metadata.id);
-            const next = await Actions.next(this.session, { continuation_token: payload });
-            return parseComments(next.data);
-          };
-          
-          return comment;
-        }
-      }).filter((c) => c);
-      
-      response.getContinuation = async () => {
-        const continuation_item = items.find((item) => item.continuationItemRenderer);
-        if (!continuation_item) throw new Utils.InnertubeError('You\'ve reached the end');
-        
-        const is_reply = !!continuation_item.continuationItemRenderer.button;
-        const payload = Utils.findNode(continuation_item, 'continuationItemRenderer', 'token', is_reply && 5 || 3);
-        const next = await Actions.next(this.session, { continuation_token: payload.token });
-     
-        return parseComments(next.data);
-      };
-      
-      return response;
-    };
-    
-    return parseComments(this.data);
-  }
-  
-  #processHomeFeed() {
-    const contents = Utils.findNode(this.data, 'contents', 'videoRenderer', 9, false)
-    
-    const parseItems = (contents) => {
-      const videos = YTDataItems.VideoItem.parse(contents);
-
-      const getContinuation = async () => {
-        const citem = contents.find((item) => item.continuationItemRenderer);
-        const ctoken = citem.continuationItemRenderer.continuationEndpoint.continuationCommand.token;
-
-        const response = await Actions.browse(this.session, 'continuation', { ctoken });
-        if (!response.success) throw new Utils.InnertubeError('Could not retrieve continuation', response);
-
-        return parseItems(response.data.onResponseReceivedActions[0].appendContinuationItemsAction.continuationItems);
-      }
-
-      return { videos, getContinuation };
-    }
-
-    return parseItems(contents);
-  }
-  
-  #processSubscriptionFeed() {
-    const contents = Utils.findNode(this.data, 'contents', 'contents', 9, false);
-    
-    const subsfeed = { items: [] };
-
-    const parseItems = (contents) => {
-      contents.forEach((section) => {
-        if (!section.itemSectionRenderer) return;
-
-        const section_contents = section.itemSectionRenderer.contents[0];
-        const section_title = section_contents.shelfRenderer.title.runs[0].text;
-        const section_items = section_contents.shelfRenderer.content.gridRenderer.items;
-        
-        const items = YTDataItems.GridVideoItem.parse(section_items);
-        
-        subsfeed.items.push({
-          date: section_title,
-          videos: items
-        });
-      });
-
-      subsfeed.getContinuation = async () => {
-        const citem = contents.find((item) => item.continuationItemRenderer);
-        const ctoken = citem.continuationItemRenderer.continuationEndpoint.continuationCommand.token;
-
-        const response = await Actions.browse(this.session, 'continuation', { ctoken });
-        if (!response.success) throw new Utils.InnertubeError('Could not retrieve continuation', response);
-
-        const ccontents = Utils.findNode(response.data, 'onResponseReceivedActions', 'itemSectionRenderer', 4, false);
-        subsfeed.items = [];
-
-        return parseItems(ccontents);
-      }
-
-      return subsfeed;
-    };
-    
-    return parseItems(contents);
-  }
-  
-  #processChannel() {
-    const tabs = this.data.contents.twoColumnBrowseResultsRenderer.tabs;
-    const metadata = this.data.metadata;
-
-    const home_tab = tabs.find((tab) => tab.tabRenderer.title == 'Home');
-    const home_contents = home_tab.tabRenderer.content.sectionListRenderer.contents;
-    const home_shelves = [];
-
-    home_contents.forEach((content) => {
-      if (content.itemSectionRenderer) {
-        const contents = content.itemSectionRenderer.contents[0];
-        const list = contents?.shelfRenderer?.content.horizontalListRenderer;
-        if (!list) return; // Ignores featured channels (for now only videos & playlists are supported)
-
-        const shelf = {
-          title: contents.shelfRenderer.title.runs[0].text,
-          content: []
-        };
-
-        shelf.content = list.items.map((item) => {
-          if (item.gridVideoRenderer) {
-            return YTDataItems.GridVideoItem.parseItem(item);
-          } else if (item.gridPlaylistRenderer) {
-            return YTDataItems.GridPlaylistItem.parseItem(item);
-          }
-        });
-      
-        home_shelves.push(shelf);
-      }
-    });
-    
-    const ch_info = YTDataItems.ChannelMetadata.parse(metadata);
-    
-    return {
-      ...ch_info,
-      content: {
-        // Home page of the channel, always available in the first request.
-        home_page: home_shelves,
-        
-        // TODO: Implement these (note: they require additional requests)
-        getVideos: () => {},
-        getPlaylists: () => {},
-        getCommunity: () => {},
-        getChannels: () => {},
-        getAbout: () => {}
-      }
-    }
-  }
-  
-  #processNotifications() {
-    const contents = this.data.actions[0].openPopupAction.popup.multiPageMenuRenderer.sections[0];
-    if (!contents.multiPageMenuNotificationSectionRenderer) throw new Utils.InnertubeError('No notifications', response);
-    
-    const parseItems = (items) => {
-      const parsed_items = YTDataItems.NotificationItem.parse(items);
-      
-      const getContinuation = async () => {
-        const citem = items.find((item) => item.continuationItemRenderer);
-        const ctoken = citem?.continuationItemRenderer?.continuationEndpoint?.getNotificationMenuEndpoint?.ctoken;
-
-        const response = await Actions.notifications(this.session, 'get_notification_menu', { ctoken });
-        if (!response.success) throw new Utils.InnertubeError('Could not retrieve continuation', response);
-
-        return parseItems(response.data.actions[0].appendContinuationItemsAction.continuationItems);
-      }
-
-      return { items: parsed_items, getContinuation };
-    }
-    
-    return parseItems(contents.multiPageMenuNotificationSectionRenderer.items);
-  }
-  
-  #processTrending() {
-    const tabs = Utils.findNode(this.data, 'contents', 'tabRenderer', 4, false);
-    const categories = {};
-    
-    const trending = tabs.map((tab) => {
-      const tab_renderer = tab.tabRenderer;
-      const tab_content = tab_renderer?.content;
-      const category_title = tab_renderer.title.toLowerCase();
-     
-      categories[category_title] = {};
-      
-      if (tab_content) { // The “Now” category is always available
-        const contents = tab_content.sectionListRenderer.contents;
-       
-        categories[category_title].content = contents.map((content) => {
-          const shelf = content.itemSectionRenderer.contents[0].shelfRenderer;
-          const parsed_shelf = YTDataItems.ShelfRenderer.parse(shelf);
-          return parsed_shelf;
-        });
-      } else { // The rest can only be fetched with additional calls 
-        const params = tab_renderer.endpoint.browseEndpoint.params;
-        categories[category_title].getVideos = async () => {
-          const response = await Actions.browse(this.session, 'trending', { params });
-          if (!response.success) throw new Utils.InnertubeError('Could not retrieve category videos', response);
-          
-          const tabs = Utils.findNode(response, 'contents', 'tabRenderer', 4, false);
-          const tab = tabs.find((tab) => tab.tabRenderer.title === tab_renderer.title);
-         
-          const contents = tab.tabRenderer.content.sectionListRenderer.contents;
-          const items = Utils.findNode(contents, 'itemSectionRenderer', 'items', 8, false);
-          
-          return YTDataItems.VideoItem.parse(items);
-        };
-      }
-    });
-    
-    return categories;
-  }
-  
-  #processHistory() {
-    const contents = Utils.findNode(this.data, 'contents', 'videoRenderer', 9, false)
-    
-    const history = { items: [] };
-
-    const parseItems = (contents) => {
-      contents.forEach((section) => {
-        if (!section.itemSectionRenderer) return;
-
-        const header = section.itemSectionRenderer.header.itemSectionHeaderRenderer.title;
-        const section_title = header?.simpleText || header?.runs.map((run) => run.text).join('');
-        const contents = section.itemSectionRenderer.contents;
-
-        const section_items = YTDataItems.VideoItem.parse(contents);
-
-        history.items.push({
-          date: section_title,
-          videos: section_items
-        });
-      });
-
-      history.getContinuation = async () => {
-        const citem = contents.find((item) => item.continuationItemRenderer);
-        const ctoken = citem.continuationItemRenderer.continuationEndpoint.continuationCommand.token;
-
-        const response = await Actions.browse(this.session, 'continuation', { ctoken });
-        if (!response.success) throw new Utils.InnertubeError('Could not retrieve continuation', response);
-
-        history.items = [];
-
-        return parseItems(response.data.onResponseReceivedActions[0].appendContinuationItemsAction.continuationItems);
-      }
-
-      return history;
-    }
-
-    return parseItems(contents);
-  }
-}
-
-module.exports = Parser;

lib/parser/youtube/index.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const VideoResultItem = require('./search/VideoResultItem');
-const SearchSuggestionItem = require('./search/SearchSuggestionItem');
-const PlaylistItem = require('./others/PlaylistItem');
-const NotificationItem = require('./others/NotificationItem');
-const VideoItem = require('./others/VideoItem');
-const GridVideoItem = require('./others/GridVideoItem');
-const GridPlaylistItem = require('./others/GridPlaylistItem');
-const ChannelMetadata = require('./others/ChannelMetadata');
-const ShelfRenderer = require('./others/ShelfRenderer');
-const CommentThread = require('./others/CommentThread');
-
-module.exports = { VideoResultItem, SearchSuggestionItem, PlaylistItem, NotificationItem, VideoItem, GridVideoItem, GridPlaylistItem, ChannelMetadata, ShelfRenderer, CommentThread };

lib/parser/youtube/others/ChannelMetadata.js

@@ -1,20 +0,0 @@
-'use strict';
-
-class ChannelMetadata {
-  static parse(data) {
-    return {
-      title: data.channelMetadataRenderer.title,
-      description: data.channelMetadataRenderer.description,
-      metadata: {
-        url: data.channelMetadataRenderer?.channelUrl,
-        rss_urls: data.channelMetadataRenderer?.rssUrl,
-        vanity_channel_url: data.channelMetadataRenderer?.vanityChannelUrl,
-        external_id: data.channelMetadataRenderer?.externalId,
-        is_family_safe: data.channelMetadataRenderer?.isFamilySafe,
-        keywords: data.channelMetadataRenderer?.keywords
-      }
-    }
-  }
-}
-
-module.exports = ChannelMetadata;

lib/parser/youtube/others/CommentThread.js

@@ -1,37 +0,0 @@
-'use strict';
-
-const Constants = require('../../../utils/Constants');
-
-class CommentThread {
-  static parseItem(item) {
-    if (item.commentThreadRenderer || item.commentRenderer) {
-      const comment = item?.commentThreadRenderer?.comment || item;
-      const replies = item?.commentThreadRenderer?.replies;
-      
-      const like_btn = comment.commentRenderer?.actionButtons?.commentActionButtonsRenderer.likeButton;
-      const dislike_btn = comment.commentRenderer?.actionButtons?.commentActionButtonsRenderer.dislikeButton;
-
-      return {
-        text: comment.commentRenderer.contentText.runs.map((run) => run.text).join(''),
-        author: {
-          name: comment.commentRenderer.authorText.simpleText,
-          thumbnails: comment.commentRenderer.authorThumbnail.thumbnails,
-          channel_id: comment.commentRenderer.authorEndpoint.browseEndpoint.browseId,
-          channel_url: Constants.URLS.YT_BASE  + comment.commentRenderer.authorEndpoint.browseEndpoint.canonicalBaseUrl
-        },
-        metadata: {
-          published: comment.commentRenderer.publishedTimeText.runs[0].text,
-          is_reply: !!item.commentRenderer,
-          is_liked: like_btn.toggleButtonRenderer.isToggled,
-          is_disliked: dislike_btn.toggleButtonRenderer.isToggled,
-          is_pinned: comment.commentRenderer.pinnedCommentBadge && true || false,
-          is_channel_owner: comment.commentRenderer.authorIsChannelOwner,
-          like_count: parseInt(like_btn?.toggleButtonRenderer?.accessibilityData?.accessibilityData.label.replace(/\D/g, '')),
-          reply_count: comment.commentRenderer.replyCount || 0,
-          id: comment.commentRenderer.commentId,
-        }
-      }
-    }
-  }
-}
-module.exports = CommentThread;

lib/parser/youtube/others/GridPlaylistItem.js

@@ -1,20 +0,0 @@
-'use strict';
-
-class GridPlaylistItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item)).filter((item) => item); 
-  }
-  
-  static parseItem(item) {
-    return {
-      id: item?.gridPlaylistRenderer.playlistId,
-      title: item?.gridPlaylistRenderer.title?.runs?.map((run) => run.text).join(''),
-      metadata: {
-        thumbnail: item?.gridPlaylistRenderer.thumbnail?.thumbnails?.slice(-1)[0] || {},
-        video_count: item?.gridPlaylistRenderer.videoCountShortText?.simpleText || 'N/A',
-      }
-    };
-  }
-}
-
-module.exports = GridPlaylistItem;

lib/parser/youtube/others/GridVideoItem.js

@@ -1,35 +0,0 @@
-'use strict';
-
-const Constants = require('../../../utils/Constants');
-
-class GridVideoItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item)).filter((item) => item); 
-  }
-  
-  static parseItem(item) {
-    return {
-      id: item.gridVideoRenderer.videoId,
-      title: item?.gridVideoRenderer?.title?.runs?.map((run) => run.text).join(' '),
-      channel: {
-        id: item?.gridVideoRenderer?.shortBylineText?.runs[0]?.navigationEndpoint?.browseEndpoint?.browseId,
-        name: item?.gridVideoRenderer?.shortBylineText?.runs[0]?.text || 'N/A',
-        url: `${Constants.URLS.YT_BASE}${item?.gridVideoRenderer?.shortBylineText?.runs[0]?.navigationEndpoint?.browseEndpoint?.canonicalBaseUrl}`
-      },
-      metadata: {
-        view_count: item?.gridVideoRenderer?.viewCountText?.simpleText || 'N/A',
-        short_view_count_text: {
-          simple_text: item?.gridVideoRenderer?.shortViewCountText?.simpleText || 'N/A',
-          accessibility_label: item?.gridVideoRenderer?.shortViewCountText?.accessibility?.accessibilityData?.label || 'N/A',
-        },
-        thumbnail: item?.gridVideoRenderer?.thumbnail?.thumbnails.slice(-1)[0] || [],
-        moving_thumbnail: item?.gridVideoRenderer?.richThumbnail?.movingThumbnailRenderer?.movingThumbnailDetails?.thumbnails[0] || {},
-        published: item?.gridVideoRenderer?.publishedTimeText?.simpleText || 'N/A',
-        badges: item?.gridVideoRenderer?.badges?.map((badge) => badge.metadataBadgeRenderer.label) || [],
-        owner_badges: item?.gridVideoRenderer?.ownerBadges?.map((badge) => badge.metadataBadgeRenderer.tooltip) || []
-      }
-    };
-  }
-}
-
-module.exports = GridVideoItem;

lib/parser/youtube/others/NotificationItem.js

@@ -1,25 +0,0 @@
-'use strict';
-
-class NotificationItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item)).filter((item) => item); 
-  }
-  
-  static parseItem(item) {
-    if (item.notificationRenderer) {
-      const notification = item.notificationRenderer;
-      return {
-        title: notification?.shortMessage?.simpleText,
-        sent_time: notification?.sentTimeText?.simpleText,
-        channel_name: notification?.contextualMenu?.menuRenderer?.items[1]?.menuServiceItemRenderer?.text?.runs[1]?.text || 'N/A',
-        channel_thumbnail: notification?.thumbnail?.thumbnails[0],
-        video_thumbnail: notification?.videoThumbnail?.thumbnails[0],
-        video_url: notification.navigationEndpoint.watchEndpoint && `https://youtu.be/${notification.navigationEndpoint.watchEndpoint.videoId}` || 'N/A',
-        read: notification.read,
-        notification_id: notification.notificationId,
-      };
-    }
-  }
-}
-
-module.exports = NotificationItem;

lib/parser/youtube/others/PlaylistItem.js

@@ -1,26 +0,0 @@
-'use strict';
-
-const Utils = require('../../../utils/Utils');
-
-class PlaylistItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item)).filter((item) => item); 
-  }
-  
-  static parseItem(item) {
-    if (item.playlistVideoRenderer)
-      return {
-        id: item?.playlistVideoRenderer?.videoId,
-        title: item?.playlistVideoRenderer?.title?.runs[0]?.text,
-        author: item?.playlistVideoRenderer?.shortBylineText?.runs[0]?.text,
-        duration: {
-          seconds: Utils.timeToSeconds(item?.playlistVideoRenderer?.lengthText?.simpleText || '0'),
-          simple_text: item?.playlistVideoRenderer?.lengthText?.simpleText || 'N/A',
-          accessibility_label: item?.playlistVideoRenderer?.lengthText?.accessibility?.accessibilityData?.label || 'N/A'
-        },
-        thumbnails: item?.playlistVideoRenderer?.thumbnail?.thumbnails,
-      };
-  }
-}
-
-module.exports = PlaylistItem;

lib/parser/youtube/others/ShelfRenderer.js

@@ -1,41 +0,0 @@
-'use strict';
-
-const VideoItem = require('./VideoItem');
-const GridVideoItem = require('./GridVideoItem');
-
-class ShelfRenderer {
-  static parse(data) {
-    return {
-      title: this.getTitle(data.title),
-      videos: this.parseItems(data.content)
-    }
-  }
-  
-  static getTitle(data) {
-    if ('runs' in (data || {})) {
-      return data.runs.map((run) => run.text).join('');
-    } else if ('simpleText' in (data || {})) {
-      return data.simpleText;
-    } else {
-      return 'Others';
-    }
-  }
-  
-  static parseItems(data) {
-    let items;
-  
-    if ('expandedShelfContentsRenderer' in data) {
-      items = data.expandedShelfContentsRenderer.items;
-    } else if ('horizontalListRenderer' in data) {
-      items = data.horizontalListRenderer.items;
-    } 
-    
-    const videos = ('gridVideoRenderer' in items[0])
-      && GridVideoItem.parse(items) 
-      || VideoItem.parse(items);
-      
-    return videos;
-  }
-}
-
-module.exports = ShelfRenderer;

lib/parser/youtube/others/VideoItem.js

@@ -1,46 +0,0 @@
-'use strict';
-
-const Utils = require('../../../utils/Utils');
-const Constants = require('../../../utils/Constants');
-
-class VideoItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item)).filter((item) => item); 
-  }
-  
-  static parseItem(item) {
-    item = (item.richItemRenderer && item.richItemRenderer.content.videoRenderer)
-      && item.richItemRenderer.content
-      || item;
-    
-    if (item.videoRenderer) return {
-      id: item.videoRenderer.videoId,
-      title: item.videoRenderer.title.runs.map((run) => run.text).join(' '),
-      description: item?.videoRenderer?.descriptionSnippet?.runs[0]?.text || 'N/A',
-      channel: {
-        id: item?.videoRenderer?.shortBylineText?.runs[0]?.navigationEndpoint?.browseEndpoint?.browseId,
-        name: item?.videoRenderer?.shortBylineText?.runs[0]?.text || 'N/A',
-        url: `${Constants.URLS.YT_BASE}${item?.videoRenderer?.shortBylineText?.runs[0]?.navigationEndpoint?.browseEndpoint?.canonicalBaseUrl}`
-      },
-      metadata: {
-        view_count: item?.videoRenderer?.viewCountText?.simpleText || 'N/A',
-        short_view_count_text: {
-          simple_text: item?.videoRenderer?.shortViewCountText?.simpleText || 'N/A',
-          accessibility_label: item?.videoRenderer?.shortViewCountText?.accessibility?.accessibilityData?.label || 'N/A',
-        },
-        thumbnail: item?.videoRenderer?.thumbnail?.thumbnails.slice(-1)[0] || {},
-        moving_thumbnail: item?.videoRenderer?.richThumbnail?.movingThumbnailRenderer?.movingThumbnailDetails?.thumbnails[0] || {},
-        published: item?.videoRenderer?.publishedTimeText?.simpleText || 'N/A',
-        duration: {
-          seconds: Utils.timeToSeconds(item?.videoRenderer?.lengthText?.simpleText || '0'),
-          simple_text: item?.videoRenderer?.lengthText?.simpleText || 'N/A',
-          accessibility_label: item?.videoRenderer?.lengthText?.accessibility?.accessibilityData?.label || 'N/A'
-        },
-        badges: item?.videoRenderer?.badges?.map((badge) => badge.metadataBadgeRenderer.label) || [],
-        owner_badges: item?.videoRenderer?.ownerBadges?.map((badge) => badge.metadataBadgeRenderer.tooltip) || []
-      }
-    }
-  }
-}
-
-module.exports = VideoItem;

lib/parser/youtube/search/SearchSuggestionItem.js

@@ -1,12 +0,0 @@
-'use strict';
-
-class SearchSuggestionItem {
-  static parse(data, bold_text) {
-    return data.map((item) => ({
-      text: item.trim(),
-      bold_text: bold_text.trim().toLowerCase()
-    }));
-  }
-}
-
-module.exports = SearchSuggestionItem;

lib/parser/youtube/search/VideoResultItem.js

@@ -1,43 +0,0 @@
-'use strict';
-
-const Utils = require('../../../utils/Utils');
-const Constants = require('../../../utils/Constants');
-
-class VideoResultItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item)).filter((item) => item); 
-  }
-  
-  static parseItem(item) {
-    const renderer = item.videoRenderer || item.compactVideoRenderer;
-    if (renderer) return {
-      id: renderer.videoId,
-      url: `https://youtu.be/${renderer.videoId}`,
-      title: renderer.title.runs[0].text,
-      description: renderer?.detailedMetadataSnippets && renderer?.detailedMetadataSnippets[0].snippetText.runs.map((item) => item.text).join('') || 'N/A',
-      channel: {
-        id: renderer?.ownerText?.runs[0]?.navigationEndpoint?.browseEndpoint?.browseId,
-        name: renderer?.ownerText?.runs[0]?.text,
-        url: `${Constants.URLS.YT_BASE}${renderer.ownerText.runs[0].navigationEndpoint?.browseEndpoint?.canonicalBaseUrl}`
-      },
-      metadata: {
-        view_count: renderer?.viewCountText?.simpleText || 'N/A',
-        short_view_count_text: {
-          simple_text: renderer?.shortViewCountText?.simpleText || 'N/A',
-          accessibility_label: renderer?.shortViewCountText?.accessibility?.accessibilityData?.label || 'N/A',
-        },
-        thumbnails: renderer?.thumbnail.thumbnails,
-        duration: {
-          seconds: Utils.timeToSeconds(renderer?.lengthText?.simpleText || '0'),
-          simple_text: renderer?.lengthText?.simpleText || 'N/A',
-          accessibility_label: renderer?.lengthText?.accessibility?.accessibilityData?.label || 'N/A'
-        },
-        published: renderer?.publishedTimeText?.simpleText || 'N/A',
-        badges: renderer?.badges?.map((item) => item.metadataBadgeRenderer.label) || [],
-        owner_badges: renderer?.ownerBadges?.map((item) => item.metadataBadgeRenderer.tooltip) || []
-      }
-    };
-  }
-}
-
-module.exports = VideoResultItem;

lib/parser/ytmusic/index.js

@@ -1,12 +0,0 @@
-'use strict';
-
-const SongResultItem = require('./search/SongResultItem');
-const VideoResultItem = require('./search/VideoResultItem');
-const AlbumResultItem = require('./search/AlbumResultItem');
-const ArtistResultItem = require('./search/ArtistResultItem');
-const PlaylistResultItem = require('./search/PlaylistResultItem');
-const MusicSearchSuggestionItem = require('./search/MusicSearchSuggestionItem');
-const TopResultItem = require('./search/TopResultItem');
-const PlaylistItem = require('./others/PlaylistItem');
-
-module.exports = { SongResultItem, VideoResultItem, AlbumResultItem, ArtistResultItem, PlaylistResultItem, MusicSearchSuggestionItem, TopResultItem, PlaylistItem };

lib/parser/ytmusic/others/PlaylistItem.js

@@ -1,28 +0,0 @@
-'use strict';
-
-const Utils = require('../../../utils/Utils');
-
-class PlaylistItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item)).filter((item) => item.id); 
-  }
-  
-  static parseItem(item) {
-    const item_renderer = item.musicResponsiveListItemRenderer;
-    const fixed_columns = item_renderer.fixedColumns;
-    const flex_columns = item_renderer.flexColumns;
-
-    return {
-      id: item_renderer.playlistItemData && item_renderer.playlistItemData.videoId,
-      title: flex_columns[0].musicResponsiveListItemFlexColumnRenderer.text.runs[0].text,
-      author: flex_columns[1].musicResponsiveListItemFlexColumnRenderer.text.runs[0].text,
-      duration: {
-        seconds: Utils.timeToSeconds(fixed_columns[0].musicResponsiveListItemFixedColumnRenderer.text.runs[0].text || '0'),
-        simple_text: fixed_columns[0].musicResponsiveListItemFixedColumnRenderer.text.runs[0].text,
-      },
-      thumbnails: item_renderer.thumbnail.musicThumbnailRenderer.thumbnail.thumbnails
-    }
-  }
-}
-
-module.exports = PlaylistItem;

lib/parser/ytmusic/search/AlbumResultItem.js

@@ -1,21 +0,0 @@
-'use strict';
-
-class AlbumResultItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item));
-  }
-  
-  static parseItem(item) {
-    const list_item = item.musicResponsiveListItemRenderer;
-    return {
-      id: list_item.navigationEndpoint.browseEndpoint.browseId,
-      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,
-      thumbnails: list_item?.thumbnail.musicThumbnailRenderer.thumbnail.thumbnails,
-    };
-  }
-}
-
-module.exports = AlbumResultItem;

lib/parser/ytmusic/search/ArtistResultItem.js

@@ -1,19 +0,0 @@
-'use strict';
-
-class ArtistResultItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item));
-  }
-
-  static parseItem(item) {
-    const list_item = item.musicResponsiveListItemRenderer;
-    return {
-      id: list_item.navigationEndpoint.browseEndpoint.browseId,
-      name: list_item.flexColumns[0]?.musicResponsiveListItemFlexColumnRenderer.text.runs[0]?.text,
-      subscribers: list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs[2]?.text,
-      thumbnails: list_item?.thumbnail.musicThumbnailRenderer.thumbnail.thumbnails,
-    };
-  }
-}
-
-module.exports = ArtistResultItem;

lib/parser/ytmusic/search/MusicSearchSuggestionItem.js

@@ -1,22 +0,0 @@
-'use strict';
-
-class MusicSearchSuggestionItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item)); 
-  }
-  
-  static parseItem(item) {
-    let suggestion;
-    
-    item.historySuggestionRenderer &&
-      (suggestion = item.historySuggestionRenderer.suggestion) ||
-      (suggestion = item.searchSuggestionRenderer.suggestion);
-
-    return {
-      text: suggestion.runs.map((run) => run.text).join('').trim(),
-      bold_text: suggestion.runs[0].text.trim()
-    };
-  }
-}
-
-module.exports = MusicSearchSuggestionItem;

lib/parser/ytmusic/search/PlaylistResultItem.js

@@ -1,23 +0,0 @@
-'use strict';
-
-class PlaylistResultItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item));
-  }
-
-  static parseItem(item) {
-    const list_item = item.musicResponsiveListItemRenderer;
-    const watch_playlist_endpoint = list_item?.overlay?.musicItemThumbnailOverlayRenderer
-    ?.content?.musicPlayButtonRenderer?.playNavigationEndpoint?.watchPlaylistEndpoint;
-
-    return {
-      id: watch_playlist_endpoint?.playlistId,
-      title: list_item.flexColumns[0]?.musicResponsiveListItemFlexColumnRenderer.text.runs[0]?.text,
-      author: list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs[2]?.text,
-      channel_id: list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs[2]?.navigationEndpoint?.browseEndpoint.browseId || '0',
-      total_items: parseInt(list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs[4]?.text.match(/\d+/g)),
-    };
-  }
-}
-
-module.exports = PlaylistResultItem;

lib/parser/ytmusic/search/SongResultItem.js

@@ -1,22 +0,0 @@
-'use strict';
-
-class SongResultItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item)).filter((item) => item);
-  }
-
-  static parseItem(item) {
-    const list_item = item.musicResponsiveListItemRenderer;
-    if (list_item.playlistItemData) return {
-      id: list_item.playlistItemData.videoId,
-      title: list_item.flexColumns[0]?.musicResponsiveListItemFlexColumnRenderer.text.runs[0]?.text,
-      artist: list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs[2]?.text,
-      album: list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs[4]?.text,
-      duration: list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs
-      .find((run) => /^\d+$/.test(run.text.replace(/:/g, ''))).text,
-      thumbnails: list_item.thumbnail.musicThumbnailRenderer.thumbnail.thumbnails,
-    };
-  }
-}
-
-module.exports = SongResultItem;

lib/parser/ytmusic/search/TopResultItem.js

@@ -1,33 +0,0 @@
-'use strict';
-
-const SongResultItem = require('./SongResultItem');
-const VideoResultItem = require('./VideoResultItem');
-const AlbumResultItem = require('./AlbumResultItem');
-const ArtistResultItem = require('./ArtistResultItem');
-const PlaylistResultItem = require('./PlaylistResultItem');
-
-class TopResultItem {
-  static parse(data) {
-    return data.map((item) => {
-      const list_item = item.musicResponsiveListItemRenderer;
-
-      const runs = list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs;
-      const type = runs[0].text.toLowerCase();
-
-      const parsed_item = ({
-        playlist: () => PlaylistResultItem.parseItem(item),
-        song: () => SongResultItem.parseItem(item),
-        video: () => VideoResultItem.parseItem(item),
-        artist: () => ArtistResultItem.parseItem(item),
-        album: () => AlbumResultItem.parseItem(item),
-        single: () => AlbumResultItem.parseItem(item)
-      }[type])();
-
-      parsed_item && (parsed_item.type = type);
-
-      return parsed_item;
-    }).filter((item) => item);
-  }
-}
-
-module.exports = TopResultItem;

lib/parser/ytmusic/search/VideoResultItem.js

@@ -1,22 +0,0 @@
-'use strict';
-
-class VideoResultItem {
-  static parse(data) {
-    return data.map((item) => this.parseItem(item)).filter((item) => item); 
-  }
-  
-  static parseItem(item) {
-    const list_item = item.musicResponsiveListItemRenderer;
-    if (list_item.playlistItemData) return {
-      id: list_item.playlistItemData.videoId,
-      title: list_item.flexColumns[0]?.musicResponsiveListItemFlexColumnRenderer.text.runs[0]?.text,
-      author: list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs[2]?.text,
-      views: list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs[4]?.text,
-      duration: list_item.flexColumns[1]?.musicResponsiveListItemFlexColumnRenderer.text.runs
-      .find((run) => /^\d+$/.test(run.text.replace(/:/g, ''))).text,
-      thumbnails: list_item?.thumbnail.musicThumbnailRenderer.thumbnail.thumbnails,
-    };
-  }
-}
-
-module.exports = VideoResultItem;

lib/proto/index.js

@@ -1,109 +0,0 @@
-'use strict';
-
-const messages = require('./messages');
-
-class Proto {
-  static encodeSearchFilter(period, duration, order) {
-    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 buf = messages.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(buf).toString('base64'));
-  }
-  
-  static encodeMessageParams(channel_id, video_id) {
-    const buf = messages.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');
-  }
-  
-  static encodeCommentsSectionParams(video_id, options = {}) {
-    const sort_menu = { TOP_COMMENTS: 0, NEWEST_FIRST: 1 };
-    
-    const buf = messages.GetCommentsSectionParams.encode({
-      ctx: { video_id },
-      unk_param: 6,
-      params: {
-        opts: {
-          video_id,
-          sort_by: sort_menu[options.sort_by || 'TOP_COMMENTS'],
-          type: options.type || 2
-        },
-        target: 'comments-section'
-      }
-    });
-    
-    return encodeURIComponent(Buffer.from(buf).toString('base64'));
-  }
-  
-  static encodeCommentRepliesParams(video_id, comment_id) {
-    const buf = messages.GetCommentsSectionParams.encode({
-      ctx: { video_id },
-      unk_param: 6,
-      params: {
-        replies_opts: {
-          video_id, comment_id,
-          unkopts: { unk_param: 0 },
-          unk_param_1: 1, unk_param_2: 10,
-          channel_id: ' ' // Seems like this can be omitted
-        },
-        target: `comment-replies-item-${comment_id}`
-      }
-    });
-    
-    return encodeURIComponent(Buffer.from(buf).toString('base64'));
-  }
-  
-  static encodeCommentParams(video_id) {
-    const buf = messages.CreateCommentParams.encode({
-      video_id, params: { index: 0 },
-      number: 7
-    });
-    
-    return encodeURIComponent(Buffer.from(buf).toString('base64'));
-  }
-  
-  static encodeCommentReplyParams(comment_id, video_id) {
-    const buf = messages.CreateCommentReplyParams.encode({
-      video_id, comment_id,
-      params: { unk_num: 0 },
-      unk_num: 7
-    });
-
-    return encodeURIComponent(Buffer.from(buf).toString('base64'));
-  }
-  
-  static encodeCommentActionParams(type, comment_id, video_id) {
-    const buf = messages.PeformCommentActionParams.encode({
-      type, comment_id, video_id,
-      unk_num: 2, unk_num_1: 0, unk_num_2: 0,
-      unk_num_3: "0", unk_num_4: 0,
-      unk_num_5: 12, unk_num_6: 0,
-    });
-
-    return encodeURIComponent(Buffer.from(buf).toString('base64'));
-  }
-  
-  static encodeNotificationPref(channel_id, index) {
-    const buf = messages.NotificationPreferences.encode({
-      channel_id, pref_id: { index },
-      number_0: 0, number_1: 4
-    });
-
-    return encodeURIComponent(Buffer.from(buf).toString('base64'));
-  }
-}
-
-module.exports = Proto;

lib/proto/youtube.proto

@@ -1,120 +0,0 @@
-syntax = "proto2";
-package proto;
-
-message NotificationPreferences {
-  required string channel_id = 1;
- 
-  message Preference {
-    required int32 index = 1;
-  }
-  Preference pref_id = 2;
-  
-  optional int32 number_0 = 3;
-  optional int32 number_1 = 4;
-}
-
-message LiveMessageParams {
-  message Params {
-    message Ids {
-      required string channel_id = 1;
-      required string video_id = 2;
-    }
-    Ids ids = 5;
-  }
-  Params params = 1;
-  
-  optional int32 number_0 = 2;
-  optional int32 number_1 = 3;
-}
-
-message GetCommentsSectionParams {
-  message Context {
-    string video_id = 2;
-  }
-  Context ctx = 2;
-  
-  required int32 unk_param = 3;
-  
-  message Params {
-    optional string unk_token = 1;
-    
-    message Options {
-      required string video_id = 4;
-      required int32 sort_by = 6;
-      required int32 type = 15;
-    }
-    
-    message RepliesOptions {
-      required string comment_id = 2;
-    
-      message UnkOpts {
-        required int32 unk_param = 1;
-      }
-      UnkOpts unkopts = 4;
-      
-      optional string channel_id = 5;
-      required string video_id = 6;
-      
-      required int32 unk_param_1 = 8;
-      required int32 unk_param_2 = 9;
-    }
-    
-    optional Options opts = 4;
-    optional RepliesOptions replies_opts = 3;
-    
-    optional int32 page = 5;
-    required string target = 8;
-  }
-  
-  Params params = 6;
-}
-
-message CreateCommentParams {
-  required string video_id = 2;
-  message Params {
-    required int32 index = 1;
-  }
-  Params params = 5;
-  required int32 number = 10;
-}
-
-message CreateCommentReplyParams {
-  required string video_id = 2;
-  required string comment_id = 4;
- 
-  message UnknownParams {
-    required int32 unk_num = 1;
-  }
-  UnknownParams params = 5;
-  
-  optional int32 unk_num = 10;
-}
-
-message PeformCommentActionParams {
-  required int32 type = 1;
-  optional int32 unk_num = 2;
-  
-  required string comment_id = 3;
-  required string video_id = 5;
-  
-  optional int32 unk_num_1 = 6;
-  optional int32 unk_num_2 = 7;
-  
-  optional string unk_num_3 = 9;
-  
-  optional int32 unk_num_4 = 10;
-  optional int32 unk_num_5 = 21;
-  
-  optional string channel_id = 23;
-  optional int32 unk_num_6 = 30;
-}
-
-message SearchFilter {
-  int32 number = 1;
-  message Filter {
-    int32 param_0 = 1;
-    int32 param_1 = 2;
-    int32 param_2 = 3;
-  }
-  Filter filter = 2;
-}

lib/utils/Constants.js

@@ -1,125 +0,0 @@
-'use strict';
-
-const Utils = require('./Utils');
-
-module.exports = {
-  URLS: {
-    YT_BASE: 'https://www.youtube.com',
-    YT_BASE_API: 'https://www.youtube.com/youtubei/',
-    YT_STUDIO_BASE_API: 'https://studio.youtube.com/youtubei/',
-    YT_SUGGESTIONS: 'https://suggestqueries.google.com/complete/',
-    YT_MUSIC: 'https://music.youtube.com',
-    YT_MUSIC_BASE_API: 'https://music.youtube.com/youtubei/'
-  },
-  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'
-      }
-    },
-    REGEX: {
-      AUTH_SCRIPT: /<script id=\"base-js\" src=\"(.*?)\" nonce=".*?"><\/script>/,
-      CLIENT_IDENTITY: /.+?={};var .+?={clientId:\"(?<id>.+?)\",.+?:\"(?<secret>.+?)\"},/
-    }
-  },
-  DEFAULT_HEADERS: (config) => {
-    return {
-      headers: {
-        'Cookie': config?.cookie || '',
-        'user-agent': Utils.getRandomUserAgent('desktop').userAgent,
-        'Referer': 'https://www.google.com/',
-        'Accept': 'text/html',
-        'Accept-Language': `en-${config?.gl || 'US'}`,
-        'Accept-Encoding': 'gzip'
-      }
-    };
-  },
-  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_HEADERS_BASE: {
-    'accept': '*/*',
-    'content-type': 'application/json',
-  },
-  VIDEO_INFO_REQBODY: (id, sts, context) => {
-    return {
-      playbackContext: {
-        contentPlaybackContext: {
-          'currentUrl': '/watch?v=' + id,
-          'vis': 0,
-          'splay': false,
-          'autoCaptionsDefaultOn': false,
-          'autonavState': 'STATE_OFF',
-          'html5Preference': 'HTML5_PREF_WANTS',
-          'signatureTimestamp': sts,
-          'referer': 'https://www.youtube.com',
-          'lactMilliseconds': '-1'
-        }
-      },
-      context: context,
-      videoId: id
-    };
-  },
-  YTMUSIC_VERSION: '1.20211213.00.00',
-  METADATA_KEYS: [
-    'embed', 'view_count', 'average_rating', 'allow_ratings',
-    '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', 'author'
-  ],
-  ACCOUNT_SETTINGS: {
-    // Notifications
-    SUBSCRIPTIONS: 'NOTIFICATION_SUBSCRIPTION_NOTIFICATIONS',
-    RECOMMENDED_VIDEOS: 'NOTIFICATION_RECOMMENDATION_WEB_CONTROL',
-    CHANNEL_ACTIVITY: 'NOTIFICATION_COMMENT_WEB_CONTROL',
-    COMMENT_REPLIES: 'NOTIFICATION_COMMENT_REPLY_OTHER_WEB_CONTROL',
-    USER_MENTION: 'NOTIFICATION_USER_MENTION_WEB_CONTROL',
-    SHARED_CONTENT: 'NOTIFICATION_RETUBING_WEB_CONTROL',
-
-    // Privacy 
-    PLAYLISTS_PRIVACY: 'PRIVACY_DISCOVERABLE_SAVED_PLAYLISTS',
-    SUBSCRIPTIONS_PRIVACY: 'PRIVACY_DISCOVERABLE_SUBSCRIPTIONS'
-  },
-  BASE64_DIALECT: {
-    NORMAL: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'.split(''),
-    REVERSE: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_'.split('')
-  },
-  NTOKEN_REGEX: {
-    CALLS: /c\[(.*?)\]\((.+?)\)/g,
-    PLACEHOLDERS: /c\[(.*?)\]=c/g,
-  },
-  FUNCS_REGEX: /d\.push\(e\)|d\.reverse\(\)|d\[0\]\)\[0\]\)|f=d\[0];d\[0\]|d\.length;d\.splice\(e,1\)|function\(\){for\(var|function\(d,e,f\){var|function\(d\){for\(var|reverse\(\)\.forEach|unshift\(d\.pop\(\)\)|function\(d,e\){for\(var f/,
-  FUNCS: {
-    PUSH: 'd.push(e)',
-    REVERSE_1: 'd.reverse()',
-    REVERSE_2: 'function(d){for(var',
-    SPLICE: 'd.length;d.splice(e,1)',
-    SWAP0_1: 'd[0])[0])',
-    SWAP0_2: 'f=d[0];d[0]',
-    ROTATE_1: 'reverse().forEach',
-    ROTATE_2: 'unshift(d.pop())',
-    BASE64_DIA: 'function(){for(var',
-    TRANSLATE_1: 'function(d,e){for(var f',
-    TRANSLATE_2: 'function(d,e,f){var'
-  }
-};

lib/utils/Request.js

@@ -1,53 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-const Utils = require('./Utils');
-const Constants = require('./Constants');
-
-class Request {
-  constructor (session) {
-    this.session = session;
- 
-    this.instance = Axios.create({
-      baseURL: Constants.URLS.YT_BASE_API + session.version,
-      headers: Constants.INNERTUBE_HEADERS_BASE,
-      params: { key: session.key },
-      timeout: 15000
-    });
-    
-    this.#setupInterceptor();
-    
-    return this.instance;
-  }
-  
-  #setupInterceptor() {
-    this.instance.interceptors.request.use((config) => {
-      const is_ytmusic = config.data.includes(Constants.URLS.YT_MUSIC);
-      
-      config.headers['accept-language'] = `en-${this.session.config.gl || 'US'}`;
-      config.headers['x-goog-visitor-id'] = this.session.context.client.visitorData || ''
-      config.headers['x-youtube-client-version'] = this.session.context.client.clientVersion;
-      config.headers['x-origin'] = is_ytmusic && Constants.URLS.YT_MUSIC || Constants.URLS.YT_BASE;
-      config.headers['origin'] = is_ytmusic && Constants.URLS.YT_MUSIC || Constants.URLS.YT_BASE;
-      
-      is_ytmusic && (config.baseURL = Constants.URLS.YT_MUSIC_BASE_API + this.session.version);
-   
-      if (this.session.logged_in) {
-        const cookie = this.session.config.cookie;
-  
-        const token = cookie 
-          && this.session.auth_apisid 
-          || this.session.access_token;
-        
-        config.headers.cookie = cookie || '';
-        config.headers.authorization = cookie && token || `Bearer ${token}`;
-        
-        !cookie && (delete config.params.key);
-      }
-      
-      return config;
-    }, (error) => Promise.reject(error));
-  }
-}
-
-module.exports = Request;

lib/utils/Utils.js

@@ -1,132 +0,0 @@
-'use strict';
-
-const Crypto = require('crypto');
-const UserAgent = require('user-agents');
-const Flatten = require('flat');
-
-function InnertubeError(message, info) {
-  this.info = info || {};
-  this.stack = Error(message).stack;
-}
-
-InnertubeError.prototype = Object.create(Error.prototype);
-InnertubeError.prototype.constructor = InnertubeError;
-
-class ParsingError extends InnertubeError {};
-class DownloadError extends InnertubeError {};
-class MissingParamError extends InnertubeError {};
-class UnavailableContentError extends InnertubeError {};
-class NoStreamingDataError extends InnertubeError {};
-
-/**
- * Utility to help access deep properties of an object.
- * 
- * @param {object} obj - The object.
- * @param {string} key - Key of the property being accessed.
- * @param {string} target - Anything that might be inside of the property.
- * @param {number} depth - Maximum number of nested objects to flatten.
- * @param {boolean} safe - If set to true arrays will be preserved.
- */
-function findNode(obj, key, target, depth, safe = true) {
-  const flat_obj = Flatten(obj, { safe, maxDepth: depth || 2 });
-  const result = Object.keys(flat_obj).find((entry) => entry.includes(key) && JSON.stringify(flat_obj[entry] || '{}').includes(target));
-  if (!result) throw new ParsingError(`Expected to find "${key}" with content "${target}" but got ${result}`, { key, target, data_snippet: `${JSON.stringify(flat_obj).slice(0, 300)}..` });
-  return flat_obj[result];
-}
-
-/**
- * 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");
-}
-
-/**
- * Returns a random user agent.
- *
- * @param {string} type - mobile | desktop
- * @returns {object}
- */
-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 
- * @returns {string}
- */
-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(' ');
-}
-
-/**
- * Converts time (h:m:s) to seconds.
- * 
- * @param {string} time 
- * @returns {number} seconds
- */
-function timeToSeconds(time) {
-  let params = time.split(':');
-  return parseInt(({
-    3: +params[0] * 3600 + +params[1] * 60 + +params[2],
-    2: +params[0] * 60 + +params[1],
-    1: +params[0]
-  })[params.length]);
-}
-
-/**
- * Converts strings in camelCase to snake_case.
- *
- * @param {string} string The string in camelCase.
- * @returns {string}
- */
-function camelToSnake(string) {
-  return string[0].toLowerCase() + string.slice(1, string.length).replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-
-/**
- * Turns the ntoken transform data into a valid json array
- * 
- * @param {string} data 
- * @returns {string}
- */
-function refineNTokenData(data) {
-  return data
-    .replace(/function\(d,e\)/g, '"function(d,e)').replace(/function\(d\)/g, '"function(d)')
-    .replace(/function\(\)/g, '"function()').replace(/function\(d,e,f\)/g, '"function(d,e,f)')
-    .replace(/\[function\(d,e,f\)/g, '["function(d,e,f)').replace(/,b,/g, ',"b",')
-    .replace(/,b/g, ',"b"').replace(/b,/g, '"b",').replace(/b]/g, '"b"]')
-    .replace(/\[b/g, '["b"').replace(/}]/g, '"]').replace(/},/g, '}",')
-    .replace(/""/g, '').replace(/length]\)}"/g, 'length])}');
-}
-
-const errors = { UnavailableContentError, ParsingError, DownloadError, InnertubeError, MissingParamError, NoStreamingDataError };
-const functions = { findNode, getRandomUserAgent, generateSidAuth, getStringBetweenStrings, camelToSnake, timeToSeconds, refineNTokenData };
-
-module.exports = { ...functions, ...errors };

package.json

@@ -1,34 +1,62 @@
 {
   "name": "youtubei.js",
-  "version": "1.4.2",
-  "description": "A full-featured library that allows you to get detailed info about any video, subscribe, unsubscribe, like, dislike, comment, search, download videos/music and much more!",
-  "main": "index.js",
+  "version": "2.6.0",
+  "description": "Full-featured wrapper around YouTube's private API. Supports YouTube, YouTube Music and YouTube Studio (WIP).",
+  "main": "./dist/index.js",
+  "browser": "./bundle/browser.js",
+  "types": "./dist",
   "author": "LuanRT <luan.lrt4@gmail.com> (https://github.com/LuanRT)",
-  "funding": "https://ko-fi.com/luanrt",
-  "license": "MIT",
-  "engines": {
-    "node": ">=14"
-  },
-  "scripts": {
-    "test": "node test"
-  },
-  "types": "./typings/index.d.ts",
+  "funding": [
+    "https://github.com/sponsors/LuanRT"
+  ],
+  "contributors": [
+    "Wykerd (https://github.com/wykerd/)",
+    "MasterOfBob777 (https://github.com/MasterOfBob777)",
+    "patrickkfkan (https://github.com/patrickkfkan)",
+    "akkadaska (https://github.com/akkadaska)"
+  ],
   "directories": {
     "test": "./test",
-    "typings": "./typings",
     "examples": "./examples",
-    "lib": "./lib"
+    "dist": "./dist"
   },
-  "dependencies": {
-    "axios": "^0.21.4",
-    "flat": "^5.0.2",
-    "protocol-buffers-encodings": "^1.1.1",
-    "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.3.1",
+    "linkedom": "^0.14.12",
+    "undici": "^5.7.0"
+  },
+  "devDependencies": {
+    "@protobuf-ts/plugin": "^2.7.0",
+    "@types/jest": "^28.1.7",
+    "@types/node": "^17.0.45",
+    "@typescript-eslint/eslint-plugin": "^5.30.6",
+    "@typescript-eslint/parser": "^5.30.6",
+    "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"
   },
   "bugs": {
     "url": "https://github.com/LuanRT/YouTube.js/issues"
@@ -36,21 +64,25 @@
   "homepage": "https://github.com/LuanRT/YouTube.js#readme",
   "keywords": [
     "yt",
+    "dl",
     "ytdl",
     "youtube",
-    "youtube-dl",
     "youtubedl",
+    "youtube-dl",
     "youtube-downloader",
-    "innertube",
+    "youtube-music",
+    "youtube-studio",
     "innertubeapi",
+    "innertube",
     "unofficial",
     "downloader",
     "livechat",
-    "dislike",
+    "studio",
+    "upload",
+    "ytmusic",
     "search",
     "comment",
-    "like",
-    "api",
-    "dl"
+    "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')}
+
+export const YTNodes = {
+  ${json.join(',\n  ')}
+};
+
+const map: Record<string, YTNodeConstructor> = YTNodes;
+
+/**
+ * @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));
+
+})();