youtubei 0.0.1-rc.3 → 0.0.1-rc.32

package/dist/classes/ChannelCompact.js

@@ -8,121 +8,132 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("../common");
-var _1 = require(".");
-var constants_1 = require("../constants");
-/**
- * Represent a Youtube Channel
- */
-var ChannelCompact = /** @class */ (function () {
-    function ChannelCompact(channel) {
-        if (channel === void 0) { channel = {}; }
+const common_1 = require("../common");
+const _1 = require(".");
+const constants_1 = require("../constants");
+/**  Represents a Youtube Channel */
+class ChannelCompact extends _1.Base {
+    /** @hidden */
+    constructor(channel = {}) {
+        super();
+        /** Loaded videos on the channel, fetched from `channel.nextVideos()` */
+        this.videos = [];
+        /** Loaded playlists on the channel, fetched from `channel.nextPlaylists()` */
+        this.playlists = [];
+        /** Current continuation token to load next videos */
+        this.videoContinuation = null;
+        /** Current continuation token to load next playlists */
+        this.playlistContinuation = null;
         Object.assign(this, channel);
     }
+    /** The URL of the channel page */
+    get url() {
+        return `https://www.youtube.com/channel/${this.id}`;
+    }
     /**
-     * Get videos from current Channel
+     * Load this instance with raw data from Youtube
      *
-     * TODO: Add continuation support
+     * @hidden
      */
-    ChannelCompact.prototype.getVideos = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, common_1.axios.post(constants_1.I_END_POINT + "/browse", {
-                            browseId: this.id,
-                            params: "EgZ2aWRlb3M%3D",
-                        })];
-                    case 1:
-                        response = _a.sent();
-                        return [2 /*return*/, response.data.contents.twoColumnBrowseResultsRenderer.tabs[1].tabRenderer.content.sectionListRenderer.contents[0].itemSectionRenderer.contents[0].gridRenderer.items
-                                .filter(function (i) { return i.gridVideoRenderer; })
-                                .map(function (i) { return new _1.VideoCompact().load(i.gridVideoRenderer); })];
-                }
-            });
-        });
-    };
+    load(data) {
+        const { channelId, title, thumbnail, videoCountText, subscriberCountText } = data;
+        this.id = channelId;
+        this.name = title.simpleText;
+        this.thumbnails = new _1.Thumbnails().load(thumbnail.thumbnails);
+        this.videoCount = common_1.stripToInt(videoCountText === null || videoCountText === void 0 ? void 0 : videoCountText.runs[0].text) || 0;
+        this.subscriberCount = subscriberCountText === null || subscriberCountText === void 0 ? void 0 : subscriberCountText.simpleText;
+        this.videos = [];
+        this.playlists = [];
+        return this;
+    }
     /**
-     * Get playlists from current channel
+     * Load next 30 videos made by the channel, and push the loaded videos to {@link Channel.videos}
+     *
+     * @example
+     * ```js
+     * const channel = await youtube.findOne(CHANNEL_NAME, {type: "channel"});
+     * await channel.nextVideos();
+     * console.log(channel.videos) // first 30 videos
+     *
+     * let newVideos = await channel.nextVideos();
+     * console.log(newVideos) // 30 loaded videos
+     * console.log(channel.videos) // first 60 videos
      *
-     * TODO: Add continuation support
+     * await channel.nextVideos(0); // load the rest of the videos in the channel
+     * ```
+     *
+     * @param count How many time to load the next videos, pass `0` to load all
+     *
+     * @return New loaded videos
      */
-    ChannelCompact.prototype.getPlaylists = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var response, section, gridPlaylistRenderer;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, common_1.axios.post(constants_1.I_END_POINT + "/browse", {
-                            browseId: this.id,
-                            params: "EglwbGF5bGlzdHM%3D",
-                        })];
-                    case 1:
-                        response = _a.sent();
-                        section = response.data.contents.twoColumnBrowseResultsRenderer.tabs[2].tabRenderer.content
-                            .sectionListRenderer;
-                        // Has category
-                        if ("shelfRenderer" in section.contents[0].itemSectionRenderer.contents[0]) {
-                            gridPlaylistRenderer = section.contents
-                                .map(function (c) {
-                                return c.itemSectionRenderer.contents[0].shelfRenderer.content
-                                    .horizontalListRenderer.items;
-                            })
-                                .flat();
-                        }
-                        else {
-                            gridPlaylistRenderer =
-                                section.contents[0].itemSectionRenderer.contents[0].gridRenderer.items;
-                        }
-                        return [2 /*return*/, gridPlaylistRenderer.map(function (i) {
-                                return new _1.PlaylistCompact().load(i.gridPlaylistRenderer);
-                            })];
-                }
-            });
+    nextVideos(count = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newVideos = [];
+            for (let i = 0; i < count || count == 0; i++) {
+                if (this.videoContinuation === undefined)
+                    break;
+                const items = yield this.getTabData("videos");
+                this.videoContinuation = common_1.getContinuationFromItems(items);
+                const videos = common_1.mapFilter(items, "gridVideoRenderer");
+                newVideos.push(...videos.map((i) => new _1.VideoCompact({ client: this.client }).load(i)));
+            }
+            this.videos.push(...newVideos);
+            return newVideos;
         });
