cloud-ytdl 1.0.0-rc

package/lib/agents.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const { ProxyAgent } = require('undici')
+const { HttpsProxyAgent } = require('https-proxy-agent')
+const { Cookie, CookieJar, canonicalDomain } = require('tough-cookie')
+const { CookieAgent } = require('http-cookie-agent/undici')
+
+const mapSameSite = s =>
+  s === 'strict' || s === 'lax' || s === 'none' ? s : 'none'
+
+const toCookie = c => {
+  if (c instanceof Cookie) return c
+  if (!c || !c.name) return null
+
+  return new Cookie({
+    key: c.name,
+    value: c.value ?? '',
+    expires:
+      typeof c.expirationDate === 'number'
+        ? new Date(c.expirationDate * 1000)
+        : 'Infinity',
+    domain: canonicalDomain(c.domain || 'youtube.com'),
+    path: c.path || '/',
+    secure: !!c.secure,
+    httpOnly: !!c.httpOnly,
+    sameSite: mapSameSite(c.sameSite),
+    hostOnly: !!c.hostOnly,
+  })
+}
+
+const ensureSOCS = cookies => {
+  if (!Array.isArray(cookies)) return
+
+  if (!cookies.some(c => c?.name === 'SOCS')) {
+    cookies.push({
+      name: 'SOCS',
+      value: 'CAI',
+      domain: '.youtube.com',
+      path: '/',
+      secure: true,
+      httpOnly: false,
+      sameSite: 'lax',
+      hostOnly: false,
+    })
+  }
+}
+
+
+const addCookies = (exports.addCookies = (jar, cookies = []) => {
+  if (!Array.isArray(cookies)) return
+
+  ensureSOCS(cookies)
+
+  for (const c of cookies) {
+    const ck = toCookie(c)
+    if (!ck) continue
+    jar.setCookieSync(ck, 'https://www.youtube.com')
+  }
+})
+
+exports.addCookiesFromString = (jar, str) => {
+  if (typeof str !== 'string') return
+  const parsed = str
+    .split(';')
+    .map(s => Cookie.parse(s))
+    .filter(Boolean)
+
+  addCookies(jar, parsed)
+}
+
+
+const createAgent = (exports.createAgent = (cookies, opts) => {
+  if (cookies && !Array.isArray(cookies) && typeof cookies === 'object') {
+    opts = cookies
+    cookies = []
+  }
+
+  cookies ??= []
+  opts ??= {}
+
+  const jar = opts.cookies?.jar || new CookieJar()
+
+  if (!opts.cookies) addCookies(jar, cookies)
+
+  return {
+    dispatcher: new CookieAgent({
+      ...opts,
+      cookies: { jar },
+    }),
+    jar,
+    localAddress: opts.localAddress,
+  }
+})
+
+exports.createProxyAgent = (options, cookies = []) => {
+  if (typeof options === 'string') {
+    options = { uri: options }
+  }
+
+  const jar = new CookieJar()
+  addCookies(jar, cookies)
+
+  return {
+    agent: new HttpsProxyAgent(options.uri),
+    dispatcher: new CookieAgent({
+      dispatcher: new ProxyAgent(options),
+      cookies: { jar },
+    }),
+    jar,
+    localAddress: options.localAddress,
+  }
+}
+
+exports.defaultAgent = createAgent()

package/lib/cache.js

@@ -0,0 +1,45 @@
+const { setTimeout, clearTimeout } = require("timers");
+
+module.exports = class Cache extends Map {
+  constructor(timeout = 1000) {
+    super();
+    this.timeout = timeout;
+  }
+
+  set(key, value) {
+    const old = super.get(key);
+    if (old) clearTimeout(old.tid);
+
+    const tid = setTimeout(() => this.delete(key), this.timeout);
+    tid.unref?.();
+
+    return super.set(key, { tid, value });
+  }
+
+  get(key) {
+    return super.get(key)?.value ?? null;
+  }
+
+  getOrSet(key, fn) {
+    if (this.has(key)) return this.get(key);
+
+    const value = fn();
+    this.set(key, value);
+
+    Promise.resolve(value).catch(() => this.delete(key));
+    return value;
+  }
+
+  delete(key) {
+    const entry = super.get(key);
+    if (!entry) return false;
+
+    clearTimeout(entry.tid);
+    return super.delete(key);
+  }
+
+  clear() {
+    for (const { tid } of super.values()) clearTimeout(tid);
+    super.clear();
+  }
+};

