chore(main): release 5.0.2 (#394)

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

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

.eslintrc.yml

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

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/config.yml

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

.github/ISSUE_TEMPLATE/feature.yml

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

.github/ISSUE_TEMPLATE/issue.yml

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

.github/ISSUE_TEMPLATE/question.yml

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

.github/labeler_config.yml

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

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

@@ -0,0 +1,18 @@
+name: lint
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - 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,29 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: Build
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [ 12.x, 14.x, 15.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 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: 6
-        days-before-close: 2
+        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

@@ -0,0 +1,77 @@
+# YouTube player cache directory
+cache/
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+# pnpm
+.pnpm-debug.log*
+pnpm-lock.yaml
+
+# Downloaded assets
+*.mp4
+*.webm
+*.mkv
+
+# Temporary files for testing
+tmp/
+
+# Build output
+dist/
+bundle/*.js.*
+bundle/*.js
+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,205 @@
+# Changelog
+
+## [5.0.2](https://github.com/LuanRT/YouTube.js/compare/v5.0.1...v5.0.2) (2023-04-30)
+
+
+### Bug Fixes
+
+* **VideoInfo:** Use microformat view_count when videoDetails view_count is NaN ([#393](https://github.com/LuanRT/YouTube.js/issues/393)) ([7c0abfc](https://github.com/LuanRT/YouTube.js/commit/7c0abfccd78a6c291d898f898d73a4f16170e2a9))
+
+## [5.0.1](https://github.com/LuanRT/YouTube.js/compare/v5.0.0...v5.0.1) (2023-04-30)
+
+
+### Bug Fixes
+
+* **web:** slow downloads due to visitor data ([#391](https://github.com/LuanRT/YouTube.js/issues/391)) ([4f7ec07](https://github.com/LuanRT/YouTube.js/commit/4f7ec07c3f689219b07e8291877c23b6fbf45fb1))
+
+## [5.0.0](https://github.com/LuanRT/YouTube.js/compare/v4.3.0...v5.0.0) (2023-04-29)
+
+
+### ⚠ BREAKING CHANGES
+
+* overhaul core classes and remove redundant code ([#388](https://github.com/LuanRT/YouTube.js/issues/388))
+
+### Features
+
+* **NavigationEndpoint:** parse `content` prop ([dd21f8c](https://github.com/LuanRT/YouTube.js/commit/dd21f8c75ae1d76180faab4f0ef9ee40920966e3))
+
+
+### Bug Fixes
+
+* **android:** workaround streaming URLs returning 403 ([#390](https://github.com/LuanRT/YouTube.js/issues/390)) ([75ea09d](https://github.com/LuanRT/YouTube.js/commit/75ea09dde86b1bdf13b197d6e02701899300a371))
+
+
+### Code Refactoring
+
+* overhaul core classes and remove redundant code ([#388](https://github.com/LuanRT/YouTube.js/issues/388)) ([95e0294](https://github.com/LuanRT/YouTube.js/commit/95e0294eabfdb20bbee2a4bfb751fd101402c5d6))
+
+## [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 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.

LICENSE

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

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,81 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const Innertube = require('..');
-
-async function start() {
-  const youtube = await new Innertube();
-
-  // Searching, getting details about videos & making interactions:
-  const search = await youtube.search('Looking for life on Mars - documentary');
-  console.info('Search results:', search);
-  
-  if (search.videos.length === 0) 
-    return console.error('Could not find any video about that on YouTube.');
-  
-  const video = await youtube.getDetails(search.videos[0].id).catch((error) => error);
-  console.info('Video details:', video);
- 
-  if (video instanceof Error) 
-    return console.error('Could not get details for ' + search.videos[0].title);
-  
-  if (youtube.logged_in) {
-    const myNotifications = await youtube.getNotifications();
-    console.info('My notifications:', myNotifications);
-
-    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

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

lib/Actions.js

@@ -1,165 +0,0 @@
-'use strict';
-
-const Uuid = require('uuid');
-const Axios = require('axios');
-const Utils = require('./Utils');
-const Constants = require('./Constants');
-
-async function engage(session, engagement_type, args = {}) {
-  if (!session.logged_in) throw new Error('You are not logged in');
-  let data = {};
-  switch (engagement_type) {
-    case 'like/like':
-    case 'like/dislike':
-    case 'like/removelike':
-      data = {
-        context: session.context,
-        target: {
-          videoId: args.video_id
-        }
-      };
-      break;
-    case 'subscription/subscribe':
-    case 'subscription/unsubscribe':
-      data = {
-        context: session.context,
-        channelIds: [args.channel_id]
-      };
-      break;
-    case 'comment/create_comment':
-      data = {
-        context: session.context,
-        commentText: args.text,
-        createCommentParams: Utils.generateCommentParams(args.video_id)
-      };
-      break;
-    default:
-  }
-
-  const response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/${engagement_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`, JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session, id: args.video_id, data })).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
-  return {
-    success: true,
-    status_code: response.status
-  };
-}
-
-async function browse(session, action_type) {
-  if (!session.logged_in) throw new Error('You are not logged in');
-  let data;
-  switch (action_type) {
-    case 'subscriptions_feed':
-      data = {
-        context: session.context,
-        browseId: 'FEsubscriptions'
-      };
-      break;
-    default:
-  }
-
-  const response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/browse${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`, JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session })).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
-}
-
-async function notifications(session, action_type, args = {}) {
-  if (!session.logged_in) throw new Error('You are not logged in');
-  let data;
-  switch (action_type) {
-    case 'modify_channel_preference':
-      let pref_types = { PERSONALIZED: 1, ALL: 2, NONE: 3 };
-      data = {
-        context: session.context,
-        params: Utils.encodeNotificationPref(args.channel_id, pref_types[args.pref.toUpperCase()])
-      };
-      break;
-    case 'get_notification_menu':
-      data = {
-        context: session.context,
-        notificationsMenuRequestType: 'NOTIFICATIONS_MENU_REQUEST_TYPE_INBOX'
-      };
-      break;
-    case 'get_unseen_count':
-      data = {
-        context: session.context
-      };
-      break;
-    default:
-  }
-
-  const response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/notification/${action_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`, JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session })).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
-  if (action_type === 'modify_channel_preference') return { success: true, status_code: response.status };
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
-}
-
-async function livechat(session, action_type, args = {}) {
-  let data;
-  switch (action_type) {
-    case 'live_chat/send_message':
-      data = {
-        context: session.context,
-        params: Utils.generateMessageParams(args.channel_id, args.video_id),
-        clientMessageId: `ytjs-${Uuid.v4()}`,
-        richMessage: {
-          textSegments: [{ text: args.text }]
-        }
-      };
-      break;
-    case 'live_chat/get_item_context_menu':
-      data = {
-        context: session.context
-      };
-      break;
-    case 'live_chat/moderate':
-      data = {
-        context: session.context,
-        params: args.cmd_params
-      };
-      break;
-    default:
-  }
-
-  const response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/${action_type}${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`, JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session, params: args.params })).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
-}
-
-async function getContinuation(session, info = {}) {
-  let data = { context: session.context };
-  info.continuation_token && (data.continuation = info.continuation_token);
-
-  if (info.video_id) {
-    data.videoId = info.video_id;
-    data.racyCheckOk = true;
-    data.contentCheckOk = false;
-    data.autonavState = 'STATE_NONE';
-    data.playbackContext = {
-      vis: 0,
-      lactMilliseconds: '-1'
-    };
-    data.captionsRequested = false;
-  }
-
-  const response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/next${session.logged_in && session.cookie.length < 1 ? '' : `?key=${session.key}`}`, JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session })).catch((error) => error);
-  if (response instanceof Error) return { success: false, status_code: response.response.status, message: response.message };
-  return {
-    success: true,
-    status_code: response.status,
-    data: response.data
-  };
-}
-
-module.exports = { engage, browse, notifications, livechat, getContinuation };

lib/Constants.js

@@ -1,266 +0,0 @@
-'use strict';
-
-const Utils = require('./Utils');
-
-module.exports = {
-  URLS: {
-    YT_BASE_URL: 'https://www.youtube.com',
-    YT_MOBILE_URL: 'https://m.youtube.com',
-    YT_WATCH_PAGE: 'https://m.youtube.com/watch'
-  },
-  OAUTH: {
-    SCOPE: 'http://gdata.youtube.com https://www.googleapis.com/auth/youtube-paid-content',
-    GRANT_TYPE: 'http://oauth.net/grant_type/device/1.0',
-    MODEL_NAME: 'ytlr::',
-    HEADERS: {
-      headers: {
-        'accept': '*/*',
-        'origin': 'https://www.youtube.com',
-        'user-agent': 'Mozilla/5.0 (ChromiumStylePlatform) Cobalt/Version',
-        'content-type': 'application/json',
-        'referer': `https://www.youtube.com/tv`,
-        'accept-language': 'en-US'
-      }
-    }
-  },
-  DEFAULT_HEADERS: (session) => {
-    return {
-      headers: {
-        'Cookie': session.cookie,
-        'user-agent': Utils.getRandomUserAgent('desktop').userAgent,
-        'Referer': 'https://www.google.com/',
-        'Accept': 'text/html',
-        'Accept-Language': 'en-US,en',
-        'Accept-Encoding': 'gzip',
-        'Upgrade-Insecure-Requests': 1
-      }
-    };
-  },
-  STREAM_HEADERS: {
-    'Accept': '*/*',
-    'User-Agent': Utils.getRandomUserAgent('desktop').userAgent,
-    'Connection': 'keep-alive',
-    'Origin': 'https://www.youtube.com',
-    'Referer': 'https://www.youtube.com',
-    'DNT': '?1'
-  },
-  INNERTUBE_REQOPTS: (info) => {
-    info.desktop === undefined && (info.desktop = true);
-    let req_opts = {
-      params: info.params || {},
-      headers: {
-        'accept': '*/*',
-        'user-agent': Utils.getRandomUserAgent(info.desktop ? 'desktop' : 'mobile').userAgent,
-        'content-type': 'application/json',
-        'accept-language': 'en-US,en;q=0.9',
-        'x-goog-authuser': 0,
-        'x-goog-visitor-id': info.session.context.client.visitorData || '',
-        'x-youtube-client-name': info.desktop ? 1 : 2,
-        'x-youtube-client-version': info.session.context.client.clientVersion,
-        'x-youtube-chrome-connected': 'source=Chrome,mode=0,enable_account_consistency=true,supervised=false,consistency_enabled_by_default=false',
-        'x-origin': info.desktop ? 'https://www.youtube.com' : 'https://m.youtube.com',
-        'origin': info.desktop ? 'https://www.youtube.com' : 'https://m.youtube.com',
-      }
-    };
-
-    info.id && (req_opts.headers.referer = (info.desktop ? 'https://www.youtube.com' : 'https://m.youtube.com') + '/watch?v=' + info.id);
-
-    if (info.session.logged_in && info.desktop) {
-      req_opts.headers.Cookie = info.session.cookie;
-      req_opts.headers.authorization = info.session.cookie.length < 1 ? `Bearer ${info.session.access_token}` : info.session.auth_apisid;
-    }
-
-    return req_opts;
-  },
-  VIDEO_INFO_REQBODY: (id, sts, context) => {
-    return {
-      playbackContext: {
-        contentPlaybackContext: {
-          'currentUrl': '/watch?v=' + id,
-          'vis': 0,
-          'splay': false,
-          'autoCaptionsDefaultOn': false,
-          'autonavState': 'STATE_OFF',
-          'html5Preference': 'HTML5_PREF_WANTS',
-          'signatureTimestamp': sts,
-          'referer': 'https://www.youtube.com',
-          'lactMilliseconds': '-1'
-        }
-      },
-      context: context,
-      videoId: id
-    };
-  },
-  BASE64_DIALECT: {
-    NORMAL: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'.split(''),
-    REVERSE: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_'.split('')
-  },
-  FUNCS_REGEX: /d\.push\(e\)|d\.reverse\(\)|d\[0\]\)\[0\]\)|f=d\[0];d\[0\]|d\.length;d\.splice\(e,1\)|function\(\){for\(var|function\(d,e,f\){var h=f|function\(d\){for\(var|reverse\(\)\.forEach|unshift\(d\.pop\(\)\)|function\(d,e\){for\(var f/,
-  FUNCS: {
-    PUSH: 'd.push(e)',
-    REVERSE_1: 'd.reverse()',
-    REVERSE_2: 'function(d){for(var',
-    SPLICE: 'd.length;d.splice(e,1)',
-    SWAP0_1: 'd[0])[0])',
-    SWAP0_2: 'f=d[0];d[0]',
-    ROTATE_1: 'reverse().forEach',
-    ROTATE_2: 'unshift(d.pop())',
-    BASE64_DIA: 'function(){for(var',
-    TRANSLATE_1: 'function(d,e){for(var f',
-    TRANSLATE_2: 'function(d,e,f){var h=f'
-  },
-  // Helper functions, felt like Utils.js wasn't the right place for them:
-  formatNTransformData: (data) => {
-    return data
-      .replace(/function\(d,e\)/g, '"function(d,e)').replace(/function\(d\)/g, '"function(d)')
-      .replace(/function\(\)/g, '"function()').replace(/function\(d,e,f\)/g, '"function(d,e,f)')
-      .replace(/\[function\(d,e,f\)/g, '["function(d,e,f)')
-      .replace(/,b,/g, ',"b",').replace(/,b/g, ',"b"').replace(/b,/g, '"b",').replace(/b]/g, '"b"]')
-      .replace(/\[b/g, '["b"').replace(/}]/g, '"]').replace(/},/g, '}",').replace(/""/g, '')
-      .replace(/length]\)}"/g, 'length])}');
-  },
-  formatVideoData: (data, context, is_desktop) => {
-    let video_details = {};
-    let metadata = {};
-
-    if (is_desktop) {
-      metadata.embed = data.microformat.playerMicroformatRenderer.embed;
-      metadata.view_count = parseInt(data.videoDetails.viewCount);
-      metadata.average_rating = data.videoDetails.averageRating;
-      metadata.length_seconds = data.microformat.playerMicroformatRenderer.lengthSeconds;
-      metadata.channel_id = data.videoDetails.channelId;
-      metadata.channel_url = data.microformat.playerMicroformatRenderer.ownerProfileUrl;
-      metadata.external_channel_id = data.microformat.playerMicroformatRenderer.externalChannelId;
-      metadata.is_live_content = data.videoDetails.isLiveContent;
-      metadata.is_family_safe = data.microformat.playerMicroformatRenderer.isFamilySafe;
-      metadata.is_unlisted = data.microformat.playerMicroformatRenderer.isUnlisted;
-      metadata.is_private = data.videoDetails.isPrivate;
-      metadata.has_ypc_metadata = data.microformat.playerMicroformatRenderer.hasYpcMetadata;
-      metadata.category = data.microformat.playerMicroformatRenderer.category;
-      metadata.channel_name = data.microformat.playerMicroformatRenderer.ownerChannelName;
-      metadata.publish_date = data.microformat.playerMicroformatRenderer.publishDate || 'N/A';
-      metadata.upload_date = data.microformat.playerMicroformatRenderer.uploadDate || 'N/A';
-      metadata.keywords = data.videoDetails.keywords || [];
-
-      video_details.title = data.videoDetails.title;
-      video_details.description = data.videoDetails.shortDescription;
-      video_details.thumbnail = data.videoDetails.thumbnail.thumbnails.slice(-1)[0];
-      video_details.metadata = metadata;
-    } else {
-      metadata.embed = data[2].playerResponse.microformat.playerMicroformatRenderer.embed;
-      metadata.likes = parseInt(data[3].response.contents.singleColumnWatchNextResults.results.results.contents[1].slimVideoMetadataSectionRenderer.contents[1].slimVideoActionBarRenderer.buttons[0].slimMetadataToggleButtonRenderer.button.toggleButtonRenderer.defaultText.accessibility.accessibilityData.label.replace(/\D/g, ''));
-      metadata.dislikes = parseInt(data[3].response.contents.singleColumnWatchNextResults.results.results.contents[1].slimVideoMetadataSectionRenderer.contents[1].slimVideoActionBarRenderer.buttons[1].slimMetadataToggleButtonRenderer.button.toggleButtonRenderer.defaultText.accessibility.accessibilityData.label.replace(/\D/g, ''));
-      metadata.view_count = parseInt(data[2].playerResponse.videoDetails.viewCount);
-      metadata.average_rating = data[2].playerResponse.videoDetails.averageRating;
-      metadata.length_seconds = data[2].playerResponse.microformat.playerMicroformatRenderer.lengthSeconds;
-      metadata.channel_id = data[2].playerResponse.videoDetails.channelId;
-      metadata.channel_url = data[2].playerResponse.microformat.playerMicroformatRenderer.ownerProfileUrl;
-      metadata.external_channel_id = data[2].playerResponse.microformat.playerMicroformatRenderer.externalChannelId;
-      metadata.is_live_content = data[2].playerResponse.videoDetails.isLiveContent;
-      metadata.is_family_safe = data[2].playerResponse.microformat.playerMicroformatRenderer.isFamilySafe;
-      metadata.is_unlisted = data[2].playerResponse.microformat.playerMicroformatRenderer.isUnlisted;
-      metadata.is_private = data[2].playerResponse.videoDetails.isPrivate;
-      metadata.has_ypc_metadata = data[2].playerResponse.microformat.playerMicroformatRenderer.hasYpcMetadata;
-      metadata.category = data[2].playerResponse.microformat.playerMicroformatRenderer.category;
-      metadata.channel_name = data[2].playerResponse.microformat.playerMicroformatRenderer.ownerChannelName;
-      metadata.publish_date = data[2].playerResponse.microformat.playerMicroformatRenderer.publishDate;
-      metadata.upload_date = data[2].playerResponse.microformat.playerMicroformatRenderer.uploadDate;
-      metadata.keywords = data[2].playerResponse.videoDetails.keywords;
-
-      video_details.title = data[2].playerResponse.videoDetails.title;
-      video_details.description = data[2].playerResponse.videoDetails.shortDescription;
-      video_details.thumbnail = data[2].playerResponse.videoDetails.thumbnail.thumbnails.slice(-1)[0];
-
-      // Functions
-      video_details.like = () => {};
-      video_details.dislike = () => {};
-      video_details.removeLike = () => {};
-      video_details.subscribe = () => {};
-      video_details.unsubscribe = () => {};
-      video_details.comment = () => {};
-      video_details.getComments = () => {};
-      video_details.setNotificationPref = () => {};
-      video_details.getLivechat = () => {};
-
-      // Additional metadata
-      video_details.metadata = metadata;
-    }
-    return video_details;
-  },
-  filters: (order) => {
-    return (({
-      'any,any,relevance': 'EgIQAQ%3D%3D',
-      'hour,any,relevance': 'EgIIAQ%3D%3D',
-      'day,any,relevance': 'EgQIAhAB',
-      'week,any,relevance': 'EgQIAxAB',
-      'month,any,relevance': 'EgQIBBAB',
-      'year,any,relevance': 'EgQIBRAB',
-      'any,short,relevance': 'EgQQARgB',
-      'hour,short,relevance': 'EgYIARABGAE%3D',
-      'day,short,relevance': 'EgYIAhABGAE%3D',
-      'week,short,relevance': 'EgYIAxABGAE%3D',
-      'month,short,relevance': 'EgYIBBABGAE%3D',
-      'year,short,relevance': 'EgYIBRABGAE%3D',
-      'any,long,relevance': 'EgQQARgC',
-      'hour,long,relevance': 'EgYIARABGAI%3D',
-      'day,long,relevance': 'EgYIAhABGAI%3D',
-      'week,long,relevance': 'EgYIAxABGAI%3D',
-      'month,long,relevance': 'EgYIBBABGAI%3D',
-      'year,long,relevance': 'EgYIBRABGAI%3D',
-      'any,any,age': 'CAISAhAB',
-      'hour,any,age': 'CAISBAgBEAE%3D',
-      'day,any,age': 'CAISBAgCEAE%3D',
-      'week,any,age': 'CAISBAgDEAE%3D',
-      'month,any,age': 'CAISBAgEEAE%3D',
-      'year,any,age': 'CAISBAgFEAE%3D',
-      'any,short,age': 'CAISBBABGAE%3D',
-      'hour,short,age': 'CAISBggBEAEYAQ%3D%3D',
-      'day,short,age': 'CAISBggCEAEYAQ%3D%3D',
-      'week,short,age': 'CAISBggDEAEYAQ%3D%3D',
-      'month,short,age': 'CAISBggEEAEYAQ%3D%3D',
-      'year,short,age': 'CAISBggFEAEYAQ%3D%3D',
-      'any,long,age': 'CAISBBABGAI%3D',
-      'hour,long,age': 'CAISBggBEAEYAg%3D%3D',
-      'day,long,age': 'CAISBggCEAEYAg%3D%3D',
-      'week,long,age': 'CAISBggDEAEYAg%3D%3D',
-      'month,long,age': 'CAISBggEEAEYAg%3D%3D',
-      'year,long,age': 'CAISBggFEAEYAg%3D%3D',
-      'any,any,views': 'CAMSAhAB',
-      'hour,any,views': 'CAMSBAgBEAE%3D',
-      'day,any,views': 'CAMSBAgCEAE%3D',
-      'week,any,views': 'CAMSBAgDEAE%3D',
-      'month,any,views': 'CAMSBAgEEAE%3D',
-      'year,any,views': 'CAMSBAgFEAE%3D',
-      'any,short,views': 'CAMSBBABGAE%3D',
-      'hour,short,views': 'CAMSBggBEAEYAQ%3D%3D',
-      'day,short,views': 'CAMSBggCEAEYAQ%3D%3D',
-      'week,short,views': 'CAMSBggDEAEYAQ%3D%3D',
-      'month,short,views': 'CAMSBggEEAEYAQ%3D%3D',
-      'year,short,views': 'CAMSBggFEAEYAQ%3D%3D',
-      'any,long,views': 'CAMSBBABGAI%3D',
-      'hour,long,views': 'CAMSBggBEAEYAg%3D%3D',
-      'day,long,views': 'CAMSBggCEAEYAg%3D%3D',
-      'week,long,views': 'CAMSBggDEAEYAg%3D%3D',
-      'month,long,views': 'CAMSBggEEAEYAg%3D%3D',
-      'year,long,views': 'CAMSBggFEAEYAg%3D%3D',
-      'any,any,rating': 'CAESAhAB',
-      'hour,any,rating': 'CAESBAgBEAE%3D',
-      'day,any,rating': 'CAESBAgCEAE%3D',
-      'week,any,rating': 'CAESBAgDEAE%3D',
-      'month,any,rating': 'CAESBAgEEAE%3D',
-      'year,any,rating': 'CAESBAgFEAE%3D',
-      'any,short,rating': 'CAESBBABGAE%3D',
-      'hour,short,rating': 'CAESBggBEAEYAQ%3D%3D',
-      'day,short,rating': 'CAESBggCEAEYAQ%3D%3D',
-      'week,short,rating': 'CAESBggDEAEYAQ%3D%3D',
-      'month,short,rating': 'CAESBggEEAEYAQ%3D%3D',
-      'year,short,rating': 'CAESBggFEAEYAQ%3D%3D',
-      'any,long,rating': 'CAESBBABGAI%3D',
-      'hour,long,rating': 'CAESBggBEAEYAg%3D%3D',
-      'day,long,rating': 'CAESBggCEAEYAg%3D%3D',
-      'week,long,rating': 'CAESBggDEAEYAg%3D%3D',
-      'month,long,rating': 'CAESBggEEAEYAg%3D%3D',
-      'year,long,rating': 'CAESBggFEAEYAg%3D%3D'
-    })[order] || 'EgIQAQ%3D%3D');
-  }
-};

lib/Innertube.js

@@ -1,469 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-const Stream = require('stream');
-const OAuth = require('./OAuth');
-const Utils = require('./Utils');
-const Player = require('./Player');
-const NToken = require('./NToken');
-const Actions = require('./Actions');
-const Livechat = require('./Livechat');
-const Constants = require('./Constants');
-const SigDecipher = require('./Sig');
-const EventEmitter = require('events');
-const TimeToSeconds = require('time-to-seconds');
-const CancelToken = Axios.CancelToken;
-
-class Innertube extends EventEmitter {
-  constructor(cookie) {
-    super();
-    this.cookie = cookie || '';
-    this.retry_count = 0;
-    return this.init();
-  }
-
-  async init() {
-    const response = await Axios.get(Constants.URLS.YT_BASE_URL, Constants.DEFAULT_HEADERS(this)).catch((error) => error);
-    if (response instanceof Error) throw new Error(`Could not extract Innertube data: ${response.message}`);
-
-    try {
-      const innertube_data = JSON.parse(`{${Utils.getStringBetweenStrings(response.data, 'ytcfg.set({', '});')}}`);
-      if (innertube_data.INNERTUBE_CONTEXT) {
-        this.context = innertube_data.INNERTUBE_CONTEXT;
-        this.key = innertube_data.INNERTUBE_API_KEY;
-        this.id_token = innertube_data.ID_TOKEN;
-        this.session_token = innertube_data.XSRF_TOKEN;
-        this.player_url = innertube_data.PLAYER_JS_URL;
-        this.logged_in = innertube_data.LOGGED_IN;
-        this.sts = innertube_data.STS;
-        this.context.client.hl = 'en';
-        this.context.client.gl = 'US';
-
-        this.player = new Player(this);
-        await this.player.init();
-
-        if (this.logged_in && this.cookie.length > 1) {
-          this.auth_apisid = Utils.getStringBetweenStrings(this.cookie, 'PAPISID=', ';');
-          this.auth_apisid = Utils.generateSidAuth(this.auth_apisid);
-        }
-      } else {
-        this.retry_count += 1;
-        if (this.retry_count >= 10) throw new Error('Could not retrieve Innertube data');
-        return this.init();
-      }
-    } catch (err) {
-      this.retry_count += 1;
-      if (this.retry_count >= 10) throw new Error('Could not retrieve Innertube data');
-      return this.init();
-    }
-    return this;
-  }
-
-  signIn(credentials = {}) {
-    return new Promise(async (resolve, reject) => {
-      const oauth = new OAuth(credentials);
-      if (credentials.access_token && credentials.refresh_token) {
-        let token_validity = await oauth.checkTokenValidity(credentials.access_token, this);
-        if (token_validity === 'VALID') {
-          this.access_token = credentials.access_token;
-          this.refresh_token = credentials.refresh_token;
-          this.logged_in = true;
-          resolve();
-        } else {
-          oauth.refreshAccessToken(credentials.refresh_token);
-          oauth.on('refresh-token', (data) => {
-            this.access_token = data.access_token;
-            this.refresh_token = credentials.refresh_token;
-            this.logged_in = true;
-            this.emit('update-credentials', {
-              access_token: data.access_token,
-              refresh_token: credentials.refresh_token,
-              status: data.status
-            });
-            resolve();
-          });
-        }
-      } else {
-        oauth.on('auth', (data) => {
-          if (data.status === 'SUCCESS') {
-            this.emit('auth', data);
-            this.access_token = data.access_token;
-            this.refresh_token = data.refresh_token;
-            this.logged_in = true;
-            resolve();
-          } else {
-            this.emit('auth', data);
-          }
-        });
-      }
-    });
-  }
-
-  async search(query, options = { period: 'any', order: 'relevance', duration: 'any' }) {
-    if (!query) throw new Error('No query was provided');
-
-    const response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/search${this.logged_in && this.cookie.length < 1 ? '' : `?key=${this.key}`}`, JSON.stringify({ context: this.context, params: Constants.filters(options.period + ',' + options.duration + ',' + options.order), query }), Constants.INNERTUBE_REQOPTS({ session: this })).catch((error) => error);
-    if (response instanceof Error) throw new Error(`Could not search on YouTube: ${response.message}`);
-
-    let content = response.data.contents.twoColumnSearchResultsRenderer.primaryContents.sectionListRenderer.contents[0].itemSectionRenderer.contents;
-    let search_response = {};
-
-    search_response.search_metadata = {};
-    search_response.search_metadata.query = content[0].showingResultsForRenderer ? content[0].showingResultsForRenderer.originalQuery.simpleText : query;
-    search_response.search_metadata.corrected_query = content[0].showingResultsForRenderer ? content[0].showingResultsForRenderer.correctedQueryEndpoint.searchEndpoint.query : query;
-    search_response.search_metadata.estimated_results = parseInt(response.data.estimatedResults);
-    search_response.videos = content.map((data) => {
-      if (!data.videoRenderer) return;
-      let video = data.videoRenderer;
-      return {
-        title: video.title.runs[0].text,
-        description: video.detailedMetadataSnippets && video.detailedMetadataSnippets[0].snippetText.runs.map((item) => item.text).join('') || 'N/A',
-        author: video.ownerText.runs[0].text,
-        id: video.videoId,
-        url: `https://youtu.be/${video.videoId}`,
-        channel_url: `${Constants.URLS.YT_BASE_URL}${video.ownerText.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url}`,
-        metadata: {
-          view_count: video.viewCountText && video.viewCountText.simpleText || 'N/A',
-          short_view_count_text: {
-            simple_text: video.shortViewCountText && video.shortViewCountText.simpleText || 'N/A',
-            accessibility_label: video.shortViewCountText && (video.shortViewCountText.accessibility && video.shortViewCountText.accessibility.accessibilityData.label || 'N/A') || 'N/A',
-          },
-          thumbnails: video.thumbnail.thumbnails,
-          duration: {
-            seconds: TimeToSeconds(video.lengthText && video.lengthText.simpleText || '0'),
-            simple_text: video.lengthText && video.lengthText.simpleText || 'N/A',
-            accessibility_label: video.lengthText && video.lengthText.accessibility.accessibilityData.label || 'N/A'
-          },
-          published: video.publishedTimeText && video.publishedTimeText.simpleText || 'N/A',
-          badges: video.badges && video.badges.map((item) => item.metadataBadgeRenderer.label) || 'N/A',
-          owner_badges: video.ownerBadges && video.ownerBadges.map((item) => item.metadataBadgeRenderer.tooltip) || 'N/A '
-        }
-      };
-    }).filter((video_block) => video_block !== undefined);
-    return search_response;
-  }
-
-  async getDetails(id) {
-    if (!id) return { error: 'Missing video id' };
-
-    const data = await this.requestVideoInfo(id, false);
-    const video_data = Constants.formatVideoData(data, this, false);
-
-    if (video_data.metadata.is_live_content) {
-      const data_continuation = await Actions.getContinuation(this, { video_id: id });
-      if (!data_continuation.data.contents.twoColumnWatchNextResults.conversationBar) return;
-      video_data.getLivechat = () => new Livechat(this, data_continuation.data.contents.twoColumnWatchNextResults.conversationBar.liveChatRenderer.continuations[0].reloadContinuationData.continuation, video_data.metadata.channel_id, id);
-    } else {
-      video_data.getLivechat = () => {};
-    }
-
-    video_data.like = () => Actions.engage(this, 'like/like', { video_id: id });
-    video_data.dislike = () => Actions.engage(this, 'like/dislike', { video_id: id });
-    video_data.removeLike = () => Actions.engage(this, 'like/removelike', { video_id: id });
-    video_data.subscribe = () => Actions.engage(this, 'subscription/subscribe', { video_id: id, channel_id: video_data.metadata.channel_id });
-    video_data.unsubscribe = () => Actions.engage(this, 'subscription/unsubscribe', { video_id: id, channel_id: video_data.metadata.channel_id });
-    video_data.comment = text => Actions.engage(this, 'comment/create_comment', { video_id: id, text });
-    video_data.getComments = () => this.getComments(id);
-    video_data.setNotificationPref = pref => Actions.notifications(this, 'modify_channel_preference', { channel_id: video_data.metadata.channel_id, pref: pref || 'NONE' });
-
-    return video_data;
-  }
-
-  async getComments(video_id, token) {
-    let comment_section_token;
-
-    if (!token) {
-      const data_continuation = await Actions.getContinuation(this, { video_id });
-      const item_section_renderer = data_continuation.data.contents.twoColumnWatchNextResults.results.results.contents.find((item) => item.itemSectionRenderer);
-      comment_section_token = item_section_renderer.itemSectionRenderer.contents[0].continuationItemRenderer.continuationEndpoint.continuationCommand.token;
-    }
-
-    const response = await Actions.getContinuation(this, { continuation_token: comment_section_token || token });
-    if (!response.success) throw new Error('Could not fetch comments section');
-
-    const comments_section = { comments: [] };
-    !token && (comments_section.comment_count = response.data.onResponseReceivedEndpoints[0].reloadContinuationItemsCommand.continuationItems && response.data.onResponseReceivedEndpoints[0].reloadContinuationItemsCommand.continuationItems[0].commentsHeaderRenderer.countText.runs[0].text || 'N/A');
-
-    let continuation_token;
-    !token && (continuation_token = response.data.onResponseReceivedEndpoints[1].reloadContinuationItemsCommand.continuationItems.find((item) => item.continuationItemRenderer).continuationItemRenderer.continuationEndpoint.continuationCommand.token) ||
-      (continuation_token = response.data.onResponseReceivedEndpoints[0].appendContinuationItemsAction.continuationItems.find((item) => item.continuationItemRenderer).continuationItemRenderer.continuationEndpoint.continuationCommand.token);
-
-    comments_section.getContinuation = () => this.getComments(video_id, continuation_token);
-
-    let contents;
-    !token && (contents = response.data.onResponseReceivedEndpoints[1].reloadContinuationItemsCommand.continuationItems) ||
-      (contents = response.data.onResponseReceivedEndpoints[0].appendContinuationItemsAction.continuationItems);
-
-    contents.forEach((thread) => {
-      if (!thread.commentThreadRenderer) return;
-      const comment = {
-        text: thread.commentThreadRenderer.comment.commentRenderer.contentText.runs.map((t) => t.text).join(' '),
-        author: {
-          name: thread.commentThreadRenderer.comment.commentRenderer.authorText.simpleText,
-          thumbnail: thread.commentThreadRenderer.comment.commentRenderer.authorThumbnail.thumbnails,
-          channel_id: thread.commentThreadRenderer.comment.commentRenderer.authorEndpoint.browseEndpoint.browseId
-        },
-        metadata: {
-          published: thread.commentThreadRenderer.comment.commentRenderer.publishedTimeText.runs[0].text,
-          is_liked: thread.commentThreadRenderer.comment.commentRenderer.isLiked,
-          is_channel_owner: thread.commentThreadRenderer.comment.commentRenderer.authorIsChannelOwner,
-          like_count: thread.commentThreadRenderer.comment.commentRenderer.voteCount && thread.commentThreadRenderer.comment.commentRenderer.voteCount.simpleText || 'N/A',
-          reply_count: thread.commentThreadRenderer.comment.commentRenderer.replyCount || 0,
-          id: thread.commentThreadRenderer.comment.commentRenderer.commentId,
-        }
-      };
-      comments_section.comments.push(comment);
-    });
-
-    return comments_section;
-  }
-
-  async getSubscriptionsFeed() {
-    const response = await Actions.browse(this, 'subscriptions_feed');
-    if (!response.success) throw new Error('Could not fetch subscriptions feed');
-
-    const contents = response.data.contents.twoColumnBrowseResultsRenderer.tabs[0].tabRenderer.content.sectionListRenderer.contents;
-    const subscriptions_feed = {};
-
-    contents.forEach((section) => {
-      if (!section.itemSectionRenderer) return;
-
-      const section_contents = section.itemSectionRenderer.contents[0];
-      const section_items = section_contents.shelfRenderer.content.gridRenderer.items;
-
-      const key = section_contents.shelfRenderer.title.runs[0].text;
-      subscriptions_feed[key.toLowerCase().replace(/ +/g, '_')] = [];
-
-      section_items.forEach((item) => {
-        const content = {
-          title: item.gridVideoRenderer.title.runs.map((run) => run.text).join(' '),
-          id: item.gridVideoRenderer.videoId,
-          channel: item.gridVideoRenderer.shortBylineText && item.gridVideoRenderer.shortBylineText.runs[0].text || 'N/A',
-          metadata: {
-            view_count: item.gridVideoRenderer.viewCountText && item.gridVideoRenderer.viewCountText.simpleText || 'N/A',
-            thumbnail: item.gridVideoRenderer.thumbnail && item.gridVideoRenderer.thumbnail.thumbnails || [],
-            published: item.gridVideoRenderer.publishedTimeText && item.gridVideoRenderer.publishedTimeText.simpleText || 'N/A',
-            badges: item.gridVideoRenderer.badges && item.gridVideoRenderer.badges.map((badge) => badge.metadataBadgeRenderer.label) || 'N/A',
-            owner_badges: item.gridVideoRenderer.ownerBadges && item.gridVideoRenderer.ownerBadges.map((badge) => badge.metadataBadgeRenderer.tooltip) || 'N/A'
-          }
-        };
-
-        subscriptions_feed[key.toLowerCase().replace(/ +/g, '_')].push(content);
-      });
-    });
-
-    return subscriptions_feed;
-  }
-
-  async getNotifications() {
-    const response = await Actions.notifications(this, 'get_notification_menu');
-    if (!response.success) throw new Error('Could not fetch notifications');
-
-    const contents = response.data.actions[0].openPopupAction.popup.multiPageMenuRenderer.sections[0];
-    if (!contents.multiPageMenuNotificationSectionRenderer) return { error: 'You don\'t have any notification.' };
-    return contents.multiPageMenuNotificationSectionRenderer.items.map((notification) => {
-      if (!notification.notificationRenderer) return;
-      notification = notification.notificationRenderer;
-      return {
-        title: notification.shortMessage.simpleText,
-        sent_time: notification.sentTimeText.simpleText,
-        channel_name: notification.contextualMenu.menuRenderer.items[1].menuServiceItemRenderer.text.runs[1].text,
-        channel_thumbnail: notification.thumbnail.thumbnails[0],
-        video_thumbnail: notification.videoThumbnail.thumbnails[0],
-        video_url: `https://youtu.be/${notification.navigationEndpoint.watchEndpoint.videoId}`,
-        read: notification.read,
-        notification_id: notification.notificationId,
-      };
-    }).filter((notification_block) => notification_block);
-  }
-
-  async getUnseenNotificationsCount() {
-    const response = await Actions.notifications(this, 'get_unseen_count');
-    if (!response.success) throw new Error('Could not fetch unseen notifications count');
-    return response.data.unseenCount;
-  }
-
-  async requestVideoInfo(id, desktop) {
-    let response;
-    !desktop && (response = await Axios.get(`${Constants.URLS.YT_WATCH_PAGE}?v=${id}&t=8s&pbj=1`, Constants.INNERTUBE_REQOPTS({ session: this, id, desktop: false })).catch((error) => error)) ||
-      (response = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/player${this.logged_in && this.cookie.length < 1 ? '' : `?key=${this.key}`}`, JSON.stringify(Constants.VIDEO_INFO_REQBODY(id, this.sts, this.context)), Constants.INNERTUBE_REQOPTS({ session: this, id, desktop: true })).catch((error) => error));
-    if (response instanceof Error) throw new Error('Could not retrieve watch page info: ' + response.message);
-    return response.data;
-  }
-
-  download(id, options = {}) {
-    if (!id) throw new Error('Missing video id');
-
-    options.quality = options.quality || '360p';
-    options.type = options.type || 'videoandaudio';
-    options.format = options.format || 'mp4';
-
-    let cancel;
-    let cancelled = false;
-
-    const stream = new Stream.PassThrough();
-    this.requestVideoInfo(id, true).then(async (video_data) => {
-      let formats = [];
-
-      if (video_data.playabilityStatus.status === 'LOGIN_REQUIRED') return stream.emit('error', { message: 'You must login to download age-restricted videos.', error_type: 'LOGIN_REQUIRED', playability_status: video_data.playabilityStatus.status });
-      if (!video_data.streamingData) return stream.emit('error', { message: 'Streaming data not available.', error_type: 'NO_STREAMING_DATA', playability_status: video_data.playabilityStatus.status });
-
-      formats = formats.concat(video_data.streamingData.formats || []).concat(video_data.streamingData.adaptiveFormats || []);
-      formats.forEach((format) => {
-        format.url = format.url || format.signatureCipher || format.cipher;
-
-        if (format.signatureCipher || format.cipher) {
-          format.url = new SigDecipher(format.url, this.context.client.clientVersion, this.player).decipher();
-        } else {
-          const url_components = new URL(format.url);
-          url_components.searchParams.set('cver', this.context.client.clientVersion);
-          url_components.searchParams.set('ratebypass', 'yes');
-          url_components.searchParams.set('n', new NToken(this.player.ntoken_sc).transform(url_components.searchParams.get('n')));
-          format.url = url_components.toString();
-        }
-
-        format.has_audio = !!format.audioBitrate || !!format.audioQuality;
-        format.has_video = !!format.qualityLabel;
-
-        delete format.cipher;
-        delete format.signatureCipher;
-      });
-
-      formats.hls_manifest_url = video_data.streamingData.hlsManifestUrl || undefined;
-      formats.dash_manifest_url = video_data.streamingData.dashManifestUrl || undefined;
-
-      const video_details = Constants.formatVideoData(video_data, this, true);
-
-      let url;
-      let bitrates;
-      let filtered_streams;
-
-      switch (options.type) {
-        case 'video':
-          filtered_streams = formats.filter((format) => format.has_video && !format.has_audio);
-          break;
-        case 'audio':
-          filtered_streams = formats.filter((format) => format.has_audio && !format.has_video);
-          break;
-        case 'videoandaudio':
-          filtered_streams = formats.filter((format) => format.has_video && format.has_audio);
-          break;
-        default:
-          filtered_streams = formats.filter((format) => format.has_video && format.has_audio);
-          break;
-      }
-
-      if (options.type != 'videoandaudio') {
-        let streams;
-
-        options.type != 'audio' && (streams = filtered_streams.filter((format) => format.mimeType.includes(options.format || 'mp4') && format.qualityLabel == options.quality)) ||
-          (streams = filtered_streams.filter((format) => format.mimeType.includes(options.format || 'mp4')));
-
-        streams == undefined || streams.length == 0 && (streams = filtered_streams.filter((format) => format.quality == 'medium'));
-
-        bitrates = streams.map((format) => format.bitrate);
-        url = streams.filter((format) => format.bitrate === Math.max(...bitrates))[0];
-      }
-
-      const selected_format = options.type == 'videoandaudio' ? filtered_streams[0] : url;
-      if (!selected_format) {
-        return stream.emit('error', { message: 'Could not find any suitable format.', type: 'FORMAT_UNAVAILABLE' });
-      } else {
-        stream.emit('info', { video_details, selected_format, formats });
-      }
-
-      if (options.type == 'videoandaudio' && !options.range) {
-        const response = await Axios.get(selected_format.url, {
-          responseType: 'stream',
-          cancelToken: new CancelToken(function executor(c) { cancel = c; }),
-          headers: Constants.STREAM_HEADERS
-        }).catch((error) => error);
-
-        if (response instanceof Error) {
-          stream.emit('error', { message: response.message, type: 'REQUEST_FAILED' });
-          return stream;
-        } else {
-          stream.emit('start');
-        }
-
-        let downloaded_size = 0;
-        response.data.on('data', (chunk) => {
-          downloaded_size += chunk.length;
-          let size = (response.headers['content-length'] / 1024 / 1024).toFixed(2);
-          let percentage = Math.floor((downloaded_size / response.headers['content-length']) * 100);
-          stream.emit('progress', { chunk_size: chunk.length, downloaded_size: (downloaded_size / 1024 / 1024).toFixed(2), percentage, size, raw_data: { chunk_size: chunk.length, downloaded: downloaded_size, size: response.headers['content-length'] } });
-        });
-
-        response.data.on('error', (err) => {
-          if (cancelled) {
-            stream.emit('error', { message: 'The download was cancelled.', type: 'DOWNLOAD_CANCELLED' });
-          } else {
-            stream.emit('error', { message: err.message, type: 'DOWNLOAD_ABORTED' });
-          }
-        });
-
-        response.data.pipe(stream, { end: true });
-      } else {
-        const chunk_size = 1048576 * 10; // 10MB
-       
-        let chunk_start = (options.range && options.range.start || 0);
-        let chunk_end = (options.range && options.range.end || chunk_size);
-        let downloaded_size = 0;
-        let must_end = false;
-
-        stream.emit('start');
-
-        const downloadChunk = async () => {
-          (chunk_end >= selected_format.contentLength || options.range) && (must_end = true);
-          options.range && (selected_format.contentLength = options.range.end);
-
-          const response = await Axios.get(`${selected_format.url}&range=${chunk_start}-${chunk_end || ''}`, {
-            responseType: 'stream',
-            cancelToken: new CancelToken(function executor(c) { cancel = c; }),
-            headers: Constants.STREAM_HEADERS
-          }).catch((error) => error);
-
-          if (response instanceof Error) {
-            stream.emit('error', { message: response.message, type: 'REQUEST_FAILED' });
-            return stream;
-          }
-
-          response.data.on('data', (chunk) => {
-            downloaded_size += chunk.length;
-            let size = (selected_format.contentLength / 1024 / 1024).toFixed(2);
-            let percentage = Math.floor((downloaded_size / selected_format.contentLength) * 100);
-            stream.emit('progress', { chunk_size: chunk.length, downloaded_size: (downloaded_size / 1024 / 1024).toFixed(2), percentage, size, raw_data: { chunk_size: chunk.length, downloaded: downloaded_size, size: response.headers['content-length'] } });
-          });
-
-          response.data.on('error', (err) => {
-            if (cancelled) {
-              stream.emit('error', { message: 'The download was cancelled.', type: 'DOWNLOAD_CANCELLED' });
-            } else {
-              stream.emit('error', { message: err.message, type: 'DOWNLOAD_ABORTED' });
-            }
-          });
-
-          response.data.on('end', () => {
-            if (!must_end && !options.range) {
-              chunk_start = chunk_end + 1;
-              chunk_end += chunk_size;
-              downloadChunk();
-            }
-          });
-
-          response.data.pipe(stream, { end: must_end });
-        };
-        downloadChunk();
-      }
-    });
-
-    stream.cancel = () => {
-      cancelled = true;
-      cancel();
-    };
-
-    return stream;
-  }
-}
-
-module.exports = Innertube;

lib/Livechat.js

@@ -1,132 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-const Actions = require('./Actions');
-const Constants = require('./Constants');
-const EventEmitter = require('events');
-
-class Livechat extends EventEmitter {
-  constructor(session, token, channel_id, video_id) {
-    super(session);
-    this.ctoken = token;
-    this.session = session;
-    this.video_id = video_id;
-    this.channel_id = channel_id;
-
-    this.message_queue = [];
-    this.id_cache = [];
-
-    this.poll_intervals_ms = 1000;
-    this.running = true;
-
-    this.poll();
-  }
-
-  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 poll() {
-    if (!this.running) return;
-
-    let data;
-
-    data = { context: this.session.context, continuation: this.ctoken };
-    const livechat = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/live_chat/get_live_chat${this.session.logged_in && this.session.cookie.length < 1 ? '' : `?key=${this.session.key}`}`, JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session: this.session, data, desktop: true }));
-    if (livechat instanceof Error) throw new Error(`Error polling livechat: ${livechat.message}`);
-
-    const continuation_contents = livechat.data.continuationContents;
-    const action_group = continuation_contents.liveChatContinuation.actions;
-    this.enqueueActionGroup(action_group);
-
-    // Why don't we just emit the message directly? Well, enqueueing the messages is necessary so they are not emitted in a “messy” way, funny enough that's exactly how YouTube does it in its live chat js script.
-    this.message_queue.forEach((message, index) => {
-      if (this.id_cache.includes(message.id)) return;
-      setTimeout(() => this.emit('chat-update', message), message.timestamp / 1000 - new Date().getTime());
-      this.id_cache.push(message.id);
-    });
-
-    this.message_queue = [];
-
-    data = { context: this.session.context, videoId: this.video_id };
-    if (this.metadata_ctoken) data.continuation = this.metadata_ctoken;
-
-    const updated_metadata = await Axios.post(`${Constants.URLS.YT_BASE_URL}/youtubei/v1/updated_metadata${this.session.logged_in && this.session.cookie.length < 1 ? '' : `?key=${this.session.key}`}`, JSON.stringify(data), Constants.INNERTUBE_REQOPTS({ session: this.session, data, desktop: true }));
-    if (updated_metadata instanceof Error) throw new Error(`Error polling updated metadata: ${updated_metadata.message}`);
-    this.metadata_ctoken = updated_metadata.data.continuation.timedContinuationData.continuation;
-
-    const metadata = updated_metadata.data.actions;
-    this.emit('update-metadata', {
-      likes: metadata[1].updateToggleButtonTextAction.defaultText.simpleText,
-      dislikes: metadata[2].updateToggleButtonTextAction.defaultText.simpleText,
-      view_count: {
-        simple_text: metadata[0].updateViewershipAction.viewCount.videoViewCountRenderer.viewCount.simpleText,
-        short_view_count: metadata[0].updateViewershipAction.viewCount.videoViewCountRenderer.extraShortViewCount.simpleText
-      }
-    });
-
-    this.livechat_poller = setTimeout(async () => await this.poll(), this.poll_intervals_ms);
-  }
-
-  async sendMessage(text) {
-    const message = await Actions.livechat(this.session, 'live_chat/send_message', { text, channel_id: this.channel_id, video_id: this.video_id });
-    if (!message.success) return message;
-
-    const deleteMessage = async () => {
-      const menu = await Actions.livechat(this.session, 'live_chat/get_item_context_menu', { params: { params: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.contextMenuEndpoint.liveChatItemContextMenuEndpoint.params, pbj: 1 } });
-      if (!menu.success) return menu;
-
-      const chat_item_menu = menu.data.liveChatItemContextMenuSupportedRenderers.menuRenderer.items[0];
-
-      const cmd = await Actions.livechat(this.session, 'live_chat/moderate', { cmd_params: chat_item_menu.menuServiceItemRenderer.serviceEndpoint.moderateLiveChatEndpoint.params });
-      if (!cmd.success) return cmd;
-
-      return { success: true, status_code: cmd.status_code };
-    };
-
-    return {
-      success: true,
-      status_code: message.status_code,
-      deleteMessage,
-      message_data: {
-        text: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.message.runs.map((item) => item.text).join(' '),
-        author: {
-          name: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.authorName && message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.authorName.simpleText || 'N/',
-          channel_id: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.authorExternalChannelId,
-          profile_picture: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.authorPhoto.thumbnails
-        },
-        timestamp: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.timestampUsec,
-        id: message.data.actions[0].addChatItemAction.item.liveChatTextMessageRenderer.id
-      }
-    };
-  }
-
-  async blockUser(msg_params) {
-    /* TODO: Implement this */
-    throw new Error('Not implemented');
-  }
-
-  stop() {
-    this.running = false;
-    clearTimeout(this.livechat_poller);
-  }
-}
-
-module.exports = Livechat;