-    };
+    }
     /**
-     * Load instance attributes from youtube raw data
+     * Load next 30 playlists made by the channel, and push the loaded playlists to {@link Channel.playlists}
+     *
+     * @example
+     * ```js
+     * const channel = await youtube.findOne(CHANNEL_NAME, {type: "channel"});
+     * await channel.nextPlaylists();
+     * console.log(channel.playlists) // first 30 playlists
+     *
+     * let newPlaylists = await channel.nextPlaylists();
+     * console.log(newPlaylists) // 30 loaded playlists
+     * console.log(channel.playlists) // first 60 playlists
+     *
+     * await channel.nextPlaylists(0); // load the rest of the playlists in the channel
+     * ```
      *
-     * @param youtubeRawData raw object from youtubei
+     * @param count How many time to load the next playlists, pass `0` to load all
+     *
+     * @return New loaded playlists
      */
-    ChannelCompact.prototype.load = function (youtubeRawData) {
+    nextPlaylists(count = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newPlaylists = [];
+            for (let i = 0; i < count || count == 0; i++) {
+                if (this.playlistContinuation === undefined)
+                    break;
+                const items = yield this.getTabData("playlists");
+                this.playlistContinuation = common_1.getContinuationFromItems(items);
+                const playlists = common_1.mapFilter(items, "gridPlaylistRenderer");
+                newPlaylists.push(...playlists.map((i) => new _1.PlaylistCompact({ client: this.client }).load(i)));
+            }
+            this.playlists.push(...newPlaylists);
+            return newPlaylists;
+        });
+    }
+    /** Get tab data from youtube */
+    getTabData(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = name === "videos" ? "EgZ2aWRlb3M%3D" : "EglwbGF5bGlzdHMgAQ%3D%3D";
+            const continuation = name === "videos" ? this.videoContinuation : this.playlistContinuation;
+            const response = yield this.client.http.post(`${constants_1.I_END_POINT}/browse`, {
+                data: { browseId: this.id, params, continuation },
+            });
+            return ChannelCompact.parseTabData(name, response.data);
+        });
+    }
+    /** Parse tab data from request, tab name is ignored if it's a continuation data */
+    static parseTabData(name, data) {
         var _a;
-        var channelId = youtubeRawData.channelId, title = youtubeRawData.title, thumbnail = youtubeRawData.thumbnail, videoCountText = youtubeRawData.videoCountText, navigationEndpoint = youtubeRawData.navigationEndpoint;
-        this.id = channelId;
-        this.name = title.simpleText;
-        this.thumbnail = "https:" + thumbnail.thumbnails[thumbnail.thumbnails.length - 1].url;
-        this.url = "https://www.youtube.com" + navigationEndpoint.browseEndpoint.canonicalBaseUrl;
-        this.videoCount = (_a = +(videoCountText === null || videoCountText === void 0 ? void 0 : videoCountText.runs[0].text.replace(/[^0-9]/g, ""))) !== null && _a !== void 0 ? _a : 0;
-        return this;
-    };
-    return ChannelCompact;
-}());
+        const index = name === "videos" ? 1 : 2;
+        return (((_a = data.contents) === null || _a === void 0 ? void 0 : _a.twoColumnBrowseResultsRenderer.tabs[index].tabRenderer.content.sectionListRenderer.contents[0].itemSectionRenderer.contents[0].gridRenderer.items) ||
+            data.onResponseReceivedActions[0].appendContinuationItemsAction.continuationItems);
+    }
+}
 exports.default = ChannelCompact;

package/dist/classes/Chat.d.ts