package/lib/format-utils.js

@@ -0,0 +1,148 @@
+const utils = require("./utils");
+const FORMATS = require("./format");
+
+const audioRanks = ["mp4a", "mp3", "vorbis", "aac", "opus", "flac"];
+const videoRanks = ["mp4v", "avc1", "Sorenson H.283", "MPEG-4 Visual", "VP8", "VP9", "H.264"];
+
+const vBitrate = f => f.bitrate || 0;
+const aBitrate = f => f.audioBitrate || 0;
+const vRank = f => videoRanks.findIndex(e => f.codecs?.includes(e));
+const aRank = f => audioRanks.findIndex(e => f.codecs?.includes(e));
+
+const sortBy = (a, b, fns) => {
+  for (const fn of fns) {
+    const r = fn(b) - fn(a);
+    if (r) return r;
+  }
+  return 0;
+};
+
+const sortVideo = (a, b) =>
+  sortBy(a, b, [f => +f.qualityLabel, vBitrate, vRank]);
+
+const sortAudio = (a, b) =>
+  sortBy(a, b, [aBitrate, aRank]);
+
+const sortFormats = (a, b) =>
+  sortBy(a, b, [
+    f => +!!f.isHLS,
+    f => +!!f.isDashMPD,
+    f => +(f.contentLength > 0),
+    f => +(f.hasVideo && f.hasAudio),
+    f => +f.hasVideo,
+    f => +f.qualityLabel || 0,
+    vBitrate,
+    aBitrate,
+    vRank,
+    aRank,
+  ]);
+
+const byQuality = (quality, formats) => {
+  const find = q => formats.find(f => `${f.itag}` === `${q}`);
+  return Array.isArray(quality)
+    ? find(quality.find(q => find(q)))
+    : find(quality);
+};
+
+const chooseFormat = (formats, opts = {}) => {
+  formats = Array.isArray(formats) ? formats : [formats];
+
+  if (typeof opts.format === "object") {
+    if (!opts.format.url) throw Error("Invalid format");
+    return opts.format;
+  }
+
+  if (opts.filter) formats = filterFormats(formats, opts.filter);
+
+  if (formats.some(f => f.isHLS)) {
+    formats = formats.filter(f => f.isHLS || !f.isLive);
+  }
+
+  const q = opts.quality || "highest";
+  let f;
+
+  switch (q) {
+    case "highest":
+      f = formats[0];
+      break;
+    case "lowest":
+      f = formats[formats.length - 1];
+      break;
+    case "highestaudio": {
+      formats = filterFormats(formats, "audio").sort(sortAudio);
+      const best = formats[0];
+      const same = formats.filter(x => sortAudio(best, x) === 0);
+      const worstV = Math.min(...same.map(x => +x.qualityLabel || 0));
+      f = same.find(x => (+x.qualityLabel || 0) === worstV);
+      break;
+    }
+    case "lowestaudio":
+      f = filterFormats(formats, "audio").sort(sortAudio).at(-1);
+      break;
+    case "highestvideo": {
+      formats = filterFormats(formats, "video").sort(sortVideo);
+      const best = formats[0];
+      const same = formats.filter(x => sortVideo(best, x) === 0);
+      const worstA = Math.min(...same.map(x => x.audioBitrate || 0));
+      f = same.find(x => (x.audioBitrate || 0) === worstA);
+      break;
+    }
+    case "lowestvideo":
+      f = filterFormats(formats, "video").sort(sortVideo).at(-1);
+      break;
+    default:
+      f = byQuality(q, formats);
+  }
+
+  if (!f) throw Error(`No such format found: ${q}`);
+  return f;
+};
+
+const filterFormats = (formats, filter) => {
+  let fn;
+  switch (filter) {
+    case "videoandaudio":
+    case "audioandvideo":
+      fn = f => f.hasVideo && f.hasAudio;
+      break;
+    case "video":
+      fn = f => f.hasVideo;
+      break;
+    case "videoonly":
+      fn = f => f.hasVideo && !f.hasAudio;
+      break;
+    case "audio":
+      fn = f => f.hasAudio;
+      break;
+    case "audioonly":
+      fn = f => !f.hasVideo && f.hasAudio;
+      break;
+    default:
+      if (typeof filter !== "function") {
+        throw TypeError(`Given filter (${filter}) is not supported`);
+      }
+      fn = filter;
+  }
+  return formats.filter(f => f.url && fn(f));
+};
+
+const addFormatMeta = f => {
+  f = { ...FORMATS[f.itag], ...f };
+  f.hasVideo = !!f.qualityLabel;
+  f.hasAudio = !!f.audioBitrate;
+  f.container = f.mimeType?.split(";")[0].split("/")[1] || null;
+  f.codecs = f.mimeType ? utils.between(f.mimeType, 'codecs="', '"') : null;
+  f.videoCodec = f.hasVideo && f.codecs ? f.codecs.split(", ")[0] : null;
+  f.audioCodec = f.hasAudio && f.codecs ? f.codecs.split(", ").at(-1) : null;
+  f.isLive = /\bsource[/=]yt_live_broadcast\b/.test(f.url);
+  f.isHLS = /\/manifest\/hls_(variant|playlist)\//.test(f.url);
+  f.isDashMPD = /\/manifest\/dash\//.test(f.url);
+  return f;
+};
+
+module.exports = {
+  sortFormats,
+  chooseFormat,
+  filterFormats,
+  addFormatMeta,
+};

