chore(main): release 4.3.0 (#384)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.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

@@ -2,6 +2,8 @@
 .github
 test/
 cache/
-lib/proto/messages.js
+src/proto/youtube.ts
 coverage/
-node_modules/
+node_modules/
+dist/
+src/proto/generated/

.eslintrc.yml

@@ -1,10 +1,19 @@
+plugins:
+  [ '@typescript-eslint', 'eslint-plugin-tsdoc' ]
 env:
   commonjs: true
   es2021: true
   node: true
-extends: eslint:recommended
+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
@@ -17,10 +26,14 @@ rules:
       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: error
+  no-unused-private-class-members: 'off'
   no-prototype-builtins: 'off'
   no-async-promise-executor: 'off'
   no-case-declarations: 'off'
@@ -29,7 +42,7 @@ rules:
   no-implied-eval: error
   arrow-spacing: error
   no-invalid-this: error
-  no-lone-blocks: error
+  no-lone-blocks: 'off'
   no-new-func: error
   no-new-wrappers: error
   no-new: error
@@ -42,4 +55,33 @@ rules:
   no-useless-call: error
   no-useless-concat: error
   no-useless-escape: error
-  no-useless-return: 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: [ 'https://www.buymeacoffee.com/luanrt' ]

.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,53 @@
+version: 1
+labels:
+  - label: "breaking-change"
+    title: "^refactor!:.*"
+
+  - label: "github"
+    files:
+      - ".github/.*"
+      
+  - label: "git"
+    files:
+      - ".gitignore"
+      - ".gitattributes"
+      
+  - label: "tests"
+    files:
+      - "test/.*"
+    
+  - label: "docs"
+    files:
+      - "docs/.*"
+      - "README.md"
+      
+  - label: "parser"
+    files:
+      - "src/parser/.*"
+      - "src/Innertube.ts"
+      
+  - label: "core"
+    files:
+      - "src/core/.*"
+      
+  - label: "protobuf"
+    files:
+      - "src/proto/.*"
+  
+  - label: "xsmall-diff"
+    size-below: 10
+    
+  - label: "small-diff"
+    size-above: 9
+    size-below: 100
+    
+  - label: "medium-diff"
+    size-above: 99
+    size-below: 500
+    
+  - label: "large-diff"
+    size-above: 499
+    size-below: 1000
+    
+  - label: "xlarge-diff"
+    size-above: 999

.github/pull_request_template.md

@@ -1,27 +1,6 @@
-# Pull Request Template
-
-## Description
-
-Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change.
-
-Fixes # (issue)
-
-## Type of change
-
-Please delete options that are not relevant.
-
-- [ ] Bug fix (non-breaking change which fixes an issue)
-- [ ] New feature (non-breaking change which adds functionality)
-- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
-- [ ] This change requires a documentation update
-
-## Checklist:
-
-- [ ] My code follows the style guidelines of this project
-- [ ] I have performed a self-review of my own code
-- [ ] I have commented my code, particularly in hard-to-understand areas
-- [ ] I have made corresponding changes to the documentation
-- [ ] My changes generate no new warnings
-- [ ] I have added tests that prove my fix is effective or that my feature works
-- [ ] New and existing unit tests pass locally with my changes
-- [ ] I have checked my code and corrected any misspellings
+<!-- Thank you for submitting a Pull Request! Please:
+* Read our contributing guidelines: https://github.com/LuanRT/YouTube.js/blob/main/CONTRIBUTING.md
+* Add "Fixes #<issue_number>" to the PR description if you are fixing an issue.
+* Ensure that the code is up-to-date with the `main` branch.
+* Include a description of the proposed changes and how to test them.
+-->

.github/workflows/labeler.yml

@@ -0,0 +1,14 @@
+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

@@ -1,17 +1,18 @@
-name: Lint
+name: lint
 
-on: [push, pull_request]
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
 
 jobs:
-  eslint:
-    name: Lint
+  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
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm run lint

.github/workflows/node.js.yml

@@ -1,26 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [ 14.x, 15.x, 16.x ]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - run: npm install
-    - run: npm run test

.github/workflows/release-please.yml

@@ -0,0 +1,62 @@
+name: release-please
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  release-please:
+    permissions:
+      contents: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: google-github-actions/release-please-action@v3
+        id: release
+        with:
+          release-type: node
+          package-name: youtubei.js
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: "16.x"
+      - name: Build for Deno
+        run: |
+          npm ci
+          npm run build:deno
+        if: ${{ steps.release.outputs.release_created }}
+      - name: Move Deno files
+        run: |
+          mkdir build
+          mv deno build/deno
+          cp deno.ts build/deno.ts
+          cp {LICENSE,README.md} build
+        if: ${{ steps.release.outputs.release_created }}
+      - name: Push to the Deno branch
+        uses: s0/git-publish-subdir-action@develop
+        env:
+          REPO: self
+          BRANCH: deno
+          FOLDER: ./build
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SKIP_EMPTY_COMMITS: true
+          MESSAGE: "chore: ${{ steps.release.outputs.tag_name }} release"
+          TAG: ${{ steps.release.outputs.tag_name }}-deno
+        if: ${{ steps.release.outputs.release_created }}
+      - name: Remove Deno folder
+        run: rm -rf build
+        if: ${{ steps.release.outputs.release_created }}
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "16.x"
+          registry-url: "https://registry.npmjs.org"
+        if: ${{ steps.release.outputs.release_created }}
+      - name: Publish package to npmjs
+        run: |
+          npm ci
+          npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        if: ${{ steps.release.outputs.release_created }}

.github/workflows/stale.yml

@@ -11,9 +11,7 @@ jobs:
     - uses: actions/stale@v3
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
-        stale-issue-message: 'This issue has been automatically marked as stale because it has not had
-  recent activity. It will be closed if no further activity occurs. Thank you
-  for your contributions.'
+        stale-issue-message: 'This issue has been automatically marked as stale because it has not had 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: 30
+        days-before-stale: 60
         days-before-close: 4

.github/workflows/test.yml

@@ -0,0 +1,18 @@
+name: test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm run test

.gitignore

@@ -9,7 +9,6 @@ yarn-debug.log*
 yarn-error.log*
 lerna-debug.log*
 .pnpm-debug.log*
-.npmignore
 
 # Coverage directory used by tools like istanbul
 coverage
@@ -49,4 +48,30 @@ jspm_packages/
 .yarn/unplugged
 .yarn/build-state.yml
 .yarn/install-state.gz
-.pnp.*
+.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
+bundle/*.cjs
+bundle/*.cjs.*
+deno/
+
+# VSCode files
+.vscode/
+
+# MacOS
+.DS_Store

.npmignore

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

CHANGELOG.md

@@ -0,0 +1,170 @@
+# Changelog
+
+## [4.3.0](https://github.com/LuanRT/YouTube.js/compare/v4.2.0...v4.3.0) (2023-04-13)
+
+
+### Features
+
+* **GridVideo:** add `upcoming`, `upcoming_text`, `is_reminder_set` and `buttons` ([05de3ec](https://github.com/LuanRT/YouTube.js/commit/05de3ec97a1fea92543b5e5f84933b86a07ab830)), closes [#380](https://github.com/LuanRT/YouTube.js/issues/380)
+* **MusicResponsiveListItem:** make flex/fixed cols public ([#382](https://github.com/LuanRT/YouTube.js/issues/382)) ([096bf36](https://github.com/LuanRT/YouTube.js/commit/096bf362c9bd46a510ecb0d01623c70841e26e26))
+* **ToggleMenuServiceItem:** parse default nav endpoint ([a056696](https://github.com/LuanRT/YouTube.js/commit/a0566969ba436f31ca3722d09442a0c6302235d7))
+* **ytmusic:** add taste builder nodes ([#383](https://github.com/LuanRT/YouTube.js/issues/383)) ([a9cad49](https://github.com/LuanRT/YouTube.js/commit/a9cad49333aa85c98bbb96e5f2d5b57d9beeb0c7))
+
+## [4.2.0](https://github.com/LuanRT/YouTube.js/compare/v4.1.1...v4.2.0) (2023-04-09)
+
+
+### Features
+
+* Enable importHelpers in tsconfig to reduce output size ([#378](https://github.com/LuanRT/YouTube.js/issues/378)) ([0b301de](https://github.com/LuanRT/YouTube.js/commit/0b301de6a1e1352a64881c1751a84360922a77cd))
+* **parser:** ignore PrimetimePromo node ([ce9d9c5](https://github.com/LuanRT/YouTube.js/commit/ce9d9c56b4f45c0139d74edc95c295ecfd1ee4b1))
+* **PlaylistVideo:** Extract video_info and accessibility_label texts ([#376](https://github.com/LuanRT/YouTube.js/issues/376)) ([c9135e6](https://github.com/LuanRT/YouTube.js/commit/c9135e66d3c9c72b8d063eedcf3cc2123800946d))
+
+## [4.1.1](https://github.com/LuanRT/YouTube.js/compare/v4.1.0...v4.1.1) (2023-03-29)
+
+
+### Bug Fixes
+
+* **PlayerCaptionsTracklist:** parse props only if they exist in the node ([470d8d9](https://github.com/LuanRT/YouTube.js/commit/470d8d94063f0159cd005c9eb15fd1a4a175bea0)), closes [#372](https://github.com/LuanRT/YouTube.js/issues/372)
+* **Search:** Return search results even if there are ads ([#373](https://github.com/LuanRT/YouTube.js/issues/373)) ([2c5907f](https://github.com/LuanRT/YouTube.js/commit/2c5907f80fd76452afe87d1722fe35a4f45a22e0))
+
+## [4.1.0](https://github.com/LuanRT/YouTube.js/compare/v4.0.1...v4.1.0) (2023-03-24)
+
+
+### Features
+
+* **Session:** allow setting a custom visitor data token ([#371](https://github.com/LuanRT/YouTube.js/issues/371)) ([13ebf0a](https://github.com/LuanRT/YouTube.js/commit/13ebf0a03973e7ba7b65e9f72c4333927e4254f6))
+* **ShowingResultsFor:** parse all props ([1d9587e](https://github.com/LuanRT/YouTube.js/commit/1d9587e8c1ee0b11bb0e444c3d1e98162e9e1059))
+
+
+### Bug Fixes
+
+* **http:** android tv http client missing `clientName` ([#370](https://github.com/LuanRT/YouTube.js/issues/370)) ([cb8fafe](https://github.com/LuanRT/YouTube.js/commit/cb8fafe94b8ab330ae58211a892923321d65d890))
+* **node:** Electron apps crashing ([#367](https://github.com/LuanRT/YouTube.js/issues/367)) ([e7eacd9](https://github.com/LuanRT/YouTube.js/commit/e7eacd974211c90e7fbddfbf8019388cda3dfa5a))
+* **parser:** Make Video.is_live work on channel pages ([#368](https://github.com/LuanRT/YouTube.js/issues/368)) ([bd35faa](https://github.com/LuanRT/YouTube.js/commit/bd35faa5978f0b822e98d019523be1303374ddc0))
+* **toDash:** Generate unique Representation ids ([#366](https://github.com/LuanRT/YouTube.js/issues/366)) ([a8b507e](https://github.com/LuanRT/YouTube.js/commit/a8b507ee65ccd8edc9aea2aef8a908fa272bb23c))
+* **Utils:** Properly parse timestamps with thousands separators ([#363](https://github.com/LuanRT/YouTube.js/issues/363)) ([1c72a41](https://github.com/LuanRT/YouTube.js/commit/1c72a41675e47f711bd61ebb898bca5527406a79))
+
+## [4.0.1](https://github.com/LuanRT/YouTube.js/compare/v4.0.0...v4.0.1) (2023-03-16)
+
+
+### Bug Fixes
+
+* **Channel:** type mismatch in `subscribe_button` prop ([573c864](https://github.com/LuanRT/YouTube.js/commit/573c8643aae16ec7b6be5b333619a5d8c91ca5c1))
+
+## [4.0.0](https://github.com/LuanRT/YouTube.js/compare/v3.3.0...v4.0.0) (2023-03-15)
+
+
+### ⚠ BREAKING CHANGES
+
+* **Parser:** general refactoring of parsers ([#344](https://github.com/LuanRT/YouTube.js/issues/344))
+* The `toDash` functions are now asynchronous, they now return a `Promise<string>` instead of a `string`, as we need to fetch the first sequence of the OTF format streams while building the manifest.
+
+### Features
+
+* Add support for OTF format streams ([3e4d41b](https://github.com/LuanRT/YouTube.js/commit/3e4d41bf06ba16232979977c705444f2032bcde6))
+* **parser:** add `GridMix` ([#356](https://github.com/LuanRT/YouTube.js/issues/356)) ([a8e7e64](https://github.com/LuanRT/YouTube.js/commit/a8e7e644ec6df3b3c98a313f0321da27b4ca456e))
+* **parser:** add `GridShow` and `ShowCustomThumbnail` ([8ef4b42](https://github.com/LuanRT/YouTube.js/commit/8ef4b42d444c4fbe5cd65a55c0e0e7aa31738755)), closes [#459](https://github.com/LuanRT/YouTube.js/issues/459)
+* **parser:** add `MusicCardShelf` ([#358](https://github.com/LuanRT/YouTube.js/issues/358)) ([9b005d6](https://github.com/LuanRT/YouTube.js/commit/9b005d62d6590a2ddf6848dabfa33fce36e8df9c))
+* **parser:** Add `play_all_button` to `Shelf` ([#345](https://github.com/LuanRT/YouTube.js/issues/345)) ([427db5b](https://github.com/LuanRT/YouTube.js/commit/427db5bbc2bf3e8ec60371d504c2ab1cdae6e918))
+* **parser:** add `view_playlist` to `Playlist` ([#348](https://github.com/LuanRT/YouTube.js/issues/348)) ([9cb4530](https://github.com/LuanRT/YouTube.js/commit/9cb45302997771d909487b1ecba6f38655abef48))
+* **parser:** add InfoPanelContent and InfoPanelContainer nodes ([4784dfa](https://github.com/LuanRT/YouTube.js/commit/4784dfa563a4dbeaee31811824d5aa37a67f5557)), closes [#326](https://github.com/LuanRT/YouTube.js/issues/326)
+* **Parser:** just-in-time YTNode generation ([#310](https://github.com/LuanRT/YouTube.js/issues/310)) ([2cee590](https://github.com/LuanRT/YouTube.js/commit/2cee59024c730c34aa06052849ed6fb3f862ef33))
+* **yt:** add support for movie items and trailers ([#349](https://github.com/LuanRT/YouTube.js/issues/349)) ([9f1c31d](https://github.com/LuanRT/YouTube.js/commit/9f1c31d7a09532e80a187b14acceff31c22579bf))
+
+
+### Code Refactoring
+
+* **Parser:** general refactoring of parsers ([#344](https://github.com/LuanRT/YouTube.js/issues/344)) ([b13bf6e](https://github.com/LuanRT/YouTube.js/commit/b13bf6e9926c19a1939e0f4b69cbd53d1af0f7c8))
+
+## [3.3.0](https://github.com/LuanRT/YouTube.js/compare/v3.2.0...v3.3.0) (2023-03-09)
+
+
+### Features
+
+* **parser:** add `ConversationBar` node ([b2253df](https://github.com/LuanRT/YouTube.js/commit/b2253df8022217dc486155d8cacbf22db04dd9c2))
+* **VideoInfo:** support get by endpoint + more info ([#342](https://github.com/LuanRT/YouTube.js/issues/342)) ([0d35fe0](https://github.com/LuanRT/YouTube.js/commit/0d35fe0ca5e87a877b76cbb6cf3c92843eac5a99))
+
+
+### Bug Fixes
+
+* **MultiMarkersPlayerBar:** avoid observing undefined objects ([f351770](https://github.com/LuanRT/YouTube.js/commit/f3517708ff34093a544c09d6f5f1ec806130d5cc))
+* **SharedPost:** import `Menu` node directly (oops) ([3e3dc35](https://github.com/LuanRT/YouTube.js/commit/3e3dc351bb44faec87616d9b922924d14a95f29f))
+* **ytmusic:** use static visitor id to avoid empty API responses ([f9754f5](https://github.com/LuanRT/YouTube.js/commit/f9754f5ac61d0f11b025f37f93783f971560268b)), closes [#279](https://github.com/LuanRT/YouTube.js/issues/279)
+
+## [3.2.0](https://github.com/LuanRT/YouTube.js/compare/v3.1.1...v3.2.0) (2023-03-08)
+
+
+### Features
+
+* Add support for descriptive audio tracks ([#338](https://github.com/LuanRT/YouTube.js/issues/338)) ([574b67a](https://github.com/LuanRT/YouTube.js/commit/574b67a1f707a32378586dd2fe7b2f36f4ab6ddb))
+* export `FormatUtils`' types ([2d774e2](https://github.com/LuanRT/YouTube.js/commit/2d774e26aae79f3d1b115e0e85c148ae80985529))
+* **parser:** add `banner` to `PlaylistHeader` ([#337](https://github.com/LuanRT/YouTube.js/issues/337)) ([95033e7](https://github.com/LuanRT/YouTube.js/commit/95033e723ef912706e4d176de6b2760f017184e1))
+* **parser:** SharedPost ([#332](https://github.com/LuanRT/YouTube.js/issues/332)) ([ce53ac1](https://github.com/LuanRT/YouTube.js/commit/ce53ac18435cbcb20d6d4c4ab52fd156091e7592))
+* **VideoInfo:** add `game_info` and `category` ([#333](https://github.com/LuanRT/YouTube.js/issues/333)) ([214aa14](https://github.com/LuanRT/YouTube.js/commit/214aa147ce6306e37a6bf860a7bed5635db4797e))
+* **YouTube/Search:** add `SearchSubMenu` node ([#340](https://github.com/LuanRT/YouTube.js/issues/340)) ([a511608](https://github.com/LuanRT/YouTube.js/commit/a511608f18b37b0d9f2c7958ed5128330fabcfa0))
+* **yt:** add `getGuide()` ([#335](https://github.com/LuanRT/YouTube.js/issues/335)) ([2cc7b8b](https://github.com/LuanRT/YouTube.js/commit/2cc7b8bcd6938c7fb3af4f854a1d78b86d153873))
+
+
+### Bug Fixes
+
+* **SegmentedLikeDislikeButton:** like/dislike buttons can also be a simple `Button` ([9b2738f](https://github.com/LuanRT/YouTube.js/commit/9b2738f1285b278c3e83541857651be9a6248288))
+* **YouTube:** fix warnings when retrieving members-only content ([#341](https://github.com/LuanRT/YouTube.js/issues/341)) ([95f1d40](https://github.com/LuanRT/YouTube.js/commit/95f1d4077ff3775f36967dca786139a09e2830a2))
+* **ytmusic:** export search filters type ([cf8a33c](https://github.com/LuanRT/YouTube.js/commit/cf8a33c79f5432136b865d535fd0ecedc2393382))
+
+## [3.1.1](https://github.com/LuanRT/YouTube.js/compare/v3.1.0...v3.1.1) (2023-03-01)
+
+
+### Bug Fixes
+
+* **Channel:** getting community continuations ([#329](https://github.com/LuanRT/YouTube.js/issues/329)) ([4c7b8a3](https://github.com/LuanRT/YouTube.js/commit/4c7b8a34030effa26c4ea186d3e9509128aec31c))
+
+## [3.1.0](https://github.com/LuanRT/YouTube.js/compare/v3.0.0...v3.1.0) (2023-02-26)
+
+
+### Features
+
+* Add upcoming and live info to playlist videos ([#317](https://github.com/LuanRT/YouTube.js/issues/317)) ([a0bfe16](https://github.com/LuanRT/YouTube.js/commit/a0bfe164279ec27b0c49c6b0c32222c1a92df5c3))
+* **VideoSecondaryInfo:** add support for attributed descriptions ([#325](https://github.com/LuanRT/YouTube.js/issues/325)) ([f933cb4](https://github.com/LuanRT/YouTube.js/commit/f933cb45bcb92c07b3bc063d63869a51cbff4eb0))
+
+
+### Bug Fixes
+
+* **parser:** export YTNodes individually so they can be used as types ([200632f](https://github.com/LuanRT/YouTube.js/commit/200632f374d5e0e105b600d579a2665a6fb36e38)), closes [#321](https://github.com/LuanRT/YouTube.js/issues/321)
+* **PlayerMicroformat:** Make the embed field optional ([#320](https://github.com/LuanRT/YouTube.js/issues/320)) ([a0e6cef](https://github.com/LuanRT/YouTube.js/commit/a0e6cef00fb9e3f52593cec22704f7ddc1f7553e))
+* send correct UA for Android requests ([f4e0f30](https://github.com/LuanRT/YouTube.js/commit/f4e0f30e6e94b347b28d67d9a86284ea2d23ee15)), closes [#322](https://github.com/LuanRT/YouTube.js/issues/322)
+
+## [3.0.0](https://github.com/LuanRT/YouTube.js/compare/v2.9.0...v3.0.0) (2023-02-17)
+
+
+### ⚠ BREAKING CHANGES
+
+* cleanup platform support ([#306](https://github.com/LuanRT/YouTube.js/issues/306))
+
+### Features
+
+* add parser support for MultiImage community posts ([#298](https://github.com/LuanRT/YouTube.js/issues/298)) ([de61782](https://github.com/LuanRT/YouTube.js/commit/de61782f1a673cbe66ae9b410341e39b7501ba84))
+* add support for hashtag feeds ([#312](https://github.com/LuanRT/YouTube.js/issues/312)) ([bf12740](https://github.com/LuanRT/YouTube.js/commit/bf12740333a82c26fe84e7c702c2fbb8859814fc))
+* add support for YouTube Kids ([#291](https://github.com/LuanRT/YouTube.js/issues/291)) ([2bbefef](https://github.com/LuanRT/YouTube.js/commit/2bbefefbb7cb061f3e7b686158b7568c32f0da5d))
+* allow checking whether a channel has optional tabs ([#296](https://github.com/LuanRT/YouTube.js/issues/296)) ([ceefbed](https://github.com/LuanRT/YouTube.js/commit/ceefbed98c70bb936e2d2df58c02834842acfdfc))
+* **Channel:** Add getters for all optional tabs ([#303](https://github.com/LuanRT/YouTube.js/issues/303)) ([b2900f4](https://github.com/LuanRT/YouTube.js/commit/b2900f48a7aa4c22635e1819ba9f636e81964f2c))
+* **Channel:** add support for sorting the playlist tab ([#295](https://github.com/LuanRT/YouTube.js/issues/295)) ([50ef712](https://github.com/LuanRT/YouTube.js/commit/50ef71284db41e5f94bb511892651d22a1d363a0))
+* extract channel error alert ([0b99180](https://github.com/LuanRT/YouTube.js/commit/0b991800a5c67f0e702251982b52eb8531f36f19))
+* **FormatUtils:** support multiple audio tracks in the DASH manifest ([#308](https://github.com/LuanRT/YouTube.js/issues/308)) ([a69e43b](https://github.com/LuanRT/YouTube.js/commit/a69e43bf3ae02f2428c4aa86f647e3e5e0db5ba6))
+* improve support for dubbed content ([#293](https://github.com/LuanRT/YouTube.js/issues/293)) ([d6c5a9b](https://github.com/LuanRT/YouTube.js/commit/d6c5a9b971444d0cd746aaf5310d3389793680ea))
+* parse isLive in CompactVideo ([#294](https://github.com/LuanRT/YouTube.js/issues/294)) ([2acb7da](https://github.com/LuanRT/YouTube.js/commit/2acb7da0198bfeca6ff911cf95cf06a220fccaa5))
+* **parser:** add `ChannelAgeGate` node ([1cdf701](https://github.com/LuanRT/YouTube.js/commit/1cdf701c8403db6b681a26ecb1df2daa51add454))
+* **parser:** Text#toHTML ([#300](https://github.com/LuanRT/YouTube.js/issues/300)) ([e82e23d](https://github.com/LuanRT/YouTube.js/commit/e82e23dfbb24dff3ddf45754c7319d783990e254))
+* **ytkids:** add `getChannel()` ([#292](https://github.com/LuanRT/YouTube.js/issues/292)) ([0fc29f0](https://github.com/LuanRT/YouTube.js/commit/0fc29f0bbf965215146a6ae192494c74e6cefcbb))
+
+
+### Bug Fixes
+
+* assign MetadataBadge's label ([#311](https://github.com/LuanRT/YouTube.js/issues/311)) ([e37cf62](https://github.com/LuanRT/YouTube.js/commit/e37cf627322f688fcef18d41345f77cbccd58829))
+* **ChannelAboutFullMetadata:** fix error when there are no primary links ([#299](https://github.com/LuanRT/YouTube.js/issues/299)) ([f62c66d](https://github.com/LuanRT/YouTube.js/commit/f62c66db396ba7d2f93007414101112b49d8375f))
+* **TopicChannelDetails:** avatar and subtitle parsing ([#302](https://github.com/LuanRT/YouTube.js/issues/302)) ([d612590](https://github.com/LuanRT/YouTube.js/commit/d612590530f5fe590fee969810b1dd44c37f0457))
+* **VideoInfo:** Gracefully handle missing watch next continuation ([#288](https://github.com/LuanRT/YouTube.js/issues/288)) ([13ad377](https://github.com/LuanRT/YouTube.js/commit/13ad3774c9783ed2a9f286aeee88110bd43b3a73))
+
+
+### Code Refactoring
+
+* cleanup platform support ([#306](https://github.com/LuanRT/YouTube.js/issues/306)) ([2ccbe2c](https://github.com/LuanRT/YouTube.js/commit/2ccbe2ce6260ace3bfac8b4b391e583fbcc4e286))

COLLABORATORS.md

@@ -0,0 +1,18 @@
+# Collaborators
+
+This page lists the collaborators who have contributed to the development and success of the project.
+
+## [LuanRT](https://github.com/LuanRT)
+[![Github Sponsors](https://img.shields.io/badge/donate-30363D?style=flat-square&logo=GitHub-Sponsors&logoColor=#white)](https://github.com/sponsors/LuanRT) 
+[![Ko-Fi](https://img.shields.io/badge/Ko--Fi-30363D?style=flat-square&logo=ko-fi)](https://ko-fi.com/luanrt)
+
+Owner and maintainer.
+
+## [Wykerd](https://github.com/wykerd/)
+Initial parser implementation, several bug fixes, major refactorings and general maintenance.
+
+## [MasterOfBob777](https://github.com/MasterOfBob777)
+Bug fixes and TypeScript support.
+
+## [patrickkfkan](https://github.com/patrickkfkan)
+Major refactorings, improved YouTube Music support, and bug fixes.

CONTRIBUTING.md

@@ -0,0 +1,66 @@
+Welcome to YouTube.js! We're thrilled to have you interested in contributing to our project. As a community-driven project, we believe in the power of collaboration and look forward to working with you. To get started, please follow our easy-to-follow guidelines:
+
+## Issues
+
+### Creating a new issue
+Before creating a new issue, we recommend searching for similar or related issues to avoid duplication efforts. However, if you can't find one, you're more than welcome to create a new issue using a relevant issue form. Please make sure to describe the issue as clearly and concisely as possible.
+
+### Solving an issue
+If you want to lend a hand by solving an issue, it's always good to browse existing issues to find one that grabs your attention. You can narrow down the search using tags as filters. If you find an issue you'd like to help with, please feel free to open a Pull Request with a fix. We appreciate documentation updates and grammar fixes too!
+
+## Making Changes
+
+1. Fork the repository on GitHub.
+2. Ensure that you have the latest Node.js v16 version installed.
+3. Create a working branch and start making your changes and improvements!
+
+### Committing updates
+When you're done with the changes, make sure to commit them. Don't forget to write a clear, descriptive commit message. We recommend following the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification.
+
+### Creating a Pull Request
+Once you're happy with your updates, create a pull request on GitHub. This is the most efficient way to get your contribution reviewed and eventually merged into our codebase.
+
+- Use the pull request template to fill in the necessary details.
+- If you're solving an issue, link the pull request to that issue.
+- Enable the checkbox to allow maintainers to edit the branch and update it for merging.
+- Changes may be required before we can merge your changes, and we'll let you know what needs to be done.
+
+### Testing, Linting, and Building
+We have some automated processes set up for testing, linting, and building. Please run the following commands to test, lint, and build your code before submitting it:
+
+Testing:
+```sh
+npm run test
+```
+
+Linting:
+```sh
+npm run lint
+```
+
+Building:
+```sh
+# Build all
+npm run build
+
+# Protobuf
+npm run build:proto
+
+# Parser map
+npm run build:parser-map
+
+# Deno
+npm run build:deno
+
+# ES Module
+npm run build:esm
+
+# Node
+npm run bundle:node
+
+# Browser
+npm run bundle:browser
+npm run bundle:browser:prod
+```
+
+We appreciate your efforts and contributions to YouTube.js! Together, we can make this project even better.

bundle/browser.d.ts

@@ -0,0 +1 @@
+export * from '../dist/src/platform/lib.js';

bundle/node.d.cts

@@ -0,0 +1 @@
+export * from '../dist/src/platform/lib.js';

deno.ts

@@ -0,0 +1,3 @@
+export * from './deno/src/platform/deno.ts';
+import Innertube from './deno/src/platform/deno.ts';
+export default Innertube;

docs/API/account.md

@@ -0,0 +1,115 @@
+# 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 the original InnerTube response(s), parsed and sanitized.
+
+</p>
+</details>
+
+<a name="gettimewatched"></a>
+### getTimeWatched()
+
+Retrieves time watched statistics.
+
+**Returns:** `Promise.<TimeWatched>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<timewatched>#page`
+  - Returns the original InnerTube response(s), parsed and 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.
+
+- `<settings>#page`
+  - Returns the original InnerTube response(s), parsed and sanitized.
+
+</p>
+</details>
+
+<a name="getanalytics"></a>
+### getAnalytics()
+
+Retrieves basic channel analytics.
+
+**Returns:** `Promise.<Analytics>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<analytics>#page`
+  - Returns the original InnerTube response(s), parsed and sanitized.
+
+</p>
+</details>

docs/API/feed.md

@@ -0,0 +1,115 @@
+# Feed
+
+Represents a YouTube feed. This class provides a set of utility methods for parsing and interacting with feeds.
+
+## API 
+
+* Feed
+  * [.videos](#videos)
+  * [.posts](#posts)
+  * [.channels](#channels)
+  * [.playlists](#playlists)
+  * [.shelves](#shelves)
+  * [.memo](#memo)
+  * [.page_contents](#page_contents)
+  * [.secondary_contents](#secondary_contents)
+  * [.page](#page)
+  * [.has_continuation](#has_continuation)
+  * [.getContinuationData()](#getcontinuationdata)
+  * [.getContinuation()](#getcontinuation)
+  * [.getShelf(title)](#getshelf)
+
+<a name="videos"></a>
+### videos
+
+Returns all videos in the feed.
+
+**Returns:** `ObservedArray<Video | GridVideo | ReelItem | CompactVideo | PlaylistVideo | PlaylistPanelVideo | WatchCardCompactVideo>`
+
+<a name="posts"></a>
+### posts
+
+Returns all posts in the feed.
+
+**Returns:** `ObservedArray<Post | BackstagePost>`
+
+<a name="channels"></a>
+### channels
+
+Returns all channels in the feed.
+
+**Returns:** `ObservedArray<Channel | GridChannel>`
+
+<a name="playlists"></a>
+### playlists
+
+Returns all playlists in the feed.
+
+**Returns:** `ObservedArray<Playlist | GridPlaylist>`
+
+<a name="shelves"></a>
+### shelves
+
+Returns all shelves in the feed.
+
+**Returns:** `ObservedArray<Shelf | RichShelf | ReelShelf>`
+
+<a name="memo"></a>
+### memo
+
+Returns the memoized feed contents.
+
+**Returns:** `Memo`
+
+<a name="page_contents"></a>
+### page_contents
+
+Returns the page contents.
+
+**Returns:** `SectionList | MusicQueue | RichGrid | ReloadContinuationItemsCommand`
+
+<a name="secondary_contents"></a>
+### secondary_contents
+
+Returns the secondary contents node.
+
+**Returns:** `SuperParsedResult<YTNode> | undefined `
+
+<a name="page"></a>
+### page
+
+Returns the original InnerTube response, parsed and sanitized.
+
+**Returns:** `T extends IParsedResponse = IParsedResponse`
+
+<a name="has_continuation"></a>
+### has_continuation
+
+Returns whether the feed has a continuation.
+
+**Returns:** `boolean`
+
+<a name="getcontinuationdata"></a>
+### getContinuationData()
+
+Returns the continuation data.
+
+**Returns:** `Promise<T | undefined>`
+
+<a name="getcontinuation"></a>
+### getContinuation()
+
+Retrieves the feed's continuation.
+
+**Returns:** `Promise<Feed<T>>`
+
+<a name="getshelf"></a>
+### getShelf(title)
+
+Gets a shelf by its title.
+
+**Returns:** `Shelf | RichShelf | ReelShelf | undefined`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| title | `string` | The title of the shelf to get |

docs/API/filterable-feed.md

@@ -0,0 +1,38 @@
+# FilterableFeed
+
+Represents a feed that can be filtered. 
+
+> **Note** 
+> This class extends the [Feed](feed.md) class.
+
+## API
+
+* FilterableFeed
+  * [.filter_chips](#filter_chips)
+  * [.filters](#filters)
+  * [.getFilteredFeed(filter: string | ChipCloudChip)](#getfilteredfeed)
+
+<a name="filter_chips"></a>
+### filter_chips
+
+Returns the feed's filter chips.
+
+**Returns:** `ObservedArray<ChipCloudChip>`
+
+<a name="filters"></a>
+### filters
+
+Returns the feed's filter chips as an array of strings.
+
+**Returns:** `string[]`
+
+<a name="getfilteredfeed"></a>
+### getFilteredFeed(filter: string | ChipCloudChip)
+
+Returns a new [Feed](feed.md) with the given filter applied.
+
+**Returns:** `Promise<Feed<T>>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| filter | `string` \| `ChipCloudChip` | The filter to apply |

docs/API/interaction-manager.md

@@ -0,0 +1,108 @@
+# InteractionManager
+
+Handles direct interactions.
+
+## API
+
+* InteractionManager 
+  * [.like(video_id)](#like) 
+  * [.dislike(video_id)](#dislike) 
+  * [.removeRating(video_id)](#removerating) 
+  * [.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.<ApiResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="dislike"></a>
+### dislike(video_id)
+
+Dislikes given video.
+
+**Returns:** `Promise.<ApiResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="removerating"></a>
+### removeLike(video_id)
+
+Remover like/dislike.
+
+**Returns:** `Promise.<ApiResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | Video id |
+
+<a name="subscribe"></a>
+### subscribe(channel_id)
+
+Subscribes to given channel.
+
+**Returns:** `Promise.<ApiResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| channel_id | `string` | Channel id |
+
+<a name="unsubscribe"></a>
+### unsubscribe(channel_id)
+
+Unsubscribes from given channel.
+
+**Returns:** `Promise.<ApiResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| channel_id | `string` | Channel id |
+
+<a name="comment"></a>
+### comment(video_id, text)
+
+Posts a comment on given video.
+
+**Returns:** `Promise.<ApiResponse>`
+
+| 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.<ApiResponse>`
+
+| 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.<ApiResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| channel_id | `string` | Channel id |
+| type | `string` | `PERSONALIZED`, `ALL` or `NONE` |

docs/API/kids.md

@@ -0,0 +1,113 @@
+# YouTube Kids
+
+YouTube Kids is a modified version of the YouTube app, with a simplified interface and curated content. This class allows you to interact with its API.
+
+## API
+  
+* Kids
+  * [.search(query)](#search)
+  * [.getInfo(video_id)](#getinfo)
+  * [.getChannel(channel_id)](#getchannel)
+  * [.getHomeFeed()](#gethomefeed)
+
+<a name="search"></a>
+### search(query)
+
+Searches the given query on YouTube Kids.
+
+**Returns:** `Promise.<Search>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| query | `string` | The query to search |
+
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<search>#page`
+  - Returns the original InnerTube response(s), parsed and sanitized.
+
+</p>
+</details> 
+
+<a name="getinfo"></a>
+### getInfo(video_id)
+
+Retrieves video info.
+
+**Returns:** `Promise.<VideoInfo>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| video_id | `string` | The video id |
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<info>#toDash(url_transformer?, format_filter?)`
+  - Generates a DASH manifest from the streaming data.
+
+- `<info>#chooseFormat(options)`
+  - Selects the format that best matches the given options. This method is used internally by `#download`.
+
+- `<info>#download(options?)`
+  - Downloads the video.
+
+- `<info>#addToWatchHistory()`
+  - Adds the video to the watch history.
+
+- `<info>#page`
+  - Returns the original InnerTube response(s), parsed and sanitized.
+
+</p>
+</details> 
+
+<a name="getchannel"></a>
+### getChannel(channel_id)
+
+Retrieves channel info.
+
+**Returns:** `Promise.<Channel>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| channel_id | `string` | The channel id |
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<channel>#getContinuation()`
+  - Retrieves next batch of videos.
+
+- `<channel>#has_continuation`
+  - Returns whether there are more videos to retrieve.
+
+- `<channel>#page`
+  - Returns the original InnerTube response(s), parsed and sanitized.
+
+</p>
+</details>
+
+<a name="gethomefeed"></a>
+### getHomeFeed()
+
+Retrieves the home feed.
+
+**Returns:** `Promise.<HomeFeed>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<feed>#selectCategoryTab(tab: string | KidsCategoryTab)`
+  - Selects the given category tab.
+
+- `<feed>#categories`
+  - Returns available categories.
+
+- `<feed>#page`
+  - Returns the original InnerTube response(s), parsed and sanitized.

docs/API/music.md

@@ -0,0 +1,347 @@
+# YouTube Music
+
+YouTube Music is a music streaming service developed by YouTube, a subsidiary of Google. It provides a tailored interface for the service oriented towards music streaming, with a greater emphasis on browsing and discovery compared to its main service. This class allows you to interact with its API.
+
+## 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.
+
+- `<info>#toDash(url_transformer?, format_filter?)`
+  - Generates a DASH manifest from the streaming data.
+
+- `<info>#chooseFormat(options)`
+  - Selects the format that best matches the given options. This method is used internally by `#download`.
+
+- `<info>#download(options?)`
+  - Downloads the track.
+
+- `<info>#addToWatchHistory()`
+  - Adds the song to the watch history.
+
+- `<info>#page`
+  - Returns the original InnerTube response(s), parsed and sanitized.
+
+</p>
+</details> 
+
+<a name="search"></a>
+### search(query, filters?)
+
+Searches on YouTube Music.
+
+**Returns:** `Promise.<Search>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| query | `string` | Search query |
+| filters? | `MusicSearchFilters` | Search filters |
+
+<details>
+<summary>Search Filters</summary>
+
+| Filter | Type | Value | Description |
+| --- | --- | --- | --- |
+| type | `string` | `all`, `song`, `video`, `album`, `playlist`, `artist` | Search type |
+
+</details>
+
+<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 the original InnerTube response(s), parsed and 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).
+
+- `<homefeed>#page`
+  - Returns the original InnerTube response(s), parsed and sanitized.
+
+</p>
+</details> 
+
+<a name="getexplore"></a>
+### getExplore()
+
+Retrieves “Explore” feed.
+
+**Returns:** `Promise.<Explore>`
+
+<details>
+<summary>Methods & Getters</summary>
+<p>
+
+- `<explore>#page`
+  - Returns the original InnerTube response(s), parsed and 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>#applySort(sort_by)`
+  - Applies given sort option 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_options`
+  - Returns available sort options.
+
+- `<library>#page`
+  - Returns the original InnerTube response(s), parsed and 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 the original InnerTube response(s), parsed and 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 the original InnerTube response(s), parsed and 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 the original InnerTube response(s), parsed and 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 the original InnerTube response(s), parsed and 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.<ApiResponse>`
+
+| 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.<ApiResponse>`
+
+| 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.<ApiResponse>`
+
+| 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.<ApiResponse>`
+
+| 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.<ApiResponse>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| file | `BodyInit` | Video file |
+| metadata | `UploadedVideoMetadata` | Video metadata |

docs/API/tabbed-feed.md

@@ -0,0 +1,62 @@
+# TabbedFeed
+
+Represents a feed with tabs. 
+
+> **Note**
+> This class extends the [Feed](feed.md) class.
+
+## API
+
+* TabbedFeed
+  * [.tabs](#tabs)
+  * [.getTabByName(title: string)](#gettabbyname)
+  * [.getTabByURL(url: string)](#gettabbyurl)
+  * [.hasTabWithURL(url: string)](#hastabwithurl)
+  * [.title](#title)
+
+<a name="tabs"></a>
+### tabs
+
+Returns the feed's tabs as an array of strings.
+
+**Returns:** `string[]`
+
+<a name="gettabbyname"></a>
+### getTabByName(title: string)
+
+Fetches a tab by its title.
+
+**Returns:** `Promise<TabbedFeed<T>>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| title | `string` | The title of the tab to get |
+
+<a name="gettabbyurl"></a>
+### getTabByURL(url: string)
+
+Fetches a tab by its URL.
+
+**Returns:** `Promise<TabbedFeed<T>>`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| url | `string` | The URL of the tab to get |
+
+<a name="hastabwithurl"></a>
+### hasTabWithURL(url: string)
+
+Returns whether the feed has a tab with the given URL.
+
+**Returns:** `boolean`
+
+| Param | Type | Description |
+| --- | --- | --- |
+| url | `string` | The URL to check |
+
+<a name="title"></a>
+### title
+
+Returns the currently selected tab's title.
+
+**Returns:** `string | undefined`

docs/updating-the-parser.md

@@ -0,0 +1,62 @@
+# Updating the Parser
+
+YouTube is constantly changing, so it is not uncommon 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 (also known as YTNodes) dynamically without hard-coding their path in the response. This way, whenever a new renderer pops up (e.g., when YouTube adds a new feature or makes a minor UI change), the library will print a warning similar to this:
+
+```
+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!
+Introspected and JIT generated this class in the meantime:
+class SomeRenderer extends YTNode {
+  static type = 'SomeRenderer';
+
+  // ...
+
+  constructor(data: RawNode) {
+    super();
+    // ...
+  }
+}
+```
+
+This warning **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, suppose we have found a new renderer named `verticalListRenderer`. In that case, to let the parser know it exists at compile-time, we would have to create a file with the following structure:
+
+> `../classes/VerticalList.ts`
+
+```ts
+import Parser from '..';
+import { YTNode } from '../helpers';
+import type { RawNode } from '../index.js';
+
+class VerticalList extends YTNode {
+  static type = 'VerticalList';
+
+  header;
+  contents;
+
+  constructor(data: RawNode) {
+    // parse the data here, ex;
+    this.header = Parser.parseItem(data.header);
+    this.contents = Parser.parseArray(data.contents);
+  }
+}
+
+export default VerticalList;
+```
+
+You may use the parser's generated class for the new renderer as a starting point for your own implementation.
+
+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,38 @@
+const { Innertube, UniversalCache } = require('youtubei.js');
+
+(async () => {
+  const yt = await Innertube.create({
+    // required if you wish to use OAuth#cacheCredentials
+    cache: new UniversalCache(false)
+  });
+
+  // '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', async ({ credentials }) => {
+    console.log('Credentials updated:', credentials);
+    await yt.session.oauth.cacheCredentials();
+  });
+
+  // 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,63 @@
+# Browser Usage Example
+
+YouTube.js works in the browser!
+
+## Usage
+
+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/web.bundle.min";
+
+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.
+
+If you don't want to run the example yourself, you can see it in action here: [ytjsexample.pages.dev](https://ytjsexample.pages.dev/).

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,30 @@
+<!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>YouTube.js Example</title>
+</head>
+
+<body>
+  <form>
+    <input type="text" name="id" placeholder="Video ID or URL" />
+    <input type="submit" value="Play" />
+  </form>
+  <div id="loader"></div>
+  <div id="video_container">
+    <video id="video"></video>
+    <h2 id="title"></h2>
+    <div id="metadata"></div>
+    <hr />
+    <div id="description"></div>
+  </div>
+  <footer>
+    <p>Powered by <a href="https://github.com/LuanRT/YouTube.js">YouTube.js</a></p>
+  </footer>
+  <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,158 @@
+import './style.css';
+import { Innertube, UniversalCache } from '../../../../bundle/browser';
+import dashjs from 'dashjs';
+
+const description = document.getElementById('description') as HTMLDivElement;
+const form = document.querySelector('form') as HTMLFormElement;
+const title = document.getElementById('title') as HTMLHeadingElement;
+const metadata = document.getElementById('metadata') as HTMLDivElement;
+const loader = document.getElementById('loader') as HTMLDivElement;
+const video = document.getElementById('video') as HTMLVideoElement;
+const video_container = document.getElementById('video_container') as HTMLDivElement;
+
+async function main() {
+  const yt = await Innertube.create({
+    generate_session_locally: true,
+    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]));
+
+      // @ts-ignore
+      input.duplex = 'half';
+
+      // 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(false),
+  });
+
+  form.animate({ opacity: [0, 1] }, { duration: 300, easing: 'ease-in-out' });
+  form.style.display = 'block';
+
+  showUI(false);
+
+  let player: dashjs.MediaPlayerClass | undefined;
+
+  form.addEventListener('submit', async (e) => {
+    e.preventDefault();
+
+    if (player) {
+      player.reset();
+    }
+
+    hideUI();
+
+    let video_id;
+
+    const video_id_or_url = document.querySelector<HTMLInputElement>('input[type=text]')?.value;
+
+    if (!video_id_or_url) {
+      title.textContent = 'No video id or URL provided';
+      showUI(false);
+      return;
+    }
+
+    try {
+      if (video_id_or_url.match(/(http|https):\/\/([\w_-]+(?:(?:\.[\w_-]+)+))([\w.,@?^=%&:\/~+#-]*[\w@?^=%&\/~+#-])/)) {
+        const endpoint = await yt.resolveURL(video_id_or_url);
+
+        if (!endpoint.payload.videoId) {
+          title.textContent = 'Could not resolve URL';
+          showUI(false);
+          return;
+        }
+
+        video_id = endpoint.payload.videoId;
+      } else {
+        video_id = video_id_or_url;
+      }
+
+      const info = await yt.getInfo(video_id);
+
+      title.textContent = info.basic_info.title || null;
+      description.innerHTML = info.secondary_info?.description.toHTML() || '';
+      title.textContent = info.basic_info.title || null;
+
+      document.title = info.basic_info.title || '';
+
+      metadata!.innerHTML = '';
+      metadata!.innerHTML += `<div class="metadata_item">${info.primary_info?.published.toHTML()}</div>`;
+      metadata!.innerHTML += `<div class="metadata_item">${info.primary_info?.view_count.toHTML()}</div>`;
+      metadata!.innerHTML += `<div class="metadata_item">${info.basic_info.like_count} likes</div>`;
+
+      showUI(true);
+
+      const dash = await info.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');
+      video_element.poster = info.basic_info.thumbnail![0].url;
+
+      // use dash.js to parse the manifest
+      if (player) {
+        player.destroy();
+      }
+
+      player = dashjs.MediaPlayer().create();
+      player.initialize(video_element, uri, true);
+      player.setInitialMediaSettingsFor('audio', { lang: 'en-US' });
+    } catch (error) {
+      title.textContent = 'An error occurred (see console)';
+      showUI(false);
+      console.error(error);
+    }
+  });
+}
+
+function showUI(with_video = true) {
+  loader.style.display = 'none';
+  video.style.display = with_video ? 'block' : 'none';
+  video_container.animate({ opacity: [0, 1] }, { duration: 300, easing: 'ease-in-out' });
+  video_container.style.display = 'block';
+}
+
+function hideUI() {
+  video_container.style.display = 'none';
+  loader.style.display = 'block';
+}
+
+main();

examples/browser/web/src/style.css

@@ -0,0 +1,90 @@
+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;
+  background-color: rgb(32, 32, 32);
+  color: rgb(255, 255, 255);
+}
+
+hr {
+  height: 1px;
+  width: 100%;
+  border: 1px solid transparent;
+  background-color: rgb(68, 68, 68);
+}
+
+form {
+  margin: 0.5rem 0;
+  display: none;
+}
+
+#loader {
+  display: block;
+  border: 10px solid rgb(68, 68, 68);
+  border-top: 10px solid rgb(255, 255, 255);
+  border-radius: 50%;
+  width: 50px;
+  height: 50px;
+  align-self: center;
+  animation: spin 1s linear infinite;
+  margin: 0.5rem 0;
+}
+
+@keyframes spin {
+  0% {
+    transform: rotate(0deg);
+  }
+
+  100% {
+    transform: rotate(360deg);
+  }
+}
+
+#video_container {
+  display: none;
+  flex-direction: column;
+  position: relative;
+  width: 70vw !important;
+  margin: 0.5rem 0;
+}
+
+#metadata {
+  display: flex;
+  flex-direction: row;
+  align-self: left;
+  margin: 0.5rem 0;
+}
+
+#metadata > .metadata_item {
+  margin: 0 0.3rem;
+  background-color: beige;
+  color: black;
+  font: 1em bold;
+  padding: 0.2rem 0.5rem;
+  border-radius: 0.3rem;
+}
+
+#video_container > #description {
+  align-self: left;
+  margin-left: 0.5rem;
+  font-size: medium;
+}
+
+video {
+  width: 100%;
+  height: 40vw;
+}
+
+footer {
+  margin: 0.5rem 0;
+}
+
+@media screen and (max-width: 768px) {
+  video {
+    height: auto;
+  }
+  #video_container {
+    width: 100% !important;
+  }
+}

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,50 @@
+import { Innertube, UniversalCache, YTNodes } from 'youtubei.js';
+
+(async () => {
+  const yt = await Innertube.create({ cache: new UniversalCache(false), generate_session_locally: true });
+
+  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('\nVideos:');
+  const videos = await channel.getVideos();
+
+  for (const video of videos.videos) {
+    console.info('Video:', video.title.toString());
+  }
+
+  console.info('\nPopular videos:');
+  const popular_videos = await videos.applyFilter('Popular');
+  for (const video of popular_videos.videos) {
+    console.info('Video:', video.title.toString());
+  }
+
+  console.info('\nPlaylists:');
+  const playlists = await channel.getPlaylists();
+
+  for (const playlist of playlists.playlists) {
+    console.info('Playlist:', playlist.title.toString());
+  }
+
+  console.info('\nChannels:');
+  const channels = await channel.getChannels();
+ 
+  for (const channel of channels.channels) {
+    console.info('Channel:', channel.author.name);
+  }
+
+  console.info('\nCommunity 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`](../../src/parser/classes/comments/Comment.ts) 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,50 @@
+# 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`
+  * [.has_continuation](#hascontinuation) ⇒ `boolean`
+  * [.has_replies](#hasreplies) ⇒ `boolean`
+
+<a name="comment"></a>
+### comment
+The top-level comment. **Note:** More about `Comment` [here](./Comment.md).
+
+**Type:** [`Comment`](../../src/parser/classes/comments/Comment.ts)
+
+<a name="replies"></a>
+### replies
+An array of replies to the top-level comment. (not populated until [`getReplies()`](#getreplies) is called).
+
+**Type:** [`Comment[]`](../../src/parser/classes/comments/Comment.ts)
+
+<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>`](../../src/parser/classes/comments/CommentThread.ts)
+
+<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>`](../../src/parser/classes/comments/CommentThread.ts)
+
+<a name="hascontinuation"></a>
+### has_continuation
+Whether there are more replies to be retrieved.
+
+**Type:** `boolean`
+
+<a name="hasreplies"></a>
+### has_replies
+
+Whether there are replies to the top-level comment.
+
+**Type:** `boolean`

examples/comments/README.md

@@ -0,0 +1,65 @@
+## Comments
+YouTube.js has full support for comments, including comment actions such as translating, liking, disliking and replying.
+
+## Usage
+Get a [`Comments`](../../src/parser/youtube/Comments.ts) instance:
+
+```js
+const comments = await yt.getComments(VIDEO_ID);
+```
+
+## API
+* Comments
+  * [.contents](#commentthread) ⇒ `CommentThread[]`
+  * [.applySort](#applysort) ⇒ `function`
+  * [.createComment](#createComment) ⇒ `function`
+  * [.getContinuation](#getc) ⇒ `function`
+  * [.has_continuation](#has_continuation) ⇒ `getter`
+  * [.page](#page) ⇒ `getter`
+
+<a name="commentthread"></a>
+### contents
+A list of comment threads. **Note:** More about comment threads [**here**](./CommentThread.md).
+
+**Type:** [`CommentThread[]`](../../src/parser/classes/comments/CommentThread.ts)
+
+<a name="applysort"></a>
+### applySort(sort)
+Applies given sort option to the comments.
+
+| Param | Type | Description |
+| --- | --- | --- |
+| sort | `string` | Sort option. Can be `TOP_COMMENTS`, `NEWEST_FIRST` |
+
+**Returns:** [`Promise.<Comments>`](../../src/parser/youtube/Comments.ts)
+
+<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>`](../../src/parser/youtube/Comments.ts)
+
+<a name="has_continuation"></a>
+### has_continuation
+Returns whether there are more comments to be fetched.
+
+**Type:** `boolean`
+
+<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,45 @@
+import { Innertube, UniversalCache } from 'youtubei.js';
+
+(async () => {
+  const yt = await Innertube.create({ cache: new UniversalCache(false), generate_session_locally: true });
+
+  const comment_section = await yt.getComments('a-rqu-hjobc');
+
+  console.info(`This video has ${comment_section.header?.comments_count.toString() || 'N/A'} comments.\n`);
+
+  for (const thread of comment_section.contents) {
+    const comment = thread.comment;
+
+    if (comment) {
+      console.info(
+        `${comment.is_pinned ? '[Pinned]' : ''}`,
+        `${comment.is_member ? `${comment.sponsor_comment_badge?.tooltip}` : ''}`,
+        `${comment.author.name} • ${comment.published}\n`,
+        `${comment.content.toString()}`, '\n',
+        `Likes: ${comment.vote_count}`, '\n'
+      );
+
+      if (thread.has_replies) {
+        console.info('Replies:', '\n');
+
+        let comment_thread = await thread.getReplies();
+
+        while (true) {
+          for (const reply of comment_thread?.replies || []) {
+            console.info(
+              `> ${reply.author.name} • ${reply.published}\n`,
+              `${reply.content.toString()}`, '\n',
+              `Likes: ${reply.vote_count}`, '\n'
+            );
+          }
+
+          try {
+            comment_thread = await comment_thread.getContinuation();
+          } catch { break; };
+        }
+      }
+    }
+
+    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 'https://deno.land/x/youtubei/deno.ts';
+
+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,44 @@
+import { Innertube, UniversalCache, Utils } from 'youtubei.js';
+import { existsSync, mkdirSync, createWriteStream } from 'fs';
+
+(async () => {
+  const yt = await Innertube.create({ cache: new UniversalCache(false), generate_session_locally: true });
+
+  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 video+audio
+      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 Utils.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,112 @@
+## Live Chat
+
+Represents a livestream chat. 
+
+## 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`
+  * [.applyFilter](#applyfilter) ⇒ `function`
+  * [.getItemMenu](#getitemmenu) ⇒ `function`
+  * [.sendMessage](#sendmessage) ⇒ `function`
+
+<a name="ev"></a>
+### ev
+Live Chat's EventEmitter.
+
+**Events:**
+
+- `start`
+  
+  Fired when the live chat is started.
+ 
+  Arguments:
+  | Type | Description |
+  | --- | --- |                                       
+  | `LiveChatContinuation` | Initial chat data, actions, info, etc. |
+
+- `chat-update`
+
+  Fired when a new chat action is received.
+
+  Arguments:
+  | Type | Description |
+  | --- | --- |
+  | `ChatAction` | Chat action |
+
+- `metadata-update`
+
+  Fired when the livestream's metadata is updated.
+ 
+  Arguments:
+  | Type | Description |
+  | --- | --- |
+  | `LiveMetadata` | Livestream metadata |
+
+- `error`
+  
+  Fired when an error occurs.
+  
+  Arguments:
+  | Type | Description |
+  | --- | --- |
+  | `Error` | Details about the error |
+  
+- `end`
+ 
+  Fired when the livestream ends.
+
+<a name="start"></a>
+### start()
+Starts the Live Chat.
+
+<a name="stop"></a>
+### stop()
+Stops the Live Chat.
+
+<a name="applyfilter"></a>
+### applyFilter(filter)
+
+Applies given filter to the live chat.
+
+| Param | Type | Description |
+| --- | --- | --- |
+| filter | `string` | Can be `TOP_CHAT` or `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,106 @@
+import { Innertube, UniversalCache, YTNodes, LiveChatContinuation } from 'youtubei.js';
+import { ChatAction, LiveMetadata } from 'youtubei.js/dist/src/parser/youtube/LiveChat';
+
+(async () => {
+  const yt = await Innertube.create({ cache: new UniversalCache(false), generate_session_locally: true });
+
+  const search = await yt.search('lofi hip hop radio - beats to relax/study to');
+  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 a live chat — this is; initial actions (pinned messages, top donations..), account's info and so forth.
+     */
+    console.info(`Hey ${initial_data.viewer_name || 'Guest'}, welcome to Live Chat!`);
+
+    const pinned_action = initial_data.actions.firstOfType(YTNodes.AddBannerToLiveChatCommand);
+
+    if (pinned_action) {
+      if (pinned_action.banner?.contents?.is(YTNodes.LiveChatTextMessage)) {
+        console.info(
+          '\n', 'Pinned message:\n',
+          pinned_action.banner.contents.author?.name.toString(), '-', pinned_action?.banner.contents.message.toString(),
+          '\n'
+        );
+      }
+    }
+  });
+
+  livechat.on('error', (error: Error) => console.info('Live chat error:', error));
+
+  livechat.on('end', () => console.info('This live stream has ended.'));
+
+  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(
+            `${item.as(YTNodes.LiveChatTextMessage).author?.is_moderator ? '[MOD]' : ''}`,
+            `${hours} - ${item.as(YTNodes.LiveChatTextMessage).author?.name.toString()}:\n` +
+            `${item.as(YTNodes.LiveChatTextMessage).message.toString()}\n`
+          );
+          break;
+        case 'LiveChatPaidMessage':
+          console.info(
+            `${item.as(YTNodes.LiveChatPaidMessage).author?.is_moderator ? '[MOD]' : ''}`,
+            `${hours} - ${item.as(YTNodes.LiveChatPaidMessage).author.name.toString()}:\n` +
+            `${item.as(YTNodes.LiveChatPaidMessage).message.toString()}\n`,
+            `${item.as(YTNodes.LiveChatPaidMessage).purchase_amount}\n`
+          );
+          break;
+        case 'LiveChatPaidSticker':
+          console.info(
+            `${item.as(YTNodes.LiveChatPaidSticker).author?.is_moderator ? '[MOD]' : ''}`,
+            `${hours} - ${item.as(YTNodes.LiveChatPaidSticker).author.name.toString()}:\n` +
+            `${item.as(YTNodes.LiveChatPaidSticker).purchase_amount}\n`
+          );
+          break;
+        default:
+          console.debug(action);
+          break;
+      }
+    }
+
+    if (action.is(YTNodes.AddBannerToLiveChatCommand)) {
+      console.info('Message pinned:', action.banner?.contents);
+    }
+
+    if (action.is(YTNodes.RemoveBannerForLiveChatCommand)) {
+      console.info(`Message with action id ${action.target_action_id} was unpinned.`);
+    }
+
+    if (action.is(YTNodes.RemoveChatItemAction)) {
+      console.warn(`Message with action id ${action.target_item_id} just got deleted!`, '\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.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(false) });
+  
+  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!', upload);
+})();