@@ -0,0 +1,29 @@
+import { Base, ChannelCompact, Video, BaseAttributes } from ".";
+import { YoutubeRawData } from "../common";
+/** @hidden */
+interface ChatAttributes extends BaseAttributes {
+    video: Video;
+    author: ChannelCompact;
+    message: string;
+    timestamp: number;
+}
+/** Represents a chat in a live stream */
+export default class Chat extends Base implements ChatAttributes {
+    /** The video this chat belongs to */
+    video: Video;
+    /** The chat's author */
+    author: ChannelCompact;
+    /** The message of this chat */
+    message: string;
+    /** Timestamp in usec / microsecond */
+    timestamp: number;
+    /** @hidden */
+    constructor(chat?: Partial<ChatAttributes>);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): Chat;
+}
+export {};

package/dist/classes/Chat.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+/** Represents a chat in a live stream */
+class Chat extends _1.Base {
+    /** @hidden */
+    constructor(chat = {}) {
+        super();
+        Object.assign(this, chat);
+    }
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data) {
+        const { id, message, authorName, authorPhoto, timestampUsec, authorExternalChannelId, } = data;
+        // Basic information
+        this.id = id;
+        this.message = message.runs.map((r) => r.text).join("");
+        this.author = new _1.ChannelCompact({
+            id: authorExternalChannelId,
+            name: authorName.simpleText,
+            thumbnails: authorPhoto.thumbnails,
+            client: this.client,
+        });
+        this.timestamp = +timestampUsec;
+        return this;
+    }
+}
+exports.default = Chat;

package/dist/classes/Client.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import { HTTP } from "../common";
+import { Playlist, Video, SearchResult, LiveVideo, Channel, MixPlaylist } from ".";
+import { SearchResultType } from "./SearchResult";
+import { RequestOptions } from "https";
+export declare namespace Client {
+    type SearchType = "video" | "channel" | "playlist" | "all";
+    type SearchOptions = {
+        /** Search type, can be `"video"`, `"channel"`, `"playlist"`, or `"all"` */
+        type?: SearchType;
+        /** Raw search params to be passed on the request, ignores `type` value if this is provided */
+        params?: string;
+    };
+    type ClientOptions = {
+        cookie: string;
+        /** Optional options for http client */
+        requestOptions: Partial<RequestOptions>;
+        /** Optional options passed when sending a request to youtube (context.client) */
+        youtubeClientOptions: Record<string, unknown>;
+        /** Use Node `https` module, set false to use `http` */
+        https: boolean;
+    };
+}
+/** Youtube Client */
+export default class Client {
+    /** @hidden */
+    http: HTTP;
+    constructor(options?: Partial<Client.ClientOptions>);
+    /**
+     * Searches for videos / playlists / channels
+     *
+     * @param query The search query
+     * @param searchOptions Search options
+     *
+     */
+    search<T extends Client.SearchOptions>(query: string, searchOptions?: T): Promise<SearchResult<T["type"]>>;
+    /**
+     * Search for videos / playlists / channels and returns the first result
+     *
+     * @return Can be {@link VideoCompact} | {@link PlaylistCompact} | {@link Channel} | `undefined`
+     */
+    findOne<T extends Client.SearchOptions>(query: string, searchOptions?: Partial<T>): Promise<SearchResultType<T["type"]> | undefined>;
+    /** Get playlist information and its videos by playlist id or URL */
+    getPlaylist<T extends Playlist | MixPlaylist | undefined>(playlistIdOrUrl: string): Promise<T>;
+    /** Get video information by video id or URL */
+    getVideo<T extends Video | LiveVideo | undefined>(videoIdOrUrl: string): Promise<T>;
+    /** Get channel information by channel id+ */
+    getChannel(channelId: string): Promise<Channel | undefined>;
+}

package/dist/classes/Client.js

