@hallelx/youtube-transcript 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,1224 @@
+#!/usr/bin/env node
+'use strict';
+
+// src/settings.ts
+var WATCH_URL_TEMPLATE = "https://www.youtube.com/watch?v={video_id}";
+var INNERTUBE_API_URL_TEMPLATE = "https://www.youtube.com/youtubei/v1/player?key={api_key}";
+var INNERTUBE_CONTEXT = {
+  client: {
+    clientName: "ANDROID",
+    clientVersion: "20.10.38"
+  }
+};
+function watchUrl(videoId) {
+  return WATCH_URL_TEMPLATE.replace("{video_id}", videoId);
+}
+function innertubeApiUrl(apiKey) {
+  return INNERTUBE_API_URL_TEMPLATE.replace("{api_key}", apiKey);
+}
+
+// src/errors/index.ts
+var YouTubeTranscriptApiException = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ERROR_MESSAGE_TEMPLATE = "\nCould not retrieve a transcript for the video {video_url}!";
+var CAUSE_MESSAGE_INTRO = " This is most likely caused by:\n\n{cause}";
+var GITHUB_REFERRAL = "\n\nIf you are sure that the described cause is not responsible for this error and that a transcript should be retrievable, please create an issue at https://github.com/jdepoix/youtube-transcript-api/issues. Please add which version of youtube_transcript_api you are using and provide the information needed to replicate the error. Also make sure that there are no open issues which already describe your problem!";
+var CouldNotRetrieveTranscript = class extends YouTubeTranscriptApiException {
+  videoId;
+  static CAUSE_MESSAGE = "";
+  constructor(videoId) {
+    super("");
+    this.videoId = videoId;
+    this.message = this.buildErrorMessage();
+  }
+  buildErrorMessage() {
+    let errorMessage = ERROR_MESSAGE_TEMPLATE.replace(
+      "{video_url}",
+      watchUrl(this.videoId)
+    );
+    const cause = this.cause;
+    if (cause) {
+      errorMessage += CAUSE_MESSAGE_INTRO.replace("{cause}", cause) + GITHUB_REFERRAL;
+    }
+    return errorMessage;
+  }
+  get cause() {
+    return this.constructor.CAUSE_MESSAGE;
+  }
+  toString() {
+    return this.buildErrorMessage();
+  }
+};
+var YouTubeDataUnparsable = class extends CouldNotRetrieveTranscript {
+  static CAUSE_MESSAGE = "The data required to fetch the transcript is not parsable. This should not happen, please open an issue (make sure to include the video ID)!";
+};
+var YouTubeRequestFailed = class extends CouldNotRetrieveTranscript {
+  reason = "";
+  static CAUSE_MESSAGE = "Request to YouTube failed: {reason}";
+  constructor(videoId, httpError) {
+    super(videoId);
+    this.reason = typeof httpError === "string" ? httpError : String(httpError);
+    this.message = this.buildErrorMessage();
+  }
+  get cause() {
+    if (!this.reason) return "";
+    return this.constructor.CAUSE_MESSAGE.replace("{reason}", this.reason);
+  }
+};
+var VideoUnplayable = class _VideoUnplayable extends CouldNotRetrieveTranscript {
+  reason = null;
+  subReasons = [];
+  static CAUSE_MESSAGE = "The video is unplayable for the following reason: {reason}";
+  static SUBREASON_MESSAGE = "\n\nAdditional Details:\n{sub_reasons}";
+  _initialized = false;
+  constructor(videoId, reason, subReasons) {
+    super(videoId);
+    this.reason = reason;
+    this.subReasons = subReasons;
+    this._initialized = true;
+    this.message = this.buildErrorMessage();
+  }
+  get cause() {
+    if (!this._initialized) return "";
+    let reason = this.reason === null ? "No reason specified!" : this.reason;
+    if (this.subReasons.length > 0) {
+      const subReasons = this.subReasons.map((s) => ` - ${s}`).join("\n");
+      reason = reason + _VideoUnplayable.SUBREASON_MESSAGE.replace("{sub_reasons}", subReasons);
+    }
+    return this.constructor.CAUSE_MESSAGE.replace(
+      "{reason}",
+      reason
+    );
+  }
+};
+var VideoUnavailable = class extends CouldNotRetrieveTranscript {
+  static CAUSE_MESSAGE = "The video is no longer available";
+};
+var InvalidVideoId = class extends CouldNotRetrieveTranscript {
+  static CAUSE_MESSAGE = 'You provided an invalid video id. Make sure you are using the video id and NOT the url!\n\nDo NOT run: `YouTubeTranscriptApi().fetch("https://www.youtube.com/watch?v=1234")`\nInstead run: `YouTubeTranscriptApi().fetch("1234")`';
+};
+var REQUEST_BLOCKED_BASE_CAUSE_MESSAGE = "YouTube is blocking requests from your IP. This usually is due to one of the following reasons:\n- You have done too many requests and your IP has been blocked by YouTube\n- You are doing requests from an IP belonging to a cloud provider (like AWS, Google Cloud Platform, Azure, etc.). Unfortunately, most IPs from cloud providers are blocked by YouTube.\n\n";
+var RequestBlocked = class _RequestBlocked extends CouldNotRetrieveTranscript {
+  static CAUSE_MESSAGE = REQUEST_BLOCKED_BASE_CAUSE_MESSAGE + `There are two things you can do to work around this:
+1. Use proxies to hide your IP address, as explained in the "Working around IP bans" section of the README (https://github.com/jdepoix/youtube-transcript-api?tab=readme-ov-file#working-around-ip-bans-requestblocked-or-ipblocked-exception).
+2. (NOT RECOMMENDED) If you authenticate your requests using cookies, you will be able to continue doing requests for a while. However, YouTube will eventually permanently ban the account that you have used to authenticate with! So only do this if you don't mind your account being banned!`;
+  static WITH_GENERIC_PROXY_CAUSE_MESSAGE = `YouTube is blocking your requests, despite you using proxies. Keep in mind that a proxy is just a way to hide your real IP behind the IP of that proxy, but there is no guarantee that the IP of that proxy won't be blocked as well.
+
+The only truly reliable way to prevent IP blocks is rotating through a large pool of residential IPs, by using a provider like Webshare (https://www.webshare.io/?referral_code=w0xno53eb50g), which provides you with a pool of >30M residential IPs (make sure to purchase "Residential" proxies, NOT "Proxy Server" or "Static Residential"!).
+
+You will find more information on how to easily integrate Webshare here: https://github.com/jdepoix/youtube-transcript-api?tab=readme-ov-file#using-webshare`;
+  static WITH_WEBSHARE_PROXY_CAUSE_MESSAGE = `YouTube is blocking your requests, despite you using Webshare proxies. Please make sure that you have purchased "Residential" proxies and NOT "Proxy Server" or "Static Residential", as those won't work as reliably! The free tier also uses "Proxy Server" and will NOT work!
+
+The only reliable option is using "Residential" proxies (not "Static Residential"), as this allows you to rotate through a pool of over 30M IPs, which means you will always find an IP that hasn't been blocked by YouTube yet!
+
+You can support the development of this open source project by making your Webshare purchases through this affiliate link: https://www.webshare.io/?referral_code=w0xno53eb50g 
+
+Thank you for your support! <3`;
+  _proxyConfig = null;
+  withProxyConfig(proxyConfig) {
+    this._proxyConfig = proxyConfig ?? null;
+    this.message = this.buildErrorMessage();
+    return this;
+  }
+  get cause() {
+    if (this._proxyConfig !== null && this._proxyConfig !== void 0) {
+      const name = this._proxyConfig.constructor?.name ?? "";
+      if (name === "WebshareProxyConfig") {
+        return _RequestBlocked.WITH_WEBSHARE_PROXY_CAUSE_MESSAGE;
+      }
+      if (name) {
+        return _RequestBlocked.WITH_GENERIC_PROXY_CAUSE_MESSAGE;
+      }
+    }
+    return this.constructor.CAUSE_MESSAGE;
+  }
+};
+var IpBlocked = class extends RequestBlocked {
+  static CAUSE_MESSAGE = REQUEST_BLOCKED_BASE_CAUSE_MESSAGE + 'Ways to work around this are explained in the "Working around IP bans" section of the README (https://github.com/jdepoix/youtube-transcript-api?tab=readme-ov-file#working-around-ip-bans-requestblocked-or-ipblocked-exception).\n';
+};
+var TranscriptsDisabled = class extends CouldNotRetrieveTranscript {
+  static CAUSE_MESSAGE = "Subtitles are disabled for this video";
+};
+var AgeRestricted = class extends CouldNotRetrieveTranscript {
+  static CAUSE_MESSAGE = "This video is age-restricted. Therefore, you are unable to retrieve transcripts for it without authenticating yourself.\n\nUnfortunately, Cookie Authentication is temporarily unsupported in youtube-transcript-api, as recent changes in YouTube's API broke the previous implementation. I will do my best to re-implement it as soon as possible.";
+};
+var NotTranslatable = class extends CouldNotRetrieveTranscript {
+  static CAUSE_MESSAGE = "The requested language is not translatable";
+};
+var TranslationLanguageNotAvailable = class extends CouldNotRetrieveTranscript {
+  static CAUSE_MESSAGE = "The requested translation language is not available";
+};
+var FailedToCreateConsentCookie = class extends CouldNotRetrieveTranscript {
+  static CAUSE_MESSAGE = "Failed to automatically give consent to saving cookies";
+};
+var NoTranscriptFound = class extends CouldNotRetrieveTranscript {
+  _requestedLanguageCodes = [];
+  _transcriptData = { toString: () => "" };
+  _initialized = false;
+  static CAUSE_MESSAGE = "No transcripts were found for any of the requested language codes: {requested_language_codes}\n\n{transcript_data}";
+  constructor(videoId, requestedLanguageCodes, transcriptData) {
+    super(videoId);
+    this._requestedLanguageCodes = Array.from(requestedLanguageCodes);
+    this._transcriptData = transcriptData;
+    this._initialized = true;
+    this.message = this.buildErrorMessage();
+  }
+  get cause() {
+    if (!this._initialized) return "";
+    const langs = `[${this._requestedLanguageCodes.map((c) => `'${c}'`).join(", ")}]`;
+    return this.constructor.CAUSE_MESSAGE.replace(
+      "{requested_language_codes}",
+      langs
+    ).replace("{transcript_data}", String(this._transcriptData));
+  }
+};
+var PoTokenRequired = class extends CouldNotRetrieveTranscript {
+  static CAUSE_MESSAGE = "The requested video cannot be retrieved without a PO Token. If this happens, please open a GitHub issue!";
+};
+
+// src/utils/htmlEntities.ts
+var NAMED = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0"
+};
+function decodeHtmlEntities(input) {
+  if (!input) return input;
+  return input.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z][a-zA-Z0-9]+);/g, (match, body) => {
+    if (body.startsWith("#x") || body.startsWith("#X")) {
+      const code = Number.parseInt(body.slice(2), 16);
+      if (Number.isFinite(code) && code >= 0 && code <= 1114111) {
+        try {
+          return String.fromCodePoint(code);
+        } catch {
+          return match;
+        }
+      }
+      return match;
+    }
+    if (body.startsWith("#")) {
+      const code = Number.parseInt(body.slice(1), 10);
+      if (Number.isFinite(code) && code >= 0 && code <= 1114111) {
+        try {
+          return String.fromCodePoint(code);
+        } catch {
+          return match;
+        }
+      }
+      return match;
+    }
+    const named = NAMED[body];
+    return named ?? match;
+  });
+}
+
+// src/transcripts/fetchedTranscript.ts
+var FetchedTranscript = class {
+  snippets;
+  videoId;
+  language;
+  languageCode;
+  isGenerated;
+  constructor(init) {
+    this.snippets = init.snippets;
+    this.videoId = init.videoId;
+    this.language = init.language;
+    this.languageCode = init.languageCode;
+    this.isGenerated = init.isGenerated;
+  }
+  [Symbol.iterator]() {
+    return this.snippets[Symbol.iterator]();
+  }
+  get length() {
+    return this.snippets.length;
+  }
+  toRawData() {
+    return this.snippets.map((s) => ({
+      text: s.text,
+      start: s.start,
+      duration: s.duration
+    }));
+  }
+};
+
+// src/utils/xml.ts
+var TEXT_ELEMENT_REGEX = /<text\b([^>]*)>([\s\S]*?)<\/text>/g;
+var ATTR_REGEX = /([a-zA-Z_:][\w:.-]*)\s*=\s*"([^"]*)"/g;
+function parseTranscriptXml(raw) {
+  const out = [];
+  TEXT_ELEMENT_REGEX.lastIndex = 0;
+  let match;
+  while ((match = TEXT_ELEMENT_REGEX.exec(raw)) !== null) {
+    const attrString = match[1] ?? "";
+    const innerText = match[2] ?? "";
+    const attrs = {};
+    ATTR_REGEX.lastIndex = 0;
+    let attrMatch;
+    while ((attrMatch = ATTR_REGEX.exec(attrString)) !== null) {
+      const key = attrMatch[1];
+      const value = attrMatch[2];
+      if (key !== void 0 && value !== void 0) {
+        attrs[key] = value;
+      }
+    }
+    out.push({ text: innerText, attrs });
+  }
+  return out;
+}
+
+// src/transcripts/parser.ts
+var FORMATTING_TAGS = [
+  "strong",
+  "em",
+  "b",
+  "i",
+  "mark",
+  "small",
+  "del",
+  "ins",
+  "sub",
+  "sup"
+];
+var STRIP_ALL_REGEX = /<[^>]*>/gi;
+function buildPreserveRegex() {
+  const formats = FORMATTING_TAGS.join("|");
+  return new RegExp(`<\\/?(?!\\/?(${formats})\\b).*?\\b>`, "gi");
+}
+var TranscriptParser = class {
+  _htmlRegex;
+  constructor(preserveFormatting = false) {
+    this._htmlRegex = preserveFormatting ? buildPreserveRegex() : STRIP_ALL_REGEX;
+  }
+  parse(rawData) {
+    const elements = parseTranscriptXml(rawData);
+    const out = [];
+    for (const el of elements) {
+      if (el.text === "") continue;
+      const xmlDecoded = decodeHtmlEntities(el.text);
+      const htmlDecoded = decodeHtmlEntities(xmlDecoded);
+      this._htmlRegex.lastIndex = 0;
+      const stripped = htmlDecoded.replace(this._htmlRegex, "");
+      const startAttr = el.attrs["start"] ?? "0";
+      const durAttr = el.attrs["dur"] ?? "0.0";
+      out.push({
+        text: stripped,
+        start: Number.parseFloat(startAttr),
+        duration: Number.parseFloat(durAttr)
+      });
+    }
+    return out;
+  }
+};
+
+// src/transcripts/transcript.ts
+var Transcript = class _Transcript {
+  videoId;
+  language;
+  languageCode;
+  isGenerated;
+  translationLanguages;
+  _httpClient;
+  _url;
+  _translationLanguagesByCode;
+  constructor(httpClient, videoId, url, language, languageCode, isGenerated, translationLanguages) {
+    this._httpClient = httpClient;
+    this.videoId = videoId;
+    this._url = url;
+    this.language = language;
+    this.languageCode = languageCode;
+    this.isGenerated = isGenerated;
+    this.translationLanguages = translationLanguages;
+    this._translationLanguagesByCode = new Map(
+      translationLanguages.map((tl) => [tl.languageCode, tl.language])
+    );
+  }
+  get isTranslatable() {
+    return this.translationLanguages.length > 0;
+  }
+  async fetch(options = {}) {
+    if (this._url.includes("&exp=xpe")) {
+      throw new PoTokenRequired(this.videoId);
+    }
+    const response = await this._httpClient.get(this._url);
+    if (response.status === 429) {
+      throw new IpBlocked(this.videoId);
+    }
+    if (!response.ok) {
+      throw new YouTubeRequestFailed(
+        this.videoId,
+        `${response.status} ${response.statusText}`
+      );
+    }
+    const xml = await response.text();
+    const parser = new TranscriptParser(options.preserveFormatting ?? false);
+    const snippets = parser.parse(xml);
+    return new FetchedTranscript({
+      snippets,
+      videoId: this.videoId,
+      language: this.language,
+      languageCode: this.languageCode,
+      isGenerated: this.isGenerated
+    });
+  }
+  translate(languageCode) {
+    if (!this.isTranslatable) {
+      throw new NotTranslatable(this.videoId);
+    }
+    const targetLanguage = this._translationLanguagesByCode.get(languageCode);
+    if (targetLanguage === void 0) {
+      throw new TranslationLanguageNotAvailable(this.videoId);
+    }
+    return new _Transcript(
+      this._httpClient,
+      this.videoId,
+      `${this._url}&tlang=${languageCode}`,
+      targetLanguage,
+      languageCode,
+      true,
+      []
+    );
+  }
+  toString() {
+    return `${this.languageCode} ("${this.language}")${this.isTranslatable ? "[TRANSLATABLE]" : ""}`;
+  }
+};
+
+// src/transcripts/transcriptList.ts
+var TranscriptList = class _TranscriptList {
+  videoId;
+  _manuallyCreated;
+  _generated;
+  _translationLanguages;
+  constructor(videoId, manuallyCreated, generated, translationLanguages) {
+    this.videoId = videoId;
+    this._manuallyCreated = manuallyCreated;
+    this._generated = generated;
+    this._translationLanguages = translationLanguages;
+  }
+  static build(httpClient, videoId, captionsJson) {
+    const translationLanguages = (captionsJson.translationLanguages ?? []).map((tl) => ({
+      language: tl.languageName.runs[0]?.text ?? "",
+      languageCode: tl.languageCode
+    }));
+    const manuallyCreated = /* @__PURE__ */ new Map();
+    const generated = /* @__PURE__ */ new Map();
+    for (const caption of captionsJson.captionTracks) {
+      const isAsr = caption.kind === "asr";
+      const target = isAsr ? generated : manuallyCreated;
+      const cleanedUrl = caption.baseUrl.replace("&fmt=srv3", "");
+      const transcriptTranslationLangs = caption.isTranslatable ? translationLanguages : [];
+      target.set(
+        caption.languageCode,
+        new Transcript(
+          httpClient,
+          videoId,
+          cleanedUrl,
+          caption.name.runs[0]?.text ?? "",
+          caption.languageCode,
+          isAsr,
+          transcriptTranslationLangs
+        )
+      );
+    }
+    return new _TranscriptList(
+      videoId,
+      manuallyCreated,
+      generated,
+      translationLanguages
+    );
+  }
+  *[Symbol.iterator]() {
+    for (const t of this._manuallyCreated.values()) yield t;
+    for (const t of this._generated.values()) yield t;
+  }
+  findTranscript(languageCodes) {
+    return this._findTranscript(languageCodes, [
+      this._manuallyCreated,
+      this._generated
+    ]);
+  }
+  findGeneratedTranscript(languageCodes) {
+    return this._findTranscript(languageCodes, [this._generated]);
+  }
+  findManuallyCreatedTranscript(languageCodes) {
+    return this._findTranscript(languageCodes, [this._manuallyCreated]);
+  }
+  _findTranscript(languageCodes, transcriptDicts) {
+    const codes = Array.from(languageCodes);
+    for (const code of codes) {
+      for (const dict of transcriptDicts) {
+        const found = dict.get(code);
+        if (found !== void 0) return found;
+      }
+    }
+    throw new NoTranscriptFound(this.videoId, codes, this);
+  }
+  toString() {
+    const describe = (lines) => lines.length === 0 ? "None" : lines.map((l) => ` - ${l}`).join("\n");
+    const manuallyCreated = describe(
+      Array.from(this._manuallyCreated.values()).map((t) => t.toString())
+    );
+    const generated = describe(
+      Array.from(this._generated.values()).map((t) => t.toString())
+    );
+    const translations = describe(
+      this._translationLanguages.map(
+        (tl) => `${tl.languageCode} ("${tl.language}")`
+      )
+    );
+    return `For this video (${this.videoId}) transcripts are available in the following languages:
+
+(MANUALLY CREATED)
+${manuallyCreated}
+
+(GENERATED)
+${generated}
+
+(TRANSLATION LANGUAGES)
+${translations}`;
+  }
+};
+
+// src/transcripts/fetcher.ts
+var PLAYABILITY_STATUS_OK = "OK";
+var PLAYABILITY_STATUS_ERROR = "ERROR";
+var PLAYABILITY_STATUS_LOGIN_REQUIRED = "LOGIN_REQUIRED";
+var REASON_BOT_DETECTED = "Sign in to confirm you\u2019re not a bot";
+var REASON_AGE_RESTRICTED = "This video may be inappropriate for some users.";
+var REASON_VIDEO_UNAVAILABLE = "This video is unavailable";
+var INNERTUBE_API_KEY_REGEX = /"INNERTUBE_API_KEY":\s*"([a-zA-Z0-9_-]+)"/;
+var CONSENT_COOKIE_REGEX = /name="v" value="(.*?)"/;
+var CONSENT_FORM_MARKER = 'action="https://consent.youtube.com/s"';
+var RECAPTCHA_MARKER = 'class="g-recaptcha"';
+async function raiseHttpErrors(response, videoId) {
+  if (response.status === 429) {
+    throw new IpBlocked(videoId);
+  }
+  if (!response.ok) {
+    throw new YouTubeRequestFailed(
+      videoId,
+      `${response.status} ${response.statusText || "HTTP error"}`
+    );
+  }
+  return response;
+}
+var TranscriptListFetcher = class {
+  _httpClient;
+  _proxyConfig;
+  constructor(httpClient, proxyConfig) {
+    this._httpClient = httpClient;
+    this._proxyConfig = proxyConfig;
+  }
+  async fetch(videoId) {
+    const captionsJson = await this._fetchCaptionsJson(videoId, 0);
+    return TranscriptList.build(this._httpClient, videoId, captionsJson);
+  }
+  async _fetchCaptionsJson(videoId, tryNumber) {
+    try {
+      const html = await this._fetchVideoHtml(videoId);
+      const apiKey = this._extractInnertubeApiKey(html, videoId);
+      const innertubeData = await this._fetchInnertubeData(videoId, apiKey);
+      return this._extractCaptionsJson(innertubeData, videoId);
+    } catch (err) {
+      if (err instanceof RequestBlocked) {
+        const retries = this._proxyConfig?.retriesWhenBlocked ?? 0;
+        if (tryNumber + 1 < retries) {
+          return this._fetchCaptionsJson(videoId, tryNumber + 1);
+        }
+        throw err.withProxyConfig(this._proxyConfig ?? null);
+      }
+      throw err;
+    }
+  }
+  _extractInnertubeApiKey(html, videoId) {
+    const match = INNERTUBE_API_KEY_REGEX.exec(html);
+    if (match && match[1]) {
+      return match[1];
+    }
+    if (html.includes(RECAPTCHA_MARKER)) {
+      throw new IpBlocked(videoId);
+    }
+    throw new YouTubeDataUnparsable(videoId);
+  }
+  _extractCaptionsJson(innertubeData, videoId) {
+    this._assertPlayability(innertubeData.playabilityStatus, videoId);
+    const captionsJson = innertubeData.captions?.playerCaptionsTracklistRenderer;
+    if (!captionsJson || !captionsJson.captionTracks) {
+      throw new TranscriptsDisabled(videoId);
+    }
+    return captionsJson;
+  }
+  _assertPlayability(playabilityStatusData, videoId) {
+    if (!playabilityStatusData) return;
+    const status = playabilityStatusData.status;
+    if (!status || status === PLAYABILITY_STATUS_OK) return;
+    const reason = playabilityStatusData.reason;
+    if (status === PLAYABILITY_STATUS_LOGIN_REQUIRED) {
+      if (reason === REASON_BOT_DETECTED) {
+        throw new RequestBlocked(videoId);
+      }
+      if (reason === REASON_AGE_RESTRICTED) {
+        throw new AgeRestricted(videoId);
+      }
+    }
+    if (status === PLAYABILITY_STATUS_ERROR && reason === REASON_VIDEO_UNAVAILABLE) {
+      if (videoId.startsWith("http://") || videoId.startsWith("https://")) {
+        throw new InvalidVideoId(videoId);
+      }
+      throw new VideoUnavailable(videoId);
+    }
+    const subreasons = playabilityStatusData.errorScreen?.playerErrorMessageRenderer?.subreason?.runs ?? [];
+    throw new VideoUnplayable(
+      videoId,
+      reason ?? null,
+      subreasons.map((r) => r.text ?? "")
+    );
+  }
+  _createConsentCookie(html, videoId) {
+    const match = CONSENT_COOKIE_REGEX.exec(html);
+    if (!match || !match[1]) {
+      throw new FailedToCreateConsentCookie(videoId);
+    }
+    this._httpClient.setCookie("CONSENT", `YES+${match[1]}`, ".youtube.com");
+  }
+  async _fetchVideoHtml(videoId) {
+    let html = await this._fetchHtml(videoId);
+    if (html.includes(CONSENT_FORM_MARKER)) {
+      this._createConsentCookie(html, videoId);
+      html = await this._fetchHtml(videoId);
+      if (html.includes(CONSENT_FORM_MARKER)) {
+        throw new FailedToCreateConsentCookie(videoId);
+      }
+    }
+    return html;
+  }
+  async _fetchHtml(videoId) {
+    const response = await this._httpClient.get(watchUrl(videoId));
+    const checked = await raiseHttpErrors(response, videoId);
+    const text = await checked.text();
+    return decodeHtmlEntities(text);
+  }
+  async _fetchInnertubeData(videoId, apiKey) {
+    const response = await this._httpClient.post(innertubeApiUrl(apiKey), {
+      context: INNERTUBE_CONTEXT,
+      videoId
+    });
+    const checked = await raiseHttpErrors(response, videoId);
+    return await checked.json();
+  }
+};
+
+// src/utils/httpClient.ts
+function isBun() {
+  return typeof globalThis.Bun !== "undefined";
+}
+function isDeno() {
+  return typeof globalThis.Deno !== "undefined";
+}
+function createCookieJar() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    set(name, value, domain) {
+      const key = domain.startsWith(".") ? domain : `.${domain}`;
+      let inner = store.get(key);
+      if (!inner) {
+        inner = /* @__PURE__ */ new Map();
+        store.set(key, inner);
+      }
+      inner.set(name, value);
+    },
+    get(host) {
+      const parts = [];
+      for (const [domain, cookies] of store) {
+        const bare = domain.startsWith(".") ? domain.slice(1) : domain;
+        if (host === bare || host.endsWith(`.${bare}`)) {
+          for (const [name, value] of cookies) {
+            parts.push(`${name}=${value}`);
+          }
+        }
+      }
+      return parts.length > 0 ? parts.join("; ") : void 0;
+    }
+  };
+}
+var HttpClient = class {
+  _proxyConfig;
+  _userFetch;
+  _cookies = createCookieJar();
+  _undiciDispatcher = null;
+  _undiciLoaded = false;
+  constructor(options = {}) {
+    this._proxyConfig = options.proxyConfig;
+    this._userFetch = options.fetchFn;
+    if (this._proxyConfig && !this._userFetch && isDeno()) {
+      throw new Error(
+        "Proxy support on Deno requires a custom fetchFn. Pass `fetchFn` configured with `Deno.createHttpClient` to YouTubeTranscriptApi."
+      );
+    }
+  }
+  setCookie(name, value, domain) {
+    this._cookies.set(name, value, domain);
+  }
+  async get(url) {
+    return this._fetch(url, { method: "GET" });
+  }
+  async post(url, jsonBody) {
+    return this._fetch(url, {
+      method: "POST",
+      body: JSON.stringify(jsonBody),
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  async _fetch(url, init) {
+    const headers = new Headers(init.headers);
+    if (!headers.has("Accept-Language")) {
+      headers.set("Accept-Language", "en-US");
+    }
+    if (this._proxyConfig?.preventKeepingConnectionsAlive) {
+      headers.set("Connection", "close");
+    }
+    let host;
+    try {
+      host = new URL(url).host;
+    } catch {
+      host = "";
+    }
+    if (host) {
+      const cookieHeader = this._cookies.get(host);
+      if (cookieHeader) {
+        headers.set("Cookie", cookieHeader);
+      }
+    }
+    const finalInit = { ...init, headers };
+    if (this._userFetch) {
+      return this._userFetch(url, finalInit);
+    }
+    if (this._proxyConfig) {
+      const proxyUrl = url.startsWith("https:") ? this._proxyConfig.httpsUrl : this._proxyConfig.httpUrl;
+      if (proxyUrl) {
+        if (isBun()) {
+          const bunRef = globalThis.Bun;
+          if (bunRef) {
+            return bunRef.fetch(url, {
+              ...finalInit,
+              // Bun-specific option
+              proxy: proxyUrl
+            });
+          }
+        }
+        const dispatcher = await this._getUndiciDispatcher(proxyUrl);
+        return fetch(url, {
+          ...finalInit,
+          dispatcher
+        });
+      }
+    }
+    return fetch(url, finalInit);
+  }
+  async _getUndiciDispatcher(proxyUrl) {
+    if (this._undiciLoaded && this._undiciDispatcher) {
+      return this._undiciDispatcher;
+    }
+    try {
+      const undici = await import('undici');
+      this._undiciDispatcher = new undici.ProxyAgent({ uri: proxyUrl });
+      this._undiciLoaded = true;
+      return this._undiciDispatcher;
+    } catch (err) {
+      throw new Error(
+        "Proxy support on Node.js requires the optional peer dependency `undici`. Install it with `npm install undici`, or pass a custom `fetchFn` to YouTubeTranscriptApi. Original error: " + String(err)
+      );
+    }
+  }
+};
+
+// src/api.ts
+var YouTubeTranscriptApi = class {
+  _httpClient;
+  _fetcher;
+  constructor(options = {}) {
+    this._httpClient = new HttpClient(options);
+    this._fetcher = new TranscriptListFetcher(this._httpClient, options.proxyConfig);
+  }
+  async list(videoId) {
+    return this._fetcher.fetch(videoId);
+  }
+  async fetch(videoId, options = {}) {
+    const languages = Array.from(options.languages ?? ["en"]);
+    const transcriptList = await this.list(videoId);
+    const transcript = transcriptList.findTranscript(languages);
+    return transcript.fetch({
+      preserveFormatting: options.preserveFormatting ?? false
+    });
+  }
+};
+
+// src/formatters/base.ts
+var Formatter = class {
+};
+
+// src/formatters/jsonFormatter.ts
+var JSONFormatter = class extends Formatter {
+  formatTranscript(transcript, options = {}) {
+    return JSON.stringify(transcript.toRawData(), null, options.indent);
+  }
+  formatTranscripts(transcripts, options = {}) {
+    return JSON.stringify(
+      transcripts.map((t) => t.toRawData()),
+      null,
+      options.indent
+    );
+  }
+};
+
+// src/formatters/prettyPrintFormatter.ts
+var PrettyPrintFormatter = class extends Formatter {
+  formatTranscript(transcript) {
+    return JSON.stringify(transcript.toRawData(), null, 2);
+  }
+  formatTranscripts(transcripts) {
+    return JSON.stringify(
+      transcripts.map((t) => t.toRawData()),
+      null,
+      2
+    );
+  }
+};
+
+// src/formatters/textFormatter.ts
+var TextFormatter = class extends Formatter {
+  formatTranscript(transcript) {
+    return transcript.snippets.map((s) => s.text).join("\n");
+  }
+  formatTranscripts(transcripts) {
+    return transcripts.map((t) => this.formatTranscript(t)).join("\n\n\n");
+  }
+};
+
+// src/formatters/textBasedFormatter.ts
+var TextBasedFormatter = class extends TextFormatter {
+  _secondsToTimestamp(time) {
+    const t = Number(time);
+    const totalSecs = Math.floor(t);
+    const hours = Math.floor(totalSecs / 3600);
+    const mins = Math.floor((totalSecs - hours * 3600) / 60);
+    const secs = totalSecs - hours * 3600 - mins * 60;
+    const ms = Math.round((t - totalSecs) * 1e3);
+    return this._formatTimestamp(hours, mins, secs, ms);
+  }
+  formatTranscript(transcript) {
+    const lines = [];
+    const snippets = transcript.snippets;
+    for (let i = 0; i < snippets.length; i++) {
+      const line = snippets[i];
+      const end = line.start + line.duration;
+      const next = snippets[i + 1];
+      const endTime = next !== void 0 && next.start < end ? next.start : end;
+      const timeText = `${this._secondsToTimestamp(line.start)} --> ${this._secondsToTimestamp(endTime)}`;
+      lines.push(this._formatTranscriptHelper(i, timeText, line));
+    }
+    return this._formatTranscriptHeader(lines);
+  }
+};
+function pad(value, width) {
+  return String(value).padStart(width, "0");
+}
+
+// src/formatters/srtFormatter.ts
+var SRTFormatter = class extends TextBasedFormatter {
+  _formatTimestamp(hours, mins, secs, ms) {
+    return `${pad(hours, 2)}:${pad(mins, 2)}:${pad(secs, 2)},${pad(ms, 3)}`;
+  }
+  _formatTranscriptHeader(lines) {
+    return lines.join("\n\n") + "\n";
+  }
+  _formatTranscriptHelper(i, timeText, snippet) {
+    return `${i + 1}
+${timeText}
+${snippet.text}`;
+  }
+};
+
+// src/formatters/webvttFormatter.ts
+var WebVTTFormatter = class extends TextBasedFormatter {
+  _formatTimestamp(hours, mins, secs, ms) {
+    return `${pad(hours, 2)}:${pad(mins, 2)}:${pad(secs, 2)}.${pad(ms, 3)}`;
+  }
+  _formatTranscriptHeader(lines) {
+    return "WEBVTT\n\n" + lines.join("\n\n") + "\n";
+  }
+  _formatTranscriptHelper(_i, timeText, snippet) {
+    return `${timeText}
+${snippet.text}`;
+  }
+};
+
+// src/formatters/index.ts
+var TYPES = {
+  json: JSONFormatter,
+  pretty: PrettyPrintFormatter,
+  text: TextFormatter,
+  webvtt: WebVTTFormatter,
+  srt: SRTFormatter
+};
+var UnknownFormatterType = class extends Error {
+  constructor(formatterType) {
+    super(
+      `The format '${formatterType}' is not supported. Choose one of the following formats: ${Object.keys(TYPES).join(", ")}`
+    );
+    this.name = "UnknownFormatterType";
+  }
+};
+var FormatterLoader = class {
+  static TYPES = TYPES;
+  load(formatterType = "pretty") {
+    if (!(formatterType in TYPES)) {
+      throw new UnknownFormatterType(formatterType);
+    }
+    const Cls = TYPES[formatterType];
+    return new Cls();
+  }
+};
+
+// src/proxies/proxyConfig.ts
+var InvalidProxyConfig = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidProxyConfig";
+  }
+};
+var ProxyConfig = class {
+  get preventKeepingConnectionsAlive() {
+    return false;
+  }
+  get retriesWhenBlocked() {
+    return 0;
+  }
+};
+
+// src/proxies/genericProxyConfig.ts
+var GenericProxyConfig = class extends ProxyConfig {
+  _httpUrl;
+  _httpsUrl;
+  constructor(options = {}) {
+    super();
+    const { httpUrl, httpsUrl } = options;
+    if (!httpUrl && !httpsUrl) {
+      throw new InvalidProxyConfig(
+        "GenericProxyConfig requires you to define at least one of the two: http or https"
+      );
+    }
+    this._httpUrl = httpUrl;
+    this._httpsUrl = httpsUrl;
+  }
+  get httpUrl() {
+    return this._httpUrl ?? this._httpsUrl;
+  }
+  get httpsUrl() {
+    return this._httpsUrl ?? this._httpUrl;
+  }
+};
+
+// src/proxies/webshareProxyConfig.ts
+var DEFAULT_DOMAIN_NAME = "p.webshare.io";
+var DEFAULT_PORT = 80;
+var ROTATE_SUFFIX = "-rotate";
+var WebshareProxyConfig = class extends GenericProxyConfig {
+  proxyUsername;
+  proxyPassword;
+  domainName;
+  proxyPort;
+  _filterIpLocations;
+  _retriesWhenBlocked;
+  constructor(options) {
+    super({ httpUrl: "placeholder" });
+    this.proxyUsername = options.proxyUsername;
+    this.proxyPassword = options.proxyPassword;
+    this.domainName = options.domainName ?? DEFAULT_DOMAIN_NAME;
+    this.proxyPort = options.proxyPort ?? DEFAULT_PORT;
+    this._filterIpLocations = options.filterIpLocations ?? [];
+    this._retriesWhenBlocked = options.retriesWhenBlocked ?? 10;
+  }
+  get url() {
+    const locationCodes = this._filterIpLocations.map((code) => `-${code.toUpperCase()}`).join("");
+    let username = this.proxyUsername;
+    if (username.endsWith(ROTATE_SUFFIX)) {
+      username = username.slice(0, -ROTATE_SUFFIX.length);
+    }
+    const encodedUser = encodeURIComponent(username);
+    const encodedPass = encodeURIComponent(this.proxyPassword);
+    return `http://${encodedUser}${locationCodes}${ROTATE_SUFFIX}:${encodedPass}@${this.domainName}:${this.proxyPort}/`;
+  }
+  get httpUrl() {
+    return this.url;
+  }
+  get httpsUrl() {
+    return this.url;
+  }
+  get preventKeepingConnectionsAlive() {
+    return true;
+  }
+  get retriesWhenBlocked() {
+    return this._retriesWhenBlocked;
+  }
+};
+
+// src/utils/argv.ts
+var ArgvError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ArgvError";
+  }
+};
+function parseArgs(argv, spec) {
+  const flags = {};
+  const positional = [];
+  for (const [name, def] of Object.entries(spec)) {
+    if (def.default !== void 0) {
+      flags[name] = def.default;
+    } else if (def.kind === "boolean") {
+      flags[name] = false;
+    } else if (def.kind === "string[]") {
+      flags[name] = [];
+    }
+  }
+  const known = new Set(Object.keys(spec));
+  let i = 0;
+  let stopFlags = false;
+  while (i < argv.length) {
+    const token = argv[i];
+    if (stopFlags) {
+      positional.push(token);
+      i++;
+      continue;
+    }
+    if (token === "--") {
+      stopFlags = true;
+      i++;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const eqIdx = token.indexOf("=");
+      const rawName = eqIdx === -1 ? token.slice(2) : token.slice(2, eqIdx);
+      const inlineValue = eqIdx === -1 ? void 0 : token.slice(eqIdx + 1);
+      const name = rawName.replace(/-/g, "_");
+      if (!known.has(name)) {
+        throw new ArgvError(`Unknown argument: --${rawName}`);
+      }
+      const def = spec[name];
+      if (def.kind === "boolean") {
+        if (inlineValue !== void 0) {
+          throw new ArgvError(`Argument --${rawName} does not take a value`);
+        }
+        flags[name] = true;
+        i++;
+      } else if (def.kind === "string") {
+        if (inlineValue !== void 0) {
+          flags[name] = inlineValue;
+          i++;
+        } else {
+          const next = argv[i + 1];
+          if (next === void 0) {
+            throw new ArgvError(`Argument --${rawName} requires a value`);
+          }
+          flags[name] = next;
+          i += 2;
+        }
+      } else {
+        const collected = [];
+        if (inlineValue !== void 0) {
+          collected.push(inlineValue);
+          i++;
+        } else {
+          i++;
+        }
+        while (i < argv.length) {
+          const peek = argv[i];
+          if (peek === "--" || peek.startsWith("--")) break;
+          collected.push(peek);
+          i++;
+        }
+        flags[name] = collected;
+      }
+    } else {
+      positional.push(token);
+      i++;
+    }
+  }
+  return { positional, flags };
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var SPEC = {
+  list_transcripts: { kind: "boolean", default: false },
+  languages: { kind: "string[]", default: ["en"] },
+  exclude_generated: { kind: "boolean", default: false },
+  exclude_manually_created: { kind: "boolean", default: false },
+  format: { kind: "string", default: "pretty" },
+  translate: { kind: "string", default: "" },
+  webshare_proxy_username: { kind: "string", default: "" },
+  webshare_proxy_password: { kind: "string", default: "" },
+  http_proxy: { kind: "string", default: "" },
+  https_proxy: { kind: "string", default: "" },
+  version: { kind: "boolean", default: false },
+  help: { kind: "boolean", default: false }
+};
+var HELP_TEXT = `Usage: youtube-transcript [options] VIDEO_ID [VIDEO_ID ...]
+
+Fetch transcripts/subtitles for one or more YouTube videos.
+
+Options:
+  --list-transcripts             List available transcript languages instead of fetching.
+  --languages CODE [CODE ...]    Language codes in descending priority (default: en).
+  --exclude-generated            Skip auto-generated transcripts.
+  --exclude-manually-created     Skip manually created transcripts.
+  --format FORMAT                Output format: json, pretty, text, webvtt, srt (default: pretty).
+  --translate CODE               Translate to the given language code.
+  --webshare-proxy-username U    Webshare "Proxy Username".
+  --webshare-proxy-password P    Webshare "Proxy Password".
+  --http-proxy URL               HTTP proxy URL.
+  --https-proxy URL              HTTPS proxy URL.
+  --version                      Print version and exit.
+  --help                         Show this help message and exit.
+`;
+var YouTubeTranscriptCli = class {
+  _argv;
+  constructor(argv) {
+    this._argv = argv;
+  }
+  async run() {
+    let parsed;
+    try {
+      parsed = parseArgs(this._argv, SPEC);
+    } catch (err) {
+      if (err instanceof ArgvError) {
+        return { output: err.message, exitCode: 2 };
+      }
+      throw err;
+    }
+    const flags = parsed.flags;
+    if (flags["help"] === true) {
+      return { output: HELP_TEXT, exitCode: 0 };
+    }
+    if (flags["version"] === true) {
+      return { output: `youtube-transcript, version ${VERSION}`, exitCode: 0 };
+    }
+    if (parsed.positional.length === 0) {
+      return {
+        output: "error: at least one VIDEO_ID is required\n\n" + HELP_TEXT,
+        exitCode: 2
+      };
+    }
+    const videoIds = parsed.positional.map((id) => id.replace(/\\/g, ""));
+    const excludeManually = flags["exclude_manually_created"] === true;
+    const excludeGenerated = flags["exclude_generated"] === true;
+    if (excludeManually && excludeGenerated) {
+      return { output: "", exitCode: 0 };
+    }
+    let proxyConfig;
+    const httpProxy = flags["http_proxy"];
+    const httpsProxy = flags["https_proxy"];
+    if (httpProxy !== "" || httpsProxy !== "") {
+      proxyConfig = new GenericProxyConfig({
+        httpUrl: httpProxy || void 0,
+        httpsUrl: httpsProxy || void 0
+      });
+    }
+    const wsUser = flags["webshare_proxy_username"];
+    const wsPass = flags["webshare_proxy_password"];
+    if (wsUser !== "" || wsPass !== "") {
+      proxyConfig = new WebshareProxyConfig({
+        proxyUsername: wsUser,
+        proxyPassword: wsPass
+      });
+    }
+    const api = new YouTubeTranscriptApi({ proxyConfig });
+    const collected = [];
+    const exceptions = [];
+    let successCount = 0;
+    for (const videoId of videoIds) {
+      try {
+        const list = await api.list(videoId);
+        if (flags["list_transcripts"] === true) {
+          collected.push(list);
+        } else {
+          const fetched = await this._fetchTranscript(
+            list,
+            flags["languages"],
+            excludeManually,
+            excludeGenerated,
+            flags["translate"]
+          );
+          collected.push(fetched);
+        }
+        successCount++;
+      } catch (err) {
+        exceptions.push(err instanceof Error ? err.toString() : String(err));
+      }
+    }
+    const printSections = [...exceptions];
+    if (collected.length > 0) {
+      if (flags["list_transcripts"] === true) {
+        for (const item of collected) {
+          printSections.push(String(item));
+        }
+      } else {
+        const formatter = new FormatterLoader().load(flags["format"]);
+        printSections.push(
+          formatter.formatTranscripts(collected)
+        );
+      }
+    }
+    const output = printSections.join("\n\n");
+    const exitCode = successCount === 0 && videoIds.length > 0 ? 1 : 0;
+    return { output, exitCode };
+  }
+  async _fetchTranscript(transcriptList, languages, excludeManually, excludeGenerated, translate) {
+    let transcript;
+    if (excludeManually) {
+      transcript = transcriptList.findGeneratedTranscript(languages);
+    } else if (excludeGenerated) {
+      transcript = transcriptList.findManuallyCreatedTranscript(languages);
+    } else {
+      transcript = transcriptList.findTranscript(languages);
+    }
+    if (translate !== "") {
+      transcript = transcript.translate(translate);
+    }
+    return transcript.fetch();
+  }
+};
+async function main(argv = process.argv.slice(2)) {
+  const cli = new YouTubeTranscriptCli(argv);
+  const { output, exitCode } = await cli.run();
+  if (output) {
+    process.stdout.write(output + "\n");
+  }
+  process.exit(exitCode);
+}
+var isDirectRun = (() => {
+  try {
+    if (typeof process === "undefined" || !process.argv[1]) return false;
+    const entry = process.argv[1];
+    return entry.endsWith("cli.js") || entry.endsWith("cli.cjs");
+  } catch {
+    return false;
+  }
+})();
+if (isDirectRun) {
+  void main();
+}
+
+exports.YouTubeTranscriptCli = YouTubeTranscriptCli;
+exports.main = main;
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map