index.js

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

jest.config.js

@@ -1,7 +1,17 @@
-'use strict';
 
-module.exports = {
-  roots: [ '<rootDir>/test' ],
-  testMatch: [ '**/*.test.js' ],
-  testTimeout: 10000
+
+export default {
+  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,652 +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 Actions = require('./core/Actions');
-const Livechat = require('./core/Livechat');
-const SessionBuilder = require('./core/SessionBuilder');
-const AccountManager = require('./core/AccountManager');
-const PlaylistManager = require('./core/PlaylistManager');
-const InteractionManager = require('./core/InteractionManager');
-
-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');
-
-/**
- * Innertube instance.
- * @namespace
- */
-class Innertube {
-  #player;
-  
-  /**
-   * @example
-   * ```js
-   * const Innertube = require('youtubei.js');
-   * const youtube = await new Innertube();
-   * ```
-   * 
-   * @param {object} [config]
-   * @param {string} [config.gl]
-   * @param {string} [config.cookie]
-   * @param {boolean} [config.debug]
-   * 
-   * @returns {Innertube}
-   * @constructor
-   */
-  constructor(config) {
-    this.config = config || {};
-    return this.#init();
-  }
-  
-  async #init() {
-    const session = await new SessionBuilder(this.config).build();
-  
-    this.key = session.key;
-    this.version = session.api_version;
-    this.context = session.context;
-    
-    this.logged_in = false;
-    this.player_url = session.player.url;
-    this.sts = session.player.sts;
-    
-    this.#player = session.player;
-    
-    /**
-     * @fires Innertube#auth - fired when signing in to an account.
-     * @fires Innertube#update-credentials - fired when the access token is no longer valid.
-     * @type {EventEmitter}
-     */
-    this.ev = new EventEmitter();
-    this.oauth = new OAuth(this.ev);
-    
-    if (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.actions = new Actions(this);
-    
-    this.account = new AccountManager(this.actions);
-    this.playlist = new PlaylistManager(this.actions);
-    this.interact = new InteractionManager(this.actions);
-    
-    return this;
-  }
-
-  /**
-   * 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 an 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;
-  }
-  
-  /**
-   * Searches a given query.
-   *
-   * @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 {object} [options.filters] - search filters.
-   * @param {string} [options.filters.upload_date] - filter videos by upload date, can be: any | last_hour | today | this_week | this_month | this_year
-   * @param {string} [options.filters.type] - filter results by type, can be: any | video | channel | playlist | movie
-   * @param {string} [options.filters.duration] - filter videos by duration, can be: any | short | medium | long 
-   * @param {string} [options.filters.sort_by] - filter video results by order, can be: relevance | rating | upload_date | view_count
-   *
-   * @returns {Promise.<{ query: string; corrected_query: string; estimated_results: number; videos: object[] } |
-   * { results: { songs: object[]; videos: object[]; albums: object[]; community_playlists: object[] } }>} 
-   */
-  async search(query, options = { client: 'YOUTUBE' }) {
-    Utils.throwIfMissing({ query });
-    
-    const response = await this.actions.search({ query, options, client: options.client });
-
-    const results = new Parser(this, response.data, {
-      query,
-      client: options.client,
-      data_type: 'SEARCH'
-    }).parse();
-
-    return results;
-  }
-
-  /**
-   * Retrieves search suggestions for a given query.
-   * 
-   * @param {string} query - 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.<{ query: string; results: string[] }>}
-   */
-  async getSearchSuggestions(query, options = { client: 'YOUTUBE' }) {
-    Utils.throwIfMissing({ query });
-    
-    const response = await this.actions.getSearchSuggestions(options.client, query);
-    if (options.client === 'YTMUSIC' && !response.data.contents) return [];
-
-    const suggestions = new Parser(this, response.data, {
-      client: options.client,
-      data_type: 'SEARCH_SUGGESTIONS'
-    }).parse();
-
-    return suggestions;
-  }
-
-  /**
-   * Retrieves video info.
-   * @param {string} video_id - the video id.
-   * @return {Promise.<{ title: string; description: string; thumbnail: []; metadata: object }>}
-   */
-  async getDetails(video_id) {
-    Utils.throwIfMissing({ video_id });
-    
-    const response = await this.actions.getVideoInfo(video_id);
-    const continuation = await this.actions.next({ video_id });
-    response.continuation = continuation.data;
-    
-    const details = new Parser(this, response, {
-      client: 'YOUTUBE',
-      data_type: 'VIDEO_INFO'
-    }).parse();
-
-    const livechat_ctoken = continuation.data.contents?.twoColumnWatchNextResults
-      ?.conversationBar?.liveChatRenderer?.continuations?.find((continuation) => continuation.reloadContinuationData)
-      .reloadContinuationData.continuation;
-
-    details.like = () => this.actions.engage('like/like', { video_id });
-    details.dislike = () => this.actions.engage('like/dislike', { video_id });
-    details.removeLike = () => this.actions.engage('like/removelike', { video_id });
-    details.subscribe = () => this.actions.engage('subscription/subscribe', { channel_id: details.metadata.channel_id });
-    details.unsubscribe = () => this.actions.engage('subscription/unsubscribe', { channel_id: details.metadata.channel_id });
-    details.comment = (text) => this.actions.engage('comment/create_comment', { video_id, text });
-    details.getComments = (sort_by) => this.getComments(video_id, sort_by);
-    details.getLivechat = () => new Livechat(this, livechat_ctoken, details.metadata.channel_id, video_id);
-    details.setNotificationPreferences = (type) => this.actions.notifications('modify_channel_preference', { channel_id: details.metadata.channel_id, pref: type || 'NONE' });
-
-    return details;
-  }
-
-  /**
-   * Retrieves comments for a given video.
-   *
-   * @param {string} video_id - the video id.
-   * @param {string} [sort_by] - can be: `TOP_COMMENTS` or `NEWEST_FIRST`.
-   * @return {Promise.<{ page_count: number; comment_count: number; items: object[]; }>}
-   */
-  async getComments(video_id, sort_by) {
-    Utils.throwIfMissing({ video_id });
-    
-    const payload = Proto.encodeCommentsSectionParams(video_id, {
-      sort_by: sort_by || 'TOP_COMMENTS'
-    });
-
-    const response = await this.actions.next({ ctoken: payload });
-    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 - channel id
-   * @return {Promise.<{ title: string; description: string; metadata: object; content: object }>}
-   */
-  async getChannel(id) {
-    Utils.throwIfMissing({ id });
-    
-    const response = await this.actions.browse(id);
-    
-    const channel_info = new Parser(this, response.data, {
-      client: 'YOUTUBE',
-      data_type: 'CHANNEL'
-    }).parse();
-
-    return channel_info;
-  }
-
-  /**
-   * Retrieves watch history.
-   * @returns {Promise.<{ items: { date: string; videos: object[] }[] }>}
-   */
-  async getHistory() {
-    const response = await this.actions.browse('FEhistory');
-    
-    const history = new Parser(this, response, {
-      client: 'YOUTUBE',
-      data_type: 'HISTORY'
-    }).parse();
-
-    return history;
-  }
-
-  /**
-   * Retrieves home feed (aka recommendations).
-   * @returns {Promise.<{ videos: { id: string; title: string; description: string; channel: string; metadata: object }[] }>}
-   */
-  async getHomeFeed() {
-    const response = await this.actions.browse('FEwhat_to_watch');
-    
-    const homefeed = new Parser(this, response, {
-      client: 'YOUTUBE',
-      data_type: 'HOMEFEED'
-    }).parse();
-
-    return homefeed;
-  }
-
-  /**
-   * Retrieves trending content.
-   * @returns {Promise.<{ now: { content: { title: string; videos: object[]; }[] };
-   * music: { getVideos: Promise.<Array.<object>>; }; gaming: { getVideos: Promise.<Array.<object>>; };
-   * movies: { getVideos: Promise.<Array.<object>>; } }>}
-   */
-  async getTrending() {
-    const response = await this.actions.browse('FEtrending');
-    
-    const trending = new Parser(this, response, {
-      client: 'YOUTUBE',
-      data_type: 'TRENDING'
-    }).parse();
-
-    return trending;
-  }
-  
-  /**
-   * @todo finish this
-   * WIP
-   */
-  async getLibrary() {
-    const response = await this.actions.browse('FElibrary');
-    
-    const library = new Parser(this, response.data, {
-      client: 'YOUTUBE',
-      data_type: 'LIBRARY'
-    }).parse();
-
-    return library;
-  }
-
-  /**
-   * Retrieves subscriptions feed.
-   * @returns {Promise.<{ items: { date: string; videos: object[] }[] }>}
-   */
-  async getSubscriptionsFeed() {
-    const response = await this.actions.browse('FEsubscriptions');
-    
-    const subsfeed = new Parser(this, response, {
-      client: 'YOUTUBE',
-      data_type: 'SUBSFEED'
-    }).parse();
-
-    return subsfeed;
-  }
-
-  /**
-   * Retrieves notifications.
-   * @returns {Promise.<{ items: { title: string; sent_time: string; channel_name: string; channel_thumbnail: object; video_thumbnail: object; video_url: string; read: boolean; notification_id: string }[] }>}
-   */
-  async getNotifications() {
-    const response = await this.actions.notifications('get_notification_menu');
-    
-    const notifications = new Parser(this, response.data, {
-      client: 'YOUTUBE',
-      data_type: 'NOTIFICATIONS'
-    }).parse();
-
-    return notifications;
-  }
-
-  /**
-   * Retrieves unseen notifications count.
-   * @returns {Promise.<number>}
-   */
-  async getUnseenNotificationsCount() {
-    const response = await this.actions.notifications('get_unseen_count');
-    return response.data.unseenCount;
-  }
-
-  /**
-   * Retrieves lyrics for a given song if available.
-   * 
-   * @param {string} video_id 
-   * @returns {Promise.<string>}
-   */
-  async getLyrics(video_id) {
-    Utils.throwIfMissing({ video_id });
-    
-    const continuation = await this.actions.next({ video_id: video_id, client: 'YTMUSIC' });
-    const lyrics_tab = Utils.findNode(continuation, 'contents', 'Lyrics', 8, false);
-
-    const response = await this.actions.browse(lyrics_tab.endpoint?.browseEndpoint.browseId, { client: 'YTMUSIC' });
-    if (!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;
-  }
-
-  /**
-   * Retrieves the contents of a given playlist.
-   * 
-   * @param {string} playlist_id - the id of the playlist.
-   * @param {object} options - `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' }) {
-    Utils.throwIfMissing({ playlist_id });
-    
-    const response = await this.actions.browse(`VL${playlist_id}`, { client: options.client });
-    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.signature_decipher).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_decipher, 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;
-    });
-
-    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);
-
-    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 || !streams.length &&
-      (streams = filtered_formats.filter((format) => format.quality == 'medium'));
-
-    bitrates = streams.map((format) => format.bitrate);
-    format = streams.filter((format) => format.bitrate === Math.max(...bitrates))[0];
-
-    return { selected_format: format, formats };
-  }
-
-  /**
-   * An alternative to {@link download}.
-   * Returns deciphered streaming data.
-   * 
-   * @param {string} video_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: object; formats: object[] }>}
-   */
-  async getStreamingData(video_id, options = {}) {
-    Utils.throwIfMissing({ video_id });
-    
-    options.quality = options.quality || '360p';
-    options.type = options.type || 'videoandaudio';
-    options.format = options.format || 'mp4';
-
-    const data = await this.actions.getVideoInfo(video_id);
-    const streaming_data = this.#chooseFormat(options, data);
-
-    if (!streaming_data.selected_format)
-      throw new Utils.NoStreamingDataError('Could not find any suitable format.', { video_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} video_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
-   * @param {object} [options.range] - download range, indicates which bytes should be downloaded.
-   * @param {number} options.range.start - the beginning of the range.
-   * @param {number} options.range.end - the end of the range.
-   *
-   * @return {Stream.PassThrough}
-   */
-  download(video_id, options = {}) {
-    Utils.throwIfMissing({ video_id });
-    
-    options.quality = options.quality || '360p';
-    options.type = options.type || 'videoandaudio';
-    options.format = options.format || 'mp4';
-
-    let cancel;
-    let cancelled = false;
-    
-    const cpn = Utils.generateRandomString(16);
-          
-    const stream = new Stream.PassThrough();
-    this.actions.getVideoInfo(video_id, cpn).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}&cpn=${cpn}`, {
-          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}&cpn=${cpn}&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/AccountManager.js

@@ -1,251 +0,0 @@
-'use strict';
-
-const Utils = require('../utils/Utils');
-const Constants = require('../utils/Constants');
-const Proto = require('../proto');
-
-/** @namespace */
-class AccountManager {
-  #actions;
-  
-  /**
-   * @param {Actions} actions
-   * @constructor
-   */
-  constructor (actions) {
-    this.#actions = actions;
-    
-    /** @namespace */
-    this.channel = {
-      /**
-       * Edits channel name.
-       * 
-       * @param {string} new_name
-       * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-       */
-      editName: (new_name) => this.#actions.channel('channel/edit_name', { new_name }),
-  
-      /**
-       * Edits channel description.
-       * 
-       * @param {string} new_description
-       * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-       */
-      editDescription: (new_description) => this.#actions.channel('channel/edit_description', { new_description }),
-      
-      /**
-       * Retrieves basic channel analytics.
-       * @borrows AccountManager#getAnalytics as getBasicAnalytics
-       */
-      getBasicAnalytics: () => this.getAnalytics()
-    }
-    
-    /** @namespace */
-    this.settings = {
-      notifications: {
-        /**
-         * Notify about activity from the channels you're subscribed to.
-         * 
-         * @param {boolean} option - ON | OFF 
-         * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-         */
-        setSubscriptions: (option) => this.#setSetting(Constants.ACCOUNT_SETTINGS.SUBSCRIPTIONS, 'SPaccount_notifications', option),
-
-        /**
-         * Recommended content notifications.
-         * 
-         * @param {boolean} option - ON | OFF 
-         * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-         */
-        setRecommendedVideos: (option) => this.#setSetting(Constants.ACCOUNT_SETTINGS.RECOMMENDED_VIDEOS, 'SPaccount_notifications', option),
-
-        /**
-         * Notify about activity on your channel.
-         * 
-         * @param {boolean} option - ON | OFF 
-         * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-         */
-        setChannelActivity: (option) => this.#setSetting(Constants.ACCOUNT_SETTINGS.CHANNEL_ACTIVITY, 'SPaccount_notifications', option),
-
-        /**
-         * Notify about replies to your comments.
-         * 
-         * @param {boolean} option - ON | OFF 
-         * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-         */
-        setCommentReplies: (option) => this.#setSetting(Constants.ACCOUNT_SETTINGS.COMMENT_REPLIES, 'SPaccount_notifications', option),
-
-        /**
-         * Notify when others mention your channel.
-         * 
-         * @param {boolean} option - ON | OFF 
-         * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-         */
-        setMentions: (option) => this.#setSetting(Constants.ACCOUNT_SETTINGS.USER_MENTION, 'SPaccount_notifications', option),
-
-        /**
-         * Notify when others share your content on their channels.
-         * 
-         * @param {boolean} option - ON | OFF 
-         * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-         */
-        setSharedContent: (option) => this.#setSetting(Constants.ACCOUNT_SETTINGS.SHARED_CONTENT, 'SPaccount_notifications', option)
-      },
-      privacy: {
-        /**
-         * If set to true, your subscriptions won't be visible to others.
-         * 
-         * @param {boolean} option - ON | OFF 
-         * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-         */
-        setSubscriptionsPrivate: (option) => this.#setSetting(Constants.ACCOUNT_SETTINGS.SUBSCRIPTIONS_PRIVACY, 'SPaccount_privacy', option),
-
-        /**
-         * If set to true, saved playlists won't appear on your channel.
-         * 
-         * @param {boolean} option - ON | OFF 
-         * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-          */
-        setSavedPlaylistsPrivate: (option) => this.#setSetting(Constants.ACCOUNT_SETTINGS.PLAYLISTS_PRIVACY, 'SPaccount_privacy', option)
-      }
-    }
-  }
-  
-  /**
-   * Internal method to perform changes on an account's settings.
-   * 
-   * @param {string} setting_id 
-   * @param {string} type 
-   * @param {string} new_value 
-   * @private
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async #setSetting(setting_id, type, new_value) {
-    Utils.throwIfMissing({ setting_id, type, new_value });
-    
-    const values = { ON: true, OFF: false };
- 
-    if (!values.hasOwnProperty(new_value)) 
-      throw new Utils.InnertubeError('Invalid option', { option: new_value, available_options: Object.keys(values) });
-      
-    const response = await this.#actions.browse(type);
-    
-    const contents = ({
-      SPaccount_notifications: () => Utils.findNode(response.data, 'contents', 'Your preferences', 13, false).options,
-      SPaccount_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 this.#actions.account('account/set_setting', {
-      new_value: type == 'SPaccount_privacy' ? !values[new_value] : values[new_value],
-      setting_item_id
-    });
-
-    return set_setting;
-  }
-  
-  /**
-   * Retrieves channel info.
-   * @returns {Promise.<{ name: string; email: string; channel_id: string; subscriber_count: string; photo: object[]; }>}
-   */
-  async getInfo() {
-    const response = await this.#actions.account('account/accounts_list', { client: 'ANDROID' });
-    
-    const account_item_section_renderer = Utils.findNode(response.data, 'contents', 'accountItem', 8, false);
-    const profile = account_item_section_renderer.accountItem.serviceEndpoint.signInEndpoint.directSigninUserProfile;
-    
-    const name = profile.accountName;
-    const email = profile.email;
-    const photo = profile.accountPhoto.thumbnails;
-    const subscriber_count = account_item_section_renderer.accountItem.accountByline.runs.map((run) => run.text).join('');
-    const channel_id = response.data.contents[0].accountSectionListRenderer.footers[0].accountChannelRenderer.navigationEndpoint.browseEndpoint.browseId;
-    
-    return { name, email, channel_id, subscriber_count, photo };
-  }
-  
-  /**
-   * Retrieves time watched statistics.
-   * @returns {Promise.<[{ title: string; time: string; }]>}
-   */
-  async getTimeWatched() {
-    const response = await this.#actions.browse('SPtime_watched', { client: 'ANDROID' });
-    
-    const rows = Utils.findNode(response.data, 'contents', 'statRowRenderer', 11, false);
- 
-    const stats = rows.map((row) => {
-      const renderer = row.statRowRenderer;
-      if (renderer) {
-        return {
-          title: renderer.title.runs.map((run) => run.text).join(''),
-          time: renderer.contents.runs.map((run) => run.text).join('')
-        }
-      }
-    }).filter((stat) => stat);
-    
-    return stats;
-  }
-  
-  /**
-   * Retrieves basic channel analytics.
-   *
-   * @returns {Promise.<{ metrics: { title: string; subtitle: string; metric_value: string;
-   * comparison_indicator: object; series_configuration: object; }[]; top_content: { views: string; 
-   * published: string; thumbnails: object[]; duration: string; is_short: boolean }[]; }>}
-   */
-  async getAnalytics() {
-    const info = await this.getInfo();
-        
-    const params = Proto.encodeChannelAnalyticsParams(info.channel_id);
-    const action = await this.#actions.browse('FEanalytics_screen', { params, client: 'ANDROID' });
-        
-    const contents = Utils.findNode(action.data, 'contents', 'elementRenderer', 11, false);
-        
-    const analytics = {
-      metrics: {},
-      top_content: {}
-    }
-        
-    contents.forEach((el) => {
-      const element = el.elementRenderer.newElement;
-      const model = element.type.componentType.model;
-      const key = Object.keys(model)[0];
-    
-      switch (key) {
-        case 'analyticsRootModel':
-          const sections = model.analyticsRootModel.analyticsKeyMetricsData.dataModel.sections;
-           
-          analytics.metrics = sections.map((section) => ({
-            title: section.title,
-            subtitle: section.subtitle,
-            metric_value: section.metricValue,
-            comparison_indicator: section.comparisonIndicator,
-            series_configuration: section.seriesConfiguration
-          }));
-          break;
-        case 'analyticsVodCarouselCardModel':
-          const video_carousel = model.analyticsVodCarouselCardModel.videoCarouselData;
-            
-          analytics.top_content = video_carousel?.videos.map((video) => ({
-            title: video.videoTitle,
-            metadata: {
-              views: video.videoDescription.split('·')[0].trim(),
-              published: video.videoDescription.split('·')[1].trim(),
-              thumbnails: video.thumbnailDetails.thumbnails,
-              duration: video.formattedLength,
-              is_short: video.isShort
-            }
-          })) || [];
-          break;
-        default:
-          break;
-      }
-    });
-        
-    return analytics;
-  }
-}
-
-module.exports = AccountManager;

lib/core/Actions.js

@@ -1,587 +0,0 @@
-'use strict';
-
-const Uuid = require('uuid');
-const Proto = require('../proto');
-const Utils = require('../utils/Utils');
-const Constants = require('../utils/Constants');
-
-/** namespace **/
-class Actions {
-  #session;
-  #request;
-  
-  /**
-   * @param {Innertube} session
-   * @constructor
-   */
-  constructor(session) {
-    this.#session = session;
-    this.#request = session.request;
-  }
-  
-  /**
-   * Covers `/browse` endpoint, mostly used to access
-   * YouTube's sections such as the home feed, etc 
-   * and sometimes to retrieve continuations.
-   * 
-   * @param {string} id - browseId or a continuation token
-   * @param {object} args - additional arguments 
-   * @param {string} [args.params]
-   * @param {boolean} [args.is_ytm]
-   * @param {boolean} [args.is_ctoken]
-   * @param {string} [args.client]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object }>}
-   */
-  async browse(id, args = {}) {
-    if (this.#needsLogin(id) && !this.#session.logged_in)
-      throw new Utils.InnertubeError('You are not signed in');
-    
-    const data = {};
-    
-    args.params &&
-      (data.params = args.params);
-      
-    args.is_ctoken &&
-      (data.continuation = id) ||
-      (data.browseId = id);
-    
-    args.client &&
-      (data.client = args.client);
-      
-    const response = await this.#request.post('/browse', data);
-    
-    return response;
-  }
-  
-  /**
-   * Covers endpoints used to perform direct interactions
-   * on YouTube.
-   * 
-   * @param {string} action
-   * @param {object} args
-   * @param {string} [args.video_id]
-   * @param {string} [args.channel_id]
-   * @param {string} [args.comment_id]
-   * @param {string} [args.comment_action]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async engage(action, args = {}) {
-    if (!this.#session.logged_in && !args.hasOwnProperty('text'))
-      throw new Utils.InnertubeError('You are not signed in');
-      
-    const data = {};
-    
-    switch (action) {
-      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 = action === '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 target_action = ({
-          like: () => Proto.encodeCommentActionParams(5, args),
-          dislike: () => Proto.encodeCommentActionParams(4, args),
-          translate: () => Proto.encodeCommentActionParams(22, args)
-        })[args.comment_action]();
-        
-        data.actions = [ target_action ];
-        break;
-      default:
-        throw new Utils.InnertubeError('Action not implemented', action);
-    }
-    
-    const response = await this.#request.post(`/${action}`, data);
-    return response;
-  }
-  
-  /**
-   * Covers endpoints related to account management.
-   * 
-   * @param {string} action
-   * @param {object} args
-   * @param {string} [args.new_value]
-   * @param {string} [args.setting_item_id]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object }>}
-   */
-  async account(action, args = {}) {
-    if (!this.#session.logged_in) 
-      throw new Utils.InnertubeError('You are not signed in');
-
-    const data = { client: args.client };
-    
-    switch (action) {
-      case 'account/set_setting':
-        data.newValue = { boolValue: args.new_value };
-        data.settingItemId = args.setting_item_id;
-        break;
-      case 'account/accounts_list':
-        break;
-      default:
-        throw new Utils.InnertubeError('Action not implemented', action);
-    }
-    
-    const response = await this.#request.post(`/${action}`, data);
-    return response;
-  }
-  
-  /**
-   * Endpoint used for search.
-   * 
-   * @param {object} args
-   * @param {string} [args.query]
-   * @param {object} [args.options]
-   * @param {string} [args.options.period]
-   * @param {string} [args.options.duration]
-   * @param {string} [args.options.order]
-   * @param {string} [args.client]
-   * @param {string} [args.ctoken]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async search(args = {}) {
-    const data = {};
-    
-    args.query &&
-      (data.query = args.query);
-    
-    args.ctoken &&
-      (data.continuation = args.ctoken);
-    
-    args.client == 'YOUTUBE' &&
-      (data.params = Proto.encodeSearchFilter(args.options.filters));
-    
-    args.client &&
-      (data.client = args.client);
-      
-    const response = await this.#request.post('/search', data);
- 
-    return response;
-  }
-  
-  
-  /**
-   * Endpoint used fo Shorts' sound search.
-   * 
-   * @param {object} args
-   * @param {string} args.query
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async searchSound(args = {}) {
-    const data = {
-      query: args.query,
-      client: 'ANDROID',
-    };
-    
-    const response = await this.#request.post('/sfv/search', data);
-    return response;
-  }
-  
-  /**
-   * Channel management endpoints.
-   * 
-   * @param {string} action
-   * @param {object} args
-   * @param {string} [args.new_name]
-   * @param {string} [args.new_description]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async channel(action, args = {}) {
-    if (!this.#session.logged_in)
-      throw new Utils.InnertubeError('You are not signed in');
-      
-    const data = { client: args.client || 'ANDROID' };
-    
-    switch (action) {
-      case 'channel/edit_name':
-        data.givenName = args.new_name;
-        break;
-      case 'channel/edit_description':
-        data.description = args.new_description;
-        break;
-      case 'channel/get_profile_editor':
-        break;
-      default:
-        throw new Utils.InnertubeError('Action not implemented', action);
-    }
-    
-    const response = await this.#request.post(`/${action}`, data);
-  
-    return response;
-  }
-  
-  /**
-   * Covers endpoints used for playlist management.
-   * 
-   * @param {string} action
-   * @param {object} args
-   * @param {string} [args.title]
-   * @param {string} [args.ids]
-   * @param {string} [args.playlist_id]
-   * @param {string} [args.action]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async playlist(action, args = {}) {
-    if (!this.#session.logged_in) 
-      throw new Utils.InnertubeError('You are not signed in');
-      
-    const data = {};
-   
-    switch (action) {
-      case 'playlist/create':
-        data.title = args.title;
-        data.videoIds = args.ids;
-        break;
-      case 'playlist/delete':
-        data.playlistId = args.playlist_id;
-        break;
-      case 'browse/edit_playlist':
-        data.playlistId = args.playlist_id;
-        data.actions = args.ids.map((id) => ({
-          'ACTION_ADD_VIDEO': {
-            action: args.action, 
-            addedVideoId: id      
-          },
-          'ACTION_REMOVE_VIDEO': {
-            action: args.action, 
-            setVideoId: id
-          }
-        })[args.action]);
-        break;
-      default:
-        throw new Utils.InnertubeError('Action not implemented', action);
-    }
-    
-    const response = await this.#request.post(`/${action}`, data);
-   
-    return response;
-  }
-  
-  /**
-   * Covers endpoints used for notifications management.
-   * 
-   * @param {string} action
-   * @param {object} args
-   * @param {string} [args.pref]
-   * @param {string} [args.channel_id]
-   * @param {string} [args.ctoken]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async notifications(action, args = {}) {
-    if (!this.#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.params = Proto.encodeNotificationPref(args.channel_id, pref_types[args.pref.toUpperCase()]);
-        break;
-      case 'get_notification_menu':
-        data.notificationsMenuRequestType = 'NOTIFICATIONS_MENU_REQUEST_TYPE_INBOX';
-        args.ctoken && (data.ctoken = args.ctoken);
-        break;
-      case 'get_unseen_count':
-        // doesn't require any parameter
-        break;
-      default:
-        throw new Utils.InnertubeError('Action not implemented', action);
-    }
-  
-    const response = await this.#request.post(`/notification/${action}`, data);
-  
-    return response;
-  }
-  
-  /**
-   * Covers livechat endpoints.
-   * 
-   * @param {string} action
-   * @param {object} args
-   * @param {string} [args.text]
-   * @param {string} [args.video_id]
-   * @param {string} [args.channel_id]
-   * @param {string} [args.ctoken]
-   * @param {string} [args.params]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async livechat(action, args = {}) {
-    const data = {};
-    
-    switch (action) {
-      case 'live_chat/get_live_chat':
-        data.continuation = args.ctoken;
-        break;
-      case 'live_chat/send_message':
-        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':
-        // note: this is currently broken due to a recent refactor
-        break;
-      case 'live_chat/moderate':
-        data.params = args.params;
-        break;
-      case 'updated_metadata':
-        data.videoId = args.video_id;
-        args.ctoken && (data.continuation = args.ctoken);
-        break;
-      default:
-        throw new Utils.InnertubeError('Action not implemented', action);
-    }
-  
-    const response = await this.#request.post(`/${action}`, data);
-  
-    return response;
-  }
-  
-  /**
-   * Endpoint used to retrieve video thumbnails.
-   * 
-   * @param {object} args
-   * @param {string} args.video_id
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async thumbnails(args = {}) {
-    const data = {
-      client: 'ANDROID',
-      videoId: args.video_id
-    };
- 
-    const response = await this.#request.post('/thumbnails', data);
-
-    return response;
-  }
-  
-  /**
-   * Place Autocomplete endpoint, found it in the APK but
-   * doesn't seem to be used anywhere on YouTube (maybe for ads?).
-   * 
-   * Ex:
-   * ```js
-   * const places = await session.actions.geo('place_autocomplete', { input: 'San diego cafe' });
-   * console.info(places.data);
-   * ```
-   * 
-   * @param {string} action
-   * @param {object} args
-   * @param {string} args.input
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async geo(action, args = {}) {
-    if (!this.#session.logged_in)
-      throw new Utils.InnertubeError('You are not signed in');
-      
-    const data = {
-      input: args.input,
-      client: 'ANDROID'
-    };
-    
-    const response = await this.#request.post(`/geo/${action}`, data);
-
-    return response;
-  }
-  
-  /**
-   * Covers endpoints used to report content.
-   * 
-   * @param {string} action
-   * @param {object} args
-   * @param {object} [args.action]
-   * @param {string} [args.params]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async flag(action, args) {
-    if (!this.#session.logged_in)
-      throw new Utils.InnertubeError('You are not signed in');
-      
-    const data = {};
-    
-    switch (action) {
-      case 'flag/flag':
-        data.action = args.action;
-        break;
-      case 'flag/get_form':
-        data.params = args.params;
-        break;
-      default:
-        throw new Utils.InnertubeError('Action not implemented', action);
-    }
-    
-    const response = await this.#request.post(`/${action}`, data);
-  
-    return response;
-  }
-  
-  /**
-   * Covers specific YouTube Music endpoints.
-   * 
-   * @param {string} action
-   * @param {string} args.input
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async music(action, args) {
-    const data = {
-      input: args.input || '',
-      client: 'YTMUSIC'
-    };
-    
-    const response = await this.#request.post(`/music/${action}`, data);
-  
-    return response;
-  }
-  
-  /**
-   * Mostly used for pagination and specific operations.
-   * 
-   * @param {object} args
-   * @param {string} [args.video_id]
-   * @param {string} [args.ctoken]
-   * @param {string} [args.client]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async next(args = {}) {
-    const data = {};
-    
-    args.ctoken &&
-      (data.continuation = args.ctoken);
-      
-    args.video_id &&
-      (data.videoId = args.video_id);
-      
-    args.client &&
-      (data.client == args.client);
-    
-    const response = await this.#request.post('/next', data);
-  
-    return response;
-  }
-  
-  /**
-   * Used to retrieve video info.
-   * 
-   * @param {string} id
-   * @param {string} [cpn]
-   *
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async getVideoInfo(id, cpn) {
-    const data = {
-      playbackContext: {
-        contentPlaybackContext: {
-          vis: 0,
-          splay: false,
-          referer: 'https://www.youtube.com',
-          currentUrl: '/watch?v=' + id,
-          autonavState: 'STATE_OFF',
-          signatureTimestamp: this.#session.sts,
-          autoCaptionsDefaultOn: false,
-          html5Preference: 'HTML5_PREF_WANTS',
-          lactMilliseconds: '-1'
-        }
-      },
-      videoId: id
-    };
-    
-    cpn && (data.cpn = cpn);
-    
-    const response = await this.#request.post('/player', data);
-  
-    return response.data;
-  }
-  
-  /**
-   * Covers search suggestion endpoints.
-   * 
-   * @param {string} client
-   * @param {string} input
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async getSearchSuggestions(client, query) {
-    if (!['YOUTUBE', 'YTMUSIC'].includes(client))
-      throw new Utils.InnertubeError('Invalid client', client);
-    
-    const response = await ({
-      YOUTUBE: () => this.#request({ 
-        url: 'search',
-        baseURL: Constants.URLS.YT_SUGGESTIONS, 
-        params: {
-          q: query,
-          ds: 'yt',
-          client: 'youtube',
-          xssi: 't',
-          oe: 'UTF',
-          gl: this.#session.context.client.gl,
-          hl: this.#session.context.client.hl
-        }
-      }),
-      YTMUSIC: () => this.music('get_search_suggestions', { input: query })
-    }[client])();
-    
-    return response;
-  }
-  
-  /**
-   * Endpoint used to retrieve user mention suggestions.
-   * 
-   * @param {object} args
-   * @param {string} args.input
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async getUserMentionSuggestions(args = {}) {
-    if (!this.#session.logged_in)
-      throw new Utils.InnertubeError('You are not signed in');
-      
-    const data = {
-      input: args.input,
-      client: 'ANDROID'
-    };
-    
-    const response = await this.#request.post('get_user_mention_suggestions', data);
-    
-    return response;
-  }
-  
-  #needsLogin(id) {
-    return [
-      'FElibrary', 'FEhistory', 'FEsubscriptions',
-      'SPaccount_notifications',  'SPaccount_privacy',
-      'SPtime_watched'
-    ].includes(id);
-  }
-}
-
-module.exports = Actions;

lib/core/InteractionManager.js

@@ -1,134 +0,0 @@
-'use strict';
-
-const Utils = require('../utils/Utils');
-
-/** @namespace */
-class InteractionManager {
-  #actions;
-  
-  /**
-   * @param {Actions} actions
-   * @constructor
-   */
-  constructor(actions) {
-    this.#actions = actions;
-  }
-  
- /**
-  * Likes a given video.
-  * @param {string} video_id
-  * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-  */
-  async like(video_id) {
-    Utils.throwIfMissing({ video_id });
-    const action = await this.#actions.engage('like/like', { video_id });
-    return action;
-  }
-  
- /**
-  * Dislikes a given video.
-  * @param {string} video_id
-  * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-  */
-  async dislike(video_id) {
-    Utils.throwIfMissing({ video_id });
-    const action = await this.#actions.engage('like/dislike', { video_id });
-    return action;
-  }
-  
-  /**
-   * Removes a like/dislike.
-   * @param {string} video_id 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>} 
-   */
-  async removeLike(video_id) {
-    Utils.throwIfMissing({ video_id });
-    const action = await this.actions.engage('like/removelike', { video_id });
-    return action;
-  }
-  
-  /**
-   * Subscribes to a given channel.
-   * @param {string} channel_id 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async subscribe(channel_id) {
-    Utils.throwIfMissing({ channel_id });
-    const action = await this.#actions.engage('subscription/subscribe', { channel_id });
-    return action;
-  }
-  
-  /**
-   * Unsubscribes from a given channel.
-   * @param {string} channel_id 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async unsubscribe(channel_id) {
-    Utils.throwIfMissing({ channel_id });
-    const action = await this.#actions.engage('subscription/unsubscribe', { channel_id });
-    return action;
-  }
-  
-  /**
-   * Posts a comment on a given video.
-   * 
-   * @param {string} video_id 
-   * @param {string} text 
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; data: object; }>}
-   */
-  async comment(video_id, text) {
-    Utils.throwIfMissing({ video_id, text });
-    const action = await this.#actions.engage('comment/create_comment', { video_id, text });
-    return action;
-  }
-  
-  /**
-   * Translates a given text using YouTube's comment translate feature.
-   * 
-   * @param {string} text
-   * @param {string} target_language - an ISO language code
-   * @param {object} [args] - optional arguments
-   * @param {string} [args.video_id]
-   * @param {string} [args.comment_id]
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; translated_content: string; data: object; }>}
-   */
-  async translate(text, target_language, args = {}) {
-    Utils.throwIfMissing({ text, target_language });
-   
-    const response = await await this.#actions.engage('comment/perform_comment_action', {
-      video_id: args.video_id,
-      comment_id: args.comment_id,
-      target_language: target_language,
-      comment_action: 'translate',
-      text
-    });
-        
-    const translated_content = Utils.findNode(response.data, 'frameworkUpdates', 'content', 7, false);
-        
-    return {
-      success: response.success,
-      status_code: response.status_code,
-      translated_content: translated_content.content,
-      data: response.data
-    }
-  }
-  
-  /**
-   * 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: number; data: object; }>} 
-   */
-  async setNotificationPreferences(channel_id, type) {
-    Utils.throwIfMissing({ channel_id, type });
-    const action = await this.#actions.notifications('modify_channel_preference', { channel_id, pref: type || 'NONE' });
-    return action;
-  }
-}
-
-module.exports = InteractionManager;

lib/core/Livechat.js

@@ -1,137 +0,0 @@
-'use strict';
-
-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 this.session.actions.livechat('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.ctoken = this.metadata_ctoken;
-
-    const updated_metadata = await this.session.actions.livechat('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 this.session.actions.livechat('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 this.session.actions.livechat('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 this.session.actions.livechat('live_chat/moderate', { 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
-   */
-  async blockUser() {
-    throw new Error('Not implemented');
-  }
-
-  stop() {
-    this.running = false;
-    clearTimeout(this.livechat_poller);
-  }
-}
-
-module.exports = Livechat;

lib/core/OAuth.js

@@ -1,244 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-const Constants = require('../utils/Constants');
-const Uuid = require('uuid');
-
-/** @namespace */
-class OAuth {
-  #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 = {};
-  #polling_interval = 5;
-  #ev = null;
-  
-  /**
-   * @param {EventEmitter} ev
-   * @constructor
-   */
-  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: Constants.OAUTH.SCOPE,
-      device_id: Uuid.v4(),
-      model_name: Constants.OAUTH.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.#polling_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: Constants.OAUTH.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.#polling_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).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;
-  }
-  
-  /**
-   * Returns the access token.
-   * @returns {string}
-   */
-  getAccessToken() {
-    return this.#auth_info.access_token;
-  }
-  
-  /**
-   * Returns the refresh token.
-   * @returns {string}
-   */
-  getRefreshToken() {
-    return this.#auth_info.refresh_token;
-  }
-  
-  /**
-   * Checks if the auth info format 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,127 +0,0 @@
-'use strict';
-
-const os = require('os');
-const Fs = require('fs');
-const Axios = require('axios');
-const Utils = require('../utils/Utils');
-const Constants = require('../utils/Constants');
-
-/** @namespace */
-class Player {
-  #player_id;
-  #player_url;
-  #player_path;
-  
-  #ntoken_decipher_sc;
-  #signature_decipher_sc;
-  #signature_timestamp;
-  #cache_dir;
-  
-  /**
-   * Represents the YouTube Web player script.
-   * @param {string} id - the id of the player.
-   * @constructor
-   */
-  constructor(id) {
-    this.#player_id = id;
-    this.#cache_dir = `${os.tmpdir()}/cache`;
-    this.#player_url = Constants.URLS.YT_BASE + '/s/player/' + this.#player_id + '/player_ias.vflset/en_US/base.js';
-    this.#player_path = `${this.#cache_dir}/${this.#player_id}.js`;
-  }
-
-  async init() {
-    if (this.isCached()) {
-      const player_data = Fs.readFileSync(this.#player_path).toString();
-      this.#signature_timestamp = this.#extractSigTimestamp(player_data);
-      this.#signature_decipher_sc = this.#extractSigDecipherSc(player_data);
-      this.#ntoken_decipher_sc = this.#extractNTokenSc(player_data);
-    } else {
-      const response = await Axios.get(this.#player_url, { headers: { 'content-type': 'text/javascript', 'user-agent': Utils.getRandomUserAgent('desktop').userAgent } }).catch((error) => error);
-      if (response instanceof Error) throw new Utils.InnertubeError('Could not download js player', { player_id: this.#player_id });
-      
-      this.#signature_timestamp = this.#extractSigTimestamp(response.data);
-      this.#signature_decipher_sc = this.#extractSigDecipherSc(response.data);
-      this.#ntoken_decipher_sc = this.#extractNTokenSc(response.data);
-    
-      try {
-        // Delete the old player
-        Fs.existsSync(this.#cache_dir) &&
-          Fs.rmSync(this.#cache_dir, { recursive: true });
-          
-        // Cache the current player
-        Fs.mkdirSync(this.#cache_dir, { recursive: true });
-        Fs.writeFileSync(this.#player_path, response.data);
-      } finally { /* do nothing */ }
-    }
-    
-    return this;
-  }
-  
-  /**
-   * Returns the current player's url.
-   * @readonly
-   * @returns {string}
-   */
-  get url() {
-    return this.#player_url;
-  }
-  
-  /**
-   * Returns the signature timestamp.
-   * @readonly
-   * @returns {string}
-   */
-  get sts() {
-    return this.#signature_timestamp;
-  }
-  
-  /**
-   * Returns the n-token decipher algorithm.
-   * @readonly
-   * @returns {string}
-   */
-  get ntoken_decipher() {
-    return this.#ntoken_decipher_sc;
-  }
-  
-  /**
-   * Returns the signature decipher algorithm.
-   * @readonly
-   * @returns {string}
-   */
-  get signature_decipher() {
-    return this.#signature_decipher_sc;
-  }
-  
-  /**
-   * Extracts the signature timestamp from the player source code.
-   * @returns {number}
-   */
-  #extractSigTimestamp(data) {
-    return parseInt(Utils.getStringBetweenStrings(data, 'signatureTimestamp:', ','));
-  }
-  
-  /**
-   * Extracts the signature decipher algorithm.
-   * @returns {string}
-   */
-  #extractSigDecipherSc(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;
-  }
-  
-  /**
-   * Extracts the n-token decipher algorithm.
-   * @returns {string}
-   */
-  #extractNTokenSc(data) {
-    return `var b=a.split("")${Utils.getStringBetweenStrings(data, 'b=a.split("")', '}return b.join("")}')}} return b.join("");`;
-  }
-  
-  isCached() {
-    return Fs.existsSync(this.#player_path);
-  }
-}
-
-module.exports = Player;

lib/core/PlaylistManager.js

@@ -1,115 +0,0 @@
-'use strict';
-
-const Utils = require('../utils/Utils');
-
-/** @namespace */
-class PlaylistManager {
-  #actions;
-  
-  /**
-   * @param {Actions} actions
-   * @constructor
-   */
-  constructor (actions) {
-    this.#actions = actions;
-  }
-  
-  /**
-   * Creates a playlist.
-   * 
-   * @param {string} title
-   * @param {Array.<string>} video_ids
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; playlist_id: string; data: object; }>}
-   */
-  async create(title, video_ids) {
-    Utils.throwIfMissing({ title, video_ids });
-  
-    const response = await this.#actions.playlist('playlist/create', { title, ids: video_ids });
-  
-    return {
-      success: response.success,
-      status_code: response.status_code,
-      playlist_id: response.data.playlistId,
-      data: response.data
-    }
-  }
-  
-  /**
-   * Deletes a given playlist.
-   * @param {string} playlist_id
-   * @returns {Promise.<{ success: boolean; status_code: number; playlist_id: string; data: object; }>}
-   */
-  async delete(playlist_id) {
-    Utils.throwIfMissing({ playlist_id });
- 
-    const response = await this.#actions.playlist('playlist/delete', { playlist_id });
-    
-    return {
-      success: response.success,
-      status_code: response.status_code,
-      playlist_id,
-      data: response.data
-    }
-  }
-  
-  /**
-   * Adds videos to a given playlist.
-   * 
-   * @param {string} playlist_id
-   * @param {Array.<string>} video_ids
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; playlist_id: string; data: object; }>}
-   */
-  async addVideos(playlist_id, video_ids) {
-    Utils.throwIfMissing({ playlist_id, video_ids });
-     
-    const response = await this.#actions.playlist('browse/edit_playlist', {
-      ids: video_ids,
-      action: 'ACTION_ADD_VIDEO',
-      playlist_id
-    });
-
-    return {
-      success: response.success,
-      status_code: response.status_code,
-      playlist_id,
-      data: response.data
-    }
-  }
-  
-  /**
-   * Removes videos from a given playlist.
-   * 
-   * @param {string} playlist_id
-   * @param {Array.<string>} video_ids
-   * 
-   * @returns {Promise.<{ success: boolean; status_code: number; playlist_id: string; data: object; }>}
-   */
-  async removeVideos(playlist_id, video_ids) {
-    Utils.throwIfMissing({ playlist_id, video_ids });
-  
-    const plinfo = await this.#actions.browse(`VL${playlist_id}`);
-
-    const list = Utils.findNode(plinfo.data, 'contents', 'contents', 13, false);
-    if (!list.isEditable) throw new Utils.InnertubeError('This playlist cannot be edited.', playlist_id);
-
-    const videos = list.contents.filter((item) => video_ids.includes(item.playlistVideoRenderer.videoId));
-    const set_video_ids = videos.map((video) => video.playlistVideoRenderer.setVideoId);
-
-    const response = await this.#actions.playlist('browse/edit_playlist', {
-      ids: set_video_ids,
-      action: 'ACTION_REMOVE_VIDEO',
-      playlist_id
-    });
-        
-    return {
-      success: response.success,
-      status_code: response.status_code,
-      playlist_id,
-      data: response.data
-    }
-  }
-}
-
-module.exports = PlaylistManager;

lib/core/SessionBuilder.js

@@ -1,146 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-const Player = require('./Player');
-const Proto = require('../proto');
-const Utils = require('../utils/Utils');
-const Constants = require('../utils/Constants');
-const UserAgent = require('user-agents');
-
-/** @namespace */
-class SessionBuilder {
-  #config;
-  
-  #key;
-  #client_name;
-  #client_version;
-  #api_version;
-  #remote_host;
-  #context;
-  #player;
-  
-  /**
-   * @param {object} config
-   * @constructor
-   */
-  constructor(config) {
-    this.#config = config;
-  }
-  
-  async build() {
-    const data = await Promise.all([
-      this.#getYtConfig(), 
-      this.#getPlayerId() 
-    ]);
-    
-    const ytcfg = data[0][0][2];
-    
-    this.#key = ytcfg[1];
-    this.#api_version = `v${ytcfg[0][0][6]}`;
-    this.#client_name = Constants.CLIENTS.WEB.NAME;
-    this.#client_version = ytcfg[0][0][16];
-    this.#remote_host = ytcfg[0][0][3];
-    this.#player = await new Player(data[1]).init();
-  
-    this.#context = this.#buildContext();
-    
-    return this;
-  }
-  
-  /**
-   * Builds a valid context object.
-   * @returns
-   */
-  #buildContext() {
-    const user_agent = new UserAgent({ deviceCategory: 'desktop' });
-    
-    const id = Utils.generateRandomString(11);
-    const timestamp = Math.floor(Date.now() / 1000);
-    
-    const visitor_data = Proto.encodeVisitorData(id, timestamp);
-    
-    const context = {
-      client: {
-        hl: 'en',
-        gl: this.#config.gl || 'US',
-        remoteHost: this.#remote_host,
-        deviceMake: user_agent.vendor,
-        deviceModel: user_agent.platform,
-        visitorData: visitor_data,
-        userAgent: user_agent.toString(),
-        clientName: this.#client_name,
-        clientVersion: this.#client_version,
-        originalUrl: Constants.URLS.YT_BASE
-      },
-      user: { lockedSafetyMode: false },
-      request: { useSsl: true }
-    }
-    
-    return context;
-  }
-  
-  /**
-   * Retrieves initial configuration such as keys, 
-   * client data, etc.
-   * @returns Promise.<object>
-   */
-  async #getYtConfig() {
-    const response = await Axios.get(`${Constants.URLS.YT_BASE}/sw.js_data`).catch((err) => err);
-  
-    if (response instanceof Error) 
-      throw new Utils.InnertubeError('Could not retrieve configuration data', {
-        status_code: response?.response?.status || 0, 
-        message: response.message 
-      });
-    
-    return JSON.parse(response.data.replace(')]}\'', ''));
-  }
-  
-  /**
-   * Retrives the YouTube player id.
-   * @returns {Promise.<string>
-   */
-  async #getPlayerId() {
-    const response = await Axios.get(`${Constants.URLS.YT_BASE}/iframe_api`).catch((err) => err);
-  
-    if (response instanceof Error)
-      throw new Utils.InnertubeError('Could not retrieve js player id', { 
-        status_code: response?.response?.status || 0,
-        message: response.message
-      });
-      
-    return Utils.getStringBetweenStrings(response.data, 'player\\/', '\\/');
-  }
-  
-  /** @readonly */
-  get key() {
-    return this.#key;
-  }
-  
-  /** @readonly */
-  get context() {
-    return this.#context;
-  }
-  
-  /** @readonly */
-  get api_version() {
-    return this.#api_version;
-  }
-  
-  /** @readonly */
-  get client_version() {
-    return this.#client_version;
-  }
-  
-  /** @readonly */
-  get client_name() {
-    return this.#client_name;
-  }
-  
-  /** @readonly */
-  get player() {
-    return this.#player;
-  }
-}
-
-module.exports = SessionBuilder;

lib/deciphers/NToken.js

@@ -1,142 +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}
-   */
-  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(new Utils.ParsingError('Could not transform n-token, download may be throttled.', {
-        original_token: this.n, 
-        stack: err.stack
-      }));
-      return this.n;
-    }
-    return n_token.join('');
-  }
-
-  #getFunc(el) {
-    return el.match(Constants.NTOKEN_REGEX.FUNCTIONS);
-  }
-
-  /**
-   * Takes the n-transform data, refines it, and then returns a readable json array.
-   * @returns {Array}
-   */
-  #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,91 +0,0 @@
-'use strict';
-
-const Constants = require('../utils/Constants');
-const QueryString = require('querystring');
-
-class Signature {
-  constructor(url, sig_decipher_sc) {
-    this.url = url;
-    this.sig_decipher_sc = sig_decipher_sc;
-  }
-  
-  /**
-   * Deciphers signature.
-   * @returns {string}
-   */
-  decipher() {
-    let actions;
-    
-    const args = QueryString.parse(this.url);
-    const signature = args.s.split('');
-    
-    const functions = this.#getFunctions();
-
-    /**
-     * Decides what function should be used to modify the 
-     * the signature.
-     */
-    while ((actions = Constants.SIG_REGEX.ACTIONS.exec(this.sig_decipher_sc)) !== null) {
-      const action = actions.groups;
-      switch (action.name) {
-        case functions[0]:
-          this.#reverse(signature);
-          break;
-        case functions[1]:
-          this.#splice(signature, action.param);
-          break;
-        case functions[2]:
-          this.#swap(signature, action.param);
-          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();
-  }
-  
-  /**
-   * Extracts the functions used to modify the signature
-   * and returns them in the correct order.
-   * 
-   * @returns {Array.<string>}
-   */
-  #getFunctions() {
-    let func;
-    let functions = [];
-    
-    while ((func = Constants.SIG_REGEX.FUNCTIONS.exec(this.sig_decipher_sc)) !== null) {
-      if (func[0].includes('reverse')) {
-        functions[0] = func[1];
-      } else if (func[0].includes('splice')) {
-        functions[1] = func[1];
-      } else {
-        functions[2] = func[1];
-      }
-    }
-    
-    return functions;
-  }
-  
-  #swap(arr, index) {
-    let origArrI = arr[0];
-    arr[0] = arr[index % arr.length];
-    arr[index % arr.length] = origArrI;
-  }
-  
-  #splice(arr, end) {
-    arr.splice(0, end);
-  }
-  
-  #reverse(arr) {
-    arr.reverse();
-  }
-}
-
-module.exports = Signature;

