@hallelx/tytube 0.1.1

package/dist/index.js

@@ -0,0 +1,2523 @@
+// src/exceptions.ts
+var PytubeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PytubeError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var MaxRetriesExceeded = class extends PytubeError {
+  constructor(message = "Maximum number of retries exceeded") {
+    super(message);
+    this.name = "MaxRetriesExceeded";
+  }
+};
+var HTMLParseError = class extends PytubeError {
+  constructor(message = "HTML could not be parsed") {
+    super(message);
+    this.name = "HTMLParseError";
+  }
+};
+var ExtractError = class extends PytubeError {
+  constructor(message = "Data extraction failed") {
+    super(message);
+    this.name = "ExtractError";
+  }
+};
+var RegexMatchError = class extends ExtractError {
+  caller;
+  pattern;
+  constructor(caller, pattern) {
+    super(`${caller}: could not find match for ${pattern}`);
+    this.name = "RegexMatchError";
+    this.caller = caller;
+    this.pattern = pattern;
+  }
+};
+var VideoUnavailable = class extends PytubeError {
+  videoId;
+  constructor(videoId2, message) {
+    super(message ?? `${videoId2} is unavailable`);
+    this.name = "VideoUnavailable";
+    this.videoId = videoId2;
+  }
+};
+var AgeRestrictedError = class extends VideoUnavailable {
+  constructor(videoId2) {
+    super(videoId2, `${videoId2} is age restricted, and can't be accessed without logging in.`);
+    this.name = "AgeRestrictedError";
+  }
+};
+var LiveStreamError = class extends VideoUnavailable {
+  constructor(videoId2) {
+    super(videoId2, `${videoId2} is streaming live and cannot be loaded`);
+    this.name = "LiveStreamError";
+  }
+};
+var VideoPrivate = class extends VideoUnavailable {
+  constructor(videoId2) {
+    super(videoId2, `${videoId2} is a private video`);
+    this.name = "VideoPrivate";
+  }
+};
+var RecordingUnavailable = class extends VideoUnavailable {
+  constructor(videoId2) {
+    super(videoId2, `${videoId2} does not have a live stream recording available`);
+    this.name = "RecordingUnavailable";
+  }
+};
+var MembersOnly = class extends VideoUnavailable {
+  constructor(videoId2) {
+    super(videoId2, `${videoId2} is a members-only video`);
+    this.name = "MembersOnly";
+  }
+};
+var VideoRegionBlocked = class extends VideoUnavailable {
+  constructor(videoId2) {
+    super(videoId2, `${videoId2} is not available in your region`);
+    this.name = "VideoRegionBlocked";
+  }
+};
+
+// src/helpers.ts
+function regexSearch(pattern, source, group) {
+  const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+  const match = regex.exec(source);
+  if (!match) {
+    throw new RegexMatchError("regexSearch", pattern);
+  }
+  const value = match[group];
+  if (value === void 0) {
+    throw new RegexMatchError("regexSearch", pattern);
+  }
+  return value;
+}
+var NTFS_FORBIDDEN_CHARS = (() => {
+  const out = [];
+  for (let i = 0; i < 32; i++) out.push(String.fromCharCode(i));
+  return out;
+})();
+var FILENAME_FORBIDDEN_LITERALS = [
+  '"',
+  "#",
+  "$",
+  "%",
+  "'",
+  "*",
+  ",",
+  ".",
+  "/",
+  ":",
+  ";",
+  "<",
+  ">",
+  "?",
+  "\\",
+  "^",
+  "|",
+  "~"
+];
+function safeFilename(s, maxLength = 255) {
+  const forbidden = /* @__PURE__ */ new Set([...NTFS_FORBIDDEN_CHARS, ...FILENAME_FORBIDDEN_LITERALS]);
+  let out = "";
+  for (const ch of s) {
+    if (!forbidden.has(ch)) out += ch;
+  }
+  return out.slice(0, maxLength);
+}
+function uniqueify(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of items) {
+    if (seen.has(item)) continue;
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+
+// src/runtime/http.ts
+var DEFAULT_HEADERS = {
+  "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  "Accept-Language": "en-US,en;q=0.9"
+};
+function mergeHeaders(extra) {
+  return { ...DEFAULT_HEADERS, ...extra ?? {} };
+}
+function buildAbortSignal(opts) {
+  if (opts.signal && !opts.timeoutMs) return opts.signal;
+  if (!opts.signal && !opts.timeoutMs) return void 0;
+  const ctl = new AbortController();
+  if (opts.signal) {
+    if (opts.signal.aborted) ctl.abort(opts.signal.reason);
+    else opts.signal.addEventListener("abort", () => ctl.abort(opts.signal.reason), { once: true });
+  }
+  if (opts.timeoutMs) {
+    setTimeout(() => ctl.abort(new Error(`Request timed out after ${opts.timeoutMs}ms`)), opts.timeoutMs);
+  }
+  return ctl.signal;
+}
+async function doFetch(url, opts) {
+  const init = {
+    method: opts.method ?? "GET",
+    headers: mergeHeaders(opts.headers),
+    signal: buildAbortSignal(opts)
+  };
+  if (opts.body !== void 0) init.body = opts.body;
+  const res = await fetch(url, init);
+  return {
+    status: res.status,
+    headers: res.headers,
+    body: res.body,
+    text: () => res.text(),
+    arrayBuffer: () => res.arrayBuffer(),
+    json: () => res.json()
+  };
+}
+async function httpGet(url, opts = {}) {
+  return doFetch(url, { ...opts, method: "GET" });
+}
+async function httpPost(url, opts = {}) {
+  return doFetch(url, { ...opts, method: "POST" });
+}
+async function httpHead(url, opts = {}) {
+  return doFetch(url, { ...opts, method: "HEAD" });
+}
+
+// src/request.ts
+var DEFAULT_RANGE_SIZE = 9437184;
+async function get(url, opts = {}) {
+  const res = await httpGet(url, toFetchOpts(opts));
+  return res.text();
+}
+async function post(url, data, opts = {}) {
+  const headers = { ...opts.headers ?? {}, "Content-Type": "application/json" };
+  const body = data === void 0 ? "{}" : JSON.stringify(data);
+  const res = await httpPost(url, { ...toFetchOpts(opts), headers, body });
+  return res.text();
+}
+async function head(url, opts = {}) {
+  const res = await httpHead(url, toFetchOpts(opts));
+  const out = {};
+  res.headers.forEach((value, key) => {
+    out[key.toLowerCase()] = value;
+  });
+  return out;
+}
+async function filesize(url, opts = {}) {
+  const headers = await head(url, opts);
+  const len = headers["content-length"];
+  if (!len) throw new Error("Missing content-length header");
+  return parseInt(len, 10);
+}
+async function* stream(url, opts = {}) {
+  let fileSize = DEFAULT_RANGE_SIZE;
+  let downloaded = 0;
+  const maxRetries = opts.maxRetries ?? 0;
+  try {
+    const probe = await httpGet(`${url}&range=0-99999999999`, toFetchOpts(opts));
+    const cl = probe.headers.get("content-length");
+    if (cl) fileSize = parseInt(cl, 10);
+    if (probe.body) {
+      const reader = probe.body.getReader();
+      try {
+        while (true) {
+          const { done } = await reader.read();
+          if (done) break;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  } catch {
+  }
+  while (downloaded < fileSize) {
+    const stopPos = Math.min(downloaded + DEFAULT_RANGE_SIZE, fileSize) - 1;
+    const rangeUrl = `${url}&range=${downloaded}-${stopPos}`;
+    let attempt = 0;
+    let body = null;
+    while (true) {
+      if (attempt > maxRetries) throw new MaxRetriesExceeded();
+      try {
+        const res = await httpGet(rangeUrl, {
+          ...toFetchOpts(opts),
+          headers: { ...opts.headers ?? {}, Range: `bytes=${downloaded}-${stopPos}` }
+        });
+        body = res.body;
+        break;
+      } catch (err) {
+        if (isAbortError(err)) throw err;
+        attempt++;
+      }
+    }
+    if (!body) throw new MaxRetriesExceeded();
+    const reader = body.getReader();
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        if (!value) continue;
+        downloaded += value.byteLength;
+        yield value;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+}
+async function* seqStream(url, opts = {}) {
+  const parsed = new URL(url);
+  parsed.searchParams.set("sq", "0");
+  const headerUrl = parsed.toString();
+  const collected = [];
+  for await (const chunk of stream(headerUrl, opts)) {
+    yield chunk;
+    collected.push(chunk);
+  }
+  const segmentData = concatAll(collected);
+  const text = new TextDecoder("utf-8").decode(segmentData);
+  const segmentCountMatch = /Segment-Count:\s*(\d+)/.exec(text);
+  const segmentCountRaw = segmentCountMatch?.[1];
+  if (!segmentCountRaw) {
+    throw new RegexMatchError("seqStream", /Segment-Count:\s*(\d+)/);
+  }
+  const segmentCount = parseInt(segmentCountRaw, 10);
+  for (let seq = 1; seq <= segmentCount; seq++) {
+    parsed.searchParams.set("sq", String(seq));
+    const segUrl = parsed.toString();
+    yield* stream(segUrl, opts);
+  }
+}
+async function seqFilesize(url, opts = {}) {
+  const parsed = new URL(url);
+  parsed.searchParams.set("sq", "0");
+  const headerRes = await httpGet(parsed.toString(), toFetchOpts(opts));
+  const headerBytes = new Uint8Array(await headerRes.arrayBuffer());
+  let total = headerBytes.byteLength;
+  const text = new TextDecoder("utf-8").decode(headerBytes);
+  const match = /Segment-Count:\s*(\d+)/.exec(text);
+  const matchRaw = match?.[1];
+  if (!matchRaw) {
+    throw new RegexMatchError("seqFilesize", /Segment-Count:\s*(\d+)/);
+  }
+  const segmentCount = parseInt(matchRaw, 10);
+  for (let seq = 1; seq <= segmentCount; seq++) {
+    parsed.searchParams.set("sq", String(seq));
+    total += await filesize(parsed.toString(), opts);
+  }
+  return total;
+}
+function toFetchOpts(opts) {
+  return {
+    headers: opts.headers,
+    timeoutMs: opts.timeoutMs,
+    signal: opts.signal
+  };
+}
+function isAbortError(err) {
+  return err instanceof Error && (err.name === "AbortError" || err.message.includes("aborted"));
+}
+function concatAll(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.byteLength;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+
+// src/runtime/fs.ts
+var fsPromise = null;
+async function getFs() {
+  if (!fsPromise) {
+    fsPromise = (async () => {
+      try {
+        return await import('fs/promises');
+      } catch {
+        return null;
+      }
+    })();
+  }
+  return fsPromise;
+}
+async function ensureDir(dirPath) {
+  const fs = await getFs();
+  if (!fs) throw new Error("Filesystem unavailable in this runtime");
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function fileExists(filePath) {
+  const fs = await getFs();
+  if (!fs) return false;
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeText(filePath, text) {
+  const fs = await getFs();
+  if (!fs) throw new Error("Filesystem unavailable in this runtime");
+  await fs.writeFile(filePath, text, "utf-8");
+}
+
+// src/runtime/path.ts
+function joinPath(...segments) {
+  const parts = [];
+  for (const seg of segments) {
+    if (!seg) continue;
+    parts.push(seg.replace(/^[/\\]+|[/\\]+$/g, ""));
+  }
+  const joined = parts.filter((p) => p.length > 0).join("/");
+  if (segments[0]?.startsWith("/") || segments[0]?.startsWith("\\")) {
+    return "/" + joined;
+  }
+  return joined;
+}
+function isAbsolute(p) {
+  if (!p) return false;
+  if (p.startsWith("/")) return true;
+  if (/^[a-zA-Z]:[\\/]/.test(p)) return true;
+  return false;
+}
+async function resolveOutputDir(outputPath) {
+  const cwd = typeof process !== "undefined" && process.cwd ? process.cwd() : ".";
+  if (!outputPath) return cwd;
+  if (isAbsolute(outputPath)) return outputPath;
+  return joinPath(cwd, outputPath);
+}
+
+// src/captions.ts
+var Caption = class _Caption {
+  url;
+  name;
+  code;
+  constructor(track) {
+    this.url = track.baseUrl;
+    if (track.name?.simpleText) {
+      this.name = track.name.simpleText;
+    } else if (track.name?.runs) {
+      this.name = track.name.runs.find((r) => r.text)?.text ?? "";
+    } else {
+      this.name = "";
+    }
+    this.code = (track.vssId ?? track.languageCode ?? "").replace(/^\.+/, "");
+  }
+  async xmlCaptions() {
+    return get(this.url);
+  }
+  async jsonCaptions() {
+    const url = this.url.replace("fmt=srv3", "fmt=json3");
+    const text = await get(url);
+    return JSON.parse(text);
+  }
+  async generateSrtCaptions() {
+    return _Caption.xmlCaptionToSrt(await this.xmlCaptions());
+  }
+  static floatToSrtTimeFormat(d) {
+    const whole = Math.floor(d);
+    const fraction = d - whole;
+    const h = Math.floor(whole / 3600);
+    const m = Math.floor(whole % 3600 / 60);
+    const s = whole % 60;
+    const pad = (n, width = 2) => String(n).padStart(width, "0");
+    const ms = String(Math.round(fraction * 1e3)).padStart(3, "0");
+    return `${pad(h)}:${pad(m)}:${pad(s)},${ms}`;
+  }
+  static xmlCaptionToSrt(xml) {
+    const segments = [];
+    let seq = 1;
+    const re = /<text\s+([^>]*?)>([\s\S]*?)<\/text>/g;
+    let match;
+    while ((match = re.exec(xml)) !== null) {
+      const attrs = match[1] ?? "";
+      const rawText = match[2] ?? "";
+      const startMatch = /\bstart\s*=\s*"([^"]+)"/.exec(attrs);
+      const durMatch = /\bdur\s*=\s*"([^"]+)"/.exec(attrs);
+      if (!startMatch) continue;
+      const start = parseFloat(startMatch[1]);
+      const dur = durMatch ? parseFloat(durMatch[1]) : 0;
+      const end = start + dur;
+      const text = decodeXmlEntities(rawText.replace(/\n/g, " ").replace(/  +/g, " "));
+      segments.push(
+        `${seq}
+${_Caption.floatToSrtTimeFormat(start)} --> ${_Caption.floatToSrtTimeFormat(end)}
+${text}
+`
+      );
+      seq++;
+    }
+    return segments.join("\n").trim();
+  }
+  /**
+   * Write the caption track to disk as SRT or XML.
+   * Returns the absolute path of the written file.
+   */
+  async download(title, opts = {}) {
+    const srt = opts.srt ?? true;
+    let stem = title;
+    if (stem.endsWith(".srt") || stem.endsWith(".xml")) {
+      stem = stem.split(".").slice(0, -1).join(".");
+    }
+    if (opts.filenamePrefix) stem = `${safeFilename(opts.filenamePrefix)}${stem}`;
+    stem = safeFilename(stem);
+    stem += ` (${this.code})`;
+    stem += srt ? ".srt" : ".xml";
+    const dir = await resolveOutputDir(opts.outputPath);
+    await ensureDir(dir);
+    const filePath = joinPath(dir, stem);
+    const contents = srt ? await this.generateSrtCaptions() : await this.xmlCaptions();
+    await writeText(filePath, contents);
+    return filePath;
+  }
+  toString() {
+    return `<Caption lang="${this.name}" code="${this.code}">`;
+  }
+};
+function decodeXmlEntities(input) {
+  return input.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&#(\d+);/g, (_, code) => String.fromCharCode(parseInt(code, 10))).replace(/&#x([0-9a-fA-F]+);/g, (_, code) => String.fromCharCode(parseInt(code, 16)));
+}
+
+// src/parser.ts
+var CONTEXT_CLOSERS = {
+  "{": "}",
+  "[": "]",
+  '"': '"',
+  "/": "/"
+  // javascript regex
+};
+var REGEX_PRECEDING_CHARS = /* @__PURE__ */ new Set([
+  "(",
+  ",",
+  "=",
+  ":",
+  "[",
+  "!",
+  "&",
+  "|",
+  "?",
+  "{",
+  "}",
+  ";"
+]);
+function findObjectFromStartpoint(source, startPoint) {
+  const html = source.slice(startPoint);
+  const first = html[0];
+  if (first !== "{" && first !== "[") {
+    throw new HTMLParseError(`Invalid start point. Start of HTML:
+${html.slice(0, 20)}`);
+  }
+  const stack = [first];
+  let lastChar = "{";
+  let currChar = null;
+  let i = 1;
+  while (i < html.length) {
+    if (stack.length === 0) break;
+    if (currChar !== null && currChar !== " " && currChar !== "\n") {
+      lastChar = currChar;
+    }
+    currChar = html[i] ?? null;
+    if (currChar === null) break;
+    const currContext = stack[stack.length - 1];
+    if (currChar === CONTEXT_CLOSERS[currContext]) {
+      stack.pop();
+      i += 1;
+      continue;
+    }
+    if (currContext === '"' || currContext === "/") {
+      if (currChar === "\\") {
+        i += 2;
+        continue;
+      }
+    } else {
+      if (currChar in CONTEXT_CLOSERS) {
+        const isRegexLike = currChar === "/" && (lastChar === null || !REGEX_PRECEDING_CHARS.has(lastChar));
+        if (!isRegexLike) {
+          stack.push(currChar);
+        }
+      }
+    }
+    i += 1;
+  }
+  return html.slice(0, i);
+}
+function parseForObjectString(html, precedingRegex) {
+  const match = precedingRegex.exec(html);
+  if (!match) throw new HTMLParseError(`No matches for regex ${precedingRegex}`);
+  const startIndex = match.index + match[0].length;
+  return findObjectFromStartpoint(html, startIndex);
+}
+function parseForObject(html, precedingRegex) {
+  const objectString = parseForObjectString(html, precedingRegex);
+  try {
+    return JSON.parse(objectString);
+  } catch (err) {
+    throw new HTMLParseError(`Could not parse object: ${err.message}`);
+  }
+}
+function parseForAllObjects(html, precedingRegex) {
+  const flags = precedingRegex.flags.includes("g") ? precedingRegex.flags : `${precedingRegex.flags}g`;
+  const re = new RegExp(precedingRegex.source, flags);
+  const out = [];
+  let match;
+  while ((match = re.exec(html)) !== null) {
+    const startIndex = match.index + match[0].length;
+    try {
+      const objStr = findObjectFromStartpoint(html, startIndex);
+      out.push(JSON.parse(objStr));
+    } catch {
+      continue;
+    }
+    if (re.lastIndex === match.index) re.lastIndex++;
+  }
+  if (out.length === 0) {
+    throw new HTMLParseError(`No matches for regex ${precedingRegex}`);
+  }
+  return out;
+}
+
+// src/cipher.ts
+function escapeRegex(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var SIGNATURE_FUNCTION_PATTERNS = [
+  // Most reliable: the function literally splits its arg into a char array.
+  // This is the core fingerprint of every YouTube cipher function.
+  /(?:\b|[^a-zA-Z0-9$])([a-zA-Z0-9$_]{1,3})\s*=\s*function\(\s*a\s*\)\s*\{\s*a\s*=\s*a\.split\(\s*""\s*\)/,
+  /(?:\b|[^a-zA-Z0-9$])([a-zA-Z0-9$_]{1,4})\s*=\s*function\(\s*a\s*\)\s*\{\s*a\s*=\s*a\.split\(\s*""\s*\)/,
+  /([a-zA-Z0-9$_]+)\s*=\s*function\(\s*a\s*\)\s*\{\s*a\s*=\s*a\.split\(\s*""\s*\)/,
+  // Function-statement form: function NAME(a){a=a.split("")...}
+  /function\s+([a-zA-Z0-9$_]+)\s*\(\s*a\s*\)\s*\{\s*a\s*=\s*a\.split\(\s*""\s*\)/,
+  // Older / call-site forms (kept as fallbacks).
+  /(["'])signature\1\s*,\s*([a-zA-Z0-9$_]+)\(/,
+  /\.sig\|\|([a-zA-Z0-9$_]+)\(/,
+  /\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*([a-zA-Z0-9$_]+)\(/,
+  /\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*([a-zA-Z0-9$_]+)\(/,
+  /yt\.akamaized\.net\/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*([a-zA-Z0-9$_]+)\(/,
+  /\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*([a-zA-Z0-9$_]+)\(/,
+  /\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*([a-zA-Z0-9$_]+)\(/,
+  /\bc\s*&&\s*a\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*([a-zA-Z0-9$_]+)\(/,
+  /\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*([a-zA-Z0-9$_]+)\(/
+];
+var FORBIDDEN_FUNCTION_NAMES = /* @__PURE__ */ new Set([
+  "decodeURIComponent",
+  "encodeURIComponent",
+  "JSON",
+  "Math",
+  "Object",
+  "String",
+  "Number",
+  "Array",
+  "parseInt",
+  "parseFloat",
+  "function",
+  "return",
+  "typeof",
+  "undefined",
+  "null",
+  "true",
+  "false"
+]);
+function isPlausibleFunctionName(name) {
+  if (!name) return false;
+  if (!/^[a-zA-Z0-9$_]+$/.test(name)) return false;
+  if (FORBIDDEN_FUNCTION_NAMES.has(name)) return false;
+  if (name.length > 8) return false;
+  return true;
+}
+function getInitialFunctionName(js) {
+  for (const pattern of SIGNATURE_FUNCTION_PATTERNS) {
+    const globalPattern = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
+    let m;
+    while ((m = globalPattern.exec(js)) !== null) {
+      for (let i = 1; i < m.length; i++) {
+        const candidate = m[i];
+        if (candidate && isPlausibleFunctionName(candidate)) return candidate;
+      }
+      if (globalPattern.lastIndex === m.index) globalPattern.lastIndex++;
+    }
+  }
+  throw new RegexMatchError("getInitialFunctionName", "multiple");
+}
+function getThrottlingFunctionName(js) {
+  const pattern = /a\.[a-zA-Z]\s*&&\s*\([a-z]\s*=\s*a\.get\("n"\)\)\s*&&\s*\([a-z]\s*=\s*([a-zA-Z0-9$]+)(\[\d+\])?\([a-z]\)/;
+  const m = pattern.exec(js);
+  if (!m) throw new RegexMatchError("getThrottlingFunctionName", pattern);
+  const fnName = m[1];
+  const idxRaw = m[2];
+  if (!idxRaw) return fnName;
+  const idx = parseInt(idxRaw.replace(/\[|\]/g, ""), 10);
+  const arrRegex = new RegExp(`var\\s+${escapeRegex(fnName)}\\s*=\\s*\\[(.+?)\\];`);
+  const arrMatch = arrRegex.exec(js);
+  if (!arrMatch) return fnName;
+  const elements = arrMatch[1].split(",").map((s) => s.trim());
+  return elements[idx] ?? fnName;
+}
+function extractHelperObjectVarName(js, sigFuncName) {
+  const fnBody = extractSignatureFunctionBody(js, sigFuncName);
+  const m = /(?:^|;|\{)\s*([a-zA-Z0-9$_]+)\s*\.\s*[a-zA-Z0-9$_]+\s*\(/.exec(fnBody);
+  if (!m) throw new RegexMatchError("extractHelperObjectVarName", /(\w+)\./);
+  return m[1];
+}
+function extractSignatureFunctionBody(js, sigFuncName) {
+  const headerRegex = new RegExp(
+    `(?:var\\s+)?${escapeRegex(sigFuncName)}\\s*=\\s*function\\s*\\(\\s*([a-zA-Z0-9_$]+)\\s*\\)\\s*`
+  );
+  const m = headerRegex.exec(js);
+  if (!m) {
+    const altRegex = new RegExp(
+      `function\\s+${escapeRegex(sigFuncName)}\\s*\\(\\s*([a-zA-Z0-9_$]+)\\s*\\)\\s*`
+    );
+    const m2 = altRegex.exec(js);
+    if (!m2) throw new RegexMatchError("extractSignatureFunctionBody", headerRegex);
+    return findObjectFromStartpoint(js, m2.index + m2[0].length);
+  }
+  return findObjectFromStartpoint(js, m.index + m[0].length);
+}
+function extractSignatureFunctionFullSource(js, sigFuncName) {
+  const headerRegex = new RegExp(
+    `(?:var\\s+)?${escapeRegex(sigFuncName)}\\s*=\\s*function\\s*\\(\\s*([a-zA-Z0-9_$]+)\\s*\\)\\s*`
+  );
+  let m = headerRegex.exec(js);
+  let argName;
+  let bodyStart;
+  if (m) {
+    argName = m[1];
+    bodyStart = m.index + m[0].length;
+  } else {
+    const altRegex = new RegExp(
+      `function\\s+${escapeRegex(sigFuncName)}\\s*\\(\\s*([a-zA-Z0-9_$]+)\\s*\\)\\s*`
+    );
+    const m2 = altRegex.exec(js);
+    if (!m2) throw new RegexMatchError("extractSignatureFunctionFullSource", headerRegex);
+    argName = m2[1];
+    bodyStart = m2.index + m2[0].length;
+  }
+  const body = findObjectFromStartpoint(js, bodyStart);
+  return { argName, body };
+}
+function extractHelperObjectSource(js, varName) {
+  const re = new RegExp(`var\\s+${escapeRegex(varName)}\\s*=\\s*`);
+  const m = re.exec(js);
+  if (!m) throw new RegexMatchError("extractHelperObjectSource", re);
+  return findObjectFromStartpoint(js, m.index + m[0].length);
+}
+function extractThrottlingFunctionSource(js, fnName) {
+  const headerRegex = new RegExp(
+    `(?:var\\s+)?${escapeRegex(fnName)}\\s*=\\s*function\\s*\\(\\s*([a-zA-Z0-9_$]+)\\s*\\)\\s*`
+  );
+  const m = headerRegex.exec(js);
+  if (!m) {
+    const altRegex = new RegExp(
+      `function\\s+${escapeRegex(fnName)}\\s*\\(\\s*([a-zA-Z0-9_$]+)\\s*\\)\\s*`
+    );
+    const m2 = altRegex.exec(js);
+    if (!m2) throw new RegexMatchError("extractThrottlingFunctionSource", headerRegex);
+    return { argName: m2[1], body: findObjectFromStartpoint(js, m2.index + m2[0].length) };
+  }
+  return { argName: m[1], body: findObjectFromStartpoint(js, m.index + m[0].length) };
+}
+var JsExecCipher = class {
+  sigFn;
+  nFn;
+  cachedN = null;
+  constructor(js) {
+    const sigName = getInitialFunctionName(js);
+    const helperVar = extractHelperObjectVarName(js, sigName);
+    const helperSrc = extractHelperObjectSource(js, helperVar);
+    const { argName: sigArg, body: sigBody } = extractSignatureFunctionFullSource(js, sigName);
+    try {
+      this.sigFn = new Function(
+        "input",
+        `var ${helperVar} = ${helperSrc};
+         var ${sigName} = function(${sigArg}) ${sigBody};
+         return ${sigName}(input);`
+      );
+    } catch (err) {
+      throw new ExtractError(`Failed to compile signature function: ${err.message}`);
+    }
+    const nName = getThrottlingFunctionName(js);
+    const { argName: nArg, body: nBody } = extractThrottlingFunctionSource(js, nName);
+    try {
+      this.nFn = new Function(
+        "input",
+        `var ${nName} = function(${nArg}) ${nBody};
+         return ${nName}(input);`
+      );
+    } catch (err) {
+      throw new ExtractError(`Failed to compile throttling function: ${err.message}`);
+    }
+  }
+  getSignature(cipheredSignature) {
+    return this.sigFn(cipheredSignature);
+  }
+  calculateN(initialN) {
+    if (this.cachedN && this.cachedN.input === initialN) return this.cachedN.output;
+    const out = this.nFn(initialN);
+    this.cachedN = { input: initialN, output: out };
+    return out;
+  }
+};
+var canEval = (() => {
+  try {
+    new Function("return 1")();
+    return true;
+  } catch {
+    return false;
+  }
+})();
+function createCipher(js) {
+  if (canEval) return new JsExecCipher(js);
+  throw new ExtractError(
+    "eval is not available in this runtime; use the regex-port fallback (cipher-fallback.ts)."
+  );
+}
+
+// src/metadata.ts
+var YouTubeMetadata = class {
+  raw;
+  groups;
+  constructor(rawRows) {
+    this.raw = rawRows;
+    const groups = [{}];
+    for (const el of rawRows) {
+      const title = el.title?.simpleText;
+      if (!title) continue;
+      const contents = el.contents?.[0];
+      if (!contents) continue;
+      const value = contents.simpleText ?? contents.runs?.[0]?.text;
+      if (value === void 0) continue;
+      groups[groups.length - 1][title] = value;
+      if (el.hasDividerLine) groups.push({});
+    }
+    if (groups.length > 0 && Object.keys(groups[groups.length - 1]).length === 0) {
+      groups.pop();
+    }
+    this.groups = groups;
+  }
+  get rawMetadata() {
+    return this.raw;
+  }
+  get metadata() {
+    return this.groups;
+  }
+  at(index) {
+    return this.groups[index];
+  }
+  [Symbol.iterator]() {
+    return this.groups[Symbol.iterator]();
+  }
+  toJSON() {
+    return this.groups;
+  }
+  toString() {
+    return JSON.stringify(this.groups);
+  }
+};
+
+// src/extract.ts
+function videoId(url) {
+  return regexSearch(/(?:v=|\/)([0-9A-Za-z_-]{11}).*/, url, 1);
+}
+function playlistId(url) {
+  const u = new URL(url);
+  const list = u.searchParams.get("list");
+  if (!list) throw new RegexMatchError("playlistId", "list query param");
+  return list;
+}
+function channelName(url) {
+  const patterns = [
+    /(?:\/(c)\/([%\d\w_\-]+)(\/.*)?)/,
+    /(?:\/(channel)\/([%\w\d_\-]+)(\/.*)?)/,
+    /(?:\/(u)\/([%\d\w_\-]+)(\/.*)?)/,
+    /(?:\/(user)\/([%\w\d_\-]+)(\/.*)?)/
+  ];
+  for (const pattern of patterns) {
+    const m = pattern.exec(url);
+    if (m) {
+      return `/${m[1]}/${m[2]}`;
+    }
+  }
+  throw new RegexMatchError("channelName", "patterns");
+}
+function publishDate(watchHtml) {
+  try {
+    const result = regexSearch(
+      /(?<=itemprop="datePublished" content=")\d{4}-\d{2}-\d{2}/,
+      watchHtml,
+      0
+    );
+    return /* @__PURE__ */ new Date(`${result}T00:00:00Z`);
+  } catch {
+    return null;
+  }
+}
+function isAgeRestricted(watchHtml) {
+  return /og:restrictions:age/.test(watchHtml);
+}
+function playabilityStatus(watchHtml) {
+  const playerResponse = initialPlayerResponse(watchHtml);
+  const statusDict = playerResponse["playabilityStatus"] ?? {};
+  if ("liveStreamability" in statusDict) {
+    return { status: "LIVE_STREAM", reasons: ["Video is a live stream."] };
+  }
+  if ("status" in statusDict) {
+    if ("reason" in statusDict) {
+      return { status: String(statusDict["status"]), reasons: [String(statusDict["reason"])] };
+    }
+    if ("messages" in statusDict) {
+      return {
+        status: String(statusDict["status"]),
+        reasons: statusDict["messages"].map((m) => m === null ? null : String(m))
+      };
+    }
+  }
+  return { status: null, reasons: [null] };
+}
+function jsUrl(html) {
+  let baseJs;
+  try {
+    const config = getYtplayerConfig(html);
+    baseJs = config.assets?.js;
+  } catch {
+  }
+  if (!baseJs) {
+    baseJs = getYtplayerJs(html);
+  }
+  return `https://youtube.com${baseJs}`;
+}
+function getYtplayerJs(html) {
+  const patterns = [/(\/s\/player\/[\w\d]+\/[\w\d_/.]+\/base\.js)/];
+  for (const pattern of patterns) {
+    const m = pattern.exec(html);
+    if (m) return m[1];
+  }
+  throw new RegexMatchError("getYtplayerJs", "jsUrlPatterns");
+}
+function getYtplayerConfig(html) {
+  const configPatterns = [
+    /ytplayer\.config\s*=\s*/,
+    /ytInitialPlayerResponse\s*=\s*/
+  ];
+  for (const pattern of configPatterns) {
+    try {
+      return parseForObject(html, pattern);
+    } catch {
+      continue;
+    }
+  }
+  const setConfigPatterns = [/yt\.setConfig\(.*['"]PLAYER_CONFIG['"]:\s*/];
+  for (const pattern of setConfigPatterns) {
+    try {
+      return parseForObject(html, pattern);
+    } catch {
+      continue;
+    }
+  }
+  throw new RegexMatchError("getYtplayerConfig", "config_patterns, setconfig_patterns");
+}
+function getYtcfg(html) {
+  const merged = {};
+  const ytcfgPatterns = [/ytcfg\s=\s/, /ytcfg\.set\(/];
+  for (const pattern of ytcfgPatterns) {
+    try {
+      const found = parseForAllObjects(html, pattern);
+      for (const obj of found) Object.assign(merged, obj);
+    } catch {
+      continue;
+    }
+  }
+  if (Object.keys(merged).length > 0) return merged;
+  throw new RegexMatchError("getYtcfg", "ytcfgPatterns");
+}
+function initialData(watchHtml) {
+  const patterns = [
+    /window\[['"]ytInitialData['"]\]\s*=\s*/,
+    /ytInitialData\s*=\s*/
+  ];
+  for (const pattern of patterns) {
+    try {
+      return parseForObject(watchHtml, pattern);
+    } catch {
+      continue;
+    }
+  }
+  throw new RegexMatchError("initialData", "initialDataPattern");
+}
+function initialPlayerResponse(watchHtml) {
+  const patterns = [
+    /window\[['"]ytInitialPlayerResponse['"]\]\s*=\s*/,
+    /ytInitialPlayerResponse\s*=\s*/
+  ];
+  for (const pattern of patterns) {
+    try {
+      return parseForObject(watchHtml, pattern);
+    } catch {
+      continue;
+    }
+  }
+  throw new RegexMatchError("initialPlayerResponse", "initialPlayerResponsePattern");
+}
+function mimeTypeCodec(input) {
+  const pattern = /(\w+\/\w+);\s*codecs="([a-zA-Z\-0-9.,\s]*)"/;
+  const m = pattern.exec(input);
+  if (!m) throw new RegexMatchError("mimeTypeCodec", pattern);
+  const codecs = m[2].split(",").map((c) => c.trim());
+  return { mimeType: m[1], codecs };
+}
+function applyDescrambler(streamData) {
+  if ("url" in streamData && streamData.url !== void 0) return null;
+  const formats = [];
+  if (streamData.formats) formats.push(...streamData.formats);
+  if (streamData.adaptiveFormats) formats.push(...streamData.adaptiveFormats);
+  for (const data of formats) {
+    if (!data.url) {
+      const cipher = data.signatureCipher ?? data.cipher;
+      if (cipher) {
+        const params = new URLSearchParams(cipher);
+        const u = params.get("url");
+        const s = params.get("s");
+        if (u) data.url = u;
+        if (s !== null) data.s = s;
+      }
+    }
+    data.is_otf = data.type === "FORMAT_STREAM_TYPE_OTF";
+  }
+  return formats;
+}
+function manifestNeedsCipher(streamManifest) {
+  return streamManifest.some((s) => s.s !== void 0 && s.s !== null);
+}
+function needsThrottlingTransform(url) {
+  try {
+    const u = new URL(url);
+    return u.searchParams.has("n") && !u.searchParams.has("ratebypass");
+  } catch {
+    return false;
+  }
+}
+function applySignature(streamManifest, vidInfo, cipher) {
+  for (let i = 0; i < streamManifest.length; i++) {
+    const stream2 = streamManifest[i];
+    if (!stream2) continue;
+    const url = stream2.url;
+    if (!url) {
+      const liveStream = vidInfo["playabilityStatus"]?.["liveStreamability"];
+      if (liveStream) throw new LiveStreamError("UNKNOWN");
+      continue;
+    }
+    url.includes("signature") || !stream2.s && (url.includes("&sig=") || url.includes("&lsig="));
+    if (stream2.s !== void 0 && stream2.s !== null && cipher) {
+      const signature = cipher.getSignature(stream2.s);
+      const parsed = new URL(url);
+      parsed.searchParams.set("sig", signature);
+      if (needsThrottlingTransform(url)) {
+        const initialN = parsed.searchParams.get("n");
+        if (initialN) {
+          try {
+            parsed.searchParams.set("n", cipher.calculateN(initialN));
+          } catch {
+          }
+        }
+      }
+      stream2.url = `${parsed.origin}${parsed.pathname}?${parsed.searchParams.toString()}`;
+    } else if (cipher && needsThrottlingTransform(url)) {
+      try {
+        const parsed = new URL(url);
+        const initialN = parsed.searchParams.get("n");
+        if (initialN) {
+          parsed.searchParams.set("n", cipher.calculateN(initialN));
+          stream2.url = `${parsed.origin}${parsed.pathname}?${parsed.searchParams.toString()}`;
+        }
+      } catch {
+      }
+    }
+  }
+}
+function metadata(initialDataObj) {
+  try {
+    const root = initialDataObj;
+    const rows = root?.contents?.twoColumnWatchNextResults?.results?.results?.contents?.[1]?.videoSecondaryInfoRenderer?.metadataRowContainer?.metadataRowContainerRenderer?.rows ?? [];
+    const filtered = rows.filter((x) => x && "metadataRowRenderer" in x);
+    const mapped = filtered.map((x) => x.metadataRowRenderer);
+    return new YouTubeMetadata(mapped);
+  } catch {
+    return new YouTubeMetadata([]);
+  }
+}
+
+// src/innertube.ts
+var K = (suffix) => ["AI", "za", "Sy", suffix].join("");
+var KEYS = {
+  web: K("AO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8"),
+  android: K("A8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w"),
+  ios: K("B-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc"),
+  webMusic: K("C9XL3ZjWddXya6X74dJoCTL-WEYFDNX30"),
+  androidMusic: K("AOghZGza2MQSZkY_zfZ370N-PUdXEo8AI"),
+  iosMusic: K("BAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s"),
+  androidCreator: K("D_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8")
+};
+var DEFAULT_CLIENTS = {
+  WEB: {
+    context: {
+      client: {
+        clientName: "WEB",
+        clientVersion: "2.20241126.01.00",
+        hl: "en",
+        gl: "US",
+        userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36,gzip(gfe)"
+      }
+    },
+    header: {
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+      "X-YouTube-Client-Name": "1",
+      "X-YouTube-Client-Version": "2.20241126.01.00",
+      Origin: "https://www.youtube.com"
+    },
+    apiKey: KEYS.web
+  },
+  ANDROID: {
+    context: {
+      client: {
+        clientName: "ANDROID",
+        clientVersion: "19.44.38",
+        androidSdkVersion: 30,
+        osName: "Android",
+        osVersion: "14",
+        platform: "MOBILE",
+        hl: "en",
+        gl: "US",
+        userAgent: "com.google.android.youtube/19.44.38 (Linux; U; Android 14) gzip"
+      }
+    },
+    header: {
+      "User-Agent": "com.google.android.youtube/19.44.38 (Linux; U; Android 14) gzip",
+      "X-YouTube-Client-Name": "3",
+      "X-YouTube-Client-Version": "19.44.38"
+    },
+    apiKey: KEYS.android
+  },
+  IOS: {
+    context: {
+      client: {
+        clientName: "IOS",
+        clientVersion: "19.45.4",
+        deviceMake: "Apple",
+        deviceModel: "iPhone16,2",
+        osName: "iPhone",
+        osVersion: "18.1.0.22B83",
+        platform: "MOBILE",
+        hl: "en",
+        gl: "US",
+        userAgent: "com.google.ios.youtube/19.45.4 (iPhone16,2; U; CPU iOS 18_1_0 like Mac OS X)"
+      }
+    },
+    header: {
+      "User-Agent": "com.google.ios.youtube/19.45.4 (iPhone16,2; U; CPU iOS 18_1_0 like Mac OS X)",
+      "X-YouTube-Client-Name": "5",
+      "X-YouTube-Client-Version": "19.45.4"
+    },
+    apiKey: KEYS.ios
+  },
+  TV_EMBED: {
+    context: {
+      client: {
+        clientName: "TVHTML5_SIMPLY_EMBEDDED_PLAYER",
+        clientVersion: "2.0",
+        hl: "en",
+        gl: "US"
+      }
+    },
+    header: {
+      "User-Agent": "Mozilla/5.0 (PlayStation; PlayStation 4/12.00) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Safari/605.1.15",
+      "X-YouTube-Client-Name": "85",
+      "X-YouTube-Client-Version": "2.0"
+    },
+    apiKey: KEYS.web
+  },
+  WEB_EMBED: {
+    context: {
+      client: {
+        clientName: "WEB_EMBEDDED_PLAYER",
+        clientVersion: "1.20241201.00.00",
+        clientScreen: "EMBED",
+        hl: "en",
+        gl: "US"
+      }
+    },
+    header: {
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+      "X-YouTube-Client-Name": "56",
+      "X-YouTube-Client-Version": "1.20241201.00.00"
+    },
+    apiKey: KEYS.web
+  },
+  ANDROID_EMBED: {
+    context: {
+      client: {
+        clientName: "ANDROID_EMBEDDED_PLAYER",
+        clientVersion: "19.44.38",
+        clientScreen: "EMBED",
+        androidSdkVersion: 30,
+        osName: "Android",
+        osVersion: "14",
+        platform: "MOBILE",
+        hl: "en",
+        gl: "US"
+      }
+    },
+    header: {
+      "User-Agent": "com.google.android.youtube/19.44.38 (Linux; U; Android 14) gzip",
+      "X-YouTube-Client-Name": "55",
+      "X-YouTube-Client-Version": "19.44.38"
+    },
+    apiKey: KEYS.android
+  },
+  IOS_EMBED: {
+    context: {
+      client: {
+        clientName: "IOS_MESSAGES_EXTENSION",
+        clientVersion: "19.45.4",
+        deviceMake: "Apple",
+        deviceModel: "iPhone16,2",
+        osName: "iPhone",
+        osVersion: "18.1.0.22B83"
+      }
+    },
+    header: {
+      "User-Agent": "com.google.ios.youtube/19.45.4 (iPhone16,2; U; CPU iOS 18_1_0 like Mac OS X)",
+      "X-YouTube-Client-Name": "66",
+      "X-YouTube-Client-Version": "19.45.4"
+    },
+    apiKey: KEYS.ios
+  },
+  MWEB: {
+    context: {
+      client: {
+        clientName: "MWEB",
+        clientVersion: "2.20241202.07.00",
+        hl: "en",
+        gl: "US"
+      }
+    },
+    header: {
+      "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Mobile/15E148 Safari/604.1",
+      "X-YouTube-Client-Name": "2",
+      "X-YouTube-Client-Version": "2.20241202.07.00"
+    },
+    apiKey: KEYS.web
+  },
+  WEB_MUSIC: {
+    context: { client: { clientName: "WEB_REMIX", clientVersion: "1.20241127.01.00", hl: "en", gl: "US" } },
+    header: {
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+      "X-YouTube-Client-Name": "67",
+      "X-YouTube-Client-Version": "1.20241127.01.00"
+    },
+    apiKey: KEYS.webMusic
+  },
+  ANDROID_MUSIC: {
+    context: {
+      client: {
+        clientName: "ANDROID_MUSIC",
+        clientVersion: "7.27.52",
+        androidSdkVersion: 30,
+        osName: "Android",
+        osVersion: "14",
+        hl: "en",
+        gl: "US"
+      }
+    },
+    header: {
+      "User-Agent": "com.google.android.apps.youtube.music/7.27.52 (Linux; U; Android 14) gzip",
+      "X-YouTube-Client-Name": "21",
+      "X-YouTube-Client-Version": "7.27.52"
+    },
+    apiKey: KEYS.androidMusic
+  },
+  IOS_MUSIC: {
+    context: {
+      client: {
+        clientName: "IOS_MUSIC",
+        clientVersion: "7.27.0",
+        deviceMake: "Apple",
+        deviceModel: "iPhone16,2",
+        osName: "iPhone",
+        osVersion: "18.1.0.22B83"
+      }
+    },
+    header: {
+      "User-Agent": "com.google.ios.youtubemusic/7.27.0 (iPhone16,2; U; CPU iOS 18_1_0 like Mac OS X)",
+      "X-YouTube-Client-Name": "26",
+      "X-YouTube-Client-Version": "7.27.0"
+    },
+    apiKey: KEYS.iosMusic
+  },
+  WEB_CREATOR: {
+    context: {
+      client: { clientName: "WEB_CREATOR", clientVersion: "1.20241203.01.00", hl: "en", gl: "US" }
+    },
+    header: {
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+      "X-YouTube-Client-Name": "62",
+      "X-YouTube-Client-Version": "1.20241203.01.00"
+    },
+    apiKey: KEYS.web
+  },
+  ANDROID_CREATOR: {
+    context: {
+      client: {
+        clientName: "ANDROID_CREATOR",
+        clientVersion: "24.45.100",
+        androidSdkVersion: 30,
+        osName: "Android",
+        osVersion: "14"
+      }
+    },
+    header: {
+      "User-Agent": "com.google.android.apps.youtube.creator/24.45.100 (Linux; U; Android 14) gzip",
+      "X-YouTube-Client-Name": "14",
+      "X-YouTube-Client-Version": "24.45.100"
+    },
+    apiKey: KEYS.androidCreator
+  },
+  IOS_CREATOR: {
+    context: {
+      client: {
+        clientName: "IOS_CREATOR",
+        clientVersion: "24.45.100",
+        deviceMake: "Apple",
+        deviceModel: "iPhone16,2",
+        osName: "iPhone",
+        osVersion: "18.1.0.22B83"
+      }
+    },
+    header: {
+      "User-Agent": "com.google.ios.ytcreator/24.45.100 (iPhone16,2; U; CPU iOS 18_1_0 like Mac OS X)",
+      "X-YouTube-Client-Name": "15",
+      "X-YouTube-Client-Version": "24.45.100"
+    },
+    apiKey: KEYS.web
+  }
+};
+var OAUTH_CLIENT_ID = "861556708454-d6dlm3lh05idd8npek18k6be8ba3oc68.apps.googleusercontent.com";
+var OAUTH_CLIENT_SECRET = "SboVhoG9s0rNafixCSGGKXAT";
+var InnerTube = class {
+  context;
+  header;
+  apiKey;
+  useOauth;
+  onAuthPrompt;
+  accessToken = null;
+  refreshToken = null;
+  expires = null;
+  constructor(opts = {}) {
+    const clientName = opts.client ?? "ANDROID_MUSIC";
+    const cfg = DEFAULT_CLIENTS[clientName];
+    if (!cfg) throw new Error(`Unknown InnerTube client: ${clientName}`);
+    this.context = cfg.context;
+    this.header = cfg.header;
+    this.apiKey = cfg.apiKey;
+    this.useOauth = opts.useOauth ?? false;
+    this.onAuthPrompt = opts.onAuthPrompt;
+  }
+  get baseUrl() {
+    return "https://www.youtube.com/youtubei/v1";
+  }
+  baseData() {
+    return {
+      context: { client: { ...this.context.client } },
+      contentCheckOk: true,
+      racyCheckOk: true
+    };
+  }
+  endpointUrl(endpoint) {
+    const params = new URLSearchParams({ prettyPrint: "false" });
+    if (!this.useOauth) params.set("key", this.apiKey);
+    return `${endpoint}?${params.toString()}`;
+  }
+  async callApi(endpoint, data) {
+    const url = this.endpointUrl(endpoint);
+    const headers = { "Content-Type": "application/json", ...this.header };
+    if (this.useOauth) {
+      if (!this.accessToken) await this.fetchBearerToken();
+      else await this.refreshBearerToken();
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    const text = await post(url, data, { headers });
+    return JSON.parse(text);
+  }
+  // ---------- Endpoints ----------
+  async player(videoId2) {
+    const endpoint = `${this.baseUrl}/player`;
+    const data = this.baseData();
+    data["videoId"] = videoId2;
+    data["params"] = "CgIQBg==";
+    return await this.callApi(endpoint, data);
+  }
+  async search(searchQuery, continuation) {
+    const endpoint = `${this.baseUrl}/search`;
+    const data = this.baseData();
+    data["query"] = searchQuery;
+    if (continuation) data["continuation"] = continuation;
+    return await this.callApi(endpoint, data);
+  }
+  async browse(continuation) {
+    const endpoint = `${this.baseUrl}/browse`;
+    const data = this.baseData();
+    data["continuation"] = continuation;
+    return await this.callApi(endpoint, data);
+  }
+  async verifyAge(videoId2) {
+    const endpoint = `${this.baseUrl}/verify_age`;
+    const data = this.baseData();
+    data["nextEndpoint"] = { urlEndpoint: { url: `/watch?v=${videoId2}` } };
+    data["setControvercy"] = true;
+    return await this.callApi(endpoint, data);
+  }
+  async getTranscript(videoId2) {
+    const endpoint = `${this.baseUrl}/get_transcript`;
+    const data = this.baseData();
+    data["videoId"] = videoId2;
+    return await this.callApi(endpoint, data);
+  }
+  // ---------- OAuth device flow ----------
+  async refreshBearerToken(force = false) {
+    if (!this.useOauth) return;
+    if (!force && this.expires !== null && this.expires > Date.now() / 1e3) return;
+    if (!this.refreshToken) return;
+    const startTime = Math.floor(Date.now() / 1e3) - 30;
+    const body = JSON.stringify({
+      client_id: OAUTH_CLIENT_ID,
+      client_secret: OAUTH_CLIENT_SECRET,
+      grant_type: "refresh_token",
+      refresh_token: this.refreshToken
+    });
+    const text = await post("https://oauth2.googleapis.com/token", JSON.parse(body), {
+      headers: { "Content-Type": "application/json" }
+    });
+    const data = JSON.parse(text);
+    this.accessToken = data.access_token;
+    this.expires = startTime + data.expires_in;
+  }
+  async fetchBearerToken() {
+    const startTime = Math.floor(Date.now() / 1e3) - 30;
+    const text1 = await post(
+      "https://oauth2.googleapis.com/device/code",
+      { client_id: OAUTH_CLIENT_ID, scope: "https://www.googleapis.com/auth/youtube" },
+      { headers: { "Content-Type": "application/json" } }
+    );
+    const phase1 = JSON.parse(text1);
+    if (this.onAuthPrompt) {
+      await this.onAuthPrompt(phase1.verification_url, phase1.user_code);
+    } else {
+      console.log(
+        `Please open ${phase1.verification_url} and input code ${phase1.user_code}, then continue.`
+      );
+    }
+    const text2 = await post(
+      "https://oauth2.googleapis.com/token",
+      {
+        client_id: OAUTH_CLIENT_ID,
+        client_secret: OAUTH_CLIENT_SECRET,
+        device_code: phase1.device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+      },
+      { headers: { "Content-Type": "application/json" } }
+    );
+    const phase2 = JSON.parse(text2);
+    this.accessToken = phase2.access_token;
+    this.refreshToken = phase2.refresh_token;
+    this.expires = startTime + phase2.expires_in;
+  }
+};
+
+// src/itags.ts
+var t = (resolution, abr) => ({ resolution, abr });
+var PROGRESSIVE_VIDEO = {
+  5: t("240p", "64kbps"),
+  6: t("270p", "64kbps"),
+  13: t("144p", null),
+  17: t("144p", "24kbps"),
+  18: t("360p", "96kbps"),
+  22: t("720p", "192kbps"),
+  34: t("360p", "128kbps"),
+  35: t("480p", "128kbps"),
+  36: t("240p", null),
+  37: t("1080p", "192kbps"),
+  38: t("3072p", "192kbps"),
+  43: t("360p", "128kbps"),
+  44: t("480p", "128kbps"),
+  45: t("720p", "192kbps"),
+  46: t("1080p", "192kbps"),
+  59: t("480p", "128kbps"),
+  78: t("480p", "128kbps"),
+  82: t("360p", "128kbps"),
+  83: t("480p", "128kbps"),
+  84: t("720p", "192kbps"),
+  85: t("1080p", "192kbps"),
+  91: t("144p", "48kbps"),
+  92: t("240p", "48kbps"),
+  93: t("360p", "128kbps"),
+  94: t("480p", "128kbps"),
+  95: t("720p", "256kbps"),
+  96: t("1080p", "256kbps"),
+  100: t("360p", "128kbps"),
+  101: t("480p", "192kbps"),
+  102: t("720p", "192kbps"),
+  132: t("240p", "48kbps"),
+  151: t("720p", "24kbps"),
+  300: t("720p", "128kbps"),
+  301: t("1080p", "128kbps")
+};
+var DASH_VIDEO = {
+  133: t("240p", null),
+  134: t("360p", null),
+  135: t("480p", null),
+  136: t("720p", null),
+  137: t("1080p", null),
+  138: t("2160p", null),
+  160: t("144p", null),
+  167: t("360p", null),
+  168: t("480p", null),
+  169: t("720p", null),
+  170: t("1080p", null),
+  212: t("480p", null),
+  218: t("480p", null),
+  219: t("480p", null),
+  242: t("240p", null),
+  243: t("360p", null),
+  244: t("480p", null),
+  245: t("480p", null),
+  246: t("480p", null),
+  247: t("720p", null),
+  248: t("1080p", null),
+  264: t("1440p", null),
+  266: t("2160p", null),
+  271: t("1440p", null),
+  272: t("4320p", null),
+  278: t("144p", null),
+  298: t("720p", null),
+  299: t("1080p", null),
+  302: t("720p", null),
+  303: t("1080p", null),
+  308: t("1440p", null),
+  313: t("2160p", null),
+  315: t("2160p", null),
+  330: t("144p", null),
+  331: t("240p", null),
+  332: t("360p", null),
+  333: t("480p", null),
+  334: t("720p", null),
+  335: t("1080p", null),
+  336: t("1440p", null),
+  337: t("2160p", null),
+  394: t("144p", null),
+  395: t("240p", null),
+  396: t("360p", null),
+  397: t("480p", null),
+  398: t("720p", null),
+  399: t("1080p", null),
+  400: t("1440p", null),
+  401: t("2160p", null),
+  402: t("4320p", null),
+  571: t("4320p", null),
+  694: t("144p", null),
+  695: t("240p", null),
+  696: t("360p", null),
+  697: t("480p", null),
+  698: t("720p", null),
+  699: t("1080p", null),
+  700: t("1440p", null),
+  701: t("2160p", null),
+  702: t("4320p", null)
+};
+var DASH_AUDIO = {
+  139: t(null, "48kbps"),
+  140: t(null, "128kbps"),
+  141: t(null, "256kbps"),
+  171: t(null, "128kbps"),
+  172: t(null, "256kbps"),
+  249: t(null, "50kbps"),
+  250: t(null, "70kbps"),
+  251: t(null, "160kbps"),
+  256: t(null, "192kbps"),
+  258: t(null, "384kbps"),
+  325: t(null, null),
+  328: t(null, null)
+};
+var ITAGS = {
+  ...PROGRESSIVE_VIDEO,
+  ...DASH_VIDEO,
+  ...DASH_AUDIO
+};
+var HDR = /* @__PURE__ */ new Set([330, 331, 332, 333, 334, 335, 336, 337]);
+var THREE_D = /* @__PURE__ */ new Set([82, 83, 84, 85, 100, 101, 102]);
+var LIVE = /* @__PURE__ */ new Set([91, 92, 93, 94, 95, 96, 132, 151]);
+function getFormatProfile(itag) {
+  const code = typeof itag === "string" ? parseInt(itag, 10) : itag;
+  const info = ITAGS[code];
+  return {
+    resolution: info?.resolution ?? null,
+    abr: info?.abr ?? null,
+    isLive: LIVE.has(code),
+    is3d: THREE_D.has(code),
+    isHdr: HDR.has(code),
+    isDash: code in DASH_AUDIO || code in DASH_VIDEO
+  };
+}
+
+// src/stream.ts
+var Stream = class {
+  itag;
+  url;
+  mimeType;
+  codecs;
+  type;
+  subtype;
+  videoCodec;
+  audioCodec;
+  isOtf;
+  bitrate;
+  fps;
+  resolution;
+  abr;
+  isDash;
+  is3d;
+  isHdr;
+  isLive;
+  cachedFilesize;
+  state;
+  constructor(raw, state) {
+    this.state = state;
+    if (!raw.url) throw new Error("Stream missing url after descrambling");
+    this.url = raw.url;
+    this.itag = typeof raw.itag === "string" ? parseInt(raw.itag, 10) : raw.itag;
+    const { mimeType, codecs } = mimeTypeCodec(raw.mimeType ?? "");
+    this.mimeType = mimeType;
+    this.codecs = codecs;
+    const [type, subtype] = mimeType.split("/");
+    this.type = type ?? "";
+    this.subtype = subtype ?? "";
+    [this.videoCodec, this.audioCodec] = this.parseCodecs();
+    this.isOtf = raw.is_otf ?? false;
+    this.bitrate = raw.bitrate ?? null;
+    this.cachedFilesize = parseInt(String(raw.contentLength ?? "0"), 10);
+    const profile = getFormatProfile(this.itag);
+    this.isDash = profile.isDash;
+    this.abr = profile.abr;
+    this.fps = raw.fps ?? null;
+    this.resolution = profile.resolution;
+    this.is3d = profile.is3d;
+    this.isHdr = profile.isHdr;
+    this.isLive = profile.isLive;
+  }
+  // Adaptive = single codec list (audio-only OR video-only)
+  get isAdaptive() {
+    return this.codecs.length % 2 === 1;
+  }
+  get isProgressive() {
+    return !this.isAdaptive;
+  }
+  get includesAudioTrack() {
+    return this.isProgressive || this.type === "audio";
+  }
+  get includesVideoTrack() {
+    return this.isProgressive || this.type === "video";
+  }
+  parseCodecs() {
+    let video = null;
+    let audio = null;
+    if (this.codecs.length === 0) return [null, null];
+    if (this.codecs.length === 2) {
+      video = this.codecs[0] ?? null;
+      audio = this.codecs[1] ?? null;
+    } else if (this.codecs.length === 1) {
+      video = this.codecs[0] ?? null;
+    }
+    return [video, audio];
+  }
+  get title() {
+    return this.state.title ?? "Unknown YouTube Video Title";
+  }
+  async filesize() {
+    if (this.cachedFilesize === 0) {
+      try {
+        this.cachedFilesize = await filesize(this.url);
+      } catch {
+        this.cachedFilesize = await seqFilesize(this.url);
+      }
+    }
+    return this.cachedFilesize;
+  }
+  async filesizeApprox() {
+    if (this.state.duration && this.bitrate) {
+      return Math.floor(this.state.duration * this.bitrate / 8);
+    }
+    return this.filesize();
+  }
+  get expiration() {
+    try {
+      const u = new URL(this.url);
+      const expire = u.searchParams.get("expire");
+      if (!expire) return null;
+      return new Date(parseInt(expire, 10) * 1e3);
+    } catch {
+      return null;
+    }
+  }
+  get defaultFilename() {
+    return `${safeFilename(this.title)}.${this.subtype}`;
+  }
+  /** Compute the absolute output path the download will be written to. */
+  async getFilePath(opts = {}) {
+    const filename = opts.filename ?? this.defaultFilename;
+    const prefixed = opts.filenamePrefix ? `${opts.filenamePrefix}${filename}` : filename;
+    const dir = await resolveOutputDir(opts.outputPath);
+    await ensureDir(dir);
+    return joinPath(dir, prefixed);
+  }
+  async existsAtPath(filePath) {
+    if (!await fileExists(filePath)) return false;
+    const fs = await getFs();
+    if (!fs) return false;
+    const expected = await this.filesize();
+    const stat = await fs.stat(filePath);
+    return stat.size === expected;
+  }
+  /**
+   * Download the stream to the local filesystem and return the absolute path.
+   * Throws if no filesystem is available (e.g., browser); use streamChunks() instead.
+   */
+  async download(opts = {}) {
+    const fs = await getFs();
+    if (!fs) {
+      throw new Error("Filesystem unavailable in this runtime; use streamChunks() instead.");
+    }
+    const filePath = await this.getFilePath(opts);
+    const skipExisting = opts.skipExisting ?? true;
+    if (skipExisting && await this.existsAtPath(filePath)) {
+      this.fireOnComplete(filePath);
+      return filePath;
+    }
+    let bytesRemaining = await this.filesize();
+    const reqOpts = {
+      timeoutMs: opts.timeoutMs,
+      maxRetries: opts.maxRetries ?? 0,
+      signal: opts.signal
+    };
+    const handle = await fs.open(filePath, "w");
+    try {
+      let usedSeqStream = false;
+      try {
+        for await (const chunk of stream(this.url, reqOpts)) {
+          await handle.write(chunk);
+          bytesRemaining -= chunk.byteLength;
+          this.fireOnProgress(chunk, bytesRemaining);
+        }
+      } catch (err) {
+        if (!is404(err)) throw err;
+        usedSeqStream = true;
+      }
+      if (usedSeqStream) {
+        for await (const chunk of seqStream(this.url, reqOpts)) {
+          await handle.write(chunk);
+          bytesRemaining -= chunk.byteLength;
+          this.fireOnProgress(chunk, bytesRemaining);
+        }
+      }
+    } finally {
+      await handle.close();
+    }
+    this.fireOnComplete(filePath);
+    return filePath;
+  }
+  /**
+   * Stream the media as raw chunks. Browser-friendly alternative to download().
+   * Caller is responsible for collecting the chunks (write to a Blob, sink, etc.).
+   */
+  async *streamChunks(opts = {}) {
+    const reqOpts = {
+      timeoutMs: opts.timeoutMs,
+      maxRetries: opts.maxRetries ?? 0,
+      signal: opts.signal
+    };
+    let bytesRemaining = await this.filesize();
+    try {
+      for await (const chunk of stream(this.url, reqOpts)) {
+        bytesRemaining -= chunk.byteLength;
+        this.fireOnProgress(chunk, bytesRemaining);
+        yield chunk;
+      }
+    } catch (err) {
+      if (!is404(err)) throw err;
+      for await (const chunk of seqStream(this.url, reqOpts)) {
+        bytesRemaining -= chunk.byteLength;
+        this.fireOnProgress(chunk, bytesRemaining);
+        yield chunk;
+      }
+    }
+    this.fireOnComplete(null);
+  }
+  fireOnProgress(chunk, bytesRemaining) {
+    this.state.onProgress?.(this, chunk, bytesRemaining);
+  }
+  fireOnComplete(path) {
+    this.state.onComplete?.(this, path);
+  }
+  toString() {
+    const parts = [`itag="${this.itag}"`, `mime_type="${this.mimeType}"`];
+    if (this.includesVideoTrack) {
+      parts.push(`res="${this.resolution}"`, `fps="${this.fps}fps"`);
+      if (!this.isAdaptive) {
+        parts.push(`vcodec="${this.videoCodec}"`, `acodec="${this.audioCodec}"`);
+      } else {
+        parts.push(`vcodec="${this.videoCodec}"`);
+      }
+    } else {
+      parts.push(`abr="${this.abr}"`, `acodec="${this.audioCodec}"`);
+    }
+    parts.push(`progressive="${this.isProgressive}"`, `type="${this.type}"`);
+    return `<Stream: ${parts.join(" ")}>`;
+  }
+};
+function is404(err) {
+  if (!err) return false;
+  const msg = err.message ?? "";
+  return msg.includes("404");
+}
+
+// src/query.ts
+var StreamQuery = class _StreamQuery {
+  fmtStreams;
+  itagIndex;
+  constructor(fmtStreams) {
+    this.fmtStreams = fmtStreams;
+    this.itagIndex = new Map(fmtStreams.map((s) => [s.itag, s]));
+  }
+  filter(criteria = {}) {
+    const filters = [];
+    const resolution = criteria.res ?? criteria.resolution;
+    if (resolution) {
+      if (Array.isArray(resolution)) {
+        filters.push((s) => s.resolution !== null && resolution.includes(s.resolution));
+      } else {
+        filters.push((s) => s.resolution === resolution);
+      }
+    }
+    if (criteria.fps !== void 0) filters.push((s) => s.fps === criteria.fps);
+    if (criteria.mimeType !== void 0) filters.push((s) => s.mimeType === criteria.mimeType);
+    if (criteria.type !== void 0) filters.push((s) => s.type === criteria.type);
+    const subtype = criteria.subtype ?? criteria.fileExtension;
+    if (subtype !== void 0) filters.push((s) => s.subtype === subtype);
+    const abr = criteria.abr ?? criteria.bitrate;
+    if (abr !== void 0) filters.push((s) => s.abr === abr);
+    if (criteria.videoCodec !== void 0) filters.push((s) => s.videoCodec === criteria.videoCodec);
+    if (criteria.audioCodec !== void 0) filters.push((s) => s.audioCodec === criteria.audioCodec);
+    if (criteria.onlyAudio) filters.push((s) => s.includesAudioTrack && !s.includesVideoTrack);
+    if (criteria.onlyVideo) filters.push((s) => s.includesVideoTrack && !s.includesAudioTrack);
+    if (criteria.progressive) filters.push((s) => s.isProgressive);
+    if (criteria.adaptive) filters.push((s) => s.isAdaptive);
+    if (criteria.isDash !== void 0) filters.push((s) => s.isDash === criteria.isDash);
+    if (criteria.customFilters) filters.push(...criteria.customFilters);
+    return this.applyFilters(filters);
+  }
+  applyFilters(filters) {
+    let result = this.fmtStreams;
+    for (const f of filters) result = result.filter(f);
+    return new _StreamQuery(result);
+  }
+  /**
+   * Sort by an attribute. Filters out streams that don't have it. For string
+   * attributes (e.g., "720p"), sorts by the embedded integer.
+   */
+  orderBy(attribute) {
+    const present = this.fmtStreams.filter((s) => s[attribute] !== null && s[attribute] !== void 0);
+    if (present.length === 0) return new _StreamQuery(present);
+    const first = present[0][attribute];
+    if (typeof first === "string") {
+      try {
+        const sorted2 = [...present].sort((a, b) => {
+          const va = parseInt(String(a[attribute]).replace(/\D/g, ""), 10);
+          const vb = parseInt(String(b[attribute]).replace(/\D/g, ""), 10);
+          if (Number.isNaN(va) || Number.isNaN(vb)) throw new Error("non-numeric");
+          return va - vb;
+        });
+        return new _StreamQuery(sorted2);
+      } catch {
+      }
+    }
+    const sorted = [...present].sort((a, b) => {
+      const va = a[attribute];
+      const vb = b[attribute];
+      if (va < vb) return -1;
+      if (va > vb) return 1;
+      return 0;
+    });
+    return new _StreamQuery(sorted);
+  }
+  desc() {
+    return new _StreamQuery([...this.fmtStreams].reverse());
+  }
+  asc() {
+    return this;
+  }
+  getByItag(itag) {
+    return this.itagIndex.get(itag);
+  }
+  getByResolution(resolution) {
+    return this.filter({ progressive: true, subtype: "mp4", resolution }).first();
+  }
+  getLowestResolution() {
+    return this.filter({ progressive: true, subtype: "mp4" }).orderBy("resolution").first();
+  }
+  getHighestResolution() {
+    return this.filter({ progressive: true }).orderBy("resolution").last();
+  }
+  getAudioOnly(subtype = "mp4") {
+    return this.filter({ onlyAudio: true, subtype }).orderBy("abr").last();
+  }
+  otf(isOtf = false) {
+    return this.applyFilters([(s) => s.isOtf === isOtf]);
+  }
+  first() {
+    return this.fmtStreams[0];
+  }
+  last() {
+    return this.fmtStreams[this.fmtStreams.length - 1];
+  }
+  get length() {
+    return this.fmtStreams.length;
+  }
+  at(index) {
+    return this.fmtStreams[index];
+  }
+  toArray() {
+    return [...this.fmtStreams];
+  }
+  [Symbol.iterator]() {
+    return this.fmtStreams[Symbol.iterator]();
+  }
+};
+var CaptionQuery = class {
+  index;
+  constructor(captions) {
+    this.index = new Map(captions.map((c) => [c.code, c]));
+  }
+  get(langCode) {
+    return this.index.get(langCode);
+  }
+  has(langCode) {
+    return this.index.has(langCode);
+  }
+  get length() {
+    return this.index.size;
+  }
+  toArray() {
+    return [...this.index.values()];
+  }
+  [Symbol.iterator]() {
+    return this.index.values();
+  }
+};
+
+// src/youtube.ts
+var YouTube = class _YouTube {
+  videoId;
+  watchUrl;
+  embedUrl;
+  useOauth;
+  allowOauthCache;
+  state;
+  cachedJs = null;
+  cachedJsUrl = null;
+  cachedVidInfo = null;
+  cachedWatchHtml = null;
+  cachedEmbedHtml = null;
+  cachedAgeRestricted = null;
+  cachedFmtStreams = null;
+  cachedInitialData = null;
+  cachedMetadata = null;
+  cachedTitle = null;
+  cachedAuthor = null;
+  cachedPublishDate = void 0;
+  constructor(url, opts = {}) {
+    this.videoId = videoId(url);
+    this.watchUrl = `https://youtube.com/watch?v=${this.videoId}`;
+    this.embedUrl = `https://www.youtube.com/embed/${this.videoId}`;
+    this.useOauth = opts.useOauth ?? false;
+    this.allowOauthCache = opts.allowOauthCache ?? true;
+    this.state = {
+      title: null,
+      duration: null,
+      onProgress: opts.onProgress,
+      onComplete: opts.onComplete
+    };
+  }
+  static fromId(videoId2) {
+    return new _YouTube(`https://www.youtube.com/watch?v=${videoId2}`);
+  }
+  // ---------- Lazy network resources ----------
+  async watchHtml() {
+    if (this.cachedWatchHtml) return this.cachedWatchHtml;
+    this.cachedWatchHtml = await get(this.watchUrl);
+    return this.cachedWatchHtml;
+  }
+  async embedHtml() {
+    if (this.cachedEmbedHtml) return this.cachedEmbedHtml;
+    this.cachedEmbedHtml = await get(this.embedUrl);
+    return this.cachedEmbedHtml;
+  }
+  async ageRestricted() {
+    if (this.cachedAgeRestricted !== null) return this.cachedAgeRestricted;
+    this.cachedAgeRestricted = isAgeRestricted(await this.watchHtml());
+    return this.cachedAgeRestricted;
+  }
+  async jsUrl() {
+    if (this.cachedJsUrl) return this.cachedJsUrl;
+    const html = await this.ageRestricted() ? await this.embedHtml() : await this.watchHtml();
+    this.cachedJsUrl = jsUrl(html);
+    return this.cachedJsUrl;
+  }
+  async js() {
+    if (this.cachedJs) return this.cachedJs;
+    const url = await this.jsUrl();
+    this.cachedJs = await get(url);
+    return this.cachedJs;
+  }
+  async initialData() {
+    if (this.cachedInitialData) return this.cachedInitialData;
+    this.cachedInitialData = initialData(await this.watchHtml());
+    return this.cachedInitialData;
+  }
+  /**
+   * Resolve the player response containing videoDetails + streamingData.
+   *
+   * Strategy (late-2025 reality):
+   *   1. Primary: scrape `ytInitialPlayerResponse` from the watch HTML. This is
+   *      the same payload a browser sees and contains streamingData + captions.
+   *   2. Fallback: InnerTube /player endpoint (useful for age-gate bypass, but
+   *      currently rate-limited by YouTube's "Sign in to confirm you're not a
+   *      bot" check for server-side IPs).
+   *
+   * If the primary path returns a useful response we never touch InnerTube,
+   * which avoids the bot-detection entirely for normal public videos.
+   */
+  async vidInfo() {
+    if (this.cachedVidInfo) return this.cachedVidInfo;
+    try {
+      const html = await this.watchHtml();
+      const fromHtml = initialPlayerResponse(html);
+      if (fromHtml?.videoDetails && fromHtml?.streamingData) {
+        this.cachedVidInfo = fromHtml;
+        return fromHtml;
+      }
+    } catch {
+    }
+    const innertube = new InnerTube({ useOauth: this.useOauth });
+    this.cachedVidInfo = await innertube.player(this.videoId);
+    return this.cachedVidInfo;
+  }
+  async streamingData() {
+    let info = await this.vidInfo();
+    if (!info.streamingData) {
+      await this.bypassAgeGate();
+      info = await this.vidInfo();
+    }
+    if (!info.streamingData) {
+      throw new VideoUnavailable(this.videoId);
+    }
+    return info.streamingData;
+  }
+  // ---------- Availability gates ----------
+  async checkAvailability() {
+    const html = await this.watchHtml();
+    const { status, reasons } = playabilityStatus(html);
+    for (const reason of reasons) {
+      if (status === "UNPLAYABLE") {
+        if (reason === "Join this channel to get access to members-only content like this video, and other exclusive perks.") {
+          throw new MembersOnly(this.videoId);
+        }
+        if (reason === "This live stream recording is not available.") {
+          throw new RecordingUnavailable(this.videoId);
+        }
+        throw new VideoUnavailable(this.videoId);
+      } else if (status === "LOGIN_REQUIRED") {
+        if (reason === "This is a private video. Please sign in to verify that you may see it.") {
+          throw new VideoPrivate(this.videoId);
+        }
+      } else if (status === "ERROR") {
+        if (reason === "Video unavailable") {
+          throw new VideoUnavailable(this.videoId);
+        }
+      } else if (status === "LIVE_STREAM") {
+        throw new LiveStreamError(this.videoId);
+      }
+    }
+  }
+  async bypassAgeGate() {
+    const innertube = new InnerTube({ client: "ANDROID_EMBED", useOauth: this.useOauth });
+    const response = await innertube.player(this.videoId);
+    const status = response.playabilityStatus?.status;
+    if (status === "UNPLAYABLE") {
+      throw new AgeRestrictedError(this.videoId);
+    }
+    this.cachedVidInfo = response;
+  }
+  // ---------- Streams ----------
+  async fmtStreams() {
+    await this.checkAvailability();
+    if (this.cachedFmtStreams) return this.cachedFmtStreams;
+    const result = [];
+    const streamingData = await this.streamingData();
+    const manifest = applyDescrambler({
+      formats: streamingData.formats,
+      adaptiveFormats: streamingData.adaptiveFormats
+    });
+    if (!manifest) return result;
+    const vidInfo = await this.vidInfo();
+    const needsCipher = manifestNeedsCipher(manifest);
+    let cipher = null;
+    if (needsCipher) {
+      try {
+        const js = await this.js();
+        cipher = createCipher(js);
+      } catch (err) {
+        if (!(err instanceof ExtractError)) throw err;
+        this.cachedJs = null;
+        this.cachedJsUrl = null;
+        try {
+          const freshJs = await this.js();
+          cipher = createCipher(freshJs);
+        } catch {
+          cipher = null;
+        }
+      }
+    }
+    applySignature(manifest, vidInfo, cipher);
+    this.state.title = await this.title();
+    this.state.duration = await this.length();
+    for (const raw of manifest) {
+      if (!raw.url) continue;
+      if (raw.s !== void 0 && raw.s !== null && !cipher) continue;
+      result.push(new Stream(raw, this.state));
+    }
+    this.cachedFmtStreams = result;
+    return result;
+  }
+  async streams() {
+    await this.checkAvailability();
+    return new StreamQuery(await this.fmtStreams());
+  }
+  // ---------- Captions ----------
+  async captionTracks() {
+    const info = await this.vidInfo();
+    const tracks = info.captions?.playerCaptionsTracklistRenderer?.captionTracks ?? [];
+    return tracks.map((t2) => new Caption(t2));
+  }
+  async captions() {
+    return new CaptionQuery(await this.captionTracks());
+  }
+  // ---------- Metadata ----------
+  async title() {
+    if (this.cachedTitle) return this.cachedTitle;
+    const info = await this.vidInfo();
+    const t2 = info.videoDetails?.title;
+    if (!t2) {
+      await this.checkAvailability();
+      throw new PytubeError(`Could not extract title for ${this.watchUrl}`);
+    }
+    this.cachedTitle = t2;
+    return t2;
+  }
+  async description() {
+    return (await this.vidInfo()).videoDetails?.shortDescription ?? null;
+  }
+  async length() {
+    const len = (await this.vidInfo()).videoDetails?.lengthSeconds;
+    return len ? parseInt(len, 10) : 0;
+  }
+  async views() {
+    const v = (await this.vidInfo()).videoDetails?.viewCount;
+    return v ? parseInt(v, 10) : 0;
+  }
+  async rating() {
+    return (await this.vidInfo()).videoDetails?.averageRating ?? null;
+  }
+  async author() {
+    if (this.cachedAuthor) return this.cachedAuthor;
+    this.cachedAuthor = (await this.vidInfo()).videoDetails?.author ?? "unknown";
+    return this.cachedAuthor;
+  }
+  async keywords() {
+    return (await this.vidInfo()).videoDetails?.keywords ?? [];
+  }
+  async channelId() {
+    return (await this.vidInfo()).videoDetails?.channelId ?? null;
+  }
+  async channelUrl() {
+    return `https://www.youtube.com/channel/${await this.channelId()}`;
+  }
+  async thumbnailUrl() {
+    const thumbnails = (await this.vidInfo()).videoDetails?.thumbnail?.thumbnails;
+    if (thumbnails && thumbnails.length > 0) {
+      return thumbnails[thumbnails.length - 1].url;
+    }
+    return `https://img.youtube.com/vi/${this.videoId}/maxresdefault.jpg`;
+  }
+  async publishDate() {
+    if (this.cachedPublishDate !== void 0) return this.cachedPublishDate;
+    this.cachedPublishDate = publishDate(await this.watchHtml());
+    return this.cachedPublishDate;
+  }
+  async metadata() {
+    if (this.cachedMetadata) return this.cachedMetadata;
+    this.cachedMetadata = metadata(await this.initialData());
+    return this.cachedMetadata;
+  }
+  // ---------- Prefetch + sync getters ----------
+  /**
+   * Fetch and cache everything needed for synchronous metadata access.
+   * After this resolves, the *Sync getters and the `streams` getter return
+   * results immediately without further network I/O.
+   */
+  async prefetch() {
+    await this.watchHtml();
+    await this.vidInfo();
+    await this.title();
+    await this.author();
+    await this.length();
+    await this.fmtStreams();
+  }
+  get titleSync() {
+    if (!this.cachedTitle) throw new Error("Call await yt.prefetch() first.");
+    return this.cachedTitle;
+  }
+  get authorSync() {
+    if (!this.cachedAuthor) throw new Error("Call await yt.prefetch() first.");
+    return this.cachedAuthor;
+  }
+  get streamsSync() {
+    if (!this.cachedFmtStreams) throw new Error("Call await yt.prefetch() first.");
+    return new StreamQuery(this.cachedFmtStreams);
+  }
+  // ---------- Misc ----------
+  registerOnProgressCallback(fn) {
+    this.state.onProgress = fn;
+  }
+  registerOnCompleteCallback(fn) {
+    this.state.onComplete = fn;
+  }
+  toString() {
+    return `<YouTube videoId=${this.videoId}>`;
+  }
+  equals(other) {
+    return other instanceof _YouTube && other.watchUrl === this.watchUrl;
+  }
+};
+
+// src/playlist.ts
+var Playlist = class {
+  inputUrl;
+  cachedHtml = null;
+  cachedYtcfg = null;
+  cachedInitialData = null;
+  cachedSidebar = null;
+  cachedPlaylistId = null;
+  cachedVideoUrls = null;
+  constructor(url) {
+    this.inputUrl = url;
+  }
+  // ---------- Identifiers ----------
+  get playlistId() {
+    if (this.cachedPlaylistId) return this.cachedPlaylistId;
+    this.cachedPlaylistId = playlistId(this.inputUrl);
+    return this.cachedPlaylistId;
+  }
+  get playlistUrl() {
+    return `https://www.youtube.com/playlist?list=${this.playlistId}`;
+  }
+  // ---------- Network resources ----------
+  async html() {
+    if (this.cachedHtml) return this.cachedHtml;
+    this.cachedHtml = await get(this.playlistUrl);
+    return this.cachedHtml;
+  }
+  async ytcfg() {
+    if (this.cachedYtcfg) return this.cachedYtcfg;
+    this.cachedYtcfg = getYtcfg(await this.html());
+    return this.cachedYtcfg;
+  }
+  async initialData() {
+    if (this.cachedInitialData) return this.cachedInitialData;
+    this.cachedInitialData = await initialData(await this.html());
+    return this.cachedInitialData;
+  }
+  async sidebarInfo() {
+    if (this.cachedSidebar) return this.cachedSidebar;
+    const data = await this.initialData();
+    this.cachedSidebar = data.sidebar?.playlistSidebarRenderer?.items ?? [];
+    return this.cachedSidebar;
+  }
+  async ytApiKey() {
+    return String((await this.ytcfg())["INNERTUBE_API_KEY"]);
+  }
+  // ---------- Pagination ----------
+  async *paginate(untilWatchId) {
+    let [videoUrls, continuation] = this.constructor.extractVideos(
+      JSON.stringify(await this.initialData())
+    );
+    if (untilWatchId !== void 0) {
+      const idx = videoUrls.indexOf(`/watch?v=${untilWatchId}`);
+      if (idx !== -1) {
+        yield videoUrls.slice(0, idx);
+        return;
+      }
+    }
+    yield videoUrls;
+    while (continuation) {
+      const req = await this.buildContinuationRequest(continuation);
+      const text = await post(req.url, req.data, { headers: req.headers });
+      [videoUrls, continuation] = this.constructor.extractVideos(text);
+      if (untilWatchId !== void 0) {
+        const idx = videoUrls.indexOf(`/watch?v=${untilWatchId}`);
+        if (idx !== -1) {
+          yield videoUrls.slice(0, idx);
+          return;
+        }
+      }
+      yield videoUrls;
+    }
+  }
+  async buildContinuationRequest(continuation) {
+    return {
+      url: `https://www.youtube.com/youtubei/v1/browse?key=${await this.ytApiKey()}`,
+      headers: {
+        "X-YouTube-Client-Name": "1",
+        "X-YouTube-Client-Version": "2.20200720.00.02"
+      },
+      data: {
+        continuation,
+        context: { client: { clientName: "WEB", clientVersion: "2.20200720.00.02" } }
+      }
+    };
+  }
+  static extractVideos(rawJson) {
+    const data = JSON.parse(rawJson);
+    let videos = null;
+    try {
+      const sectionContents = data.contents?.twoColumnBrowseResultsRenderer?.tabs?.[0]?.tabRenderer?.content?.sectionListRenderer?.contents;
+      if (sectionContents) {
+        const importantContent = sectionContents[0]?.itemSectionRenderer?.contents?.[0]?.playlistVideoListRenderer ?? sectionContents[1]?.itemSectionRenderer?.contents?.[0]?.playlistVideoListRenderer;
+        videos = importantContent?.contents ?? null;
+      }
+    } catch {
+    }
+    if (!videos) {
+      const continuationItems = data.onResponseReceivedActions?.[0]?.appendContinuationItemsAction?.continuationItems;
+      if (continuationItems) videos = continuationItems;
+    }
+    if (!videos) return [[], null];
+    let continuation = null;
+    const last = videos[videos.length - 1];
+    const continuationToken = last?.continuationItemRenderer?.continuationEndpoint?.continuationCommand?.token;
+    if (continuationToken) {
+      continuation = String(continuationToken);
+      videos = videos.slice(0, -1);
+    }
+    const watchPaths = videos.map((v) => v?.playlistVideoRenderer?.videoId).filter((id) => typeof id === "string").map((id) => `/watch?v=${id}`);
+    return [uniqueify(watchPaths), continuation];
+  }
+  // ---------- Public iteration ----------
+  async videoUrls() {
+    if (this.cachedVideoUrls) return this.cachedVideoUrls;
+    const out = [];
+    for await (const page of this.paginate()) {
+      for (const path of page) out.push(`https://www.youtube.com${path}`);
+    }
+    this.cachedVideoUrls = out;
+    return out;
+  }
+  async *videos() {
+    for await (const page of this.paginate()) {
+      for (const path of page) yield new YouTube(`https://www.youtube.com${path}`);
+    }
+  }
+  async length() {
+    return (await this.videoUrls()).length;
+  }
+  async *[Symbol.asyncIterator]() {
+    yield* this.videos();
+  }
+  // ---------- Sidebar metadata ----------
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  async title() {
+    const sidebar = await this.sidebarInfo();
+    return sidebar[0]?.playlistSidebarPrimaryInfoRenderer?.title?.runs?.[0]?.text ?? null;
+  }
+  async description() {
+    const sidebar = await this.sidebarInfo();
+    return sidebar[0]?.playlistSidebarPrimaryInfoRenderer?.description?.simpleText ?? null;
+  }
+  async owner() {
+    const sidebar = await this.sidebarInfo();
+    return sidebar[1]?.playlistSidebarSecondaryInfoRenderer?.videoOwner?.videoOwnerRenderer?.title?.runs?.[0]?.text ?? null;
+  }
+  async ownerId() {
+    const sidebar = await this.sidebarInfo();
+    return sidebar[1]?.playlistSidebarSecondaryInfoRenderer?.videoOwner?.videoOwnerRenderer?.title?.runs?.[0]?.navigationEndpoint?.browseEndpoint?.browseId ?? null;
+  }
+  async ownerUrl() {
+    const id = await this.ownerId();
+    return id ? `https://www.youtube.com/channel/${id}` : null;
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+};
+
+// src/channel.ts
+var Channel = class extends Playlist {
+  channelUri;
+  channelUrl;
+  videosUrl;
+  playlistsUrl;
+  communityUrl;
+  featuredChannelsUrl;
+  aboutUrl;
+  cachedVideosHtml = null;
+  constructor(url) {
+    super(url);
+    this.channelUri = channelName(url);
+    this.channelUrl = `https://www.youtube.com${this.channelUri}`;
+    this.videosUrl = `${this.channelUrl}/videos`;
+    this.playlistsUrl = `${this.channelUrl}/playlists`;
+    this.communityUrl = `${this.channelUrl}/community`;
+    this.featuredChannelsUrl = `${this.channelUrl}/channels`;
+    this.aboutUrl = `${this.channelUrl}/about`;
+  }
+  async html() {
+    if (this.cachedVideosHtml) return this.cachedVideosHtml;
+    this.cachedVideosHtml = await get(this.videosUrl);
+    return this.cachedVideosHtml;
+  }
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  async channelName() {
+    const data = await this.initialData();
+    return data?.metadata?.channelMetadataRenderer?.title ?? null;
+  }
+  async channelId() {
+    const data = await this.initialData();
+    return data?.metadata?.channelMetadataRenderer?.externalId ?? null;
+  }
+  async vanityUrl() {
+    const data = await this.initialData();
+    return data?.metadata?.channelMetadataRenderer?.vanityChannelUrl ?? null;
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+  static extractVideos(rawJson) {
+    const data = JSON.parse(rawJson);
+    let videos = null;
+    try {
+      videos = data.contents?.twoColumnBrowseResultsRenderer?.tabs?.[1]?.tabRenderer?.content?.sectionListRenderer?.contents?.[0]?.itemSectionRenderer?.contents?.[0]?.gridRenderer?.items ?? null;
+    } catch {
+      videos = null;
+    }
+    if (!videos) {
+      videos = data[1]?.response?.onResponseReceivedActions?.[0]?.appendContinuationItemsAction?.continuationItems ?? data.onResponseReceivedActions?.[0]?.appendContinuationItemsAction?.continuationItems ?? null;
+    }
+    if (!videos) return [[], null];
+    let continuation = null;
+    const last = videos[videos.length - 1];
+    const continuationToken = last?.continuationItemRenderer?.continuationEndpoint?.continuationCommand?.token;
+    if (continuationToken) {
+      continuation = String(continuationToken);
+      videos = videos.slice(0, -1);
+    }
+    const watchPaths = videos.map((v) => v?.gridVideoRenderer?.videoId).filter((id) => typeof id === "string").map((id) => `/watch?v=${id}`);
+    return [uniqueify(watchPaths), continuation];
+  }
+};
+
+// src/search.ts
+var Search = class {
+  query;
+  innertube;
+  cachedResults = null;
+  currentContinuation = null;
+  initialResults = null;
+  constructor(query) {
+    this.query = query;
+    this.innertube = new InnerTube({ client: "WEB" });
+  }
+  async results() {
+    if (this.cachedResults) return this.cachedResults;
+    const [videos, continuation] = await this.fetchAndParse();
+    this.cachedResults = videos;
+    this.currentContinuation = continuation;
+    return videos;
+  }
+  /** Fetch the next page of results and append to the cached results array. */
+  async getNextResults() {
+    if (!this.cachedResults) {
+      await this.results();
+      return;
+    }
+    if (!this.currentContinuation) {
+      throw new Error("No further results available.");
+    }
+    const [videos, continuation] = await this.fetchAndParse(this.currentContinuation);
+    this.cachedResults.push(...videos);
+    this.currentContinuation = continuation;
+  }
+  async completionSuggestions() {
+    if (!this.initialResults) await this.results();
+    return this.initialResults?.refinements ?? null;
+  }
+  async fetchAndParse(continuation) {
+    const raw = await this.innertube.search(this.query, continuation);
+    if (!this.initialResults) this.initialResults = raw;
+    let sections = null;
+    try {
+      sections = raw.contents?.twoColumnSearchResultsRenderer?.primaryContents?.sectionListRenderer?.contents ?? null;
+    } catch {
+      sections = null;
+    }
+    if (!sections) {
+      sections = raw.onResponseReceivedCommands?.[0]?.appendContinuationItemsAction?.continuationItems ?? null;
+    }
+    if (!sections) return [[], null];
+    let itemRenderer = null;
+    let continuationRenderer = null;
+    for (const s of sections) {
+      if (s?.itemSectionRenderer) itemRenderer = s.itemSectionRenderer;
+      if (s?.continuationItemRenderer) continuationRenderer = s.continuationItemRenderer;
+    }
+    const nextContinuation = continuationRenderer?.continuationEndpoint?.continuationCommand?.token ?? null;
+    if (!itemRenderer) return [[], nextContinuation];
+    const videos = [];
+    for (const detail of itemRenderer.contents ?? []) {
+      if (detail?.searchPyvRenderer?.ads) continue;
+      if (detail?.shelfRenderer) continue;
+      if (detail?.radioRenderer) continue;
+      if (detail?.playlistRenderer) continue;
+      if (detail?.channelRenderer) continue;
+      if (detail?.horizontalCardListRenderer) continue;
+      if (detail?.didYouMeanRenderer) continue;
+      if (detail?.backgroundPromoRenderer) continue;
+      if (!detail?.videoRenderer) continue;
+      const vr = detail.videoRenderer;
+      const vidId = vr.videoId;
+      videos.push(new YouTube(`https://www.youtube.com/watch?v=${vidId}`));
+    }
+    return [videos, nextContinuation];
+  }
+};
+
+// src/version.ts
+var VERSION = "0.1.1";
+
+export { AgeRestrictedError, Caption, CaptionQuery, Channel, DASH_AUDIO, DASH_VIDEO, ExtractError, HTMLParseError, ITAGS, InnerTube, LiveStreamError, MaxRetriesExceeded, MembersOnly, PROGRESSIVE_VIDEO, Playlist, PytubeError, RecordingUnavailable, RegexMatchError, Search, Stream, StreamQuery, VERSION, VideoPrivate, VideoRegionBlocked, VideoUnavailable, YouTube, YouTubeMetadata, getFormatProfile };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map