lib/NToken.js

@@ -1,111 +0,0 @@
-'use strict';
-
-const Utils = require('./Utils');
-const Constants = require('./Constants');
-
-class NToken {
-  constructor(raw_code) {
-    this.raw_code = raw_code;
-    this.null_placeholder_regex = /c\[(.*?)\]=c/g;
-    this.transformation_calls_regex = /c\[(.*?)\]\((.+?)\)/g;
-  }
-
-  transform(n) {
-    let n_token = n.split('');
-
-    try {
-      let transformations = this.getTransformationData(this.raw_code);
-      transformations = transformations.map((el) => {
-        if (el != null && typeof el != 'number') {
-          const is_reverse_base64 = el.includes('case 65:');
-          (({ // Identifies the transformation functions and emulates them accordingly.
-            [Constants.FUNCS.PUSH]: () => el = (arr, i) => this.push(arr, i),
-            [Constants.FUNCS.SPLICE]: () => el = (arr, i) => this.splice(arr, i),
-            [Constants.FUNCS.SWAP0_1]: () => el = (arr, i) => this.swap0(arr, i),
-            [Constants.FUNCS.SWAP0_2]: () => el = (arr, i) => this.swap0(arr, i),
-            [Constants.FUNCS.ROTATE_1]: () => el = (arr, i) => this.rotate(arr, i),
-            [Constants.FUNCS.ROTATE_2]: () => el = (arr, i) => this.rotate(arr, i),
-            [Constants.FUNCS.REVERSE_1]: () => el = (arr) => this.reverse(arr),
-            [Constants.FUNCS.REVERSE_2]: () => el = (arr) => this.reverse(arr),
-            [Constants.FUNCS.BASE64_DIA]: () => el = () => this.getBase64Dia(is_reverse_base64),
-            [Constants.FUNCS.TRANSLATE_1]: () => el = (arr, token) => this.translate1(arr, token, is_reverse_base64),
-            [Constants.FUNCS.TRANSLATE_2]: () => el = (arr, token, base64_dic) => this.translate2(arr, token, base64_dic)
-          })[this.getFunc(el)] || (() => el === 'b' && (el = n_token)))();
-        }
-        return el;
-      });
-
-      // Fills the null placeholders with a copy of the transformations array.
-      let null_placeholder_positions = [...this.raw_code.matchAll(this.null_placeholder_regex)].map((item) => parseInt(item[1]));
-      null_placeholder_positions.forEach((pos) => transformations[pos] = transformations);
-
-      // Parses and emulates calls to functions of the transformations array.
-      let transformation_calls = [...Utils.getStringBetweenStrings(this.raw_code.replace(/\n/g, ''), 'try{', '}catch').matchAll(this.transformation_calls_regex)].map((params) => ({ index: params[1], params: params[2] }));
-      transformation_calls.forEach((data) => {
-        const param_index = data.params.split(',').map((param) => param.match(/c\[(.*?)\]/)[1]);
-        const base64_dia = (param_index[2] && transformations[param_index[2]]());
-        transformations[data.index](transformations[param_index[0]], transformations[param_index[1]], base64_dia);
-      });
-    } catch (err) {
-      console.error('Could not transform n-token, download may be throttled:', err);
-      return n;
-    }
-
-    return n_token.join('');
-  }
-
-  getFunc(el) {
-    return el.match(Constants.FUNCS_REGEX);
-  }
-
-  getTransformationData() {
-    const data = `[${Utils.getStringBetweenStrings(this.raw_code.replace(/\n/g, ''), 'c=[', '];c')}]`;
-    return JSON.parse(Constants.formatNTransformData(data));
-  }
-
-  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(''));
-  }
-
-  getBase64Dia(is_reverse_base64) {
-    const characters = is_reverse_base64 && Constants.BASE64_DIALECT.REVERSE || Constants.BASE64_DIALECT.NORMAL;
-    return characters;
-  }
-
-  swap0(arr, index) {
-    const old_value = arr[0];
-    index = (index % arr.length + arr.length) % arr.length;
-    arr[0] = arr[index];
-    arr[index] = old_value;
-  }
-
-  rotate(arr, index) {
-    index = (index % arr.length + arr.length) % arr.length;
-    arr.splice(-index).reverse().forEach((el) => arr.unshift(el));
-  }
-
-  splice(arr, index) {
-    index = (index % arr.length + arr.length) % arr.length;
-    arr.splice(index, 1);
-  }
-
-  reverse(arr) {
-    arr.reverse();
-  }
-
-  push(arr, item) {
-    arr.push(item);
-  }
-}
-
-module.exports = NToken;