lib/parser/index.js

@@ -1,589 +0,0 @@
-'use strict';
-
-const Utils = require('../utils/Utils');
-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(),
-          LIBRARY: () => this.#processLibrary(), //WIP
-          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 this.session.actions.search({ ctoken });
-        
-        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(JSON.parse(this.data.replace(')]}\'', '')));
-  }
-  
-  #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 || 'N/A',
-      last_updated: details.playlistSidebarPrimaryInfoRenderer.stats[2].runs[1]?.text || 'N/A',
-      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 = () => this.session.actions.engage('comment/perform_comment_action', { comment_action: 'like', comment_id: comment.metadata.id, video_id: this.args.video_id });
-          comment.dislike = () => this.session.actions.engage('comment/perform_comment_action', { comment_action: 'dislike', comment_id: comment.metadata.id, video_id: this.args.video_id });
-          comment.reply = (text) => this.session.actions.engage('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 this.session.actions.flag('flag/get_form', { params: payload.params });
-           
-            const action = Utils.findNode(form, 'actions', 'flagAction', 13, false);
-            const flag = await this.session.actions.flag('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 this.session.actions.next({ ctoken: payload });
-            return parseComments(next.data);
-          };
-          
-          comment.translate = async (target_language) => {
-            const response = await this.session.actions.engage('comment/perform_comment_action', {
-              text: comment.text, 
-              comment_action: 'translate',
-              comment_id: comment.metadata.id,
-              video_id: this.args.video_id,
-              target_language
-            });
-            
-            const translated_content = Utils.findNode(response.data, 'frameworkUpdates', 'content', 7, false);
-            
-            return {
-              success: response.success,
-              status_code: response.status_code,
-              translated_content: translated_content.content
-            }
-          }
-          
-          return comment;
-        }
-      }).filter((c) => c);
-      
-      response.comment = (text) => this.session.actions.engage('comment/create_comment', { video_id: this.args.video_id, text });
-   
-      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 this.session.actions.next({ ctoken: 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 this.session.actions.browse(ctoken, { is_ctoken: true });
-        
-        return parseItems(response.data.onResponseReceivedActions[0].appendContinuationItemsAction.continuationItems);
-      }
-
-      return { videos, getContinuation };
-    }
-
-    return parseItems(contents);
-  }
-  
-  #processLibrary() { // TODO: Finish this
-    const profile_data = Utils.findNode(this.data, 'contents', 'profileColumnRenderer', 3);
-    const stats_data = profile_data.profileColumnRenderer.items.find((item) => item.profileColumnStatsRenderer);
-    const stats_items = stats_data.profileColumnStatsRenderer.items;
-    const userinfo = profile_data.profileColumnRenderer.items.find((item) => item.profileColumnUserInfoRenderer);
-    
-    const stats = {};
-    
-    stats_items.forEach((item) => {
-      const label = item.profileColumnStatsEntryRenderer.label.runs.map((run) => run.text).join('');
-      stats[label.toLowerCase()] = parseInt(item.profileColumnStatsEntryRenderer.value.simpleText);
-    });
-    
-    const profile = {
-      name: userinfo.profileColumnUserInfoRenderer?.title?.simpleText,
-      thumbnails: userinfo.profileColumnUserInfoRenderer?.thumbnail.thumbnails,
-      stats
-    }
-    
-    // const content = Utils.findNode(this.data, 'contents', 'content', 8, false);
-    // console.info(content[0].itemSectionRenderer.contents[0].shelfRenderer);
-    
-    return {
-      profile
-    }
-  }
-  
-  #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 this.session.actions.browse(ctoken, { is_ctoken: true });
-        
-        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');
-    
-    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 this.session.actions.notifications('get_notification_menu', { ctoken });
-        
-        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 = {};
-    
-    tabs.forEach((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 this.session.actions.browse('FEtrending', { params });
-          
-          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 this.session.actions.browse(ctoken, { is_ctoken: true });
-        
-        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,36 +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 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) {
-    return {
-      query: data[0],
-      results: data[1].map((res) => res[0])
-    }
-  }
-}
-
-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 {
-      query: this.parseItem(data[0]).runs[0].text.trim(),
-      results: data.map((item) => this.parseItem(item).runs.map((run) => run.text).join('').trim())
-    }
-  }
-  
-  static parseItem(item) {
-    let suggestion;
-    
-    item.historySuggestionRenderer &&
-      (suggestion = item.historySuggestionRenderer.suggestion) ||
-      (suggestion = item.searchSuggestionRenderer.suggestion);
-    
-    return suggestion;
-  }
-}
-
-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;