@@ -0,0 +1,97 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const common_1 = require("../common");
+const _1 = require(".");
+/** Youtube Client */
+class Client {
+    constructor(options = {}) {
+        const fullOptions = Object.assign(Object.assign({ cookie: "", https: true, requestOptions: {} }, options), { youtubeClientOptions: Object.assign({ hl: "en", gl: "US" }, options.youtubeClientOptions) });
+        this.http = new common_1.HTTP(fullOptions);
+    }
+    /**
+     * Searches for videos / playlists / channels
+     *
+     * @param query The search query
+     * @param searchOptions Search options
+     *
+     */
+    search(query, searchOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Object.assign({ type: "all", params: "" }, searchOptions);
+            const result = new _1.SearchResult().load(this);
+            yield result.init(query, options);
+            return result;
+        });
+    }
+    /**
+     * Search for videos / playlists / channels and returns the first result
+     *
+     * @return Can be {@link VideoCompact} | {@link PlaylistCompact} | {@link Channel} | `undefined`
+     */
+    findOne(query, searchOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.search(query, searchOptions)).shift();
+        });
+    }
+    /** Get playlist information and its videos by playlist id or URL */
+    getPlaylist(playlistIdOrUrl) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const playlistId = common_1.getQueryParameter(playlistIdOrUrl, "list");
+            if (playlistId.startsWith("RD")) {
+                const response = yield this.http.post(`${constants_1.I_END_POINT}/next`, {
+                    data: { playlistId },
+                });
+                if (response.data.error) {
+                    return undefined;
+                }
+                return new _1.MixPlaylist({ client: this }).load(response.data);
+            }
+            const response = yield this.http.post(`${constants_1.I_END_POINT}/browse`, {
+                data: { browseId: `VL${playlistId}` },
+            });
+            if (response.data.error || ((_c = (_b = (_a = response.data.alerts) === null || _a === void 0 ? void 0 : _a.shift()) === null || _b === void 0 ? void 0 : _b.alertRenderer) === null || _c === void 0 ? void 0 : _c.type) === "ERROR") {
+                return undefined;
+            }
+            return new _1.Playlist({ client: this }).load(response.data);
+        });
+    }
+    /** Get video information by video id or URL */
+    getVideo(videoIdOrUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const videoId = common_1.getQueryParameter(videoIdOrUrl, "v");
+            const response = yield this.http.get(`${constants_1.WATCH_END_POINT}`, {
+                params: { v: videoId, pbj: "1" },
+            });
+            if (!response.data[3].response.contents)
+                return undefined;
+            return (!response.data[2].playerResponse.playabilityStatus.liveStreamability
+                ? new _1.Video({ client: this }).load(response.data)
+                : new _1.LiveVideo({ client: this }).load(response.data));
+        });
+    }
+    /** Get channel information by channel id+ */
+    getChannel(channelId) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.http.post(`${constants_1.I_END_POINT}/browse`, {
+                data: { browseId: channelId },
+            });
+            if (response.data.error || ((_c = (_b = (_a = response.data.alerts) === null || _a === void 0 ? void 0 : _a.shift()) === null || _b === void 0 ? void 0 : _b.alertRenderer) === null || _c === void 0 ? void 0 : _c.type) === "ERROR") {
+                return undefined;
+            }
+            return new _1.Channel({ client: this }).load(response.data);
+        });
+    }
+}
+exports.default = Client;

package/dist/classes/Comment.d.ts

@@ -0,0 +1,50 @@
+import { Base, ChannelCompact, Video, BaseAttributes, Reply } from ".";
+import { YoutubeRawData } from "../common";
+/** @hidden */
+interface CommentAttributes extends BaseAttributes {
+    video: Video;
+    author: ChannelCompact;
+    content: string;
+    publishDate: string;
+    likeCount: number;
+    isAuthorChannelOwner: boolean;
+    isPinnedComment: boolean;
+    replyCount: number;
+    replyContinuation?: string;
+}
+/** Represents a Comment / Reply */
+export default class Comment extends Base implements CommentAttributes {
+    /** The video this comment belongs to */
+    video: Video;
+    /** The comment's author */
+    author: ChannelCompact;
+    /** The content of this comment */
+    content: string;
+    /** The publish date of the comment */
+    publishDate: string;
+    /** How many likes does this comment have */
+    likeCount: number;
+    /** Whether the comment is posted by the video uploader / owner */
+    isAuthorChannelOwner: boolean;
+    /** Whether the comment is pinned */
+    isPinnedComment: boolean;
+    /** Comment's reply count */
+    replyCount: number;
+    /** Comment's loaded replies */
+    replies: Reply[];
+    /** Current continuation token to load next replies  */
+    replyContinuation?: string;
+    /** @hidden */
+    constructor(comment?: Partial<CommentAttributes>);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): Comment;
+    /** URL to the video with this comment being highlighted (appears on top of the comment section) */
+    get url(): string;
+    /** Load next replies of the comment */
+    nextReplies(count?: number): Promise<Reply[]>;
+}
+export {};

package/dist/classes/Comment.js