lib/OAuth.js

@@ -1,171 +0,0 @@
-'use strict';
-
-const Axios = require('axios');
-const Utils = require('./Utils');
-const Constants = require('./Constants');
-const EventEmitter = require('events');
-const Uuid = require("uuid");
-
-class OAuth extends EventEmitter {
-  constructor(creds) {
-    super();
-    // Default interval between requests when waiting for authorization.
-    this.refresh_interval = 5;
-
-    // OAuth URLs:
-    this.oauth_code_url = `${Constants.URLS.YT_BASE_URL}/o/oauth2/device/code`;
-    this.oauth_token_url = `${Constants.URLS.YT_BASE_URL}/o/oauth2/token`;
-
-    // Used to check whether an access token is valid or not.
-    this.guide_url = `${Constants.URLS.YT_BASE_URL}/youtubei/v1/guide`;
-
-    // These are always the same, so we shouldn't have any problems for now.
-    this.model_name = Constants.OAUTH.MODEL_NAME;
-    this.grant_type = Constants.OAUTH.GRANT_TYPE;
-    this.scope = Constants.OAUTH.SCOPE;
-
-    // Script that contains important information such as client id and client secret.
-    this.auth_script_regex = /<script id=\"base-js\" src=\"(.*?)\" nonce=".*?"><\/script>/;
-
-    // Used to find the credentials inside the script.
-    this.identity_regex = /var .+?=\"(?<id>.+?)\",.+?=\"(?<secret>.+?)\"/;
-
-    if (creds.access_token != undefined && creds.refresh_token != undefined) return;
-    this.requestAuthCode();
-  }
-
-  async requestAuthCode() {
-    const identity = await this.getClientIdentity();
-    this.client_id = identity.id;
-    this.client_secret = identity.secret;
-
-    const data = {
-      client_id: this.client_id,
-      scope: this.scope,
-      device_id: Uuid.v4(),
-      model_name: this.model_name
-    };
-
-    const response = await Axios.post(this.oauth_code_url, JSON.stringify(data), Constants.OAUTH.HEADERS).catch((error) => error);
-    if (response instanceof Error)
-      return this.emit('auth', {
-        error: 'Could not get auth code.',
-        status: 'FAILED'
-      });
-
-    this.emit('auth', {
-      code: response.data.user_code,
-      status: 'AUTHORIZATION_PENDING',
-      expires_in: response.data.expires_in,
-      verification_url: response.data.verification_url
-    });
-
-    this.refresh_interval = response.data.interval;
-
-    // Keeps requesting at a specific rate until the authorization is granted or denied.
-    this.waitForAuth(response.data.device_code);
-  }
-
-  async getClientIdentity() {
-    // The first request is made to get the auth script url, hard-coding it isn't viable as it changes overtime.
-    const yttv_response = await Axios.get(`${Constants.URLS.YT_BASE_URL}/tv`, Constants.OAUTH.HEADERS).catch((error) => error);
-    if (yttv_response instanceof Error) throw new Error(`Could not extract client identify: ${yttv_response.message}`);
-
-    // Here we get the script and extract the necessary data to proceed with the auth flow.
-    const url_body = this.auth_script_regex.exec(yttv_response.data)[1];
-    const script_url = `${Constants.URLS.YT_BASE_URL}/${url_body}`;
-    const response = await Axios.get(script_url, Constants.DEFAULT_HEADERS).catch((error) => error);
-    if (response instanceof Error) throw new Error(`Could not extract client identify: ${response.message}`);
-
-    const identity_function = Utils.getStringBetweenStrings(response.data, 'setQuery("");', '{useGaiaSandbox:');
-    const client_identity = identity_function.replace(/\n/g, '').match(this.identity_regex);
-    return client_identity.groups;
-  }
-
-  waitForAuth(device_code) {
-    const data = {
-      client_id: this.client_id,
-      client_secret: this.client_secret,
-      code: device_code,
-      grant_type: this.grant_type
-    };
-
-    setTimeout(async () => {
-      const response = await Axios.post(this.oauth_token_url, JSON.stringify(data), Constants.OAUTH.HEADERS).catch((error) => error);
-      if (response instanceof Error)
-        return this.emit('auth', {
-          error: 'Could not get auth token.',
-          status: 'FAILED'
-        });
-
-      if (response.data.error) {
-        switch (response.data.error) {
-          case 'slow_down':
-          case 'authorization_pending':
-            this.waitForAuth(device_code);
-            break;
-          case 'access_denied':
-            this.emit('auth', {
-              error: 'The access was denied.',
-              status: 'ACCESS_DENIED'
-            });
-            break;
-          case 'expired_token':
-            this.emit('auth', {
-              error: 'The device code has expired, requesting a new one.',
-              status: 'DEVICE_CODE_EXPIRED'
-            });
-            this.requestAuthCode();
-            break;
-          default:
-        }
-      } else {
-        this.emit('auth', {
-          access_token: response.data.access_token,
-          refresh_token: response.data.refresh_token,
-          token_type: response.data.token_type,
-          expires: response.data.expires_in,
-          scope: response.data.scope,
-          status: 'SUCCESS'
-        });
-      }
-    }, 1000 * this.refresh_interval);
-  }
-
-  async refreshAccessToken(refresh_token) {
-    const identity = await this.getClientIdentity();
-
-    const data = {
-      client_id: identity.id,
-      client_secret: identity.secret,
-      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.emit('refresh-token', {
-        error: 'Could not refresh access token.',
-        status: 'FAILED'
-      });
-
-    this.emit('refresh-token', {
-      access_token: response.data.access_token,
-      token_type: response.data.token_type,
-      expires: response.data.expires_in,
-      scope: response.data.scope,
-      status: 'SUCCESS'
-    });
-  }
-
-  async checkTokenValidity(access_token, session) {
-    let headers = Constants.INNERTUBE_REQOPTS({ session }).headers;
-    headers.authorization = `Bearer ${access_token}`;
-
-    const response = await Axios.post(this.guide_url, JSON.stringify({ context: session.context }), { headers }).catch((error) => error);
-    if (response instanceof Error) return 'INVALID';
-    return 'VALID';
-  }
-}
-
-module.exports = OAuth;

lib/Player.js

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

lib/Sig.js

@@ -1,77 +0,0 @@
-'use strict';
-
-const NToken = require('./NToken');
-const QueryString = require('querystring');
-
-class SigDecipher {
-  constructor(url, cver, player) {
-    this.url = url;
-    this.cver = cver;
-    this.player = player;
-    this.func_regex = /(.{2}):function\(.*?\){(.*?)}/g;
-    this.actions_regex = /;.{2}\.(.{2})\(.*?,(.*?)\)/g;
-  }
-
-  decipher() {
-    const args = QueryString.parse(this.url);
-    const functions = this.getFunctions();
-
-    function splice(arr, end) {
-      arr.splice(0, end);
-    }
-
-    function swap(arr, index) {
-      let origArrI = arr[0];
-      arr[0] = arr[index % arr.length];
-      arr[index % arr.length] = origArrI;
-    }
-
-    function reverse(arr) {
-      arr.reverse();
-    }
-
-    let actions;
-    let signature = args.s.split('');
-
-    while ((actions = this.actions_regex.exec(this.player.sig_decipher_sc)) !== null) {
-      switch (actions[1]) {
-        case functions[0]:
-          reverse(signature, actions[2]);
-          break;
-        case functions[1]:
-          splice(signature, actions[2]);
-          break;
-        case functions[2]:
-          swap(signature, actions[2]);
-          break;
-        default:
-      }
-    }
-
-    const url_components = new URL(args.url);
-    args.sp !== undefined ? url_components.searchParams.set(args.sp, signature.join('')) : url_components.searchParams.set('signature', signature.join(''));
-    url_components.searchParams.set('cver', this.cver);
-    url_components.searchParams.set('ratebypass', 'yes');
-    url_components.searchParams.set('n', new NToken(this.player.ntoken_sc).transform(url_components.searchParams.get('n')));
-    return url_components.toString();
-  }
-
-  getFunctions() {
-    let func;
-    let func_name = [];
-
-    while ((func = this.func_regex.exec(this.player.sig_decipher_sc)) !== null) {
-      if (func[0].includes('reverse()')) {
-        func_name[0] = func[1];
-      } else if (func[0].includes('splice')) {
-        func_name[1] = func[1];
-      } else {
-        func_name[2] = func[1];
-      }
-    }
-
-    return func_name;
-  }
-}
-
-module.exports = SigDecipher;

lib/Utils.js

@@ -1,86 +0,0 @@
-'use strict';
-
-const Fs = require('fs');
-const Proto = require('protons');
-const Crypto = require('crypto');
-const UserAgent = require('user-agents');
-
-function getRandomUserAgent(type) {
-  switch (type) {
-    case 'mobile':
-      return new UserAgent(/Android/).data;
-    case 'desktop':
-      return new UserAgent({ deviceCategory: 'desktop' }).data;
-    default:
-  }
-}
-
-function generateSidAuth(sid) {
-  const youtube = 'https://www.youtube.com';
-  const timestamp = Math.floor(new Date().getTime() / 1000);
-  const input = [timestamp, sid, youtube].join(' ');
-
-  let hash = Crypto.createHash('sha1');
-  let data = hash.update(input, 'utf-8');
-  let gen_hash = data.digest('hex');
-
-  return ['SAPISIDHASH', [timestamp, gen_hash].join('_')].join(' ');
-}
-
-function getStringBetweenStrings(data, start_string, end_string) {
-  const regex = new RegExp(`${escapeStringRegexp(start_string)}(.*?)${escapeStringRegexp(end_string)}`, "s");
-  const match = data.match(regex);
-  return match ? match[1] : undefined;
-}
-
-function escapeStringRegexp(string) {
-  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
-}
-
-function encodeNotificationPref(channel_id, index) {
-  const youtube_proto = Proto(Fs.readFileSync(`${__dirname}/proto/youtube.proto`));
-
-  const buf = youtube_proto.NotificationPreferences.encode({
-    channel_id,
-    pref_id: {
-      index
-    },
-    number_0: 0,
-    number_1: 4
-  });
-
-  return encodeURIComponent(Buffer.from(buf).toString('base64'));
-}
-
-function generateMessageParams(channel_id, video_id) {
-  const youtube_proto = Proto(Fs.readFileSync(`${__dirname}/proto/youtube.proto`));
-
-  const buf = youtube_proto.LiveMessageParams.encode({
-    params: {
-      ids: {
-        channel_id,
-        video_id
-      }
-    },
-    number_0: 1,
-    number_1: 4
-  });
-
-  return Buffer.from(encodeURIComponent(Buffer.from(buf).toString('base64'))).toString('base64');
-}
-
-function generateCommentParams(video_id) {
-  const youtube_proto = Proto(Fs.readFileSync(`${__dirname}/proto/youtube.proto`));
-
-  const buf = youtube_proto.CreateCommentParams.encode({
-    video_id,
-    params: {
-      index: 0
-    },
-    number: 7
-  });
-
-  return encodeURIComponent(Buffer.from(buf).toString('base64'));
-}
-
-module.exports = { getRandomUserAgent, generateSidAuth, getStringBetweenStrings, generateMessageParams, generateCommentParams, encodeNotificationPref };

lib/proto/youtube.proto

@@ -1,34 +0,0 @@
-syntax = "proto2";
-package proto;
-
-message NotificationPreferences {
-  string channel_id = 1;
-  message Preference {
-    int32 index = 1;
-  }
-  Preference pref_id = 2;
-  int32 number_0 = 3;
-  int32 number_1 = 4;
-}
-
-message LiveMessageParams {
-  message Params {
-    message Ids {
-      string channel_id = 1;
-      string video_id = 2;
-    }
-    Ids ids = 5;
-  }
-  Params params = 1;
-  int32 number_0 = 2;
-  int32 number_1 = 3;
-}
-
-message CreateCommentParams {
-  string video_id = 2;
-  message Params {
-    int32 index = 1;
-  }
-  Params params = 5;
-  int32 number = 10;
-}

package.json

@@ -1,46 +1,133 @@
 {
   "name": "youtubei.js",
-  "version": "1.2.6",
-  "description": "An object-oriented library that allows you to search, get detailed info about videos, subscribe, unsubscribe, like, dislike, comment, download videos and much more!",
-  "main": "index.js",
-  "scripts": {
-    "test": "node test"
+  "version": "5.0.2",
+  "description": "A wrapper around YouTube's private API. Supports YouTube, YouTube Music, YouTube Kids and YouTube Studio (WIP).",
+  "type": "module",
+  "types": "./dist/src/platform/lib.d.ts",
+  "typesVersions": {
+    "*": {
+      "agnostic": [
+        "./dist/src/platform/lib.d.ts"
+      ],
+      "web": [
+        "./dist/src/platform/lib.d.ts"
+      ],
+      "web.bundle": [
+        "./dist/src/platform/lib.d.ts"
+      ],
+      "web.bundle.min": [
+        "./dist/src/platform/lib.d.ts"
+      ]
+    }
   },
-  "author": "LuanRT",
-  "license": "MIT",
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./dist/src/platform/node.js",
+        "require": "./bundle/node.cjs"
+      },
+      "deno": "./dist/src/platform/deno.js",
+      "types": "./dist/src/platform/lib.d.ts",
+      "browser": "./dist/src/platform/web.js",
+      "default": "./dist/src/platform/web.js"
+    },
+    "./agnostic": {
+      "types": "./dist/src/platform/lib.d.ts",
+      "default": "./dist/src/platform/lib.js"
+    },
+    "./web": {
+      "types": "./dist/src/platform/lib.d.ts",
+      "default": "./dist/src/platform/web.js"
+    },
+    "./web.bundle": {
+      "types": "./dist/src/platform/lib.d.ts",
+      "default": "./bundle/browser.js"
+    },
+    "./web.bundle.min": {
+      "types": "./dist/src/platform/lib.d.ts",
+      "default": "./bundle/browser.min.js"
+    }
+  },
+  "author": "LuanRT <luan.lrt4@gmail.com> (https://github.com/LuanRT)",
+  "funding": [
+    "https://github.com/sponsors/LuanRT"
+  ],
+  "contributors": [
+    "Wykerd (https://github.com/wykerd/)",
+    "MasterOfBob777 (https://github.com/MasterOfBob777)",
+    "patrickkfkan (https://github.com/patrickkfkan)",
+    "akkadaska (https://github.com/akkadaska)"
+  ],
   "directories": {
-    "example": "examples",
-    "lib": "lib"
+    "test": "./test",
+    "examples": "./examples",
+    "dist": "./dist"
   },