package/lib/format.js

@@ -0,0 +1,82 @@
+module.exports = {
+  5:{mimeType:'video/flv; codecs="Sorenson H.283, mp3"',qualityLabel:"240p",bitrate:250000,audioBitrate:64},
+  6:{mimeType:'video/flv; codecs="Sorenson H.263, mp3"',qualityLabel:"270p",bitrate:800000,audioBitrate:64},
+  13:{mimeType:'video/3gp; codecs="MPEG-4 Visual, aac"',qualityLabel:null,bitrate:500000,audioBitrate:null},
+  17:{mimeType:'video/3gp; codecs="MPEG-4 Visual, aac"',qualityLabel:"144p",bitrate:50000,audioBitrate:24},
+  18:{mimeType:'video/mp4; codecs="H.264, aac"',qualityLabel:"360p",bitrate:500000,audioBitrate:96},
+  22:{mimeType:'video/mp4; codecs="H.264, aac"',qualityLabel:"720p",bitrate:2000000,audioBitrate:192},
+  34:{mimeType:'video/flv; codecs="H.264, aac"',qualityLabel:"360p",bitrate:500000,audioBitrate:128},
+  35:{mimeType:'video/flv; codecs="H.264, aac"',qualityLabel:"480p",bitrate:800000,audioBitrate:128},
+  36:{mimeType:'video/3gp; codecs="MPEG-4 Visual, aac"',qualityLabel:"240p",bitrate:175000,audioBitrate:32},
+  37:{mimeType:'video/mp4; codecs="H.264, aac"',qualityLabel:"1080p",bitrate:3000000,audioBitrate:192},
+  38:{mimeType:'video/mp4; codecs="H.264, aac"',qualityLabel:"3072p",bitrate:3500000,audioBitrate:192},
+  43:{mimeType:'video/webm; codecs="VP8, vorbis"',qualityLabel:"360p",bitrate:500000,audioBitrate:128},
+  44:{mimeType:'video/webm; codecs="VP8, vorbis"',qualityLabel:"480p",bitrate:1000000,audioBitrate:128},
+  45:{mimeType:'video/webm; codecs="VP8, vorbis"',qualityLabel:"720p",bitrate:2000000,audioBitrate:192},
+  46:{mimeType:'audio/webm; codecs="vp8, vorbis"',qualityLabel:"1080p",bitrate:null,audioBitrate:192},
+  82:{mimeType:'video/mp4; codecs="H.264, aac"',qualityLabel:"360p",bitrate:500000,audioBitrate:96},
+  83:{mimeType:'video/mp4; codecs="H.264, aac"',qualityLabel:"240p",bitrate:500000,audioBitrate:96},
+  84:{mimeType:'video/mp4; codecs="H.264, aac"',qualityLabel:"720p",bitrate:2000000,audioBitrate:192},
+  85:{mimeType:'video/mp4; codecs="H.264, aac"',qualityLabel:"1080p",bitrate:3000000,audioBitrate:192},
+  91:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"144p",bitrate:100000,audioBitrate:48},
+  92:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"240p",bitrate:150000,audioBitrate:48},
+  93:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"360p",bitrate:500000,audioBitrate:128},
+  94:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"480p",bitrate:800000,audioBitrate:128},
+  95:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"720p",bitrate:1500000,audioBitrate:256},
+  96:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"1080p",bitrate:2500000,audioBitrate:256},
+  100:{mimeType:'audio/webm; codecs="VP8, vorbis"',qualityLabel:"360p",bitrate:null,audioBitrate:128},
+  101:{mimeType:'audio/webm; codecs="VP8, vorbis"',qualityLabel:"360p",bitrate:null,audioBitrate:192},
+  102:{mimeType:'audio/webm; codecs="VP8, vorbis"',qualityLabel:"720p",bitrate:null,audioBitrate:192},
+  120:{mimeType:'video/flv; codecs="H.264, aac"',qualityLabel:"720p",bitrate:2000000,audioBitrate:128},
+  127:{mimeType:'audio/ts; codecs="aac"',qualityLabel:null,bitrate:null,audioBitrate:96},
+  128:{mimeType:'audio/ts; codecs="aac"',qualityLabel:null,bitrate:null,audioBitrate:96},
+  132:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"240p",bitrate:150000,audioBitrate:48},
+  133:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"240p",bitrate:200000,audioBitrate:null},
+  134:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"360p",bitrate:300000,audioBitrate:null},
+  135:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"480p",bitrate:500000,audioBitrate:null},
+  136:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"720p",bitrate:1000000,audioBitrate:null},
+  137:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"1080p",bitrate:2500000,audioBitrate:null},
+  138:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"4320p",bitrate:13500000,audioBitrate:null},
+  139:{mimeType:'audio/mp4; codecs="aac"',qualityLabel:null,bitrate:null,audioBitrate:48},
+  140:{mimeType:'audio/m4a; codecs="aac"',qualityLabel:null,bitrate:null,audioBitrate:128},
+  141:{mimeType:'audio/mp4; codecs="aac"',qualityLabel:null,bitrate:null,audioBitrate:256},
+  151:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"720p",bitrate:50000,audioBitrate:24},
+  160:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"144p",bitrate:100000,audioBitrate:null},
+  171:{mimeType:'audio/webm; codecs="vorbis"',qualityLabel:null,bitrate:null,audioBitrate:128},
+  172:{mimeType:'audio/webm; codecs="vorbis"',qualityLabel:null,bitrate:null,audioBitrate:192},
+  231:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"480p",bitrate:500000,audioBitrate:null},
+  232:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"720p",bitrate:800000,audioBitrate:null},
+  242:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"240p",bitrate:100000,audioBitrate:null},
+  243:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"360p",bitrate:250000,audioBitrate:null},
+  244:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"480p",bitrate:500000,audioBitrate:null},
+  247:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"720p",bitrate:700000,audioBitrate:null},
+  248:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"1080p",bitrate:1500000,audioBitrate:null},
+  249:{mimeType:'audio/webm; codecs="opus"',qualityLabel:null,bitrate:null,audioBitrate:48},
+  250:{mimeType:'audio/webm; codecs="opus"',qualityLabel:null,bitrate:null,audioBitrate:64},
+  251:{mimeType:'audio/webm; codecs="opus"',qualityLabel:null,bitrate:null,audioBitrate:160},
+  264:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"1440p",bitrate:4000000,audioBitrate:null},
+  266:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"2160p",bitrate:12500000,audioBitrate:null},
+  270:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"1080p",bitrate:2500000,audioBitrate:null},
+  271:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"1440p",bitrate:9000000,audioBitrate:null},
+  272:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"4320p",bitrate:20000000,audioBitrate:null},
+  278:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"144p 30fps",bitrate:80000,audioBitrate:null},
+  298:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"720p",bitrate:3000000,audioBitrate:null},
+  299:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"1080p",bitrate:5500000,audioBitrate:null},
+  300:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"720p",bitrate:1318000,audioBitrate:48},
+  301:{mimeType:'video/ts; codecs="H.264, aac"',qualityLabel:"1080p",bitrate:3000000,audioBitrate:128},
+  302:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"720p HFR",bitrate:2500000,audioBitrate:null},
+  303:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"1080p HFR",bitrate:5000000,audioBitrate:null},
+  308:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"1440p HFR",bitrate:10000000,audioBitrate:null},
+  311:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"720p",bitrate:1250000,audioBitrate:null},
+  312:{mimeType:'video/mp4; codecs="H.264"',qualityLabel:"1080p",bitrate:2500000,audioBitrate:null},
+  313:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"2160p",bitrate:13000000,audioBitrate:null},
+  315:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"2160p HFR",bitrate:20000000,audioBitrate:null},
+  330:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"144p HDR, HFR",bitrate:80000,audioBitrate:null},
+  331:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"240p HDR, HFR",bitrate:100000,audioBitrate:null},
+  332:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"360p HDR, HFR",bitrate:250000,audioBitrate:null},
+  333:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"240p HDR, HFR",bitrate:500000,audioBitrate:null},
+  334:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"720p HDR, HFR",bitrate:1000000,audioBitrate:null},
+  335:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"1080p HDR, HFR",bitrate:1500000,audioBitrate:null},
+  336:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"1440p HDR, HFR",bitrate:5000000,audioBitrate:null},
+  337:{mimeType:'video/webm; codecs="VP9"',qualityLabel:"2160p HDR, HFR",bitrate:12000000,audioBitrate:null}
+};