@@ -0,0 +1,84 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const common_1 = require("../common");
+const constants_1 = require("../constants");
+/** Represents a Comment / Reply */
+class Comment extends _1.Base {
+    /** @hidden */
+    constructor(comment = {}) {
+        super();
+        /** Comment's loaded replies */
+        this.replies = [];
+        Object.assign(this, comment);
+    }
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data) {
+        const { authorText, authorThumbnail, authorEndpoint, contentText, publishedTimeText, commentId, voteCount, authorIsChannelOwner, pinnedCommentBadge, replyCount, } = data.comment.commentRenderer;
+        // Basic information
+        this.id = commentId;
+        this.content = contentText.runs.map((r) => r.text).join("");
+        this.publishDate = publishedTimeText.runs.shift().text;
+        this.likeCount = +((voteCount === null || voteCount === void 0 ? void 0 : voteCount.simpleText) || 0);
+        this.isAuthorChannelOwner = authorIsChannelOwner;
+        this.isPinnedComment = !!pinnedCommentBadge;
+        this.replyCount = replyCount;
+        // Reply Continuation
+        this.replies = [];
+        this.replyContinuation = data.replies
+            ? common_1.getContinuationFromItems(data.replies.commentRepliesRenderer.contents)
+            : undefined;
+        // Author
+        const { browseId } = authorEndpoint.browseEndpoint;
+        this.author = new _1.ChannelCompact({
+            id: browseId,
+            name: authorText.simpleText,
+            thumbnails: new _1.Thumbnails().load(authorThumbnail.thumbnails),
+            client: this.client,
+        });
+        return this;
+    }
+    /** URL to the video with this comment being highlighted (appears on top of the comment section) */
+    get url() {
+        return `https://www.youtube.com/watch?v=${this.video.id}&lc=${this.id}`;
+    }
+    /** Load next replies of the comment */
+    nextReplies(count = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newReplies = [];
+            for (let i = 0; i < count || count == 0; i++) {
+                if (!this.replyContinuation)
+                    break;
+                // Send request
+                const response = yield this.client.http.post(`${constants_1.I_END_POINT}/next`, {
+                    data: { continuation: this.replyContinuation },
+                });
+                const continuationItems = response.data.onResponseReceivedEndpoints[0].appendContinuationItemsAction
+                    .continuationItems;
+                this.replyContinuation = common_1.getContinuationFromItems(continuationItems, [
+                    "button",
+                    "buttonRenderer",
+                    "command",
+                ]);
+                const replies = common_1.mapFilter(continuationItems, "commentRenderer");
+                newReplies.push(...replies.map((i) => new _1.Reply({ video: this.video, comment: this, client: this.client }).load(i)));
+            }
+            this.replies.push(...newReplies);
+            return newReplies;
+        });
+    }
+}
+exports.default = Comment;

package/dist/classes/LiveVideo.d.ts

@@ -0,0 +1,47 @@
+import { YoutubeRawData } from "../common";
+import { Chat, BaseVideo, BaseVideoAttributes } from ".";
+/** @hidden */
+interface LiveVideoAttributes extends BaseVideoAttributes {
+    watchingCount: number;
+    chatContinuation?: string;
+}
+interface LiveVideoEvents {
+    chat: (chat: Chat) => void;
+}
+declare interface LiveVideo {
+    on<T extends keyof LiveVideoEvents>(event: T, listener: LiveVideoEvents[T]): AsyncIterableIterator<any>;
+    emit<T extends keyof LiveVideoEvents>(event: T, ...args: Parameters<LiveVideoEvents[T]>): boolean;
+}
+/** Represents a video that's currently live, usually returned from `client.getVideo()` */
+declare class LiveVideo extends BaseVideo implements LiveVideoAttributes {
+    /** Number of people who's watching the live stream right now */
+    watchingCount: number;
+    /** Current continuation token to load next chat  */
+    chatContinuation: string;
+    private _delay;
+    private _chatRequestPoolingTimeout;
+    private _timeoutMs;
+    private _isChatPlaying;
+    private _chatQueue;
+    /** @hidden */
+    constructor(video?: Partial<LiveVideoAttributes>);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): LiveVideo;
+    /**
+     * Start polling for get live chat request
+     *
+     * @param delay chat delay in millisecond
+     */
+    playChat(delay?: number): void;
+    /** Stop request polling for live chat */
+    stopChat(): void;
+    /** Start request polling */
+    private pollChatContinuation;
+    /** Parse chat data from Youtube and add to chatQueue */
+    private parseChat;
+}
+export default LiveVideo;