-  "dependencies": {
-    "axios": "^0.21.4",
-    "protons": "^2.0.3",
-    "time-to-seconds": "^1.1.5",
-    "user-agents": "^1.0.778",
-    "uuid": "^8.3.2"
+  "scripts": {
+    "test": "npx jest --verbose",
+    "lint": "npx eslint ./src",
+    "lint:fix": "npx eslint --fix ./src",
+    "build": "npm run build:parser-map && npm run build:proto && npm run build:esm && npm run bundle:node && npm run bundle:browser && npm run bundle:browser:prod",
+    "build:parser-map": "node ./scripts/build-parser-map.cjs",
+    "build:proto": "npx pb-gen-ts --entry-path=\"src/proto\" --out-dir=\"src/proto/generated\" --ext-in-import=\".js\"",
+    "build:esm": "npx tsc",
+    "build:deno": "npx cpy ./src ./deno && npx cpy ./package.json ./deno && npx replace \".js';\" \".ts';\" ./deno -r && npx replace '.js\";' '.ts\";' ./deno -r && npx replace \"'linkedom';\" \"'https://esm.sh/linkedom';\" ./deno -r && npx replace \"'jintr';\" \"'https://esm.sh/jintr';\" ./deno -r && npx replace \"new Jinter.default\" \"new Jinter\" ./deno -r",
+    "bundle:node": "npx esbuild ./dist/src/platform/node.js --bundle --target=node10 --keep-names --format=cjs --platform=node --outfile=./bundle/node.cjs --external:jintr --external:undici --external:linkedom --external:tslib --sourcemap --banner:js=\"/* eslint-disable */\"",
+    "bundle:browser": "npx esbuild ./dist/src/platform/web.js --banner:js=\"/* eslint-disable */\" --bundle --target=chrome58 --keep-names --format=esm --sourcemap --define:global=globalThis --outfile=./bundle/browser.js --platform=browser",
+    "bundle:browser:prod": "npm run bundle:browser -- --outfile=./bundle/browser.min.js --minify",
+    "prepare": "npm run build",
+    "watch": "npx tsc --watch"
   },
   "repository": {
     "type": "git",
-    "url": "git+https//github.com/LuanRT/YouTube.js.git"
+    "url": "git+https://github.com/LuanRT/YouTube.js.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "jintr": "^1.0.0",
+    "linkedom": "^0.14.12",
+    "tslib": "^2.5.0",
+    "undici": "^5.19.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^28.1.7",
+    "@types/node": "^17.0.45",
+    "@typescript-eslint/eslint-plugin": "^5.30.6",
+    "@typescript-eslint/parser": "^5.30.6",
+    "cpy-cli": "^4.2.0",
+    "esbuild": "^0.14.49",
+    "eslint": "^8.19.0",
+    "eslint-plugin-tsdoc": "^0.2.16",
+    "glob": "^8.0.3",
+    "jest": "^28.1.3",
+    "pbkit": "^0.0.59",
+    "replace": "^1.2.2",
+    "ts-jest": "^28.0.8",
+    "typescript": "^5.0.0"
   },
-  "keywords": [
-    "youtube",
-    "youtube-dl",
-    "innertube",
-    "innertubeapi",
-    "livechat",
-    "api",
-    "search",
-    "like",
-    "dislike",
-    "comment",
-    "automation",
-    "downloader",
-    "comments-section",
-    "youtube-downloader"
-  ],
   "bugs": {
     "url": "https://github.com/LuanRT/YouTube.js/issues"
   },
-  "homepage": "https://github.com/LuanRT/YouTube.js#readme"
-}
+  "homepage": "https://github.com/LuanRT/YouTube.js#readme",
+  "keywords": [
+    "yt",
+    "dl",
+    "ytdl",
+    "youtube",
+    "youtubedl",
+    "youtube-dl",
+    "youtube-downloader",
+    "youtube-music",
+    "youtube-studio",
+    "innertube",
+    "unofficial",
+    "downloader",
+    "livechat",
+    "studio",
+    "upload",
+    "ytmusic",
+    "search",
+    "music",
+    "api"
+  ]
+}

