rubytube 0.5.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57d1f41767aaf6489fa9c4ed47e82f122da84f3bbf3d7f69821f86d7d15d4d04
-  data.tar.gz: 8c453e409b21603e87a701acba2725f56b570078d89a9e73d6a643568c6580df
+  metadata.gz: 58f3740a76ceb385e2032f375b37aeb5226b320c20ed0e83c41f531a88f12061
+  data.tar.gz: 13e2db3f0c1f019839565066e2cdfb5f0f607a7fba699e934f0181851e198b3f
 SHA512:
-  metadata.gz: a23289c4db4a278a0c0916cb53ad910e2bb1ecab5969b7d01253a4e881b149df8e84572754c9ff21b41b89504dac0c2bfa051b309cc66fe72278880bf4cdd51e
-  data.tar.gz: 172741601630ae665a819870ecefd9a0bc908afb393c318f65eb8b28e7e8cf26d85cc20d1aba8144237abec6c9b32977b6d4a33686b6ec1b5942fd00820bac4d
+  metadata.gz: 4d9c6816e65500a5eaf6a67bdae1fac3befc08a34506f28ae21df59b93fb993fcb8ae0767b55dbc2b17e7b9efb0c9b2c62697c48cb6a35c4b8ba461b2d5a5d3a
+  data.tar.gz: 434dd62417af5fa89ae403a7ebb8b285d371683f3333d01fd503661320095b5d8b7c2352dbdaf6dd72a91a4d213469ebe6b5cc86e05b107a26a4fb097aa848ba

data/LICENSE.txt

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2023 nightswinger
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-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.
+The MIT License (MIT)
+
+Copyright (c) 2023 nightswinger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+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.

data/README.md

