cloud-ytdl 1.0.0-rc

package/lib/info.js

@@ -0,0 +1,209 @@
+const sax = require("sax");
+const { setTimeout } = require("timers");
+
+const utils = require("./utils");
+const formatutils = require("./format-utils");
+const urlutils = require("./url-utils");
+const cache = require("./cache");
+const innertube = require("./innertube");
+
+const baseurl = "https://www.youtube.com/watch?v=";
+
+const cacheinstance = new cache();
+const watchpagecache = new cache();
+
+const agerestrictedurls = [
+  "support.google.com/youtube/?p=age_restrictions",
+  "youtube.com/t/community_guidelines",
+];
+
+const getbasicinfo = async (id, options = {}) => {
+  return getinfo(id, options);
+};
+
+const getwatchhtmlurl = (id, options) =>
+  `${baseurl + id}&hl=${options.lang || "en"}&bpctr=${Math.ceil(Date.now() / 1000)}&has_verified=1`;
+
+const getwatchhtmlpagebody = (id, options) => {
+  const url = getwatchhtmlurl(id, options);
+  return watchpagecache.getOrSet(url, () => utils.request(url, options));
+};
+
+const embedurl = "https://www.youtube.com/embed/";
+
+const getembedpagebody = (id, options) => {
+  const url = `${embedurl + id}?hl=${options.lang || "en"}`;
+  return utils.request(url, options);
+};
+
+const gethtml5player = body => {
+  const res =
+    /<script\s+src="([^"]+)"(?:\s+type="text\/javascript")?\s+name="player_ias\/base"\s*>|"jsUrl":"([^"]+)"/.exec(body);
+  return res?.[1] || res?.[2];
+};
+
+const retryfunc = async (func, args, options) => {
+  let currenttry = 0;
+  let result;
+
+  if (!options.maxRetries) options.maxRetries = 3;
+  if (!options.backoff) options.backoff = { inc: 500, max: 5000 };
+
+  while (currenttry <= options.maxRetries) {
+    try {
+      result = await func(...args);
+      break;
+    } catch (err) {
+      if (err?.statusCode < 500 || currenttry >= options.maxRetries) throw err;
+      const wait = Math.min(++currenttry * options.backoff.inc, options.backoff.max);
+      await new Promise(r => setTimeout(r, wait));
+    }
+  }
+  return result;
+};
+
+const jsonclosingchars = /^[)\]}'\s]+/;
+
+const parsejson = (source, name, json) => {
+  if (!json || typeof json === "object") return json;
+  json = json.replace(jsonclosingchars, "");
+  return JSON.parse(json);
+};
+
+const findjson = (source, name, body, left, right, prepend) => {
+  const str = utils.between(body, left, right);
+  if (!str) throw new Error(`could not find ${name} in ${source}`);
+  return parsejson(source, name, utils.cutAfterJS(`${prepend}${str}`));
+};
+
+const findplayerresponse = (source, info) => {
+  if (!info) return {};
+  const data =
+    info.args?.playerresponse ||
+    info.playerresponse ||
+    info.playerResponse ||
+    info.embeddedplayerresponse;
+  return parsejson(source, "playerresponse", data);
+};
+
+const getwatchhtmlpage = async (id, options) => {
+  const body = await getwatchhtmlpagebody(id, options);
+  const info = { page: "watch" };
+
+  info.playerresponse =
+    utils.extractYouTubeJSON(body, "ytInitialPlayerResponse") ||
+    utils.extractYouTubeJSON(body, "initialPlayerResponse");
+
+  info.response =
+    utils.extractYouTubeJSON(body, "ytInitialData") ||
+    utils.extractYouTubeJSON(body, "initialData");
+
+  info.html5player = gethtml5player(body);
+  return info;
+};
+
+const parseformats = playerresponse =>
+  (playerresponse?.streamingData?.formats || []).concat(
+    playerresponse?.streamingData?.adaptiveFormats || []
+  );
+
+const getinfo = async (id, options = {}) => {
+  utils.applyIPv6Rotations(options);
+  utils.applyDefaultHeaders(options);
+  utils.applyDefaultAgent(options);
+  utils.applyOldLocalAddress(options);
+
+  const data = await innertube.getInfo(id, {
+    headers: options.requestOptions?.headers,
+  });
+
+  if (!data.success) throw new Error("failed to fetch info");
+
+  return {
+    full: true,
+    videoDetails: data.videodetails,
+    player_response: {
+      playabilityStatus: { status: "OK" },
+      streamingData: {
+        formats: data.formats.filter(f => f.hasvideo && f.hasaudio),
+        adaptiveFormats: data.formats
+      }
+    },
+    formats: data.formats.map(f => ({
+      ...f,
+      hasVideo: f.hasvideo,
+      hasAudio: f.hasaudio,
+      mimeType: f.mimeType,
+      url: f.url,
+      isHLS: false,
+      isDashMPD: false
+    })),
+    html5player: data.html5player
+  };
+};
+
+
+const getdashmanifest = (url, options) =>
+  new Promise((resolve, reject) => {
+    const formats = {};
+    const parser = sax.parser(false);
+
+    let adaptationset;
+
+    parser.onerror = reject;
+    parser.onopentag = node => {
+      if (node.name === "ADAPTATIONSET") adaptationset = node.attributes;
+      if (node.name === "REPRESENTATION") {
+        const itag = parseInt(node.attributes.ID);
+        if (!isNaN(itag)) {
+          formats[url] = {
+            itag,
+            url,
+            bitrate: parseInt(node.attributes.BANDWIDTH),
+            mimeType: `${adaptationset.MIMETYPE}; codecs="${node.attributes.CODECS}"`,
+          };
+        }
+      }
+    };
+
+    parser.onend = () => resolve(formats);
+
+    utils.request(new URL(url, baseurl).toString(), options).then(res => {
+      parser.write(res);
+      parser.close();
+    });
+  });
+
+const getm3u8 = async (url, options) => {
+  const body = await utils.request(new URL(url, baseurl).toString(), options);
+  const formats = {};
+
+  body
+    .split("\n")
+    .filter(l => l.startsWith("http"))
+    .forEach(l => {
+      const itag = parseInt(l.match(/\/itag\/(\d+)\//)[1]);
+      formats[l] = { itag, url: l };
+    });
+
+  return formats;
+};
+
+const wrapcache = name => async (link, options = {}) => {
+  const id = await urlutils.getVideoID(link);
+  const key = [name, id, options.lang].join("-");
+  const fn = name === "getbasicinfo" ? getbasicinfo : getinfo;
+  return cacheinstance.getOrSet(key, () => fn(id, options));
+};
+
+module.exports = {
+  cacheInstance: cacheinstance,
+  watchPageCache: watchpagecache,
+  getBasicInfo: wrapcache("getbasicinfo"),
+  getInfo: wrapcache("getinfo"),
+  validateID: urlutils.validateID,
+  validateURL: urlutils.validateURL,
+  getURLVideoID: urlutils.getURLVideoID,
+  getVideoID: urlutils.getVideoID,
+};
+