scripts/build-parser-map.cjs

@@ -0,0 +1,39 @@
+const glob = require('glob');
+const fs = require('fs');
+const path = require('path');
+
+const import_list = [];
+const misc_imports = [];
+
+glob.sync('../src/parser/classes/**/*.{js,ts}', { cwd: __dirname })
+  .forEach((file) => {
+    // Trim path
+    const is_misc = file.includes('/misc/');
+    file = file.replace('../src/parser/classes/', '').replace('.js', '').replace('.ts', '');
+    const import_name = file.split('/').pop();
+
+    if (is_misc) {
+      const class_name = file.split('/').pop().replace('.js', '').replace('.ts', '');
+      misc_imports.push(`export { default as ${class_name} } from './classes/${file}.js';`);
+    } else {
+      import_list.push(`export { default as ${import_name} } from './classes/${file}.js';`);
+    }
+  });
+
+fs.writeFileSync(
+  path.resolve(__dirname, '../src/parser/nodes.ts'),
+  `// This file was auto generated, do not edit.
+// See ./scripts/build-parser-map.js
+
+${import_list.join('\n')}
+`
+);
+
+fs.writeFileSync(
+  path.resolve(__dirname, '../src/parser/misc.ts'),
+  `// This file was auto generated, do not edit.
+// See ./scripts/build-parser-map.js
+
+${misc_imports.join('\n')}
+`
+);

scripts/get-agents.js

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

src/Innertube.ts