@@ -1,28 +1,91 @@
-# RubyTube
-
-[![Gem Version](https://badge.fury.io/rb/rubytube.svg)](https://badge.fury.io/rb/rubytube)
-
-RubyTube is a Ruby implementation of the popular Python library, pytube. This library facilitates the downloading and streaming of YouTube videos, offering the robust functionality of pytube in a Ruby-friendly format.
-
-## Installation
-
-    $ gem install rubytube
-
-## Quick Start
-
-```ruby
-require 'rubytube'
-
-# Initialize with video URL
-video = RubyTube.new('https://www.youtube.com/watch?v=dQw4w9WgXcQ')
-
-# Download video
-video.streams.first.download
-
-# Filtering streams
-video.streams
-  .filter(progressive: true, file_extension: 'mp4')
-  .order(resolution: :desc)
-  .first
-  .download
-```
+# rubytube
+
+Download YouTube videos from Ruby. YouTube serves video and audio as separate tracks;
+rubytube picks the best of each and muxes them with ffmpeg, or hands you the tracks directly.
+
+## Installation
+
+```sh
+gem install rubytube
+brew install ffmpeg   # only needed for muxed video downloads (YouTube#download)
+```
+
+## Usage
+
+```ruby
+require "rubytube"
+
+yt = RubyTube::YouTube.new("https://www.youtube.com/watch?v=jNQXAC9IVRw")
+yt.title    # => "Me at the zoo"
+yt.length   # => 19
+yt.author   # => "jawed"
+
+# One call: best video + best audio, muxed with ffmpeg (stream copy, no re-encode)
+yt.download(output_path: "~/Movies")                          # => "~/Movies/Me at the zoo.mp4"
+yt.download(container: "webm", max_resolution: 1080)          # vp9 + opus
+yt.download(audio_only: true)                                 # => "Me at the zoo.m4a", no ffmpeg needed
+yt.download { |chunk, bytes_remaining| puts "#{bytes_remaining} bytes to go" }
+
+# Individual tracks
+yt.streams.best_video                    # highest resolution mp4 (video only)
+yt.streams.best_video(container: "webm", max_resolution: 720)
+yt.streams.best_audio                    # highest bitrate m4a
+yt.streams.best_audio.download(output_path: "~/Music")
+
+# StreamQuery is Enumerable — filter/order_by or plain select/sort_by
+yt.streams.video_streams.filter(container: "mp4") { |s| s.fps == 60 }.order_by(:bitrate).last
+yt.streams.audio_streams
+yt.streams.get_by_itag(140)
+```
+
+### Channels
+
+```ruby
+channel = RubyTube::Channel.new("https://www.youtube.com/@GoogleDevelopers")  # also UC..., @handle, /channel/UC...
+channel.name        # => "Google for Developers"
+channel.channel_id  # => "UC_x5XG1OV2P6uZZ5FSM9Ttw"
+
+# Lazy: only as many pages are fetched as you consume
+channel.videos.first(5).map(&:title)
+channel.videos.take_while { |v| v.published_text.end_with?("days ago") }.to_a
+channel.videos.to_a                                       # every video on the Videos tab
+
+video = channel.videos.first                              # RubyTube::VideoItem
+video.video_id; video.title; video.length                 # length in seconds
+video.view_count_text; video.published_text               # "16K views", "2 days ago" (as YouTube shows them)
+video.thumbnail_url; video.url
+video.to_youtube.download(output_path: "~/Movies")        # promote to a YouTube for streams/download
+
+yt.channel                                                # Channel of a video's uploader
+
+# Bulk download; members-only or scheduled videos raise VideoUnavailable
+channel.videos.each { |v| v.to_youtube.download(output_path: "~/Movies") rescue RubyTube::VideoUnavailable }
+```
+
+### Playlists
+
+```ruby
+playlist = RubyTube::Playlist.new("https://www.youtube.com/playlist?list=PLOU2XLYxmsIJGErt5rrCqaSGTMyyqNt2H")  # also PL..., watch?v=...&list=...
+playlist.title              # => "Compressor Head"
+playlist.length             # => 9 (videos)
+playlist.views              # => 80317
+playlist.last_updated_text  # => "Feb 23, 2026" or "3 days ago" (as YouTube shows it)
+playlist.owner; playlist.owner_id; playlist.channel   # uploader name, UC..., and its Channel
+playlist.description; playlist.thumbnail_url; playlist.url
+
+# Same lazy VideoItem enumeration as Channel#videos; private/deleted entries are listed when YouTube shows them
+playlist.videos.first(5).map(&:title)
+playlist.videos.each { |v| v.to_youtube.download(output_path: "~/Movies") rescue RubyTube::VideoUnavailable }
+```
+
+`Stream#download` writes a single track. Progressive (video+audio in one file) formats
+are no longer served in a downloadable form by YouTube, so they are not exposed.
+
+## Development
+
+```sh
+ruby test/rubytube_test.rb   # offline tests (recorded innertube fixture)
+ruby scripts/smoke.rb        # live smoke test against real YouTube (needs ffmpeg)
+ruby scripts/channel.rb URL  # live check of Channel listing
+ruby scripts/playlist.rb URL # live check of Playlist listing
+```

data/lib/rubytube/channel.rb

@@ -0,0 +1,82 @@
+module RubyTube
+  class Channel
+    CHANNEL_PATTERNS = [
+      %r{youtube\.com/channel/(UC[0-9A-Za-z_-]{22})},
+      %r{youtube\.com/(@[^/?#\s]+)},
+      /\A(UC[0-9A-Za-z_-]{22})\z/,
+      %r{\A(@[^/?#\s]+)\z}
+    ].freeze
+
+    def initialize(url)
+      @ref = self.class.extract_channel_ref(url)
+      @innertube = InnerTube.new
+    end
+
+    # Returns "UC..." or "@handle" (handles are percent-decoded, so non-ASCII ones read as written).
+    def self.extract_channel_ref(url)
+      CHANNEL_PATTERNS.each do |pattern|
+        match = pattern.match(url)
+        return URI.decode_uri_component(match[1]) if match
+      end
+      raise ExtractError, "could not extract a channel id or handle from #{url.inspect}"
+    end
+
+    def channel_id = channel_metadata["externalId"]
+    def name = channel_metadata["title"]
+
+    # Lazy: continuation pages are fetched only as far as you enumerate.
+    def videos
+      Enumerator.new do |y|
+        items = videos_tab.dig("content", "richGridRenderer", "contents") or
+          raise ExtractError, "no video grid in Videos tab of #{@ref}"
+        visitor_data = initial_data.dig("responseContext", "webResponseContextExtensionData", "ytConfigData", "visitorData")
+        seen = nil
+        loop do
+          token = nil
+          items.each do |item|
+            if (lockup = item.dig("richItemRenderer", "content", "lockupViewModel"))
+              y << VideoItem.from_lockup(lockup) if lockup["contentType"] == "LOCKUP_CONTENT_TYPE_VIDEO"
+            else
+              token = InnerTube.continuation_token(item)
+            end
+          end
+          break if token.nil? || token == seen
+
+          seen = token
+          items = Array(@innertube.browse(continuation: token, visitor_data:)
+                                  .dig("onResponseReceivedActions", 0, "appendContinuationItemsAction", "continuationItems"))
+        end
+      end.lazy
+    end
+
+    private
+
+    def page_url
+      path = @ref.start_with?("@") ? "@#{URI.encode_uri_component(@ref[1..])}" : "channel/#{@ref}"
+      URI("https://www.youtube.com/#{path}/videos")
+    end
+
+    def initial_data
+      @initial_data ||= begin
+        response = Net::HTTP.get_response(page_url, "User-Agent" => InnerTube::USER_AGENT,
+                                                    "Accept-Language" => "en-US,en;q=0.9")
+        raise ExtractError, "channel page for #{@ref} returned HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+        match = response.body.match(%r{ytInitialData\s*=\s*(\{.*?\});</script>}m) or
+          raise ExtractError, "no ytInitialData in channel page for #{@ref}"
+        JSON.parse(match[1])
+      end
+    end
+
+    def channel_metadata
+      initial_data.dig("metadata", "channelMetadataRenderer") or
+        raise ExtractError, "no channel metadata for #{@ref} (channel not found?)"
+    end
+
+    def videos_tab
+      tabs = Array(initial_data.dig("contents", "twoColumnBrowseResultsRenderer", "tabs"))
+      tabs.filter_map { |t| t["tabRenderer"] }.find { |t| t["selected"] } or
+        raise ExtractError, "no Videos tab for #{@ref}"
+    end
+  end
+end

data/lib/rubytube/innertube.rb

@@ -1,105 +1,83 @@
-module RubyTube
-  class InnerTube
-    DEFALUT_CLIENTS = {
-      "WEB" => {
-        context: {
-          client: {
-            clientName: "WEB",
-            clientVersion: "2.20200720.00.02"
-          }
-        },
-        header: {"User-Agent": "Mozilla/5.0"},
-        api_key: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8"
-      },
-      "ANDROID_MUSIC" => {
-        context: {
-          client: {
-            clientName: "ANDROID_MUSIC",
-            clientVersion: "5.16.51",
-            androidSdkVersion: 30
-          }
-        },
-        header: {"User-Agent": "com.google.android.apps.youtube.music/"},
-        api_key: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8"
-      },
-      "ANDROID_EMBED" => {
-        context: {
-          client: {
-            clientName: "ANDROID_EMBEDDED_PLAYER",
-            clientVersion: "17.31.35",
-            clientScreen: "EMBED",
-            androidSdkVersion: 30
-          }
-        },
-        header: {"User-Agent": "com.google.android.youtube/"},
-        api_key: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8"
-      }
-    }
-
-    BASE_URL = "https://www.youtube.com/youtubei/v1"
-
-    attr_accessor :context, :header, :api_key, :access_token, :refresh_token, :use_oauth, :allow_cache, :expires
-
-    def initialize(client: "WEB", use_oauth: false, allow_cache: false)
-      self.context = DEFALUT_CLIENTS[client][:context]
-      self.header = DEFALUT_CLIENTS[client][:header]
-      self.api_key = DEFALUT_CLIENTS[client][:api_key]
-      self.use_oauth = use_oauth
-      self.allow_cache = allow_cache
-    end
-
-    def cache_tokens
-      nil unless allow_cache
-
-      # TODO:
-    end
-
-    def refresh_bearer_token(force: false)
-      # TODO:
-    end
-
-    def fetch_bearer_token
-      # TODO:
-    end
-
-    def send(endpoint, query, data)
-      if use_oauth
-        query.delete(:key)
-      end
-
-      headers = {
-        "Content-Type": "application/json"
-      }
-
-      if use_oauth
-        if access_token
-          refresh_bearer_token
-          headers["Authorization"] = "Bearer #{access_token}"
-        else
-          fetch_bearer_token
-          headers["Authorization"] = "Bearer #{access_token}"
-        end
-      end
-
-      options = {}
-      options[:headers] = headers.merge(header)
-
-      options[:query] = {
-        key: api_key,
-        contentCheckOk: true,
-        racyCheckOk: true
-      }.merge(query)
-      options[:data] = data
-
-      resp = Request.post(endpoint, options)
-      JSON.parse(resp)
-    end
-
-    def player(video_id)
-      endpoint = "#{BASE_URL}/player"
-      query = {"videoId" => video_id}
-
-      send(endpoint, query, {context: context})
-    end
-  end
-end
+require "net/http"
+require "json"
+require "uri"
+
+module RubyTube
+  class InnerTube
+    BASE = "https://www.youtube.com/youtubei/v1"
+
+    CLIENT_VERSION = "1.02"
+    CLIENT_ID = "101"
+    USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_3) AppleWebKit/605.1.15 " \
+                 "(KHTML, like Gecko) Version/26.0 Safari/605.1.15"
+
+    WEB_CLIENT_ID = "1"
+    WEB_CLIENT_VERSION = "2.20260708.00.00"
+
+    CLIENT_CONTEXT = {
+      clientName: "VISIONOS",
+      clientVersion: CLIENT_VERSION,
+      deviceMake: "Apple",
+      deviceModel: "RealityDevice17,1",
+      osName: "visionOS",
+      osVersion: "26.5.23O471",
+      hl: "en",
+      gl: "US"
+    }.freeze
+
+    WEB_CLIENT_CONTEXT = {
+      clientName: "WEB",
+      clientVersion: WEB_CLIENT_VERSION,
+      hl: "en",
+      gl: "US"
+    }.freeze
+
+    # Channel/playlist listing: first page by browse_id (+ params), later pages by continuation.
+    # visitor_data (from the previous response) is optional but keeps pagination consistent.
+    def browse(continuation: nil, browse_id: nil, params: nil, visitor_data: nil)
+      client = visitor_data ? WEB_CLIENT_CONTEXT.merge(visitorData: visitor_data) : WEB_CLIENT_CONTEXT
+      body = { context: { client: }, continuation:, browseId: browse_id, params: }.compact
+      post("browse", body, client_id: WEB_CLIENT_ID, client_version: WEB_CLIENT_VERSION, visitor_data:)
+    end
+
+    # Continuation token of a listing item, or nil. YouTube has used three shapes for it.
+    def self.continuation_token(item)
+      endpoint = item.dig("continuationItemRenderer", "continuationEndpoint") ||
+                 item.dig("continuationItemViewModel", "continuationCommand", "innertubeCommand") or return
+      [endpoint, *endpoint.dig("commandExecutorCommand", "commands")]
+        .filter_map { |command| command.dig("continuationCommand", "token") }.first
+    end
+
+    def player(video_id)
+      post("player",
+           { context: { client: CLIENT_CONTEXT.merge(visitorData: visitor_data) },
+             videoId: video_id,
+             contentCheckOk: true,
+             racyCheckOk: true })
+    end
+
+    def visitor_data
+      @visitor_data ||= post("visitor_id", { context: { client: CLIENT_CONTEXT } })
+                        .dig("responseContext", "visitorData") or
+        raise ExtractError, "could not obtain visitorData"
+    end
+
+    private
+
+    def post(endpoint, payload, client_id: CLIENT_ID, client_version: CLIENT_VERSION, visitor_data: @visitor_data)
+      uri = URI("#{BASE}/#{endpoint}?prettyPrint=false")
+      request = Net::HTTP::Post.new(uri)
+      request["Content-Type"] = "application/json"
+      request["User-Agent"] = USER_AGENT
+      request["X-Youtube-Client-Name"] = client_id
+      request["X-Youtube-Client-Version"] = client_version
+      request["X-Goog-Visitor-Id"] = visitor_data if visitor_data
+      request.body = JSON.generate(payload)
+
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(request) }
+      raise ExtractError, "innertube #{endpoint} returned HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/rubytube/playlist.rb

@@ -0,0 +1,111 @@
+module RubyTube
+  class Playlist
+    PLAYLIST_ID_PATTERNS = [
+      /[?&]list=([0-9A-Za-z_-]+)/,
+      /\A((?:PL|UU|OLAK5uy_|RD|LL|FL|EC|UL|TL|PU)[0-9A-Za-z_-]{10,})\z/
+    ].freeze
+
+    attr_reader :playlist_id
+
+    def initialize(url)
+      @playlist_id = self.class.extract_playlist_id(url)
+      @innertube = InnerTube.new
+    end
+
+    def self.extract_playlist_id(url)
+      PLAYLIST_ID_PATTERNS.each do |pattern|
+        match = pattern.match(url)
+        return match[1] if match
+      end
+      raise ExtractError, "could not extract a playlist id from #{url.inspect}"
+    end
+
+    def url = "https://www.youtube.com/playlist?list=#{playlist_id}"
+    def title = metadata["title"]
+    def description = metadata["description"]
+    def length = stats_text(/([\d,]+) videos?\b/)&.delete(",")&.to_i
+    def views = stats_text(/([\d,]+) views?\b/)&.delete(",")&.to_i
+    def last_updated_text = stats_text(/(?:Last updated on |Updated )(.+)/)
+    def owner = owner_run&.dig("text")&.delete_prefix("by ")
+    def owner_id = owner_run&.dig("navigationEndpoint", "browseEndpoint", "browseId")
+    def channel = Channel.new(owner_id)
+
+    def thumbnail_url
+      thumbnails = sidebar_primary&.dig("thumbnailRenderer")&.values&.first&.dig("thumbnail", "thumbnails") ||
+                   initial_data.dig("microformat", "microformatDataRenderer", "thumbnail", "thumbnails")
+      Array(thumbnails).max_by { |t| t["width"].to_i }&.dig("url")
+    end
+
+    # Lazy: continuation pages are fetched only as far as you enumerate. Includes unavailable
+    # (private/deleted) entries when YouTube lists them; VideoItem#to_youtube raises for those.
+    def videos
+      Enumerator.new do |y|
+        items = first_page_items
+        visitor_data = initial_data.dig("responseContext", "visitorData")
+        seen = nil
+        loop do
+          token = nil
+          items.each do |item|
+            if (lockup = item["lockupViewModel"])
+              y << VideoItem.from_lockup(lockup) if lockup["contentType"] == "LOCKUP_CONTENT_TYPE_VIDEO" && lockup["contentId"]
+            else
+              token = InnerTube.continuation_token(item)
+            end
+          end
+          break if token.nil? || token == seen
+
+          seen = token
+          response = @innertube.browse(continuation: token, visitor_data:)
+          items = Array(response.dig("onResponseReceivedActions", 0, "appendContinuationItemsAction", "continuationItems") ||
+                        response.dig("onResponseReceivedEndpoints", 0, "appendContinuationItemsAction", "continuationItems"))
+        end
+      end.lazy
+    end
+
+    private
+
+    # "wgYCCAA=" is the "show unavailable videos" browse param, so private/deleted entries are listed too.
+    def initial_data
+      @initial_data ||= @innertube.browse(browse_id: "VL#{playlist_id}", params: "wgYCCAA=").tap do |data|
+        next if data["contents"]
+
+        alert = Array(data["alerts"]).filter_map { |a| a.dig("alertRenderer", "text", "runs", 0, "text") }.first
+        raise ExtractError, "playlist #{playlist_id}: #{alert || 'no contents in browse response'}"
+      end
+    end
+
+    # Video lockups plus the continuation item, which YouTube puts either at the end of the item
+    # section or as a sibling section.
+    def first_page_items
+      sections = initial_data.dig("contents", "twoColumnBrowseResultsRenderer", "tabs", 0, "tabRenderer", "content",
+                                  "sectionListRenderer", "contents") or
+        raise ExtractError, "no video list for playlist #{playlist_id}"
+      sections.flat_map { |section| section.dig("itemSectionRenderer", "contents") || [section] }
+    end
+
+    def metadata = initial_data.dig("metadata", "playlistMetadataRenderer") || {}
+    def sidebar_primary = initial_data.dig("sidebar", "playlistSidebarRenderer", "items", 0, "playlistSidebarPrimaryInfoRenderer")
+
+    def header_rows
+      Array(initial_data.dig("header", "pageHeaderRenderer", "content", "pageHeaderViewModel", "metadata",
+                             "contentMetadataViewModel", "metadataRows")).flat_map { |row| Array(row["metadataParts"]) }
+    end
+
+    # Stats appear as text runs in the sidebar (old layout) and as metadata parts in the page header (new layout).
+    def stats_text(pattern)
+      texts = Array(sidebar_primary&.dig("stats")).map { |s| s["simpleText"] || Array(s["runs"]).map { |r| r["text"] }.join } +
+              header_rows.filter_map { |part| part.dig("text", "content") }
+      texts.each { |text| (match = pattern.match(text)) and return match[1] }
+      nil
+    end
+
+    def owner_run
+      initial_data.dig("sidebar", "playlistSidebarRenderer", "items", 1, "playlistSidebarSecondaryInfoRenderer",
+                       "videoOwner", "videoOwnerRenderer", "title", "runs", 0) ||
+        header_rows.filter_map { |part| part.dig("avatarStack", "avatarStackViewModel", "text") }.first&.then do |text|
+          { "text" => text["content"],
+            "navigationEndpoint" => text.dig("commandRuns", 0, "onTap", "innertubeCommand") }
+        end
+    end
+  end
+end