package/lib/index.js

@@ -0,0 +1,169 @@
+const { PassThrough } = require("stream");
+const miniget = require("miniget");
+const m3u8stream = require("m3u8stream");
+const { parseTimestamp } = require("m3u8stream");
+const { request } = require("undici");
+const getInfo = require("./info");
+const utils = require("./utils");
+const formatUtils = require("./format-utils");
+const getPlaylistInfo = require('./playlist').getPlaylistInfo
+const urlUtils = require("./url-utils");
+const agent = require("./agents.js");
+const subtitle = require('./subtitle')
+const getPostInfo = require("./post");
+const { version } = require("../package.json");
+
+const createUndiciStream = (url, opts = {}) => {
+  const s = new PassThrough();
+
+  (async () => {
+    try {
+      const res = await request(url, {
+        method: "GET",
+        headers: opts.headers || {},
+        dispatcher: opts.dispatcher,
+      });
+
+      s.emit("response", { statusCode: res.statusCode, headers: res.headers });
+      if (res.statusCode < 200 || res.statusCode >= 400) {
+        const e = new Error(`Status code: ${res.statusCode}`);
+        e.statusCode = res.statusCode;
+        return s.emit("error", e);
+      }
+
+      for await (const c of res.body) {
+        if (s.destroyed) break;
+        s.push(c);
+      }
+      if (!s.destroyed) s.push(null);
+    } catch (e) {
+      if (!s.destroyed) s.emit("error", e);
+    }
+  })();
+
+  return s;
+};
+
+const createStream = opts => {
+  const s = new PassThrough({ highWaterMark: opts?.highWaterMark || 512 * 1024 });
+  s._destroy = () => (s.destroyed = true);
+  return s;
+};
+
+const pipeEvents = (req, stream, end) => {
+  ["abort", "request", "response", "error", "redirect", "retry", "reconnect"]
+    .forEach(e => req.prependListener(e, stream.emit.bind(stream, e)));
+  req.pipe(stream, { end });
+};
+
+const downloadFromInfoCallback = (stream, info, opts = {}) => {
+  const err = utils.playError(info.player_response);
+  if (err) return stream.emit("error", err);
+  if (!info.formats.length)
+    return stream.emit("error", Error("This video is unavailable"));
+
+  let format;
+  try {
+    format = formatUtils.chooseFormat(info.formats, opts);
+  } catch (e) {
+    return stream.emit("error", e);
+  }
+
+  stream.emit("info", info, format);
+  if (stream.destroyed) return;
+
+  let downloaded = 0;
+  const ondata = c => {
+    downloaded += c.length;
+    stream.emit("progress", c.length, downloaded);
+  };
+
+  utils.applyDefaultHeaders(opts);
+  opts.requestOptions ||= {};
+  opts.requestOptions.headers ||= {};
+
+  if (opts.agent) {
+    opts.requestOptions.agent = opts.agent.agent;
+    if (opts.agent.jar) {
+      utils.setPropInsensitive(
+        opts.requestOptions.headers,
+        "cookie",
+        opts.agent.jar.getCookieStringSync("https://www.youtube.com"),
+      );
+    }
+    if (opts.agent.localAddress) {
+      opts.requestOptions.localAddress = opts.agent.localAddress;
+    }
+  }
+
+  let req;
+
+  if (format.isHLS || format.isDashMPD) {
+    req = m3u8stream(format.url, {
+      begin: opts.begin || (format.isLive && Date.now()),
+      liveBuffer: opts.liveBuffer,
+      requestOptions: opts.requestOptions,
+      parser: format.isDashMPD ? "dash-mpd" : "m3u8",
+      id: format.itag,
+    });
+
+    req.on("progress", (seg, total) =>
+      stream.emit("progress", seg.size, seg.num, total),
+    );
+
+    pipeEvents(req, stream, true);
+  } else {
+    const ro = { ...opts.requestOptions };
+
+    if (opts.begin) format.url += `&begin=${parseTimestamp(opts.begin)}`;
+    if (opts.range) {
+      ro.headers = {
+        ...ro.headers,
+        Range: `bytes=${opts.range.start || 0}-${opts.range.end || ""}`,
+      };
+    }
+
+    req = miniget(format.url, ro);
+    req.on("data", ondata);
+    pipeEvents(req, stream, true);
+  }
+
+  stream._destroy = () => {
+    stream.destroyed = true;
+    req?.destroy?.();
+  };
+};
+
+const ytdl = (link, opts) => {
+  const s = createStream(opts);
+  ytdl.getInfo(link, opts).then(
+    info => downloadFromInfoCallback(s, info, opts),
+    e => s.emit("error", e),
+  );
+  return s;
+};
+
+module.exports = ytdl;
+
+ytdl.getBasicInfo = getInfo.getBasicInfo;
+ytdl.getInfo = getInfo.getInfo;
+ytdl.chooseFormat = formatUtils.chooseFormat;
+ytdl.getPostInfo = getPostInfo.getPostInfo;
+ytdl.filterFormats = formatUtils.filterFormats;
+ytdl.validateID = urlUtils.validateID;
+ytdl.getPlaylistInfo = getPlaylistInfo
+ytdl.validateURL = urlUtils.validateURL;
+ytdl.getSubtitles = subtitle.getSubtitles
+ytdl.getURLVideoID = urlUtils.getURLVideoID;
+ytdl.getVideoID = urlUtils.getVideoID;
+ytdl.createAgent = agent.createAgent;
+ytdl.createProxyAgent = agent.createProxyAgent;
+ytdl.cache = { info: getInfo.cache, watch: getInfo.watchPageCache };
+ytdl.version = version;
+
+ytdl.downloadFromInfo = (info, opts) => {
+  if (!info.full) throw Error("Invalid info object");
+  const s = createStream(opts);
+  setImmediate(() => downloadFromInfoCallback(s, info, opts));
+  return s;
+};