@@ -0,0 +1,423 @@
+import type { SessionOptions } from './core/Session.js';
+import Session from './core/Session.js';
+
+import NavigationEndpoint from './parser/classes/NavigationEndpoint.js';
+import type Format from './parser/classes/misc/Format.js';
+import Channel from './parser/youtube/Channel.js';
+import Comments from './parser/youtube/Comments.js';
+import Guide from './parser/youtube/Guide.js';
+import HashtagFeed from './parser/youtube/HashtagFeed.js';
+import History from './parser/youtube/History.js';
+import HomeFeed from './parser/youtube/HomeFeed.js';
+import Library from './parser/youtube/Library.js';
+import NotificationsMenu from './parser/youtube/NotificationsMenu.js';
+import Playlist from './parser/youtube/Playlist.js';
+import Search from './parser/youtube/Search.js';
+import VideoInfo from './parser/youtube/VideoInfo.js';
+
+import { Kids, Music, Studio } from './core/clients/index.js';
+import { AccountManager, InteractionManager, PlaylistManager } from './core/managers/index.js';
+import { Feed, TabbedFeed } from './core/mixins/index.js';
+
+import Proto from './proto/index.js';
+import Constants from './utils/Constants.js';
+import { InnertubeError, generateRandomString, throwIfMissing } from './utils/Utils.js';
+
+import {
+  BrowseEndpoint,
+  GetNotificationMenuEndpoint,
+  GuideEndpoint,
+  NextEndpoint,
+  PlayerEndpoint,
+  ResolveURLEndpoint,
+  SearchEndpoint
+} from './core/endpoints/index.js';
+
+import { GetUnseenCountEndpoint } from './core/endpoints/notification/index.js';
+
+import type { ApiResponse } from './core/Actions.js';
+import type { IBrowseResponse, IParsedResponse } from './parser/types/index.js';
+import type { INextRequest } from './types/index.js';
+import type { DownloadOptions, FormatOptions } from './utils/FormatUtils.js';
+
+export type InnertubeConfig = SessionOptions;
+
+export type InnerTubeClient = 'WEB' | 'ANDROID' | 'YTMUSIC_ANDROID' | 'YTMUSIC' | 'YTSTUDIO_ANDROID' | 'TV_EMBEDDED' | 'YTKIDS'
+
+export type SearchFilters = Partial<{
+  upload_date: 'all' | 'hour' | 'today' | 'week' | 'month' | 'year';
+  type: 'all' | 'video' | 'channel' | 'playlist' | 'movie';
+  duration: 'all' | 'short' | 'medium' | 'long';
+  sort_by: 'relevance' | 'rating' | 'upload_date' | 'view_count';
+  features: ('hd' | 'subtitles' | 'creative_commons' | '3d' | 'live' | 'purchased' | '4k' | '360' | 'location' | 'hdr' | 'vr180')[];
+}>;
+
+/**
+ * Provides access to various services and modules in the YouTube API.
+ */
+export default class Innertube {
+  #session: Session;
+
+  constructor(session: Session) {
+    this.#session = session;
+  }
+
+  static async create(config: InnertubeConfig = {}): Promise<Innertube> {
+    return new Innertube(await Session.create(config));
+  }
+
+  /**
+   * Retrieves video info.
+   * @param target - The video id or `NavigationEndpoint`.
+   * @param client - The client to use.
+   */
+  async getInfo(target: string | NavigationEndpoint, client?: InnerTubeClient): Promise<VideoInfo> {
+    throwIfMissing({ target });
+
+    let next_payload: INextRequest;
+
+    if (target instanceof NavigationEndpoint) {
+      next_payload = NextEndpoint.build({
+        video_id: target.payload?.videoId,
+        playlist_id: target.payload?.playlistId,
+        params: target.payload?.params,
+        playlist_index: target.payload?.index
+      });
+    } else if (typeof target === 'string') {
+      next_payload = NextEndpoint.build({
+        video_id: target
+      });
+    } else {
+      throw new InnertubeError('Invalid target, expected either a video id or a valid NavigationEndpoint', target);
+    }
+
+    if (!next_payload.videoId)
+      throw new InnertubeError('Video id cannot be empty', next_payload);
+
+    const player_payload = PlayerEndpoint.build({
+      video_id: next_payload.videoId,
+      playlist_id: next_payload?.playlistId,
+      client: client,
+      sts: this.#session.player?.sts
+    });
+
+    const player_response = this.actions.execute(PlayerEndpoint.PATH, player_payload);
+    const next_response = this.actions.execute(NextEndpoint.PATH, next_payload);
+    const response = await Promise.all([ player_response, next_response ]);
+
+    const cpn = generateRandomString(16);
+
+    return new VideoInfo(response, this.actions, cpn);
+  }
+
+  /**
+   * Retrieves basic video info.
+   * @param video_id - The video id.
+   * @param client - The client to use.
+   */
+  async getBasicInfo(video_id: string, client?: InnerTubeClient): Promise<VideoInfo> {
+    throwIfMissing({ video_id });
+
+    const response = await this.actions.execute(
+      PlayerEndpoint.PATH, PlayerEndpoint.build({
+        video_id: video_id,
+        client: client,
+        sts: this.#session.player?.sts
+      })
+    );
+
+    const cpn = generateRandomString(16);
+
+    return new VideoInfo([ response ], this.actions, cpn);
+  }
+
+  /**
+   * Searches a given query.
+   * @param query - The search query.
+   * @param filters - Search filters.
+   */
+  async search(query: string, filters: SearchFilters = {}): Promise<Search> {
+    throwIfMissing({ query });
+
+    const response = await this.actions.execute(
+      SearchEndpoint.PATH, SearchEndpoint.build({
+        query, params: filters ? Proto.encodeSearchFilters(filters) : undefined
+      })
+    );
+
+    return new Search(this.actions, response);
+  }
+
+  /**
+   * Retrieves search suggestions for a given query.
+   * @param query - The search query.
+   */
+  async getSearchSuggestions(query: string): Promise<string[]> {
+    throwIfMissing({ query });
+
+    const url = new URL(`${Constants.URLS.YT_SUGGESTIONS}search`);
+    url.searchParams.set('q', query);
+    url.searchParams.set('hl', this.#session.context.client.hl);
+    url.searchParams.set('gl', this.#session.context.client.gl);
+    url.searchParams.set('ds', 'yt');
+    url.searchParams.set('client', 'youtube');
+    url.searchParams.set('xssi', 't');
+    url.searchParams.set('oe', 'UTF');
+
+    const response = await this.#session.http.fetch(url);
+    const response_data = await response.text();
+
+    const data = JSON.parse(response_data.replace(')]}\'', ''));
+    const suggestions = data[1].map((suggestion: any) => suggestion[0]);
+
+    return suggestions;
+  }
+
+  /**
+   * Retrieves comments for a video.
+   * @param video_id - The video id.
+   * @param sort_by - Sorting options.
+   */
+  async getComments(video_id: string, sort_by?: 'TOP_COMMENTS' | 'NEWEST_FIRST'): Promise<Comments> {
+    throwIfMissing({ video_id });
+
+    const response = await this.actions.execute(
+      NextEndpoint.PATH, NextEndpoint.build({
+        continuation: Proto.encodeCommentsSectionParams(video_id, {
+          sort_by: sort_by || 'TOP_COMMENTS'
+        })
+      })
+    );
+
+    return new Comments(this.actions, response.data);
+  }
+
+  /**
+   * Retrieves YouTube's home feed (aka recommendations).
+   */
+  async getHomeFeed(): Promise<HomeFeed> {
+    const response = await this.actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({ browse_id: 'FEwhat_to_watch' })
+    );
+    return new HomeFeed(this.actions, response);
+  }
+
+  /**
+   * Retrieves YouTube's content guide.
+   */
+  async getGuide(): Promise<Guide> {
+    const response = await this.actions.execute(GuideEndpoint.PATH);
+    return new Guide(response.data);
+  }
+
+  /**
+   * Returns the account's library.
+   */
+  async getLibrary(): Promise<Library> {
+    const response = await this.actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({ browse_id: 'FElibrary' })
+    );
+    return new Library(this.actions, response);
+  }
+
+  /**
+   * Retrieves watch history.
+   * Which can also be achieved with {@link getLibrary}.
+   */
+  async getHistory(): Promise<History> {
+    const response = await this.actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({ browse_id: 'FEhistory' })
+    );
+    return new History(this.actions, response);
+  }
+
+  /**
+   * Retrieves trending content.
+   */
+  async getTrending(): Promise<TabbedFeed<IBrowseResponse>> {
+    const response = await this.actions.execute(
+      BrowseEndpoint.PATH, { ...BrowseEndpoint.build({ browse_id: 'FEtrending' }), parse: true }
+    );
+    return new TabbedFeed(this.actions, response);
+  }
+
+  /**
+   * Retrieves subscriptions feed.
+   */
+  async getSubscriptionsFeed(): Promise<Feed<IBrowseResponse>> {
+    const response = await this.actions.execute(
+      BrowseEndpoint.PATH, { ...BrowseEndpoint.build({ browse_id: 'FEsubscriptions' }), parse: true }
+    );
+    return new Feed(this.actions, response);
+  }
+
+  /**
+   * Retrieves contents for a given channel.
+   * @param id - Channel id
+   */
+  async getChannel(id: string): Promise<Channel> {
+    throwIfMissing({ id });
+    const response = await this.actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({ browse_id: id })
+    );
+    return new Channel(this.actions, response);
+  }
+
+  /**
+   * Retrieves notifications.
+   */
+  async getNotifications(): Promise<NotificationsMenu> {
+    const response = await this.actions.execute(
+      GetNotificationMenuEndpoint.PATH, GetNotificationMenuEndpoint.build({
+        notifications_menu_request_type: 'NOTIFICATIONS_MENU_REQUEST_TYPE_INBOX'
+      })
+    );
+    return new NotificationsMenu(this.actions, response);
+  }
+
+  /**
+   * Retrieves unseen notifications count.
+   */
+  async getUnseenNotificationsCount(): Promise<number> {
+    const response = await this.actions.execute(GetUnseenCountEndpoint.PATH);
+    // TODO: properly parse this
+    return response.data?.unseenCount || response.data?.actions?.[0].updateNotificationsUnseenCountAction?.unseenCount || 0;
+  }
+
+  /**
+   * Retrieves playlist contents.
+   * @param id - Playlist id
+   */
+  async getPlaylist(id: string): Promise<Playlist> {
+    throwIfMissing({ id });
+
+    if (!id.startsWith('VL')) {
+      id = `VL${id}`;
+    }
+
+    const response = await this.actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({ browse_id: id })
+    );
+
+    return new Playlist(this.actions, response);
+  }
+
+  /**
+   * Retrieves a given hashtag's page.
+   * @param hashtag - The hashtag to fetch.
+   */
+  async getHashtag(hashtag: string): Promise<HashtagFeed> {
+    throwIfMissing({ hashtag });
+
+    const response = await this.actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({
+        browse_id: 'FEhashtag',
+        params: Proto.encodeHashtag(hashtag)
+      })
+    );
+
+    return new HashtagFeed(this.actions, response);
+  }
+
+  /**
+   * An alternative to {@link download}.
+   * Returns deciphered streaming data.
+   *
+   * If you wish to retrieve the video info too, have a look at {@link getBasicInfo} or {@link getInfo}.
+   * @param video_id - The video id.
+   * @param options - Format options.
+   */
+  async getStreamingData(video_id: string, options: FormatOptions = {}): Promise<Format> {
+    const info = await this.getBasicInfo(video_id);
+    return info.chooseFormat(options);
+  }
+
+  /**
+   * Downloads a given video. If you only need the direct download link see {@link getStreamingData}.
+   * If you wish to retrieve the video info too, have a look at {@link getBasicInfo} or {@link getInfo}.
+   * @param video_id - The video id.
+   * @param options - Download options.
+   */
+  async download(video_id: string, options?: DownloadOptions): Promise<ReadableStream<Uint8Array>> {
+    const info = await this.getBasicInfo(video_id, options?.client);
+    return info.download(options);
+  }
+
+  /**
+   * Resolves the given URL.
+   * @param url - The URL.
+   */
+  async resolveURL(url: string): Promise<NavigationEndpoint> {
+    const response = await this.actions.execute(
+      ResolveURLEndpoint.PATH, { ...ResolveURLEndpoint.build({ url }), parse: true }
+    );
+    return response.endpoint;
+  }
+
+  /**
+   * Utility method to call an endpoint without having to use {@link Actions}.
+   * @param endpoint -The endpoint to call.
+   * @param args - Call arguments.
+   */
+  call<T extends IParsedResponse>(endpoint: NavigationEndpoint, args: { [key: string]: any; parse: true }): Promise<T>;
+  call(endpoint: NavigationEndpoint, args?: { [key: string]: any; parse?: false }): Promise<ApiResponse>;
+  call(endpoint: NavigationEndpoint, args?: object): Promise<IParsedResponse | ApiResponse> {
+    return endpoint.call(this.actions, args);
+  }
+
+  /**
+   * An interface for interacting with YouTube Music.
+   */
+  get music() {
+    return new Music(this.#session);
+  }
+
+  /**
+   * An interface for interacting with YouTube Studio.
+   */
+  get studio() {
+    return new Studio(this.#session);
+  }
+
+  /**
+   * An interface for interacting with YouTube Kids.
+   */
+  get kids() {
+    return new Kids(this.#session);
+  }
+
+  /**
+   * An interface for managing and retrieving account information.
+   */
+  get account() {
+    return new AccountManager(this.#session.actions);
+  }
+
+  /**
+   * An interface for managing playlists.
+   */
+  get playlist() {
+    return new PlaylistManager(this.#session.actions);
+  }
+
+  /**
+   * An interface for directly interacting with certain YouTube features.
+   */
+  get interact() {
+    return new InteractionManager(this.#session.actions);
+  }
+
+  /**
+   * An internal class used to dispatch requests.
+   */
+  get actions() {
+    return this.#session.actions;
+  }
+
+  /**
+   * The session used by this instance.
+   */
+  get session() {
+    return this.#session;
+  }
+}

src/core/Actions.ts

@@ -0,0 +1,178 @@
+import Parser, { NavigateAction } from '../parser/index.js';
+import { InnertubeError } from '../utils/Utils.js';
+
+import type Session from './Session.js';
+
+import type {
+  IBrowseResponse, IGetNotificationsMenuResponse,
+  INextResponse, IPlayerResponse, IResolveURLResponse,
+  ISearchResponse, IUpdatedMetadataResponse,
+  IParsedResponse, IRawResponse
+} from '../parser/types/index.js';
+
+export interface ApiResponse {
+  success: boolean;
+  status_code: number;
+  data: IRawResponse;
+}
+
+export type InnertubeEndpoint = '/player' | '/search' | '/browse' | '/next' | '/updated_metadata' | '/notification/get_notification_menu' | string;
+
+export type ParsedResponse<T> =
+  T extends '/player' ? IPlayerResponse :
+  T extends '/search' ? ISearchResponse :
+  T extends '/browse' ? IBrowseResponse :
+  T extends '/next' ? INextResponse :
+  T extends '/updated_metadata' ? IUpdatedMetadataResponse :
+  T extends '/navigation/resolve_url' ? IResolveURLResponse :
+  T extends '/notification/get_notification_menu' ? IGetNotificationsMenuResponse :
+  IParsedResponse;
+
+export default class Actions {
+  #session: Session;
+
+  constructor(session: Session) {
+    this.#session = session;
+  }
+
+  get session(): Session {
+    return this.#session;
+  }
+
+  /**
+   * Mimmics the Axios API using Fetch's Response object.
+   * @param response - The response object.
+   */
+  async #wrap(response: Response): Promise<ApiResponse> {
+    return {
+      success: response.ok,
+      status_code: response.status,
+      data: JSON.parse(await response.text())
+    };
+  }
+
+  /**
+   * Makes calls to the playback tracking API.
+   * @param url - The URL to call.
+   * @param client - The client to use.
+   * @param params - Call parameters.
+   */
+  async stats(url: string, client: { client_name: string; client_version: string }, params: { [key: string]: any }): Promise<Response> {
+    const s_url = new URL(url);
+
+    s_url.searchParams.set('ver', '2');
+    s_url.searchParams.set('c', client.client_name.toLowerCase());
+    s_url.searchParams.set('cbrver', client.client_version);
+    s_url.searchParams.set('cver', client.client_version);
+
+    for (const key of Object.keys(params)) {
+      s_url.searchParams.set(key, params[key]);
+    }
+
+    const response = await this.#session.http.fetch(s_url);
+
+    return response;
+  }
+
+  /**
+   * Executes an API call.
+   * @param endpoint - The endpoint to call.
+   * @param args - Call arguments
+   */
+  async execute<T extends InnertubeEndpoint>(endpoint: T, args: { [key: string]: any; parse: true; protobuf?: false; serialized_data?: any }): Promise<ParsedResponse<T>>;
+  async execute<T extends InnertubeEndpoint>(endpoint: T, args?: { [key: string]: any; parse?: false; protobuf?: true; serialized_data?: any }): Promise<ApiResponse>;
+  async execute<T extends InnertubeEndpoint>(endpoint: T, args?: { [key: string]: any; parse?: boolean; protobuf?: boolean; serialized_data?: any }): Promise<ParsedResponse<T> | ApiResponse> {
+    let data;
+
+    if (args && !args.protobuf) {
+      data = { ...args };
+
+      if (Reflect.has(data, 'browseId')) {
+        if (this.#needsLogin(data.browseId) && !this.#session.logged_in)
+          throw new InnertubeError('You must be signed in to perform this operation.');
+      }
+
+      if (Reflect.has(data, 'override_endpoint'))
+        delete data.override_endpoint;
+
+      if (Reflect.has(data, 'parse'))
+        delete data.parse;
+
+      if (Reflect.has(data, 'request'))
+        delete data.request;
+
+      if (Reflect.has(data, 'clientActions'))
+        delete data.clientActions;
+
+      if (Reflect.has(data, 'settingItemIdForClient'))
+        delete data.settingItemIdForClient;
+
+      if (Reflect.has(data, 'action')) {
+        data.actions = [ data.action ];
+        delete data.action;
+      }
+
+      if (Reflect.has(data, 'boolValue')) {
+        data.newValue = { boolValue: data.boolValue };
+        delete data.boolValue;
+      }
+
+      if (Reflect.has(data, 'token')) {
+        data.continuation = data.token;
+        delete data.token;
+      }
+
+      if (data?.client === 'YTMUSIC') {
+        data.isAudioOnly = true;
+      }
+    } else if (args) {
+      data = args.serialized_data;
+    }
+
+    const target_endpoint = Reflect.has(args || {}, 'override_endpoint') ? args?.override_endpoint : endpoint;
+
+    const response = await this.#session.http.fetch(target_endpoint, {
+      method: 'POST',
+      body: args?.protobuf ? data : JSON.stringify((data || {})),
+      headers: {
+        'Content-Type': args?.protobuf ?
+          'application/x-protobuf' :
+          'application/json'
+      }
+    });
+
+    if (args?.parse) {
+      let parsed_response = Parser.parseResponse<ParsedResponse<T>>(await response.json());
+
+      // Handle redirects
+      if (this.#isBrowse(parsed_response) && parsed_response.on_response_received_actions?.first()?.type === 'navigateAction') {
+        const navigate_action = parsed_response.on_response_received_actions.firstOfType(NavigateAction);
+        if (navigate_action) {
+          parsed_response = await navigate_action.endpoint.call(this, { parse: true });
+        }
+      }
+
+      return parsed_response;
+    }
+
+    return this.#wrap(response);
+  }
+
+  #isBrowse(response: IParsedResponse): response is IBrowseResponse {
+    return 'on_response_received_actions' in response;
+  }
+
+  #needsLogin(id: string) {
+    return [
+      'FElibrary',
+      'FEhistory',
+      'FEsubscriptions',
+      'FEmusic_listening_review',
+      'FEmusic_library_landing',
+      'SPaccount_overview',
+      'SPaccount_notifications',
+      'SPaccount_privacy',
+      'SPtime_watched'
+    ].includes(id);
+  }
+}

src/core/OAuth.ts

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

src/core/Player.ts

@@ -0,0 +1,232 @@
+import { Platform, getRandomUserAgent, getStringBetweenStrings, PlayerError } from '../utils/Utils.js';
+
+import Constants from '../utils/Constants.js';
+
+import type { ICache } from '../types/Cache.js';
+import type { FetchFunction } from '../types/PlatformShim.js';
+
+/**
+ * Represents YouTube's player script. This is required to decipher signatures.
+ */
+export default class Player {
+  #nsig_sc;
+  #sig_sc;
+  #sig_sc_timestamp;
+  #player_id;
+
+  constructor(signature_timestamp: number, sig_sc: string, nsig_sc: string, player_id: string) {
+    this.#nsig_sc = nsig_sc;
+    this.#sig_sc = sig_sc;
+
+    this.#sig_sc_timestamp = signature_timestamp;
+
+    this.#player_id = player_id;
+  }
+
+  static async create(cache: ICache | undefined, fetch: FetchFunction = Platform.shim.fetch): Promise<Player> {
+    const url = new URL('/iframe_api', Constants.URLS.YT_BASE);
+    const res = await fetch(url);
+
+    if (res.status !== 200)
+      throw new PlayerError('Failed to request player id');
+
+    const js = await res.text();
+
+    const player_id = getStringBetweenStrings(js, 'player\\/', '\\/');
+
+    if (!player_id)
+      throw new PlayerError('Failed to get player id');
+
+    // We have the playerID now we can check if we have a cached player
+    if (cache) {
+      const cached_player = await Player.fromCache(cache, player_id);
+      if (cached_player)
+        return cached_player;
+    }
+
+    const player_url = new URL(`/s/player/${player_id}/player_ias.vflset/en_US/base.js`, Constants.URLS.YT_BASE);
+
+    const player_res = await fetch(player_url, {
+      headers: {
+        'user-agent': getRandomUserAgent('desktop')
+      }
+    });
+
+    if (!player_res.ok) {
+      throw new PlayerError(`Failed to get player data: ${player_res.status}`);
+    }
+
+    const player_js = await player_res.text();
+
+    const sig_timestamp = this.extractSigTimestamp(player_js);
+
+    const sig_sc = this.extractSigSourceCode(player_js);
+    const nsig_sc = this.extractNSigSourceCode(player_js);
+
+    return await Player.fromSource(cache, sig_timestamp, sig_sc, nsig_sc, player_id);
+  }
+
+  decipher(url?: string, signature_cipher?: string, cipher?: string): string {
+    url = url || signature_cipher || cipher;
+
+    if (!url)
+      throw new PlayerError('No valid URL to decipher');
+
+    const args = new URLSearchParams(url);
+    const url_components = new URL(args.get('url') || url);
+
+    if (signature_cipher || cipher) {
+      const signature = Platform.shim.eval(this.#sig_sc, {
+        sig: args.get('s')
+      });
+
+      if (typeof signature !== 'string')
+        throw new PlayerError('Failed to decipher signature');
+
+      const sp = args.get('sp');
+
+      sp ?
+        url_components.searchParams.set(sp, signature) :
+        url_components.searchParams.set('signature', signature);
+    }
+
+    const n = url_components.searchParams.get('n');
+
+    if (n) {
+      const nsig = Platform.shim.eval(this.#nsig_sc, {
+        nsig: n
+      });
+
+      if (typeof nsig !== 'string')
+        throw new PlayerError('Failed to decipher nsig');
+
+      if (nsig.startsWith('enhanced_except_')) {
+        console.warn('Warning:\nCould not transform nsig, download may be throttled.\nChanging the InnerTube client to "ANDROID" might help!');
+      }
+
+      url_components.searchParams.set('n', nsig);
+    }
+
+    const client = url_components.searchParams.get('c');
+
+    switch (client) {
+      case 'WEB':
+        url_components.searchParams.set('cver', Constants.CLIENTS.WEB.VERSION);
+        break;
+      case 'WEB_REMIX':
+        url_components.searchParams.set('cver', Constants.CLIENTS.YTMUSIC.VERSION);
+        break;
+      case 'WEB_KIDS':
+        url_components.searchParams.set('cver', Constants.CLIENTS.WEB_KIDS.VERSION);
+        break;
+      case 'ANDROID':
+        url_components.searchParams.set('cver', Constants.CLIENTS.ANDROID.VERSION);
+        break;
+      case 'ANDROID_MUSIC':
+        url_components.searchParams.set('cver', Constants.CLIENTS.YTMUSIC_ANDROID.VERSION);
+        break;
+      case 'TVHTML5_SIMPLY_EMBEDDED_PLAYER':
+        url_components.searchParams.set('cver', Constants.CLIENTS.TV_EMBEDDED.VERSION);
+        break;
+    }
+
+    return url_components.toString();
+  }
+
+  static async fromCache(cache: ICache, player_id: string): Promise<Player | null> {
+    const buffer = await cache.get(player_id);
+
+    if (!buffer)
+      return null;
+
+    const view = new DataView(buffer);
+    const version = view.getUint32(0, true);
+
+    if (version !== Player.LIBRARY_VERSION)
+      return null;
+
+    const sig_timestamp = view.getUint32(4, true);
+
+    const sig_len = view.getUint32(8, true);
+    const sig_buf = buffer.slice(12, 12 + sig_len);
+    const nsig_buf = buffer.slice(12 + sig_len);
+
+    const decoder = new TextDecoder();
+
+    const sig_sc = decoder.decode(sig_buf);
+    const nsig_sc = decoder.decode(nsig_buf);
+
+    return new Player(sig_timestamp, sig_sc, nsig_sc, player_id);
+  }
+
+  static async fromSource(cache: ICache | undefined, sig_timestamp: number, sig_sc: string, nsig_sc: string, player_id: string): Promise<Player> {
+    const player = new Player(sig_timestamp, sig_sc, nsig_sc, player_id);
+    await player.cache(cache);
+    return player;
+  }
+
+  async cache(cache?: ICache): Promise<void> {
+    if (!cache) return;
+
+    const encoder = new TextEncoder();
+
+    const sig_buf = encoder.encode(this.#sig_sc);
+    const nsig_buf = encoder.encode(this.#nsig_sc);
+
+    const buffer = new ArrayBuffer(12 + sig_buf.byteLength + nsig_buf.byteLength);
+    const view = new DataView(buffer);
+
+    view.setUint32(0, Player.LIBRARY_VERSION, true);
+    view.setUint32(4, this.#sig_sc_timestamp, true);
+    view.setUint32(8, sig_buf.byteLength, true);
+
+    new Uint8Array(buffer).set(sig_buf, 12);
+    new Uint8Array(buffer).set(nsig_buf, 12 + sig_buf.byteLength);
+
+    await cache.set(this.#player_id, new Uint8Array(buffer));
+  }
+
+  static extractSigTimestamp(data: string): number {
+    return parseInt(getStringBetweenStrings(data, 'signatureTimestamp:', ',') || '0');
+  }
+
+  static extractSigSourceCode(data: string): string {
+    const calls = getStringBetweenStrings(data, 'function(a){a=a.split("")', 'return a.join("")}');
+    const obj_name = calls?.split(/\.|\[/)?.[0]?.replace(';', '')?.trim();
+    const functions = getStringBetweenStrings(data, `var ${obj_name}={`, '};');
+
+    if (!functions || !calls)
+      console.warn(new PlayerError('Failed to extract signature decipher algorithm'));
+
+    return `function descramble_sig(a) { a = a.split(""); let ${obj_name}={${functions}}${calls} return a.join("") } descramble_sig(sig);`;
+  }
+
+  static extractNSigSourceCode(data: string): string {
+    const sc = `function descramble_nsig(a) { let b=a.split("")${getStringBetweenStrings(data, 'b=a.split("")', '}return b.join("")}')}} return b.join(""); } descramble_nsig(nsig)`;
+
+    if (!sc)
+      console.warn(new PlayerError('Failed to extract n-token decipher algorithm'));
+
+    return sc;
+  }
+
+  get url(): string {
+    return new URL(`/s/player/${this.#player_id}/player_ias.vflset/en_US/base.js`, Constants.URLS.YT_BASE).toString();
+  }
+
+  get sts(): number {
+    return this.#sig_sc_timestamp;
+  }
+
+  get nsig_sc(): string {
+    return this.#nsig_sc;
+  }
+
+  get sig_sc(): string {
+    return this.#sig_sc;
+  }
+
+  static get LIBRARY_VERSION(): number {
+    return 2;
+  }
+}

src/core/Session.ts

@@ -0,0 +1,430 @@
+import Constants, { CLIENTS } from '../utils/Constants.js';
+import EventEmitterLike from '../utils/EventEmitterLike.js';
+import Actions from './Actions.js';
+import Player from './Player.js';
+
+import Proto from '../proto/index.js';
+import type { ICache } from '../types/Cache.js';
+import type { FetchFunction } from '../types/PlatformShim.js';
+import HTTPClient from '../utils/HTTPClient.js';
+import type { DeviceCategory } from '../utils/Utils.js';
+import { generateRandomString, getRandomUserAgent, InnertubeError, Platform, SessionError } from '../utils/Utils.js';
+import type { Credentials, OAuthAuthErrorEventHandler, OAuthAuthEventHandler, OAuthAuthPendingEventHandler } from './OAuth.js';
+import OAuth from './OAuth.js';
+
+export enum ClientType {
+  WEB = 'WEB',
+  KIDS = 'WEB_KIDS',
+  MUSIC = 'WEB_REMIX',
+  ANDROID = 'ANDROID',
+  ANDROID_MUSIC = 'ANDROID_MUSIC',
+  ANDROID_CREATOR = 'ANDROID_CREATOR',
+  TV_EMBEDDED = 'TVHTML5_SIMPLY_EMBEDDED_PLAYER'
+}
+
+export interface Context {
+  client: {
+    hl: string;
+    gl: string;
+    remoteHost?: string;
+    screenDensityFloat: number;
+    screenHeightPoints: number;
+    screenPixelDensity: number;
+    screenWidthPoints: number;
+    visitorData: string;
+    clientName: string;
+    clientVersion: string;
+    clientScreen?: string,
+    androidSdkVersion?: string;
+    osName: string;
+    osVersion: string;
+    platform: string;
+    clientFormFactor: string;
+    userInterfaceTheme: string;
+    timeZone: string;
+    userAgent?: string;
+    browserName?: string;
+    browserVersion?: string;
+    originalUrl: string;
+    deviceMake: string;
+    deviceModel: string;
+    utcOffsetMinutes: number;
+    kidsAppInfo?: {
+      categorySettings: {
+        enabledCategories: string[];
+      };
+      contentSettings: {
+        corpusPreference: string;
+        kidsNoSearchMode: string;
+      };
+    };
+  };
+  user: {
+    enableSafetyMode: boolean;
+    lockedSafetyMode: boolean;
+  };
+  thirdParty?: {
+    embedUrl: string;
+  };
+}
+
+export interface SessionOptions {
+  /**
+   * Language.
+   */
+  lang?: string;
+  /**
+   * Geolocation.
+   */
+  location?: string;
+  /**
+   * The account index to use. This is useful if you have multiple accounts logged in.
+   * **NOTE:**
+   * Only works if you are signed in with cookies.
+   */
+  account_index?: number;
+  /**
+   * Specifies whether to retrieve the JS player. Disabling this will make session creation faster.
+   * **NOTE:** Deciphering formats is not possible without the JS player.
+   */
+  retrieve_player?: boolean;
+  /**
+   * Specifies whether to enable safety mode. This will prevent the session from loading any potentially unsafe content.
+   */
+  enable_safety_mode?: boolean;
+  /**
+   * Specifies whether to generate the session data locally or retrieve it from YouTube.
+   * This can be useful if you need more performance.
+   */
+  generate_session_locally?: boolean;
+  /**
+   * Platform to use for the session.
+   */
+  device_category?: DeviceCategory;
+  /**
+   * InnerTube client type.
+   */
+  client_type?: ClientType;
+  /**
+   * The time zone.
+   */
+  timezone?: string;
+  /**
+   * Used to cache the deciphering functions from the JS player.
+   */
+  cache?: ICache;
+  /**
+   * YouTube cookies.
+   */
+  cookie?: string;
+  /**
+   * Setting this to a valid and persistent visitor data string will allow YouTube to give this session tailored content even when not logged in.
+   * A good way to get a valid one is by either grabbing it from a browser or calling InnerTube's `/visitor_id` endpoint.
+   */
+  visitor_data?: string;
+  /**
+   * Fetch function to use.
+   */
+  fetch?: FetchFunction;
+}
+
+export interface SessionData {
+  context: Context;
+  api_key: string;
+  api_version: string;
+}
+
+/**
+ * Represents an InnerTube session. This holds all the data needed to make requests to YouTube.
+ */
+export default class Session extends EventEmitterLike {
+  #api_version: string;
+  #key: string;
+  #context: Context;
+  #account_index: number;
+  #player?: Player;
+
+  oauth: OAuth;
+  http: HTTPClient;
+  logged_in: boolean;
+  actions: Actions;
+  cache?: ICache;
+
+  constructor(context: Context, api_key: string, api_version: string, account_index: number, player?: Player, cookie?: string, fetch?: FetchFunction, cache?: ICache) {
+    super();
+    this.#context = context;
+    this.#account_index = account_index;
+    this.#key = api_key;
+    this.#api_version = api_version;
+    this.#player = player;
+    this.http = new HTTPClient(this, cookie, fetch);
+    this.actions = new Actions(this);
+    this.oauth = new OAuth(this);
+    this.logged_in = !!cookie;
+    this.cache = cache;
+  }
+
+  on(type: 'auth', listener: OAuthAuthEventHandler): void;
+  on(type: 'auth-pending', listener: OAuthAuthPendingEventHandler): void;
+  on(type: 'auth-error', listener: OAuthAuthErrorEventHandler): void;
+  on(type: 'update-credentials', listener: OAuthAuthEventHandler): void;
+
+  on(type: string, listener: (...args: any[]) => void): void {
+    super.on(type, listener);
+  }
+
+  once(type: 'auth', listener: OAuthAuthEventHandler): void;
+  once(type: 'auth-pending', listener: OAuthAuthPendingEventHandler): void;
+  once(type: 'auth-error', listener: OAuthAuthErrorEventHandler): void;
+
+  once(type: string, listener: (...args: any[]) => void): void {
+    super.once(type, listener);
+  }
+
+  static async create(options: SessionOptions = {}) {
+    const { context, api_key, api_version, account_index } = await Session.getSessionData(
+      options.lang,
+      options.location,
+      options.account_index,
+      options.visitor_data,
+      options.enable_safety_mode,
+      options.generate_session_locally,
+      options.device_category,
+      options.client_type,
+      options.timezone,
+      options.fetch
+    );
+
+    return new Session(
+      context, api_key, api_version, account_index,
+      options.retrieve_player === false ? undefined : await Player.create(options.cache, options.fetch),
+      options.cookie, options.fetch, options.cache
+    );
+  }
+
+  static async getSessionData(
+    lang = '',
+    location = '',
+    account_index = 0,
+    visitor_data = '',
+    enable_safety_mode = false,
+    generate_session_locally = false,
+    device_category: DeviceCategory = 'desktop',
+    client_name: ClientType = ClientType.WEB,
+    tz: string = Intl.DateTimeFormat().resolvedOptions().timeZone,
+    fetch: FetchFunction = Platform.shim.fetch
+  ) {
+    let session_data: SessionData;
+
+    if (generate_session_locally) {
+      session_data = this.#generateSessionData({ lang, location, time_zone: tz, device_category, client_name, enable_safety_mode, visitor_data });
+    } else {
+      session_data = await this.#retrieveSessionData({ lang, location, time_zone: tz, device_category, client_name, enable_safety_mode, visitor_data }, fetch);
+    }
+
+    return { ...session_data, account_index };
+  }
+
+  static async #retrieveSessionData(options: {
+    lang: string;
+    location: string;
+    time_zone: string;
+    device_category: string;
+    client_name: string;
+    enable_safety_mode: boolean;
+    visitor_data: string;
+  }, fetch: FetchFunction = Platform.shim.fetch): Promise<SessionData> {
+    const url = new URL('/sw.js_data', Constants.URLS.YT_BASE);
+
+    let visitor_id = generateRandomString(11);
+
+    if (options.visitor_data) {
+      const decoded_visitor_data = Proto.decodeVisitorData(options.visitor_data);
+      visitor_id = decoded_visitor_data.id;
+    }
+
+    const res = await fetch(url, {
+      headers: {
+        'accept-language': options.lang || 'en-US',
+        'user-agent': getRandomUserAgent('desktop'),
+        'accept': '*/*',
+        'referer': 'https://www.youtube.com/sw.js',
+        'cookie': `PREF=tz=${options.time_zone.replace('/', '.')};VISITOR_INFO1_LIVE=${visitor_id};`
+      }
+    });
+
+    if (!res.ok)
+      throw new SessionError(`Failed to retrieve session data: ${res.status}`);
+
+    const text = await res.text();
+    const data = JSON.parse(text.replace(/^\)\]\}'/, ''));
+
+    const ytcfg = data[0][2];
+
+    const api_version = `v${ytcfg[0][0][6]}`;
+
+    const [ [ device_info ], api_key ] = ytcfg;
+
+    const context: Context = {
+      client: {
+        hl: device_info[0],
+        gl: options.location || device_info[2],
+        remoteHost: device_info[3],
+        screenDensityFloat: 1,
+        screenHeightPoints: 1080,
+        screenPixelDensity: 1,
+        screenWidthPoints: 1920,
+        visitorData: device_info[13],
+        clientName: options.client_name,
+        clientVersion: device_info[16],
+        osName: device_info[17],
+        osVersion: device_info[18],
+        platform: options.device_category.toUpperCase(),
+        clientFormFactor: 'UNKNOWN_FORM_FACTOR',
+        userInterfaceTheme: 'USER_INTERFACE_THEME_LIGHT',
+        timeZone: device_info[79] || options.time_zone,
+        browserName: device_info[86],
+        browserVersion: device_info[87],
+        originalUrl: Constants.URLS.YT_BASE,
+        deviceMake: device_info[11],
+        deviceModel: device_info[12],
+        utcOffsetMinutes: -new Date().getTimezoneOffset()
+      },
+      user: {
+        enableSafetyMode: options.enable_safety_mode,
+        lockedSafetyMode: false
+      }
+    };
+
+    return { context, api_key, api_version };
+  }
+
+  static #generateSessionData(options: {
+    lang: string;
+    location: string;
+    time_zone: string;
+    device_category: DeviceCategory;
+    client_name: string;
+    enable_safety_mode: boolean;
+    visitor_data: string;
+  }): SessionData {
+    let visitor_id = generateRandomString(11);
+
+    if (options.visitor_data) {
+      const decoded_visitor_data = Proto.decodeVisitorData(options.visitor_data);
+      visitor_id = decoded_visitor_data.id;
+    }
+
+    const context: Context = {
+      client: {
+        hl: options.lang || 'en',
+        gl: options.location || 'US',
+        screenDensityFloat: 1,
+        screenHeightPoints: 1080,
+        screenPixelDensity: 1,
+        screenWidthPoints: 1920,
+        visitorData: Proto.encodeVisitorData(visitor_id, Math.floor(Date.now() / 1000)),
+        clientName: options.client_name,
+        clientVersion: CLIENTS.WEB.VERSION,
+        osName: 'Windows',
+        osVersion: '10.0',
+        platform: options.device_category.toUpperCase(),
+        clientFormFactor: 'UNKNOWN_FORM_FACTOR',
+        userInterfaceTheme: 'USER_INTERFACE_THEME_LIGHT',
+        timeZone: options.time_zone,
+        originalUrl: Constants.URLS.YT_BASE,
+        deviceMake: '',
+        deviceModel: '',
+        utcOffsetMinutes: -new Date().getTimezoneOffset()
+      },
+      user: {
+        enableSafetyMode: options.enable_safety_mode,
+        lockedSafetyMode: false
+      }
+    };
+
+    return { context, api_key: CLIENTS.WEB.API_KEY, api_version: CLIENTS.WEB.API_VERSION };
+  }
+
+  async signIn(credentials?: Credentials): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      const error_handler: OAuthAuthErrorEventHandler = (err) => reject(err);
+
+      this.once('auth', (data) => {
+        this.off('auth-error', error_handler);
+
+        if (data.status === 'SUCCESS') {
+          this.logged_in = true;
+          resolve();
+        }
+
+        reject(data);
+      });
+
+      this.once('auth-error', error_handler);
+
+      try {
+        await this.oauth.init(credentials);
+
+        if (this.oauth.validateCredentials()) {
+          await this.oauth.refreshIfRequired();
+          this.logged_in = true;
+          resolve();
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  /**
+   * Signs out of the current account and revokes the credentials.
+   */
+  async signOut(): Promise<Response | undefined> {
+    if (!this.logged_in)
+      throw new InnertubeError('You must be signed in to perform this operation.');
+
+    const response = await this.oauth.revokeCredentials();
+    this.logged_in = false;
+
+    return response;
+  }
+
+  /**
+   * InnerTube API key.
+   */
+  get key(): string {
+    return this.#key;
+  }
+
+  /**
+   * InnerTube API version.
+   */
+  get api_version(): string {
+    return this.#api_version;
+  }
+
+  get client_version(): string {
+    return this.#context.client.clientVersion;
+  }
+
+  get client_name(): string {
+    return this.#context.client.clientName;
+  }
+
+  get account_index(): number {
+    return this.#account_index;
+  }
+
+  get context(): Context {
+    return this.#context;
+  }
+
+  get player(): Player | undefined {
+    return this.#player;
+  }
+
+  get lang(): string {
+    return this.#context.client.hl;
+  }
+}

src/core/clients/Kids.ts

@@ -0,0 +1,83 @@
+import Channel from '../../parser/ytkids/Channel.js';
+import HomeFeed from '../../parser/ytkids/HomeFeed.js';
+import Search from '../../parser/ytkids/Search.js';
+import VideoInfo from '../../parser/ytkids/VideoInfo.js';
+import type Session from '../Session.js';
+
+import { generateRandomString } from '../../utils/Utils.js';
+
+import {
+  BrowseEndpoint, NextEndpoint,
+  PlayerEndpoint, SearchEndpoint
+} from '../endpoints/index.js';
+
+export default class Kids {
+  #session: Session;
+
+  constructor(session: Session) {
+    this.#session = session;
+  }
+
+  /**
+   * Searches the given query.
+   * @param query - The query.
+   */
+  async search(query: string): Promise<Search> {
+    const response = await this.#session.actions.execute(
+      SearchEndpoint.PATH, SearchEndpoint.build({ client: 'YTKIDS', query })
+    );
+    return new Search(this.#session.actions, response);
+  }
+
+  /**
+   * Retrieves video info.
+   * @param video_id - The video id.
+   */
+  async getInfo(video_id: string): Promise<VideoInfo> {
+    const player_payload = PlayerEndpoint.build({
+      sts: this.#session.player?.sts,
+      client: 'YTKIDS',
+      video_id
+    });
+
+    const next_payload = NextEndpoint.build({
+      video_id,
+      client: 'YTKIDS'
+    });
+
+    const player_response = this.#session.actions.execute(PlayerEndpoint.PATH, player_payload);
+    const next_response = this.#session.actions.execute(NextEndpoint.PATH, next_payload);
+    const response = await Promise.all([ player_response, next_response ]);
+
+    const cpn = generateRandomString(16);
+
+    return new VideoInfo(response, this.#session.actions, cpn);
+  }
+
+  /**
+   * Retrieves the contents of the given channel.
+  * @param channel_id - The channel id.
+   */
+  async getChannel(channel_id: string): Promise<Channel> {
+    const response = await this.#session.actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({
+        browse_id: channel_id,
+        client: 'YTKIDS'
+      })
+    );
+    return new Channel(this.#session.actions, response);
+  }
+
+  /**
+   * Retrieves the home feed.
+   */
+  async getHomeFeed(): Promise<HomeFeed> {
+    const response = await this.#session.actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({
+        browse_id: 'FEkids_home',
+        client: 'YTKIDS'
+      })
+    );
+    return new HomeFeed(this.#session.actions, response);
+  }
+}

src/core/clients/Music.ts

@@ -0,0 +1,371 @@
+import Album from '../../parser/ytmusic/Album.js';
+import Artist from '../../parser/ytmusic/Artist.js';
+import Explore from '../../parser/ytmusic/Explore.js';
+import HomeFeed from '../../parser/ytmusic/HomeFeed.js';
+import Library from '../../parser/ytmusic/Library.js';
+import Playlist from '../../parser/ytmusic/Playlist.js';
+import Recap from '../../parser/ytmusic/Recap.js';
+import Search from '../../parser/ytmusic/Search.js';
+import TrackInfo from '../../parser/ytmusic/TrackInfo.js';
+
+import AutomixPreviewVideo from '../../parser/classes/AutomixPreviewVideo.js';
+import Message from '../../parser/classes/Message.js';
+import MusicCarouselShelf from '../../parser/classes/MusicCarouselShelf.js';
+import MusicDescriptionShelf from '../../parser/classes/MusicDescriptionShelf.js';
+import MusicQueue from '../../parser/classes/MusicQueue.js';
+import MusicTwoRowItem from '../../parser/classes/MusicTwoRowItem.js';
+import PlaylistPanel from '../../parser/classes/PlaylistPanel.js';
+import SearchSuggestionsSection from '../../parser/classes/SearchSuggestionsSection.js';
+import SectionList from '../../parser/classes/SectionList.js';
+import Tab from '../../parser/classes/Tab.js';
+import Proto from '../../proto/index.js';
+
+import type { ObservedArray, YTNode } from '../../parser/helpers.js';
+import type { MusicSearchFilters } from '../../types/index.js';
+import { InnertubeError, generateRandomString, throwIfMissing } from '../../utils/Utils.js';
+import type Actions from '../Actions.js';
+import type Session from '../Session.js';
+
+import {
+  BrowseEndpoint,
+  NextEndpoint,
+  PlayerEndpoint,
+  SearchEndpoint
+} from '../endpoints/index.js';
+
+import { GetSearchSuggestionsEndpoint } from '../endpoints/music/index.js';
+
+export default class Music {
+  #session: Session;
+  #actions: Actions;
+
+  constructor(session: Session) {
+    this.#session = session;
+    this.#actions = session.actions;
+  }
+
+  /**
+   * Retrieves track info. Passing a list item of type MusicTwoRowItem automatically starts a radio.
+   * @param target - Video id or a list item.
+   */
+  getInfo(target: string | MusicTwoRowItem): Promise<TrackInfo> {
+    if (target instanceof MusicTwoRowItem) {
+      return this.#fetchInfoFromListItem(target);
+    } else if (typeof target === 'string') {
+      return this.#fetchInfoFromVideoId(target);
+    }
+
+    throw new InnertubeError('Invalid target, expected either a video id or a valid MusicTwoRowItem', target);
+  }
+
+  async #fetchInfoFromVideoId(video_id: string): Promise<TrackInfo> {
+    const player_payload = PlayerEndpoint.build({
+      video_id,
+      sts: this.#session.player?.sts,
+      client: 'YTMUSIC'
+    });
+
+    const next_payload = NextEndpoint.build({
+      video_id,
+      client: 'YTMUSIC'
+    });
+
+    const player_response = this.#actions.execute(PlayerEndpoint.PATH, player_payload);
+    const next_response = this.#actions.execute(NextEndpoint.PATH, next_payload);
+    const response = await Promise.all([ player_response, next_response ]);
+
+    const cpn = generateRandomString(16);
+
+    return new TrackInfo(response, this.#actions, cpn);
+  }
+
+  async #fetchInfoFromListItem(list_item: MusicTwoRowItem | undefined): Promise<TrackInfo> {
+    if (!list_item)
+      throw new InnertubeError('List item cannot be undefined');
+
+    if (!list_item.endpoint)
+      throw new Error('This item does not have an endpoint.');
+
+    const player_response = list_item.endpoint.call(this.#actions, {
+      client: 'YTMUSIC',
+      playbackContext: {
+        contentPlaybackContext: {
+          ...{
+            signatureTimestamp: this.#session.player?.sts
+          }
+        }
+      }
+    });
+
+    const next_response = list_item.endpoint.call(this.#actions, {
+      client: 'YTMUSIC',
+      enablePersistentPlaylistPanel: true,
+      override_endpoint: '/next'
+    });
+
+    const cpn = generateRandomString(16);
+
+    const response = await Promise.all([ player_response, next_response ]);
+    return new TrackInfo(response, this.#actions, cpn);
+  }
+
+  /**
+   * Searches on YouTube Music.
+   * @param query - Search query.
+   * @param filters - Search filters.
+   */
+  async search(query: string, filters: MusicSearchFilters = {}): Promise<Search> {
+    throwIfMissing({ query });
+
+    const response = await this.#actions.execute(
+      SearchEndpoint.PATH, SearchEndpoint.build({
+        query, client: 'YTMUSIC',
+        params: filters.type && filters.type !== 'all' ? Proto.encodeMusicSearchFilters(filters) : undefined
+      })
+    );
+
+    return new Search(response, this.#actions, Reflect.has(filters, 'type') && filters.type !== 'all');
+  }
+
+  /**
+   * Retrieves the home feed.
+   */
+  async getHomeFeed(): Promise<HomeFeed> {
+    const response = await this.#actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({
+        browse_id: 'FEmusic_home',
+        client: 'YTMUSIC'
+      })
+    );
+
+    return new HomeFeed(response, this.#actions);
+  }
+
+  /**
+   * Retrieves the Explore feed.
+   */
+  async getExplore(): Promise<Explore> {
+    const response = await this.#actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({
+        client: 'YTMUSIC',
+        browse_id: 'FEmusic_explore'
+      })
+    );
+
+    return new Explore(response);
+    // TODO: return new Explore(response, this.#actions);
+  }
+
+  /**
+   * Retrieves the library.
+   */
+  async getLibrary(): Promise<Library> {
+    const response = await this.#actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({
+        client: 'YTMUSIC',
+        browse_id: 'FEmusic_library_landing'
+      })
+    );
+
+    return new Library(response, this.#actions);
+  }
+
+  /**
+   * Retrieves artist's info & content.
+   * @param artist_id - The artist id.
+   */
+  async getArtist(artist_id: string): Promise<Artist> {
+    throwIfMissing({ artist_id });
+
+    if (!artist_id.startsWith('UC') && !artist_id.startsWith('FEmusic_library_privately_owned_artist'))
+      throw new InnertubeError('Invalid artist id', artist_id);
+
+    const response = await this.#actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({
+        client: 'YTMUSIC',
+        browse_id: artist_id
+      })
+    );
+
+    return new Artist(response, this.#actions);
+  }
+
+  /**
+   * Retrieves album.
+   * @param album_id - The album id.
+   */
+  async getAlbum(album_id: string): Promise<Album> {
+    throwIfMissing({ album_id });
+
+    if (!album_id.startsWith('MPR') && !album_id.startsWith('FEmusic_library_privately_owned_release'))
+      throw new InnertubeError('Invalid album id', album_id);
+
+    const response = await this.#actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({
+        client: 'YTMUSIC',
+        browse_id: album_id
+      })
+    );
+
+    return new Album(response);
+  }
+
+  /**
+   * Retrieves playlist.
+   * @param playlist_id - The playlist id.
+   */
+  async getPlaylist(playlist_id: string): Promise<Playlist> {
+    throwIfMissing({ playlist_id });
+
+    if (!playlist_id.startsWith('VL')) {
+      playlist_id = `VL${playlist_id}`;
+    }
+
+    const response = await this.#actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({
+        client: 'YTMUSIC',
+        browse_id: playlist_id
+      })
+    );
+
+    return new Playlist(response, this.#actions);
+  }
+
+  /**
+   * Retrieves up next.
+   * @param video_id - The video id.
+   * @param automix - Whether to enable automix.
+   */
+  async getUpNext(video_id: string, automix = true): Promise<PlaylistPanel> {
+    throwIfMissing({ video_id });
+
+    const response = await this.#actions.execute(
+      NextEndpoint.PATH, { ...NextEndpoint.build({ video_id, client: 'YTMUSIC' }), parse: true }
+    );
+
+    const tabs = response.contents_memo?.getType(Tab);
+
+    const tab = tabs?.first();
+
+    if (!tab)
+      throw new InnertubeError('Could not find target tab.');
+
+    const music_queue = tab.content?.as(MusicQueue);
+
+    if (!music_queue || !music_queue.content)
+      throw new InnertubeError('Music queue was empty, the given id is probably invalid.', music_queue);
+
+    const playlist_panel = music_queue.content.as(PlaylistPanel);
+
+    if (!playlist_panel.playlist_id && automix) {
+      const automix_preview_video = playlist_panel.contents.firstOfType(AutomixPreviewVideo);
+
+      if (!automix_preview_video)
+        throw new InnertubeError('Automix item not found');
+
+      const page = await automix_preview_video.playlist_video?.endpoint.call(this.#actions, {
+        videoId: video_id,
+        client: 'YTMUSIC',
+        parse: true
+      });
+
+      if (!page || !page.contents_memo)
+        throw new InnertubeError('Could not fetch automix');
+
+      return page.contents_memo.getType(PlaylistPanel).first();
+    }
+
+    return playlist_panel;
+  }
+
+  /**
+   * Retrieves related content.
+   * @param video_id - The video id.
+   */
+  async getRelated(video_id: string): Promise<ObservedArray<MusicCarouselShelf | MusicDescriptionShelf>> {
+    throwIfMissing({ video_id });
+
+    const response = await this.#actions.execute(
+      NextEndpoint.PATH, { ...NextEndpoint.build({ video_id, client: 'YTMUSIC' }), parse: true }
+    );
+
+    const tabs = response.contents_memo?.getType(Tab);
+
+    const tab = tabs?.matchCondition((tab) => tab.endpoint.payload.browseEndpointContextSupportedConfigs?.browseEndpointContextMusicConfig?.pageType === 'MUSIC_PAGE_TYPE_TRACK_RELATED');
+
+    if (!tab)
+      throw new InnertubeError('Could not find target tab.');
+
+    const page = await tab.endpoint.call(this.#actions, { client: 'YTMUSIC', parse: true });
+
+    if (!page.contents)
+      throw new InnertubeError('Unexpected response', page);
+
+    const shelves = page.contents.item().as(SectionList).contents.as(MusicCarouselShelf, MusicDescriptionShelf);
+
+    return shelves;
+  }
+
+  /**
+   * Retrieves song lyrics.
+   * @param video_id - The video id.
+   */
+  async getLyrics(video_id: string): Promise<MusicDescriptionShelf | undefined> {
+    throwIfMissing({ video_id });
+
+    const response = await this.#actions.execute(
+      NextEndpoint.PATH, { ...NextEndpoint.build({ video_id, client: 'YTMUSIC' }), parse: true }
+    );
+
+    const tabs = response.contents_memo?.getType(Tab);
+
+    const tab = tabs?.matchCondition((tab) => tab.endpoint.payload.browseEndpointContextSupportedConfigs?.browseEndpointContextMusicConfig?.pageType === 'MUSIC_PAGE_TYPE_TRACK_LYRICS');
+
+    if (!tab)
+      throw new InnertubeError('Could not find target tab.');
+
+    const page = await tab.endpoint.call(this.#actions, { client: 'YTMUSIC', parse: true });
+
+    if (!page.contents)
+      throw new InnertubeError('Unexpected response', page);
+
+    if (page.contents.item().key('type').string() === 'Message')
+      throw new InnertubeError(page.contents.item().as(Message).text.toString(), video_id);
+
+    const section_list = page.contents.item().as(SectionList).contents;
+
+    return section_list.firstOfType(MusicDescriptionShelf);
+  }
+
+  /**
+   * Retrieves recap.
+   */
+  async getRecap(): Promise<Recap> {
+    const response = await this.#actions.execute(
+      BrowseEndpoint.PATH, BrowseEndpoint.build({
+        client: 'YTMUSIC_ANDROID',
+        browse_id: 'FEmusic_listening_review'
+      })
+    );
+
+    return new Recap(response, this.#actions);
+  }
+
+  /**
+   * Retrieves search suggestions for the given query.
+   * @param query - The query.
+   */
+  async getSearchSuggestions(query: string): Promise<ObservedArray<YTNode>> {
+    const response = await this.#actions.execute(
+      GetSearchSuggestionsEndpoint.PATH,
+      { ...GetSearchSuggestionsEndpoint.build({ input: query }), parse: true }
+    );
+
+    if (!response.contents_memo)
+      throw new InnertubeError('Unexpected response', response);
+
+    const search_suggestions_section = response.contents_memo.getType(SearchSuggestionsSection).first();
+
+    return search_suggestions_section.contents;
+  }
+}

src/core/clients/Studio.ts

@@ -0,0 +1,192 @@
+import Proto from '../../proto/index.js';
+import { Constants } from '../../utils/index.js';
+import { InnertubeError, MissingParamError, Platform } from '../../utils/Utils.js';
+
+import type { UpdateVideoMetadataOptions, UploadedVideoMetadataOptions } from '../../types/Clients.js';
+import type { ApiResponse } from '../Actions.js';
+import type Session from '../Session.js';
+
+import { CreateVideoEndpoint } from '../endpoints/upload/index.js';
+
+interface UploadResult {
+  status: string;
+  scottyResourceId: string;
+}
+
+interface InitialUploadData {
+  frontend_upload_id: string;
+  upload_id: string;
+  upload_url: string;
+  scotty_resource_id: string;
+  chunk_granularity: string;
+}
+
+export default class Studio {
+  #session: Session;
+
+  constructor(session: Session) {
+    this.#session = session;
+  }
+
+  /**
+   * Uploads a custom thumbnail and sets it for a video.
+   * @example
+   * ```ts
+   * const buffer = fs.readFileSync('./my_awesome_thumbnail.jpg');
+   * const response = await yt.studio.setThumbnail(video_id, buffer);
+   * ```
+   */
+  async setThumbnail(video_id: string, buffer: Uint8Array): Promise<ApiResponse> {
+    if (!this.#session.logged_in)
+      throw new InnertubeError('You must be signed in to perform this operation.');
+
+    if (!video_id || !buffer)
+      throw new MissingParamError('One or more parameters are missing.');
+
+    const payload = Proto.encodeCustomThumbnailPayload(video_id, buffer);
+
+    const response = await this.#session.actions.execute('/video_manager/metadata_update', {
+      protobuf: true,
+      serialized_data: payload
+    });
+
+    return response;
+  }
+
+  /**
+   * Updates a given video's metadata.
+   * @example
+   * ```ts
+   * const response = await yt.studio.updateVideoMetadata('videoid', {
+   *   tags: [ 'astronomy', 'NASA', 'APOD' ],
+   *   title: 'Artemis Mission',
+   *   description: 'A nicely written description...',
+   *   category: 27,
+   *   license: 'creative_commons'
+   *   // ...
+   * });
+   * ```
+   */
+  async updateVideoMetadata(video_id: string, metadata: UpdateVideoMetadataOptions): Promise<ApiResponse> {
+    if (!this.#session.logged_in)
+      throw new InnertubeError('You must be signed in to perform this operation.');
+
+    const payload = Proto.encodeVideoMetadataPayload(video_id, metadata);
+
+    const response = await this.#session.actions.execute('/video_manager/metadata_update', {
+      protobuf: true,
+      serialized_data: payload
+    });
+
+    return response;
+  }
+
+  /**
+   * Uploads a video to YouTube.
+   * @example
+   * ```ts
+   * const file = fs.readFileSync('./my_awesome_video.mp4');
+   * const response = await yt.studio.upload(file.buffer, { title: 'Wow!' });
+   * ```
+   */
+  async upload(file: BodyInit, metadata: UploadedVideoMetadataOptions = {}): Promise<ApiResponse> {
+    if (!this.#session.logged_in)
+      throw new InnertubeError('You must be signed in to perform this operation.');
+
+    const initial_data = await this.#getInitialUploadData();
+    const upload_result = await this.#uploadVideo(initial_data.upload_url, file);
+
+    if (upload_result.status !== 'STATUS_SUCCESS')
+      throw new InnertubeError('Could not process video.');
+
+    const response = await this.#setVideoMetadata(initial_data, upload_result, metadata);
+
+    return response;
+  }
+
+  async #getInitialUploadData(): Promise<InitialUploadData> {
+    const frontend_upload_id = `innertube_android:${Platform.shim.uuidv4()}:0:v=3,api=1,cf=3`;
+
+    const payload = {
+      frontendUploadId: frontend_upload_id,
+      deviceDisplayName: 'Pixel 6 Pro',
+      fileId: `goog-edited-video://generated?videoFileUri=content://media/external/video/media/${Platform.shim.uuidv4()}`,
+      mp4MoovAtomRelocationStatus: 'UNSUPPORTED',
+      transcodeResult: 'DISABLED',
+      connectionType: 'WIFI'
+    };
+
+    const response = await this.#session.http.fetch('/upload/youtubei', {
+      baseURL: Constants.URLS.YT_UPLOAD,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'x-goog-upload-command': 'start',
+        'x-goog-upload-protocol': 'resumable'
+      },
+      body: JSON.stringify(payload)
+    });
+
+    if (!response.ok)
+      throw new InnertubeError('Could not get initial upload data');
+
+    return {
+      frontend_upload_id,
+      upload_id: response.headers.get('x-guploader-uploadid') as string,
+      upload_url: response.headers.get('x-goog-upload-url') as string,
+      scotty_resource_id: response.headers.get('x-goog-upload-header-scotty-resource-id') as string,
+      chunk_granularity: response.headers.get('x-goog-upload-chunk-granularity') as string
+    };
+  }
+
+  async #uploadVideo(upload_url: string, file: BodyInit): Promise<UploadResult> {
+    const response = await this.#session.http.fetch_function(upload_url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'x-goog-upload-command': 'upload, finalize',
+        'x-goog-upload-file-name': `file-${Date.now()}`,
+        'x-goog-upload-offset': '0'
+      },
+      body: file
+    });
+
+    if (!response.ok)
+      throw new InnertubeError('Could not upload video');
+
+    const data = await response.json();
+
+    return data;
+  }
+
+  async #setVideoMetadata(initial_data: InitialUploadData, upload_result: UploadResult, metadata: UploadedVideoMetadataOptions) {
+    const response = await this.#session.actions.execute(
+      CreateVideoEndpoint.PATH, CreateVideoEndpoint.build({
+        resource_id: {
+          scotty_resource_id: {
+            id: upload_result.scottyResourceId
+          }
+        },
+        frontend_upload_id: initial_data.frontend_upload_id,
+        initial_metadata: {
+          title: {
+            new_title: metadata.title || new Date().toDateString()
+          },
+          description: {
+            new_description: metadata.description || '',
+            should_segment: true
+          },
+          privacy: {
+            new_privacy: metadata.privacy || 'PRIVATE'
+          },
+          draft_state: {
+            is_draft: metadata.is_draft
+          }
+        },
+        client: 'ANDROID'
+      })
+    );
+
+    return response;
+  }
+}

src/core/clients/index.ts

@@ -0,0 +1,3 @@
+export { default as Kids } from './Kids.js';
+export { default as Music } from './Music.js';
+export { default as Studio } from './Studio.js';

src/core/endpoints/BrowseEndpoint.ts

@@ -0,0 +1,19 @@
+import type { IBrowseRequest, BrowseEndpointOptions } from '../../types/index.js';
+
+export const PATH = '/browse';
+
+/**
+ * Builds a `/browse` request payload.
+ * @param opts - The options to use.
+ * @returns The payload.
+ */
+export function build(opts: BrowseEndpointOptions): IBrowseRequest {
+  return {
+    ...{
+      browseId: opts.browse_id,
+      params: opts.params,
+      continuation: opts.continuation,
+      client: opts.client
+    }
+  };
+}

src/core/endpoints/GetNotificationMenuEndpoint.ts

@@ -0,0 +1,16 @@
+import type { IGetNotificationMenuRequest, GetNotificationMenuEndpointOptions } from '../../types/index.js';
+
+export const PATH = '/notification/get_notification_menu';
+
+/**
+ * Builds a `/get_notification_menu` request payload.
+ * @param opts - The options to use.
+ * @returns The payload.
+ */
+export function build(opts: GetNotificationMenuEndpointOptions): IGetNotificationMenuRequest {
+  return {
+    ...{
+      notificationsMenuRequestType: opts.notifications_menu_request_type
+    }
+  };
+}

src/core/endpoints/GuideEndpoint.ts

@@ -0,0 +1 @@
+export const PATH = '/guide';

src/core/endpoints/NextEndpoint.ts

@@ -0,0 +1,21 @@
+import type { INextRequest, NextEndpointOptions } from '../../types/index.js';
+
+export const PATH = '/next';
+
+/**
+ * Builds a `/next` request payload.
+ * @param opts - The options to use.
+ * @returns The payload.
+ */
+export function build(opts: NextEndpointOptions): INextRequest {
+  return {
+    ...{
+      videoId: opts.video_id,
+      playlistId: opts.playlist_id,
+      params: opts.params,
+      playlistIndex: opts.playlist_index,
+      client: opts.client,
+      continuation: opts.continuation
+    }
+  };
+}

src/core/endpoints/PlayerEndpoint.ts

@@ -0,0 +1,41 @@
+import type { IPlayerRequest, PlayerEndpointOptions } from '../../types/index.js';
+
+export const PATH = '/player';
+
+/**
+ * Builds a `/player` request payload.
+ * @param opts - The options to use.
+ * @returns The payload.
+ */
+export function build(opts: PlayerEndpointOptions): IPlayerRequest {
+  return {
+    playbackContext: {
+      contentPlaybackContext: {
+        vis: 0,
+        splay: false,
+        referer: opts.playlist_id ?
+          `https://www.youtube.com/watch?v=${opts.video_id}&list=${opts.playlist_id}` :
+          `https://www.youtube.com/watch?v=${opts.video_id}`,
+        currentUrl: opts.playlist_id ?
+          `/watch?v=${opts.video_id}&list=${opts.playlist_id}` :
+          `/watch?v=${opts.video_id}`,
+        autonavState: 'STATE_ON',
+        autoCaptionsDefaultOn: false,
+        html5Preference: 'HTML5_PREF_WANTS',
+        lactMilliseconds: '-1',
+        ...{
+          signatureTimestamp: opts.sts
+        }
+      }
+    },
+    racyCheckOk: true,
+    contentCheckOk: true,
+    videoId: opts.video_id,
+    ...{
+      client: opts.client,
+      playlistId: opts.playlist_id,
+      // Workaround streaming URLs returning 403 when using Android clients and throttling in web clients.
+      params: '8AEB'
+    }
+  };
+}

src/core/endpoints/ResolveURLEndpoint.ts

@@ -0,0 +1,16 @@
+import type { IResolveURLRequest, ResolveURLEndpointOptions } from '../../types/index.js';
+
+export const PATH = '/navigation/resolve_url';
+
+/**
+ * Builds a `/resolve_url` request payload.
+ * @param opts - The options to use.
+ * @returns The payload.
+ */
+export function build(opts: ResolveURLEndpointOptions): IResolveURLRequest {
+  return {
+    ...{
+      url: opts.url
+    }
+  };
+}

src/core/endpoints/SearchEndpoint.ts

@@ -0,0 +1,19 @@
+import type { ISearchRequest, SearchEndpointOptions } from '../../types/index.js';
+
+export const PATH = '/search';
+
+/**
+ * Builds a `/search` request payload.
+ * @param opts - The options to use.
+ * @returns The payload.
+ */
+export function build(opts: SearchEndpointOptions): ISearchRequest {
+  return {
+    ...{
+      query: opts.query,
+      params: opts.params,
+      continuation: opts.continuation,
+      client: opts.client
+    }
+  };
+}

src/core/endpoints/account/AccountListEndpoint.ts

@@ -0,0 +1,13 @@
+import type { IAccountListRequest } from '../../../types/index.js';
+
+export const PATH = '/account/accounts_list';
+
+/**
+ * Builds a `/account/accounts_list` request payload.
+ * @returns The payload.
+ */
+export function build(): IAccountListRequest {
+  return {
+    client: 'ANDROID'
+  };
+}

src/core/endpoints/account/index.ts

@@ -0,0 +1 @@
+export * as AccountListEndpoint from './AccountListEndpoint.js';