extract-youtube 1.0.538 → 1.0.539

package/dist/cli-Do33ETWE.js

@@ -0,0 +1,2024 @@
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+let html_entities = require("html-entities");
+let fast_xml_parser = require("fast-xml-parser");
+let https_proxy_agent = require("https-proxy-agent");
+// src/errors/index.ts
+var _CouldNotRetrieveTranscript;
+var _RequestBlocked;
+var YOUTUBE_WATCH_URL$1 = "https://www.youtube.com/watch?v={video_id}";
+/**
+* Base exception class for all YouTube Transcript API errors.
+*/
+var YouTubeTranscriptApiException = class YouTubeTranscriptApiException extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "YouTubeTranscriptApiException";
+		Object.setPrototypeOf(this, YouTubeTranscriptApiException.prototype);
+	}
+};
+/**
+* Base exception class for transcript retrieval errors.
+*/
+var CouldNotRetrieveTranscript = class CouldNotRetrieveTranscript extends YouTubeTranscriptApiException {
+	constructor(videoId) {
+		super("");
+		this.causeMessage = "";
+		this.videoId = videoId;
+		Object.setPrototypeOf(this, CouldNotRetrieveTranscript.prototype);
+		this.message = this.buildErrorMessage();
+	}
+	buildErrorMessage() {
+		const videoUrl = YOUTUBE_WATCH_URL$1.replace("{video_id}", this.videoId);
+		let errorMessage = CouldNotRetrieveTranscript.ERROR_MESSAGE.replace("{video_url}", videoUrl);
+		const cause = this.getCause();
+		if (cause) {
+			errorMessage += CouldNotRetrieveTranscript.CAUSE_MESSAGE_INTRO.replace("{cause}", cause);
+			errorMessage += CouldNotRetrieveTranscript.GITHUB_REFERRAL;
+		}
+		return errorMessage;
+	}
+	getCause() {
+		return this.causeMessage;
+	}
+};
+_CouldNotRetrieveTranscript = CouldNotRetrieveTranscript;
+_CouldNotRetrieveTranscript.ERROR_MESSAGE = "\nCould not retrieve a transcript for the video {video_url}!";
+_CouldNotRetrieveTranscript.CAUSE_MESSAGE_INTRO = " This is most likely caused by:\n\n{cause}";
+_CouldNotRetrieveTranscript.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 YouTubeDataUnparsable = class YouTubeDataUnparsable extends CouldNotRetrieveTranscript {
+	constructor(videoId) {
+		super(videoId);
+		this.causeMessage = "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)!";
+		this.name = "YouTubeDataUnparsable";
+		Object.setPrototypeOf(this, YouTubeDataUnparsable.prototype);
+		this.message = this.buildErrorMessage();
+	}
+};
+var YouTubeRequestFailed = class YouTubeRequestFailed extends CouldNotRetrieveTranscript {
+	constructor(videoId, httpError) {
+		super(videoId);
+		this.httpErrorReason = httpError.message;
+		this.name = "YouTubeRequestFailed";
+		Object.setPrototypeOf(this, YouTubeRequestFailed.prototype);
+		this.message = this.buildErrorMessage();
+	}
+	getCause() {
+		return `Request to YouTube failed: ${this.httpErrorReason}`;
+	}
+};
+var VideoUnplayable = class VideoUnplayable extends CouldNotRetrieveTranscript {
+	constructor(videoId, unplayableReason, additionalDetails) {
+		super(videoId);
+		this.unplayableReason = unplayableReason;
+		this.additionalDetails = additionalDetails;
+		this.name = "VideoUnplayable";
+		Object.setPrototypeOf(this, VideoUnplayable.prototype);
+		this.message = this.buildErrorMessage();
+	}
+	getCause() {
+		let reason = this.unplayableReason ?? "No reason specified!";
+		if (this.additionalDetails.length > 0) {
+			const formattedDetails = this.additionalDetails.map((detail) => ` - ${detail}`).join("\n");
+			reason = `${reason}\n\nAdditional Details:\n${formattedDetails}`;
+		}
+		return `The video is unplayable for the following reason: ${reason}`;
+	}
+};
+var VideoUnavailable = class VideoUnavailable extends CouldNotRetrieveTranscript {
+	constructor(videoId) {
+		super(videoId);
+		this.causeMessage = "The video is no longer available";
+		this.name = "VideoUnavailable";
+		Object.setPrototypeOf(this, VideoUnavailable.prototype);
+		this.message = this.buildErrorMessage();
+	}
+};
+var InvalidVideoId = class InvalidVideoId extends CouldNotRetrieveTranscript {
+	constructor(videoId) {
+		super(videoId);
+		this.causeMessage = "You provided an invalid video id. Make sure you are using the video id and NOT the url!\n\nDo NOT run: `new YouTubeTranscriptApi().fetch(\"https://www.youtube.com/watch?v=1234\")`\nInstead run: `new YouTubeTranscriptApi().fetch(\"1234\")`";
+		this.name = "InvalidVideoId";
+		Object.setPrototypeOf(this, InvalidVideoId.prototype);
+		this.message = this.buildErrorMessage();
+	}
+};
+var AgeRestricted = class AgeRestricted extends CouldNotRetrieveTranscript {
+	constructor(videoId) {
+		super(videoId);
+		this.causeMessage = "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.";
+		this.name = "AgeRestricted";
+		Object.setPrototypeOf(this, AgeRestricted.prototype);
+		this.message = this.buildErrorMessage();
+	}
+};
+var FailedToCreateConsentCookie = class FailedToCreateConsentCookie extends CouldNotRetrieveTranscript {
+	constructor(videoId) {
+		super(videoId);
+		this.causeMessage = "Failed to automatically give consent to saving cookies";
+		this.name = "FailedToCreateConsentCookie";
+		Object.setPrototypeOf(this, FailedToCreateConsentCookie.prototype);
+		this.message = this.buildErrorMessage();
+	}
+};
+var TranscriptsDisabled = class TranscriptsDisabled extends CouldNotRetrieveTranscript {
+	constructor(videoId) {
+		super(videoId);
+		this.causeMessage = "Subtitles are disabled for this video";
+		this.name = "TranscriptsDisabled";
+		Object.setPrototypeOf(this, TranscriptsDisabled.prototype);
+		this.message = this.buildErrorMessage();
+	}
+};
+var NotTranslatable = class NotTranslatable extends CouldNotRetrieveTranscript {
+	constructor(videoId) {
+		super(videoId);
+		this.causeMessage = "The requested language is not translatable";
+		this.name = "NotTranslatable";
+		Object.setPrototypeOf(this, NotTranslatable.prototype);
+		this.message = this.buildErrorMessage();
+	}
+};
+var TranslationLanguageNotAvailable = class TranslationLanguageNotAvailable extends CouldNotRetrieveTranscript {
+	constructor(videoId) {
+		super(videoId);
+		this.causeMessage = "The requested translation language is not available";
+		this.name = "TranslationLanguageNotAvailable";
+		Object.setPrototypeOf(this, TranslationLanguageNotAvailable.prototype);
+		this.message = this.buildErrorMessage();
+	}
+};
+var NoTranscriptFound = class NoTranscriptFound extends CouldNotRetrieveTranscript {
+	constructor(videoId, requestedLanguageCodes, availableTranscriptData) {
+		super(videoId);
+		this.requestedLanguageCodes = requestedLanguageCodes;
+		this.availableTranscriptData = availableTranscriptData;
+		this.name = "NoTranscriptFound";
+		Object.setPrototypeOf(this, NoTranscriptFound.prototype);
+		this.message = this.buildErrorMessage();
+	}
+	getCause() {
+		return `No transcripts were found for any of the requested language codes: ${this.requestedLanguageCodes.join(", ")}\n\n` + this.availableTranscriptData.toString();
+	}
+};
+var PoTokenRequired = class PoTokenRequired extends CouldNotRetrieveTranscript {
+	constructor(videoId) {
+		super(videoId);
+		this.causeMessage = "The requested video cannot be retrieved without a PO Token. If this happens, please open a GitHub issue!";
+		this.name = "PoTokenRequired";
+		Object.setPrototypeOf(this, PoTokenRequired.prototype);
+		this.message = this.buildErrorMessage();
+	}
+};
+var RequestBlocked = class RequestBlocked extends CouldNotRetrieveTranscript {
+	constructor(videoId) {
+		super(videoId);
+		this.proxyConfig = null;
+		this.name = "RequestBlocked";
+		Object.setPrototypeOf(this, RequestBlocked.prototype);
+		this.message = this.buildErrorMessage();
+	}
+	withProxyConfig(proxyConfig) {
+		this.proxyConfig = proxyConfig;
+		this.message = this.buildErrorMessage();
+		return this;
+	}
+	getCause() {
+		if (this.proxyConfig && this.proxyConfig.constructor.name === "WebshareProxyConfig") return RequestBlocked.WITH_WEBSHARE_PROXY_CAUSE_MESSAGE;
+		if (this.proxyConfig && this.proxyConfig.constructor.name === "GenericProxyConfig") return RequestBlocked.WITH_GENERIC_PROXY_CAUSE_MESSAGE;
+		return RequestBlocked.DEFAULT_CAUSE_MESSAGE;
+	}
+};
+_RequestBlocked = RequestBlocked;
+_RequestBlocked.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";
+_RequestBlocked.DEFAULT_CAUSE_MESSAGE = _RequestBlocked.BASE_CAUSE_MESSAGE + "There are two things you can do to work around this:\n1. 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).\n2. (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!";
+_RequestBlocked.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.\n\nThe 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\"!).\n\nYou will find more information on how to easily integrate Webshare here: https://github.com/jdepoix/youtube-transcript-api?tab=readme-ov-file#using-webshare";
+_RequestBlocked.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!\n\nThe 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!\n\nYou 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 \n\nThank you for your support! <3";
+var IpBlocked = class IpBlocked extends RequestBlocked {
+	constructor(videoId) {
+		super(videoId);
+		this.causeMessage = "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\nWays 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";
+		this.name = "IpBlocked";
+		Object.setPrototypeOf(this, IpBlocked.prototype);
+		this.message = this.buildErrorMessage();
+	}
+	getCause() {
+		return this.causeMessage;
+	}
+};
+// src/models/fetched-transcript.ts
+/**
+* Represents a fetched transcript with all its snippets and metadata.
+* This class is iterable, allowing you to iterate over transcript snippets.
+*
+* @example
+* ```typescript
+* const transcript = await api.fetch('video_id');
+* for (const snippet of transcript) {
+*   console.log(snippet.text);
+* }
+* ```
+*/
+var FetchedTranscript = class {
+	/**
+	* Creates a new FetchedTranscript instance.
+	*
+	* @param {FetchedTranscriptSnippet[]} snippets - Array of transcript snippets
+	* @param {string} videoId - The video ID
+	* @param {string} language - The language name
+	* @param {string} languageCode - The language code
+	* @param {boolean} isGenerated - Whether the transcript is auto-generated
+	*/
+	constructor(snippets, videoId, language, languageCode, isGenerated) {
+		this.snippets = snippets;
+		this.videoId = videoId;
+		this.language = language;
+		this.languageCode = languageCode;
+		this.isGenerated = isGenerated;
+	}
+	/**
+	* Makes the transcript iterable, allowing for...of loops.
+	*
+	* @returns {Iterator<FetchedTranscriptSnippet>} Iterator over the snippets
+	*/
+	[Symbol.iterator]() {
+		return this.snippets[Symbol.iterator]();
+	}
+	/**
+	* Gets a snippet by index.
+	*
+	* @param {number} index - The index of the snippet
+	* @returns {FetchedTranscriptSnippet} The snippet at the given index
+	*/
+	getSnippetAtIndex(index) {
+		return this.snippets[index];
+	}
+	/**
+	* Alias for getSnippetAtIndex() for backward compatibility.
+	*
+	* @deprecated Use getSnippetAtIndex() instead
+	* @param {number} index - The index of the snippet
+	* @returns {FetchedTranscriptSnippet} The snippet at the given index
+	*/
+	get(index) {
+		return this.getSnippetAtIndex(index);
+	}
+	/**
+	* Gets the total number of snippets in the transcript.
+	*
+	* @returns {number} The number of snippets
+	*/
+	get length() {
+		return this.snippets.length;
+	}
+	/**
+	* Converts the transcript to raw data format (array of objects).
+	* This is useful for serialization or when you need plain data objects.
+	*
+	* @returns {Array<{text: string, start: number, duration: number}>} Raw transcript data
+	*/
+	toRawData() {
+		return this.snippets.map((snippet) => ({
+			text: snippet.text,
+			start: snippet.start,
+			duration: snippet.duration
+		}));
+	}
+};
+// src/parsers/transcript-parser.ts
+/**
+* @fileoverview Parser for converting YouTube transcript XML data into structured snippets
+*/
+var _TranscriptParser;
+/**
+* Parses transcript XML data from YouTube into FetchedTranscriptSnippet objects.
+*
+* @example
+* ```typescript
+* const parser = new TranscriptParser(false);
+* const snippets = parser.parseTranscriptXml(xmlData);
+* ```
+*/
+var TranscriptParser = class TranscriptParser {
+	/**
+	* Creates a new TranscriptParser instance.
+	*
+	* @param {boolean} [preserveFormatting=false] - Whether to preserve HTML formatting tags
+	*/
+	constructor(preserveFormatting = false) {
+		this.htmlRemovalRegex = this.buildHtmlRemovalRegex(preserveFormatting);
+	}
+	/**
+	* Builds a regex pattern for removing HTML tags based on formatting preferences.
+	*
+	* @private
+	* @param {boolean} preserveFormatting - Whether to preserve formatting tags
+	* @returns {RegExp} The HTML removal regex
+	*/
+	buildHtmlRemovalRegex(preserveFormatting) {
+		if (preserveFormatting) {
+			const pattern = `<\\/?(?!\\/?(?:${TranscriptParser.FORMATTING_TAGS.join("|")})\\b).*?\\b>`;
+			return new RegExp(pattern, "gi");
+		} else return /<[^>]*>/gi;
+	}
+	/**
+	* Parses raw XML transcript data into an array of transcript snippets.
+	*
+	* @param {string} xmlData - The raw XML data from YouTube's transcript API
+	* @returns {FetchedTranscriptSnippet[]} Array of parsed transcript snippets
+	*
+	* @example
+	* ```typescript
+	* const parser = new TranscriptParser();
+	* const snippets = parser.parseTranscriptXml(xmlData);
+	* for (const snippet of snippets) {
+	*   console.log(`${snippet.start}s: ${snippet.text}`);
+	* }
+	* ```
+	*/
+	parseTranscriptXml(xmlData) {
+		const textElements = new fast_xml_parser.XMLParser({
+			ignoreAttributes: false,
+			attributeNamePrefix: "@_"
+		}).parse(xmlData).transcript?.text || [];
+		return (Array.isArray(textElements) ? textElements : [textElements]).filter((element) => element["#text"]).map((element) => this.parseTranscriptSnippet(element));
+	}
+	/**
+	* Parses a single XML element into a FetchedTranscriptSnippet.
+	*
+	* @private
+	* @param {any} element - The XML element to parse
+	* @returns {FetchedTranscriptSnippet} The parsed snippet
+	*/
+	parseTranscriptSnippet(element) {
+		return {
+			text: this.cleanTranscriptText(element["#text"]),
+			start: this.parseFloatAttribute(element["@_start"]),
+			duration: this.parseFloatAttribute(element["@_dur"])
+		};
+	}
+	/**
+	* Parses a string attribute as a float, defaulting to 0 if invalid.
+	*
+	* @private
+	* @param {string | undefined} value - The attribute value to parse
+	* @returns {number} The parsed float value
+	*/
+	parseFloatAttribute(value) {
+		return parseFloat(value || "0");
+	}
+	/**
+	* Cleans transcript text by decoding HTML entities and removing HTML tags.
+	*
+	* @private
+	* @param {string} text - The raw transcript text
+	* @returns {string} The cleaned text
+	*/
+	cleanTranscriptText(text) {
+		if (typeof text !== "string") text = String(text || "");
+		return (0, html_entities.decode)(text).replace(this.htmlRemovalRegex, "");
+	}
+};
+_TranscriptParser = TranscriptParser;
+_TranscriptParser.FORMATTING_TAGS = [
+	"strong",
+	"em",
+	"b",
+	"i",
+	"mark",
+	"small",
+	"del",
+	"ins",
+	"sub",
+	"sup"
+];
+// src/utils/http-error-handler.ts
+/**
+* @fileoverview HTTP error handling utilities for YouTube API requests
+*/
+/**
+* Checks an HTTP response and throws appropriate errors if the request failed.
+*
+* @param {Response} response - The HTTP response to check
+* @param {string} videoId - The video ID associated with the request
+* @throws {IpBlocked} If status is 429 (Too Many Requests)
+* @throws {YouTubeRequestFailed} If status indicates an error
+*
+* @example
+* ```typescript
+* const response = await httpClient.get(url);
+* handleHttpErrors(response, videoId);
+* // If we reach here, the request was successful
+* ```
+*/
+function handleHttpErrors(response, videoId) {
+	if (response.status === 429) throw new IpBlocked(videoId);
+	if (!response.ok) {
+		const errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+		throw new YouTubeRequestFailed(videoId, new Error(errorMessage));
+	}
+}
+// src/models/transcript.ts
+/**
+* Represents a transcript that can be fetched or translated.
+* You typically obtain Transcript objects from a TranscriptList.
+*
+* @example
+* ```typescript
+* const transcriptList = await api.list('video_id');
+* const transcript = transcriptList.findTranscript(['en']);
+* const fetched = await transcript.fetch();
+* ```
+*/
+var Transcript = class Transcript {
+	/**
+	* Creates a new Transcript instance.
+	* You probably don't want to initialize this directly.
+	* Usually you'll access Transcript objects using a TranscriptList.
+	*
+	* @param {HttpClient} httpClient - HTTP client for making requests
+	* @param {string} videoId - The video ID
+	* @param {string} transcriptUrl - The transcript URL
+	* @param {string} language - The language name
+	* @param {string} languageCode - The language code
+	* @param {boolean} isGenerated - Whether the transcript is auto-generated
+	* @param {TranslationLanguage[]} translationLanguages - Available translation languages
+	*/
+	constructor(httpClient, videoId, transcriptUrl, language, languageCode, isGenerated, translationLanguages) {
+		this.httpClient = httpClient;
+		this.videoId = videoId;
+		this.transcriptUrl = transcriptUrl;
+		this.language = language;
+		this.languageCode = languageCode;
+		this.isGenerated = isGenerated;
+		this.translationLanguages = translationLanguages;
+		this.translationLanguagesMap = this.buildTranslationLanguagesMap(translationLanguages);
+	}
+	/**
+	* Builds a map of language codes to language names for quick lookup.
+	*
+	* @private
+	* @param {TranslationLanguage[]} languages - Array of translation languages
+	* @returns {Record<string, string>} Map of language code to language name
+	*/
+	buildTranslationLanguagesMap(languages) {
+		const map = {};
+		for (const lang of languages) map[lang.language_code] = lang.language;
+		return map;
+	}
+	/**
+	* Loads the actual transcript data from YouTube.
+	*
+	* @param {boolean} [preserveFormatting=false] - Whether to keep select HTML text formatting
+	* @returns {Promise<FetchedTranscript>} The fetched transcript with all snippets
+	* @throws {PoTokenRequired} If a PO Token is required for this video
+	* @throws {YouTubeRequestFailed} If the HTTP request fails
+	*
+	* @example
+	* ```typescript
+	* const transcript = transcriptList.findTranscript(['en']);
+	* const fetched = await transcript.fetch();
+	*
+	* // With formatting preserved
+	* const fetchedWithFormatting = await transcript.fetch(true);
+	* ```
+	*/
+	async fetch(preserveFormatting = false) {
+		if (this.transcriptUrl.includes("&exp=xpe")) throw new PoTokenRequired(this.videoId);
+		const response = await this.httpClient.get(this.transcriptUrl);
+		handleHttpErrors(response, this.videoId);
+		const xmlData = await response.text();
+		return new FetchedTranscript(new TranscriptParser(preserveFormatting).parseTranscriptXml(xmlData), this.videoId, this.language, this.languageCode, this.isGenerated);
+	}
+	/**
+	* Checks whether this transcript can be translated to other languages.
+	*
+	* @returns {boolean} True if the transcript supports translation
+	*/
+	get isTranslatable() {
+		return this.translationLanguages.length > 0;
+	}
+	/**
+	* Creates a translated version of this transcript.
+	*
+	* @param {string} targetLanguageCode - The target language code (e.g., 'de', 'fr')
+	* @returns {Transcript} A new Transcript object for the translated transcript
+	* @throws {NotTranslatable} If the transcript cannot be translated
+	* @throws {TranslationLanguageNotAvailable} If the requested language is not available
+	*
+	* @example
+	* ```typescript
+	* const englishTranscript = transcriptList.findTranscript(['en']);
+	* if (englishTranscript.isTranslatable) {
+	*   const germanTranscript = englishTranscript.translate('de');
+	*   const fetched = await germanTranscript.fetch();
+	* }
+	* ```
+	*/
+	translate(targetLanguageCode) {
+		if (!this.isTranslatable) throw new NotTranslatable(this.videoId);
+		if (!(targetLanguageCode in this.translationLanguagesMap)) throw new TranslationLanguageNotAvailable(this.videoId);
+		const translatedUrl = `${this.transcriptUrl}&tlang=${targetLanguageCode}`;
+		const translatedLanguage = this.translationLanguagesMap[targetLanguageCode];
+		return new Transcript(this.httpClient, this.videoId, translatedUrl, translatedLanguage, targetLanguageCode, true, []);
+	}
+	/**
+	* Returns a string representation of the transcript.
+	*
+	* @returns {string} A formatted string representation
+	*/
+	toString() {
+		const translatableFlag = this.isTranslatable ? "[TRANSLATABLE]" : "";
+		return `${this.languageCode} ("${this.language}")${translatableFlag}`;
+	}
+};
+// src/models/transcript-list.ts
+/**
+* Represents a list of available transcripts for a video.
+* This object is iterable and provides methods to search for specific transcripts.
+*
+* @example
+* ```typescript
+* const transcriptList = await api.list('video_id');
+*
+* // Iterate over all transcripts
+* for (const transcript of transcriptList) {
+*   console.log(transcript.language, transcript.languageCode);
+* }
+*
+* // Find a specific transcript
+* const transcript = transcriptList.findTranscript(['de', 'en']);
+* ```
+*/
+var TranscriptList = class TranscriptList {
+	/**
+	* Creates a new TranscriptList instance.
+	* The constructor is only for internal use. Use the static buildFromCaptionsJson method instead.
+	*
+	* @param {string} videoId - The video ID
+	* @param {Record<string, Transcript>} manuallyCreatedTranscripts - Map of manually created transcripts
+	* @param {Record<string, Transcript>} autoGeneratedTranscripts - Map of auto-generated transcripts
+	* @param {TranslationLanguage[]} availableTranslationLanguages - Available translation languages
+	*/
+	constructor(videoId, manuallyCreatedTranscripts, autoGeneratedTranscripts, availableTranslationLanguages) {
+		this.videoId = videoId;
+		this.manuallyCreatedTranscripts = manuallyCreatedTranscripts;
+		this.autoGeneratedTranscripts = autoGeneratedTranscripts;
+		this.availableTranslationLanguages = availableTranslationLanguages;
+	}
+	/**
+	* Factory method to build a TranscriptList from YouTube's captions JSON data.
+	*
+	* @param {HttpClient} httpClient - HTTP client for making requests
+	* @param {string} videoId - The video ID
+	* @param {CaptionsJson} captionsJson - The JSON parsed from YouTube's response
+	* @returns {TranscriptList} The created TranscriptList
+	*/
+	static buildFromCaptionsJson(httpClient, videoId, captionsJson) {
+		const translationLanguages = TranscriptList.extractTranslationLanguages(captionsJson);
+		const { manualTranscripts, generatedTranscripts } = TranscriptList.categorizeTranscripts(httpClient, videoId, captionsJson, translationLanguages);
+		return new TranscriptList(videoId, manualTranscripts, generatedTranscripts, translationLanguages);
+	}
+	/**
+	* Extracts translation languages from the captions JSON.
+	*
+	* @private
+	* @param {CaptionsJson} captionsJson - The captions JSON data
+	* @returns {TranslationLanguage[]} Array of translation languages
+	*/
+	static extractTranslationLanguages(captionsJson) {
+		return (captionsJson.translationLanguages || []).map((lang) => ({
+			language: lang.languageName.runs[0].text,
+			language_code: lang.languageCode
+		}));
+	}
+	/**
+	* Categorizes transcripts into manually created and auto-generated.
+	*
+	* @private
+	* @param {HttpClient} httpClient - HTTP client for making requests
+	* @param {string} videoId - The video ID
+	* @param {CaptionsJson} captionsJson - The captions JSON data
+	* @param {TranslationLanguage[]} translationLanguages - Available translation languages
+	* @returns {{manualTranscripts: Record<string, Transcript>, generatedTranscripts: Record<string, Transcript>}}
+	*/
+	static categorizeTranscripts(httpClient, videoId, captionsJson, translationLanguages) {
+		const manualTranscripts = {};
+		const generatedTranscripts = {};
+		for (const captionTrack of captionsJson.captionTracks) {
+			const isAutoGenerated = captionTrack.kind === "asr";
+			const targetMap = isAutoGenerated ? generatedTranscripts : manualTranscripts;
+			const transcript = new Transcript(httpClient, videoId, captionTrack.baseUrl.replace("&fmt=srv3", ""), captionTrack.name.runs[0].text, captionTrack.languageCode, isAutoGenerated, captionTrack.isTranslatable ? translationLanguages : []);
+			targetMap[captionTrack.languageCode] = transcript;
+		}
+		return {
+			manualTranscripts,
+			generatedTranscripts
+		};
+	}
+	/**
+	* Makes the transcript list iterable, allowing for...of loops.
+	* Manual transcripts are yielded first, followed by auto-generated transcripts.
+	*
+	* @returns {Iterator<Transcript>} Iterator over all transcripts
+	*/
+	[Symbol.iterator]() {
+		const manualTranscripts = Object.values(this.manuallyCreatedTranscripts);
+		const generatedTranscripts = Object.values(this.autoGeneratedTranscripts);
+		return [...manualTranscripts, ...generatedTranscripts][Symbol.iterator]();
+	}
+	/**
+	* Finds a transcript for given language codes. Manually created transcripts are
+	* returned first and only if none are found, auto-generated transcripts are used.
+	*
+	* @param {string[]} languageCodes - A list of language codes in descending priority
+	* @returns {Transcript} The found transcript
+	* @throws {NoTranscriptFound} If no transcript is found for any of the language codes
+	*
+	* @example
+	* ```typescript
+	* // Try German first, then English
+	* const transcript = transcriptList.findTranscript(['de', 'en']);
+	* ```
+	*/
+	findTranscript(languageCodes) {
+		return this.findTranscriptInMaps(languageCodes, [this.manuallyCreatedTranscripts, this.autoGeneratedTranscripts]);
+	}
+	/**
+	* Finds an automatically generated transcript for given language codes.
+	*
+	* @param {string[]} languageCodes - A list of language codes in descending priority
+	* @returns {Transcript} The found auto-generated transcript
+	* @throws {NoTranscriptFound} If no auto-generated transcript is found
+	*
+	* @example
+	* ```typescript
+	* const transcript = transcriptList.findGeneratedTranscript(['en']);
+	* ```
+	*/
+	findGeneratedTranscript(languageCodes) {
+		return this.findTranscriptInMaps(languageCodes, [this.autoGeneratedTranscripts]);
+	}
+	/**
+	* Finds a manually created transcript for given language codes.
+	*
+	* @param {string[]} languageCodes - A list of language codes in descending priority
+	* @returns {Transcript} The found manually created transcript
+	* @throws {NoTranscriptFound} If no manually created transcript is found
+	*
+	* @example
+	* ```typescript
+	* const transcript = transcriptList.findManuallyCreatedTranscript(['en']);
+	* ```
+	*/
+	findManuallyCreatedTranscript(languageCodes) {
+		return this.findTranscriptInMaps(languageCodes, [this.manuallyCreatedTranscripts]);
+	}
+	/**
+	* Internal method to find a transcript by searching through provided maps.
+	*
+	* @private
+	* @param {string[]} languageCodes - Language codes to search for
+	* @param {Record<string, Transcript>[]} transcriptMaps - Maps to search through
+	* @returns {Transcript} The found transcript
+	* @throws {NoTranscriptFound} If no transcript is found
+	*/
+	findTranscriptInMaps(languageCodes, transcriptMaps) {
+		for (const languageCode of languageCodes) for (const transcriptMap of transcriptMaps) if (languageCode in transcriptMap) return transcriptMap[languageCode];
+		throw new NoTranscriptFound(this.videoId, languageCodes, this);
+	}
+	/**
+	* Returns a formatted string representation of all available transcripts.
+	*
+	* @returns {string} A formatted string showing all available transcripts
+	*/
+	toString() {
+		const formatTranscriptMap = (transcripts) => {
+			const descriptions = Object.values(transcripts).map((t) => ` - ${t.toString()}`);
+			return descriptions.length > 0 ? descriptions.join("\n") : "None";
+		};
+		const formatTranslationLanguages = () => {
+			const descriptions = this.availableTranslationLanguages.map((lang) => ` - ${lang.language_code} ("${lang.language}")`);
+			return descriptions.length > 0 ? descriptions.join("\n") : "None";
+		};
+		return `For this video (${this.videoId}) transcripts are available in the following languages:\n\n(MANUALLY CREATED)\n${formatTranscriptMap(this.manuallyCreatedTranscripts)}\n\n(GENERATED)\n${formatTranscriptMap(this.autoGeneratedTranscripts)}\n\n(TRANSLATION LANGUAGES)\n${formatTranslationLanguages()}`;
+	}
+};
+// src/types/index.ts
+/**
+* Playability status enum values
+*/
+var PlayabilityStatus = /* @__PURE__ */ function(PlayabilityStatus) {
+	PlayabilityStatus["OK"] = "OK";
+	PlayabilityStatus["ERROR"] = "ERROR";
+	PlayabilityStatus["LOGIN_REQUIRED"] = "LOGIN_REQUIRED";
+	return PlayabilityStatus;
+}({});
+/**
+* Playability failed reason enum values
+*/
+var PlayabilityFailedReason = /* @__PURE__ */ function(PlayabilityFailedReason) {
+	PlayabilityFailedReason["BOT_DETECTED"] = "Sign in to confirm you're not a bot";
+	PlayabilityFailedReason["AGE_RESTRICTED"] = "This video may be inappropriate for some users.";
+	PlayabilityFailedReason["VIDEO_UNAVAILABLE"] = "This video is unavailable";
+	return PlayabilityFailedReason;
+}({});
+// src/fetchers/youtube-data-extractor.ts
+/**
+* @fileoverview Utilities for extracting data from YouTube HTML and InnerTube API responses
+*/
+/**
+* Extracts the InnerTube API key from YouTube's HTML page.
+*
+* @param {string} htmlContent - The HTML content from YouTube's watch page
+* @param {string} videoId - The video ID being processed
+* @returns {string} The extracted API key
+* @throws {IpBlocked} If the page contains a reCAPTCHA (IP is blocked)
+* @throws {YouTubeDataUnparsable} If the API key cannot be found
+*
+* @example
+* ```typescript
+* const html = await fetchVideoHtml(videoId);
+* const apiKey = extractInnertubeApiKey(html, videoId);
+* ```
+*/
+function extractInnertubeApiKey(htmlContent, videoId) {
+	const match = htmlContent.match(/"INNERTUBE_API_KEY":\s*"([a-zA-Z0-9_-]+)"/);
+	if (match && match.length === 2) return match[1];
+	if (htmlContent.includes("class=\"g-recaptcha\"")) throw new IpBlocked(videoId);
+	throw new YouTubeDataUnparsable(videoId);
+}
+/**
+* Extracts captions JSON from YouTube's InnerTube API response.
+*
+* @param {InnerTubeData} innertubeData - The InnerTube API response data
+* @param {string} videoId - The video ID being processed
+* @returns {CaptionsJson} The extracted captions data
+* @throws {TranscriptsDisabled} If captions are disabled for the video
+*
+* @example
+* ```typescript
+* const innertubeData = await fetchInnertubeData(videoId, apiKey);
+* const captionsJson = extractCaptionsJson(innertubeData, videoId);
+* ```
+*/
+function extractCaptionsJson(innertubeData, videoId) {
+	validatePlayabilityStatus(innertubeData.playabilityStatus, videoId);
+	const captionsJson = innertubeData.captions?.playerCaptionsTracklistRenderer;
+	if (!captionsJson || !captionsJson.captionTracks) throw new TranscriptsDisabled(videoId);
+	return captionsJson;
+}
+/**
+* Validates the playability status of a video and throws appropriate errors.
+*
+* @param {any} playabilityStatusData - The playability status data from InnerTube
+* @param {string} videoId - The video ID being validated
+* @throws {RequestBlocked} If YouTube detected a bot
+* @throws {AgeRestricted} If the video is age-restricted
+* @throws {VideoUnavailable} If the video is unavailable
+* @throws {InvalidVideoId} If the video ID is invalid (URL was provided instead)
+* @throws {VideoUnplayable} If the video is unplayable for any other reason
+*
+* @example
+* ```typescript
+* validatePlayabilityStatus(innertubeData.playabilityStatus, videoId);
+* ```
+*/
+function validatePlayabilityStatus(playabilityStatusData, videoId) {
+	if (!playabilityStatusData) return;
+	const playabilityStatus = playabilityStatusData.status;
+	if (playabilityStatus === PlayabilityStatus.OK || !playabilityStatus) return;
+	const reason = playabilityStatusData.reason;
+	if (playabilityStatus === PlayabilityStatus.LOGIN_REQUIRED) {
+		if (reason === PlayabilityFailedReason.BOT_DETECTED) throw new RequestBlocked(videoId);
+		if (reason === PlayabilityFailedReason.AGE_RESTRICTED) throw new AgeRestricted(videoId);
+	}
+	if (playabilityStatus === PlayabilityStatus.ERROR && reason === PlayabilityFailedReason.VIDEO_UNAVAILABLE) {
+		if (videoId.startsWith("http://") || videoId.startsWith("https://")) throw new InvalidVideoId(videoId);
+		throw new VideoUnavailable(videoId);
+	}
+	throw new VideoUnplayable(videoId, reason, extractPlayabilitySubreasons(playabilityStatusData));
+}
+/**
+* Extracts sub-reasons from the playability status error screen.
+*
+* @private
+* @param {any} playabilityStatusData - The playability status data
+* @returns {string[]} Array of sub-reason messages
+*/
+function extractPlayabilitySubreasons(playabilityStatusData) {
+	const runs = playabilityStatusData.errorScreen?.playerErrorMessageRenderer?.subreason?.runs;
+	if (!runs || !Array.isArray(runs)) return [];
+	return runs.map((run) => run.text || "").filter((text) => text.length > 0);
+}
+// src/fetchers/transcript-list-fetcher.ts
+/**
+* @fileoverview Fetcher for retrieving transcript lists from YouTube
+*/
+/** YouTube watch page URL template */
+var YOUTUBE_WATCH_URL = "https://www.youtube.com/watch?v={video_id}";
+/** YouTube InnerTube API URL template */
+var INNERTUBE_API_URL = "https://www.youtube.com/youtubei/v1/player?key={api_key}";
+/** InnerTube API context configuration for requests */
+var INNERTUBE_CONTEXT = { client: {
+	clientName: "ANDROID",
+	clientVersion: "20.10.38"
+} };
+/**
+* Fetches transcript lists from YouTube for given video IDs.
+* Handles consent cookies, retries on blocks, and extracts caption data.
+*
+* @example
+* ```typescript
+* const fetcher = new TranscriptListFetcher(httpClient, proxyConfig);
+* const transcriptList = await fetcher.fetchTranscriptList('dQw4w9WgXcQ');
+* ```
+*/
+var TranscriptListFetcher = class {
+	/**
+	* Creates a new TranscriptListFetcher instance.
+	*
+	* @param {HttpClient} httpClient - The HTTP client to use for requests
+	* @param {ProxyConfig | null} proxyConfig - Optional proxy configuration
+	*/
+	constructor(httpClient, proxyConfig) {
+		this.httpClient = httpClient;
+		this.proxyConfig = proxyConfig;
+	}
+	/**
+	* Fetches the list of available transcripts for a video.
+	*
+	* @param {string} videoId - The YouTube video ID
+	* @returns {Promise<TranscriptList>} The transcript list
+	* @throws {RequestBlocked} If requests are blocked and retries exhausted
+	* @throws {IpBlocked} If IP is blocked by YouTube
+	* @throws {YouTubeDataUnparsable} If YouTube data cannot be parsed
+	* @throws {TranscriptsDisabled} If transcripts are disabled for the video
+	*
+	* @example
+	* ```typescript
+	* const transcriptList = await fetcher.fetchTranscriptList('dQw4w9WgXcQ');
+	* const transcript = transcriptList.findTranscript(['en']);
+	* ```
+	*/
+	async fetchTranscriptList(videoId) {
+		const captionsJson = await this.fetchCaptionsJsonWithRetry(videoId);
+		return TranscriptList.buildFromCaptionsJson(this.httpClient, videoId, captionsJson);
+	}
+	/**
+	* Fetches captions JSON with retry logic for blocked requests.
+	*
+	* @private
+	* @param {string} videoId - The video ID
+	* @param {number} [attemptNumber=0] - Current attempt number (for retry logic)
+	* @returns {Promise<CaptionsJson>} The captions JSON data
+	*/
+	async fetchCaptionsJsonWithRetry(videoId, attemptNumber = 0) {
+		try {
+			const apiKey = extractInnertubeApiKey(await this.fetchVideoPageHtml(videoId), videoId);
+			return extractCaptionsJson(await this.fetchInnertubePlayerData(videoId, apiKey), videoId);
+		} catch (error) {
+			if (error instanceof RequestBlocked) return this.handleBlockedRequest(error, videoId, attemptNumber);
+			throw error;
+		}
+	}
+	/**
+	* Handles blocked requests with retry logic based on proxy configuration.
+	*
+	* @private
+	* @param {RequestBlocked} error - The blocked request error
+	* @param {string} videoId - The video ID
+	* @param {number} attemptNumber - Current attempt number
+	* @returns {Promise<CaptionsJson>} The captions JSON data from retry
+	* @throws {RequestBlocked} If retries are exhausted
+	*/
+	async handleBlockedRequest(error, videoId, attemptNumber) {
+		const maxRetries = this.proxyConfig?.retriesWhenBlocked || 0;
+		if (attemptNumber + 1 < maxRetries) return this.fetchCaptionsJsonWithRetry(videoId, attemptNumber + 1);
+		throw error.withProxyConfig(this.proxyConfig);
+	}
+	/**
+	* Fetches the HTML content of a video's watch page, handling consent cookies.
+	*
+	* @private
+	* @param {string} videoId - The video ID
+	* @returns {Promise<string>} The HTML content
+	* @throws {FailedToCreateConsentCookie} If consent cookie creation fails
+	*/
+	async fetchVideoPageHtml(videoId) {
+		let htmlContent = await this.fetchAndDecodeHtml(videoId);
+		if (this.isConsentPageDetected(htmlContent)) {
+			this.createConsentCookie(htmlContent, videoId);
+			htmlContent = await this.fetchAndDecodeHtml(videoId);
+			if (this.isConsentPageDetected(htmlContent)) throw new FailedToCreateConsentCookie(videoId);
+		}
+		return htmlContent;
+	}
+	/**
+	* Checks if the HTML content is a consent page.
+	*
+	* @private
+	* @param {string} htmlContent - The HTML content to check
+	* @returns {boolean} True if consent page detected
+	*/
+	isConsentPageDetected(htmlContent) {
+		return htmlContent.includes("action=\"https://consent.youtube.com/s\"");
+	}
+	/**
+	* Fetches HTML from YouTube watch page and decodes HTML entities.
+	*
+	* @private
+	* @param {string} videoId - The video ID
+	* @returns {Promise<string>} The decoded HTML content
+	*/
+	async fetchAndDecodeHtml(videoId) {
+		const url = this.buildWatchUrl(videoId);
+		const response = await this.httpClient.get(url);
+		handleHttpErrors(response, videoId);
+		const rawHtml = await response.text();
+		return (0, html_entities.decode)(rawHtml);
+	}
+	/**
+	* Builds the YouTube watch URL for a video ID.
+	*
+	* @private
+	* @param {string} videoId - The video ID
+	* @returns {string} The watch URL
+	*/
+	buildWatchUrl(videoId) {
+		return YOUTUBE_WATCH_URL.replace("{video_id}", videoId);
+	}
+	/**
+	* Creates a consent cookie from the HTML content.
+	* Note: This is a placeholder - cookie handling should be implemented in the HTTP client.
+	*
+	* @private
+	* @param {string} htmlContent - The HTML content containing consent form
+	* @param {string} videoId - The video ID
+	* @throws {FailedToCreateConsentCookie} If consent value cannot be extracted
+	*/
+	createConsentCookie(htmlContent, videoId) {
+		if (!htmlContent.match(/name="v" value="(.*?)"/)) throw new FailedToCreateConsentCookie(videoId);
+	}
+	/**
+	* Fetches player data from YouTube's InnerTube API.
+	*
+	* @private
+	* @param {string} videoId - The video ID
+	* @param {string} apiKey - The InnerTube API key
+	* @returns {Promise<InnerTubeData>} The InnerTube player data
+	*/
+	async fetchInnertubePlayerData(videoId, apiKey) {
+		const url = this.buildInnertubeApiUrl(apiKey);
+		const requestBody = this.buildInnertubeRequestBody(videoId);
+		const response = await this.httpClient.post(url, {
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(requestBody)
+		});
+		handleHttpErrors(response, videoId);
+		return await response.json();
+	}
+	/**
+	* Builds the InnerTube API URL with the provided API key.
+	*
+	* @private
+	* @param {string} apiKey - The API key
+	* @returns {string} The complete API URL
+	*/
+	buildInnertubeApiUrl(apiKey) {
+		return INNERTUBE_API_URL.replace("{api_key}", apiKey);
+	}
+	/**
+	* Builds the request body for InnerTube API calls.
+	*
+	* @private
+	* @param {string} videoId - The video ID
+	* @returns {object} The request body
+	*/
+	buildInnertubeRequestBody(videoId) {
+		return {
+			context: INNERTUBE_CONTEXT,
+			videoId
+		};
+	}
+};
+// src/http/fetch-http-client.ts
+/**
+* @fileoverview HTTP client implementation on the platform `fetch`
+*
+* Every caller (`TranscriptListFetcher`, `Transcript.fetch`) reads the result
+* as a WHATWG `Response`: `status`, `ok`, `text()`, `json()`. It has to be the
+* real `fetch`, which exists on Node 18+, Workers, Vercel and browsers. A
+* wrapper that returns a parsed body instead (grab-url did) leaves `status`
+* undefined, so `handleHttpErrors` rejects every request and no transcript
+* ever loads.
+*/
+/**
+* Simple HTTP client implementation using `fetch`, with proxy support.
+* This client handles HTTP/HTTPS requests with configurable headers and proxy settings.
+*
+* @internal
+*/
+var FetchHttpClient = class {
+	/**
+	* Creates a new FetchHttpClient instance.
+	* Sets default Accept-Language header to English.
+	*/
+	constructor() {
+		this.requestHeaders = {};
+		this.proxyConfiguration = {};
+		this.requestHeaders["Accept-Language"] = "en-US";
+	}
+	/**
+	* Sets a custom header for all requests.
+	*
+	* @param {string} headerName - The header name
+	* @param {string} headerValue - The header value
+	*/
+	setHeader(headerName, headerValue) {
+		this.requestHeaders[headerName] = headerValue;
+	}
+	/**
+	* Configures proxy settings for all requests.
+	*
+	* @param {RequestsProxyConfigDict} proxies - Proxy configuration dictionary
+	*/
+	setProxies(proxies) {
+		this.proxyConfiguration = proxies;
+	}
+	/**
+	* Performs an HTTP GET request.
+	*
+	* @param {string} url - The URL to request
+	* @param {RequestInit} [options] - Additional request options
+	* @returns {Promise<Response>} The HTTP response
+	*/
+	async get(url, options) {
+		const proxyAgent = this.getProxyAgentForUrl(url);
+		return fetch(url, {
+			...options,
+			method: "GET",
+			headers: {
+				...this.requestHeaders,
+				...options?.headers
+			},
+			agent: proxyAgent
+		});
+	}
+	/**
+	* Performs an HTTP POST request.
+	*
+	* @param {string} url - The URL to request
+	* @param {RequestInit} [options] - Additional request options
+	* @returns {Promise<Response>} The HTTP response
+	*/
+	async post(url, options) {
+		const proxyAgent = this.getProxyAgentForUrl(url);
+		return fetch(url, {
+			...options,
+			method: "POST",
+			headers: {
+				...this.requestHeaders,
+				...options?.headers
+			},
+			agent: proxyAgent
+		});
+	}
+	/**
+	* Gets the appropriate proxy agent for a given URL.
+	*
+	* @private
+	* @param {string} url - The URL being requested
+	* @returns {any} The proxy agent or undefined if no proxy is configured
+	*/
+	getProxyAgentForUrl(url) {
+		if (Object.keys(this.proxyConfiguration).length === 0) return;
+		const proxyUrl = url.startsWith("https://") ? this.proxyConfiguration.https : this.proxyConfiguration.http;
+		if (!proxyUrl) return;
+		return new https_proxy_agent.HttpsProxyAgent(proxyUrl);
+	}
+};
+// src/youtube-transcript-api.ts
+/**
+* Main API class for retrieving YouTube transcripts.
+* This is the primary entry point for the library.
+*
+* @example
+* ```typescript
+* // Basic usage
+* const api = new YouTubeTranscriptApi();
+* const transcript = await api.fetchTranscript('video_id');
+*
+* // With language preference
+* const transcript = await api.fetchTranscript('video_id', { languages: ['de', 'en'] });
+*
+* // With proxy
+* import { GenericProxyConfig } from 'youtube-transcript-api';
+* const api = new YouTubeTranscriptApi({
+*   proxyConfig: new GenericProxyConfig({
+*     httpUrl: 'http://user:pass@proxy.example.com:8080'
+*   })
+* });
+* ```
+*/
+var YouTubeTranscriptApi = class {
+	/**
+	* Creates a new YouTubeTranscriptApi instance.
+	*
+	* Note on thread-safety: As this class initializes an HTTP client,
+	* it is not thread-safe. Make sure to initialize an instance per
+	* thread if used in a multi-threading scenario!
+	*
+	* @param {Object} [options] - Configuration options
+	* @param {ProxyConfig} [options.proxyConfig] - An optional ProxyConfig object defining proxies
+	*   used for all network requests. This can be used to work around your IP being blocked
+	*   by YouTube, as described in the "Working around IP bans" section of the README.
+	* @param {HttpClient} [options.httpClient] - You can optionally pass in a custom HTTP client
+	*   if you want to share state between different instances of YouTubeTranscriptApi or
+	*   customize request behavior.
+	*
+	* @example
+	* ```typescript
+	* // Basic usage
+	* const api = new YouTubeTranscriptApi();
+	*
+	* // With Webshare proxy
+	* import { WebshareProxyConfig } from 'youtube-transcript-api';
+	* const api = new YouTubeTranscriptApi({
+	*   proxyConfig: new WebshareProxyConfig({
+	*     proxyUsername: 'your-username',
+	*     proxyPassword: 'your-password',
+	*     filterIpLocations: ['us', 'de']
+	*   })
+	* });
+	*
+	* // With generic proxy
+	* import { GenericProxyConfig } from 'youtube-transcript-api';
+	* const api = new YouTubeTranscriptApi({
+	*   proxyConfig: new GenericProxyConfig({
+	*     httpUrl: 'http://user:pass@proxy.example.com:8080',
+	*     httpsUrl: 'https://user:pass@proxy.example.com:8080'
+	*   })
+	* });
+	* ```
+	*/
+	constructor(options) {
+		const httpClient = this.initializeHttpClient(options);
+		this.configureHttpClientWithProxy(httpClient, options?.proxyConfig);
+		this.transcriptListFetcher = new TranscriptListFetcher(httpClient, options?.proxyConfig || null);
+	}
+	/**
+	* Initializes the HTTP client from options or creates a default one.
+	*
+	* @private
+	* @param {Object} [options] - Configuration options
+	* @returns {HttpClient} The initialized HTTP client
+	*/
+	initializeHttpClient(options) {
+		return options?.httpClient || new FetchHttpClient();
+	}
+	/**
+	* Configures the HTTP client with proxy settings if provided.
+	*
+	* @private
+	* @param {HttpClient} httpClient - The HTTP client to configure
+	* @param {ProxyConfig} [proxyConfig] - Optional proxy configuration
+	*/
+	configureHttpClientWithProxy(httpClient, proxyConfig) {
+		if (!proxyConfig || !(httpClient instanceof FetchHttpClient)) return;
+		const proxyDictionary = proxyConfig.toRequestsDict();
+		httpClient.setProxies(proxyDictionary);
+		if (proxyConfig.preventKeepingConnectionsAlive) httpClient.setHeader("Connection", "close");
+	}
+	/**
+	* Retrieves the transcript for a single video.
+	* This is a shortcut for calling:
+	* `api.listTranscripts(videoId).then(list => list.findTranscript(languages)).then(t => t.fetch())`
+	*
+	* @param {string} videoId - The ID of the video you want to retrieve the transcript for.
+	*   Make sure that this is the actual ID, NOT the full URL to the video!
+	* @param {Object} [options] - Fetch options
+	* @param {string[]} [options.languages=['en']] - A list of language codes in descending priority.
+	*   For example, if this is set to ['de', 'en'] it will first try to fetch the german
+	*   transcript (de) and then fetch the english transcript (en) if it fails to do so.
+	* @param {boolean} [options.preserveFormatting=false] - Whether to keep select HTML text formatting
+	* @returns {Promise<FetchedTranscript>} The fetched transcript
+	*
+	* @example
+	* ```typescript
+	* const api = new YouTubeTranscriptApi();
+	*
+	* // Fetch English transcript
+	* const transcript = await api.fetchTranscript('dQw4w9WgXcQ');
+	*
+	* // Fetch with language preference
+	* const transcript = await api.fetchTranscript('dQw4w9WgXcQ', {
+	*   languages: ['de', 'en']
+	* });
+	*
+	* // Preserve HTML formatting
+	* const transcript = await api.fetchTranscript('dQw4w9WgXcQ', {
+	*   preserveFormatting: true
+	* });
+	*
+	* // Iterate over snippets
+	* for (const snippet of transcript) {
+	*   console.log(`${snippet.start}s: ${snippet.text}`);
+	* }
+	* ```
+	*/
+	async fetchTranscript(videoId, options) {
+		const preferredLanguages = options?.languages || ["en"];
+		const preserveFormatting = options?.preserveFormatting || false;
+		return (await this.listTranscripts(videoId)).findTranscript(preferredLanguages).fetch(preserveFormatting);
+	}
+	/**
+	* Retrieves the list of transcripts which are available for a given video.
+	* It returns a TranscriptList object which is iterable and provides methods to
+	* filter the list of transcripts for specific languages.
+	*
+	* While iterating over the TranscriptList, the individual transcripts are
+	* represented by Transcript objects, which provide metadata and can either
+	* be fetched by calling transcript.fetch() or translated by calling
+	* transcript.translate('en').
+	*
+	* @param {string} videoId - The ID of the video you want to retrieve the transcript for.
+	*   Make sure that this is the actual ID, NOT the full URL to the video!
+	* @returns {Promise<TranscriptList>} A list of available transcripts
+	*
+	* @example
+	* ```typescript
+	* const api = new YouTubeTranscriptApi();
+	*
+	* // Retrieve available transcripts
+	* const transcriptList = await api.listTranscripts('video_id');
+	*
+	* // Iterate over all available transcripts
+	* for (const transcript of transcriptList) {
+	*   console.log(
+	*     transcript.videoId,
+	*     transcript.language,
+	*     transcript.languageCode,
+	*     transcript.isGenerated,
+	*     transcript.isTranslatable,
+	*     transcript.translationLanguages
+	*   );
+	*
+	*   // Fetch the actual transcript data
+	*   const fetched = await transcript.fetch();
+	*   console.log(fetched);
+	*
+	*   // Translate the transcript
+	*   if (transcript.isTranslatable) {
+	*     const translated = transcript.translate('de');
+	*     const fetchedTranslated = await translated.fetch();
+	*     console.log(fetchedTranslated);
+	*   }
+	* }
+	*
+	* // Filter for specific language
+	* const transcript = transcriptList.findTranscript(['de', 'en']);
+	*
+	* // Filter for manually created transcripts
+	* const manual = transcriptList.findManuallyCreatedTranscript(['de', 'en']);
+	*
+	* // Filter for automatically generated transcripts
+	* const generated = transcriptList.findGeneratedTranscript(['de', 'en']);
+	* ```
+	*/
+	async listTranscripts(videoId) {
+		return this.transcriptListFetcher.fetchTranscriptList(videoId);
+	}
+	/**
+	* Alias for fetchTranscript() for backward compatibility.
+	*
+	* @deprecated Use fetchTranscript() instead
+	* @param {string} videoId - The video ID
+	* @param {Object} [options] - Fetch options
+	* @returns {Promise<FetchedTranscript>} The fetched transcript
+	*/
+	async fetch(videoId, options) {
+		return this.fetchTranscript(videoId, options);
+	}
+	/**
+	* Alias for listTranscripts() for backward compatibility.
+	*
+	* @deprecated Use listTranscripts() instead
+	* @param {string} videoId - The video ID
+	* @returns {Promise<TranscriptList>} A list of available transcripts
+	*/
+	async list(videoId) {
+		return this.listTranscripts(videoId);
+	}
+};
+// src/utils/transcript-utils.ts
+/**
+* Encodes speech speed from a fetched transcript into a compact run-length string.
+* Optionally prepends a YouTube embed iframe with data-timestamps for player sync.
+* @param transcript - A FetchedTranscript returned by fetchTranscript()
+* @param addPlayer - If true, prepends an iframe embed with data-timestamps attribute
+* @returns html content, word count, run-length encoded speed string, and raw timestamps
+*/
+function encodeTranscriptSpeeds(transcript, addPlayer = false) {
+	let charCount = 0;
+	const timestamps = [];
+	const textParts = [];
+	for (const snippet of transcript.snippets) {
+		textParts.push(snippet.text);
+		charCount += snippet.text.length;
+		if (snippet.start > 0) timestamps.push([charCount, snippet.start]);
+	}
+	const content = textParts.join(" ").replace(/\s+/g, " ");
+	const word_count = content.split(/\s+/).filter(Boolean).length;
+	const speedValues = timestamps.map(([char, time]) => Math.floor(char / time) - 10);
+	if (speedValues.length === 0) return {
+		html: content,
+		word_count,
+		speeds: ""
+	};
+	const compressed = [];
+	const compressedCount = [];
+	let currentNum = speedValues[0];
+	let count = 1;
+	for (let i = 1; i < speedValues.length; i++) if (speedValues[i] === currentNum) count++;
+	else {
+		compressed.push(currentNum);
+		compressedCount.push(count);
+		currentNum = speedValues[i];
+		count = 1;
+	}
+	compressed.push(currentNum);
+	compressedCount.push(count);
+	const speeds = compressed.map((val, i) => `${val}x${compressedCount[i]}`).join(",");
+	return {
+		html: addPlayer ? `<iframe width="100%" height="315px" data-timestamps="${speeds}" src="https://www.youtube.com/embed/${transcript.videoId}" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>${content}` : content,
+		word_count,
+		speeds
+	};
+}
+// src/proxies/index.ts
+var _WebshareProxyConfig;
+/**
+* Exception for invalid proxy configurations
+*/
+var InvalidProxyConfig = class InvalidProxyConfig extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidProxyConfig";
+		Object.setPrototypeOf(this, InvalidProxyConfig.prototype);
+	}
+};
+/**
+* Base class for all proxy configurations.
+* Any proxy config can be used as long as it can be converted to a RequestsProxyConfigDict.
+*/
+var ProxyConfig = class {
+	/**
+	* If you are using rotating proxies, it can be useful to prevent the HTTP
+	* client from keeping TCP connections alive, as your IP won't be rotated on
+	* every request if your connection stays open.
+	* @returns {boolean} Whether to prevent keeping connections alive
+	*/
+	get preventKeepingConnectionsAlive() {
+		return false;
+	}
+	/**
+	* Defines how many times we should retry if a request is blocked. When using
+	* rotating residential proxies with a large IP pool it can make sense to retry a
+	* couple of times when a blocked IP is encountered, since a retry will trigger
+	* an IP rotation and the next IP might not be blocked.
+	* @returns {number} Number of retries when blocked
+	*/
+	get retriesWhenBlocked() {
+		return 0;
+	}
+};
+/**
+* Generic proxy configuration that can be used to set up any HTTP/HTTPS/SOCKS proxy.
+*
+* If only an HTTP or an HTTPS proxy is provided, it will be used for both types of
+* connections. However, you will have to provide at least one of the two.
+*
+* @example
+* ```typescript
+* const proxyConfig = new GenericProxyConfig({
+*   httpUrl: 'http://user:pass@proxy.example.com:8080',
+*   httpsUrl: 'https://user:pass@proxy.example.com:8080'
+* });
+* ```
+*/
+var GenericProxyConfig = class extends ProxyConfig {
+	/**
+	* Creates a generic proxy configuration.
+	* If only an HTTP or an HTTPS proxy is provided, it will be used for both types of
+	* connections. However, you will have to provide at least one of the two.
+	*
+	* @param {Object} options - Proxy configuration options
+	* @param {string} [options.httpUrl] - The proxy URL used for HTTP requests. Defaults to httpsUrl if not provided.
+	* @param {string} [options.httpsUrl] - The proxy URL used for HTTPS requests. Defaults to httpUrl if not provided.
+	* @throws {InvalidProxyConfig} If neither httpUrl nor httpsUrl is provided
+	*/
+	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 || null;
+		this._httpsUrl = httpsUrl || null;
+	}
+	get httpUrl() {
+		return this._httpUrl;
+	}
+	get httpsUrl() {
+		return this._httpsUrl;
+	}
+	toRequestsDict() {
+		return {
+			http: this.httpUrl || this.httpsUrl,
+			https: this.httpsUrl || this.httpUrl
+		};
+	}
+};
+/**
+* Webshare proxy configuration for rotating residential proxies.
+*
+* Webshare is a provider offering rotating residential proxies, which is the
+* most reliable way to work around being blocked by YouTube.
+*
+* If you don't have a Webshare account yet, you will have to create one
+* at https://www.webshare.io/?referral_code=w0xno53eb50g and purchase a "Residential"
+* proxy package that suits your workload (make sure NOT to purchase "Proxy Server"
+* or "Static Residential"!).
+*
+* Once you have created an account you only need the "Proxy Username" and
+* "Proxy Password" that you can find in your Webshare settings to set up this config.
+*
+* @example
+* ```typescript
+* const proxyConfig = new WebshareProxyConfig({
+*   proxyUsername: 'your-username',
+*   proxyPassword: 'your-password',
+*   filterIpLocations: ['us', 'de']
+* });
+* ```
+*/
+var WebshareProxyConfig = class WebshareProxyConfig extends GenericProxyConfig {
+	/**
+	* Creates a Webshare proxy configuration.
+	*
+	* Once you have created a Webshare account and purchased a "Residential" package
+	* (make sure NOT to purchase "Proxy Server" or "Static Residential"!), this config
+	* class allows you to easily use it by defaulting to the most reliable proxy settings
+	* (rotating residential proxies).
+	*
+	* @param {Object} options - Webshare configuration options
+	* @param {string} options.proxyUsername - "Proxy Username" found at https://dashboard.webshare.io/proxy/settings
+	* @param {string} options.proxyPassword - "Proxy Password" found at https://dashboard.webshare.io/proxy/settings
+	* @param {string[]} [options.filterIpLocations] - If you want to limit the pool of IPs to specific countries,
+	*   provide a list of location codes (e.g., ['us', 'de']). This can reduce latency and work around location-based restrictions.
+	* @param {number} [options.retriesWhenBlocked=10] - How many times to retry if a request is blocked
+	* @param {string} [options.domainName] - Custom domain name (defaults to p.webshare.io)
+	* @param {number} [options.proxyPort] - Custom proxy port (defaults to 80)
+	*/
+	constructor(options) {
+		super({ httpUrl: "placeholder" });
+		this.proxyUsername = options.proxyUsername;
+		this.proxyPassword = options.proxyPassword;
+		this.domainName = options.domainName || WebshareProxyConfig.DEFAULT_DOMAIN_NAME;
+		this.proxyPort = options.proxyPort || WebshareProxyConfig.DEFAULT_PORT;
+		this.filterIpLocations = options.filterIpLocations || [];
+		this._retriesWhenBlocked = options.retriesWhenBlocked ?? 10;
+	}
+	/**
+	* Gets the full proxy URL with location filtering and rotation settings.
+	* @returns {string} The complete proxy URL
+	*/
+	get url() {
+		const locationCodes = this.filterIpLocations.map((code) => `-${code.toUpperCase()}`).join("");
+		let username = this.proxyUsername;
+		const suffix = "-rotate";
+		if (username.endsWith(suffix)) username = username.slice(0, -7);
+		return `http://${username}${locationCodes}${suffix}:${this.proxyPassword}@${this.domainName}:${this.proxyPort}/`;
+	}
+	get httpUrl() {
+		return this.url;
+	}
+	get httpsUrl() {
+		return this.url;
+	}
+	toRequestsDict() {
+		return {
+			http: this.url,
+			https: this.url
+		};
+	}
+	get preventKeepingConnectionsAlive() {
+		return true;
+	}
+	get retriesWhenBlocked() {
+		return this._retriesWhenBlocked;
+	}
+};
+_WebshareProxyConfig = WebshareProxyConfig;
+_WebshareProxyConfig.DEFAULT_DOMAIN_NAME = "p.webshare.io";
+_WebshareProxyConfig.DEFAULT_PORT = 80;
+// src/formatters/index.ts
+/**
+* Base abstract class for all transcript formatters.
+*/
+var Formatter = class {};
+/**
+* Formatter that converts transcripts to pretty-printed JSON format.
+*/
+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);
+	}
+};
+/**
+* Formatter that converts transcripts to JSON format.
+*/
+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);
+	}
+};
+/**
+* Formatter that converts transcripts to plain text format with no timestamps.
+*/
+var TextFormatter = class extends Formatter {
+	formatTranscript(transcript) {
+		return transcript.snippets.map((snippet) => snippet.text).join("\n");
+	}
+	formatTranscripts(transcripts) {
+		return transcripts.map((t) => this.formatTranscript(t)).join("\n\n\n");
+	}
+};
+/**
+* Base class for subtitle formatters (SRT, WebVTT).
+*/
+var SubtitleFormatterBase = class extends TextFormatter {
+	secondsToTimestamp(timeInSeconds) {
+		const hours = Math.floor(timeInSeconds / 3600);
+		const remainder = timeInSeconds % 3600;
+		const minutes = Math.floor(remainder / 60);
+		const seconds = Math.floor(remainder % 60);
+		const milliseconds = Math.round((timeInSeconds - Math.floor(timeInSeconds)) * 1e3);
+		return this.formatTimestamp(hours, minutes, seconds, milliseconds);
+	}
+	formatTranscript(transcript) {
+		const formattedLines = [];
+		for (let i = 0; i < transcript.snippets.length; i++) {
+			const snippet = transcript.snippets[i];
+			const snippetEndTime = snippet.start + snippet.duration;
+			const actualEndTime = i < transcript.snippets.length - 1 && transcript.snippets[i + 1].start < snippetEndTime ? transcript.snippets[i + 1].start : snippetEndTime;
+			const timeRangeText = `${this.secondsToTimestamp(snippet.start)} --> ${this.secondsToTimestamp(actualEndTime)}`;
+			formattedLines.push(this.formatSubtitleEntry(i, timeRangeText, snippet));
+		}
+		return this.formatTranscriptHeader(formattedLines);
+	}
+};
+/**
+* Formatter that converts transcripts to SRT (SubRip) format.
+*/
+var SRTFormatter = class extends SubtitleFormatterBase {
+	formatTimestamp(h, m, s, ms) {
+		const pad = (n, w) => n.toString().padStart(w, "0");
+		return `${pad(h, 2)}:${pad(m, 2)}:${pad(s, 2)},${pad(ms, 3)}`;
+	}
+	formatTranscriptHeader(lines) {
+		return lines.join("\n\n") + "\n";
+	}
+	formatSubtitleEntry(index, timeRange, snippet) {
+		return `${index + 1}\n${timeRange}\n${snippet.text}`;
+	}
+};
+/**
+* Formatter that converts transcripts to WebVTT format.
+*/
+var WebVTTFormatter = class extends SubtitleFormatterBase {
+	formatTimestamp(h, m, s, ms) {
+		const pad = (n, w) => n.toString().padStart(w, "0");
+		return `${pad(h, 2)}:${pad(m, 2)}:${pad(s, 2)}.${pad(ms, 3)}`;
+	}
+	formatTranscriptHeader(lines) {
+		return "WEBVTT\n\n" + lines.join("\n\n") + "\n";
+	}
+	formatSubtitleEntry(index, timeRange, snippet) {
+		return `${timeRange}\n${snippet.text}`;
+	}
+};
+// package.json
+var package_exports = /* @__PURE__ */ __exportAll({
+	author: () => "",
+	bin: () => bin,
+	default: () => package_default,
+	dependencies: () => dependencies,
+	description: () => description,
+	devDependencies: () => devDependencies,
+	engines: () => engines,
+	exports: () => exports$1,
+	files: () => files,
+	keywords: () => keywords,
+	license: () => license,
+	main: () => main$1,
+	module: () => module$1,
+	name: () => name,
+	peerDependencies: () => peerDependencies,
+	peerDependenciesMeta: () => peerDependenciesMeta,
+	repository: () => repository,
+	scripts: () => scripts,
+	types: () => types,
+	version: () => version
+}), name, version, description, main$1, module$1, types, exports$1, bin, files, scripts, keywords, license, repository, dependencies, peerDependencies, peerDependenciesMeta, devDependencies, engines, package_default;
+var init_package = __esmMin((() => {
+	name = "extract-youtube";
+	version = "1.0.414";
+	description = "Fast, no-browser serverless-optimized YouTube transcript extractor, with optional cloud-ytdl audio/video download (MP3 via ffmpeg) and a media HTTP API, with a video library admin API (D1 or in-memory) and React UI: a floating YouTube player, a synced-transcript modal, video grid/list components and library admin screens";
+	main$1 = "dist/index.cjs";
+	module$1 = "dist/index.mjs";
+	types = "dist/index.d.ts";
+	exports$1 = {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.mjs",
+			"require": "./dist/index.cjs"
+		},
+		"./react": {
+			"types": "./dist/react/index.d.ts",
+			"import": "./dist/react/index.mjs",
+			"require": "./dist/react/index.cjs"
+		},
+		"./library": {
+			"types": "./dist/library/index.d.ts",
+			"import": "./dist/library/index.mjs",
+			"require": "./dist/library/index.cjs"
+		},
+		"./download": {
+			"types": "./dist/download/index.d.ts",
+			"import": "./dist/download/index.mjs",
+			"require": "./dist/download/index.cjs"
+		}
+	};
+	bin = { "extract-youtube": "dist/cli.js" };
+	files = ["dist", "src"];
+	scripts = {
+		"clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+		"build": "npm run clean && npm run build:lib && npm run build:cli && npm run build:react && npm run build:library && npm run build:download && npm run build:types",
+		"build:types": "tsc6 --emitDeclarationOnly --declaration --declarationMap",
+		"build:lib": "vite build",
+		"build:cli": "BUILD_CLI=true vite build",
+		"build:react": "BUILD_REACT=true vite build",
+		"build:library": "BUILD_LIBRARY=true vite build",
+		"build:download": "BUILD_DOWNLOAD=true vite build",
+		"build:bundle": "npm run build:lib && npm run build:cli && npm run build:react && npm run build:library && npm run build:download",
+		"build:legacy": "tsc",
+		"ship": "npm run build && npx standard-version --release-as patch; npm publish",
+		"test": "jest",
+		"test:coverage": "jest --coverage",
+		"test:speeds": "bun src/cli.ts dQw4w9WgXcQ -f speeds",
+		"lint": "eslint src --ext .ts"
+	};
+	keywords = [
+		"youtube",
+		"transcript",
+		"subtitles",
+		"captions",
+		"api",
+		"serverless",
+		"lambda",
+		"vercel",
+		"cloudflare",
+		"edge",
+		"typescript",
+		"youtube-transcript",
+		"youtube-transcript-api",
+		"srt",
+		"webvtt",
+		"video",
+		"parsing",
+		"extraction",
+		"optimized",
+		"react",
+		"floating-player",
+		"picture-in-picture",
+		"video-player",
+		"youtube-player",
+		"playlist",
+		"video-library",
+		"video-grid",
+		"admin",
+		"cloudflare-d1",
+		"youtube-downloader",
+		"mp3",
+		"audio-extraction",
+		"storybook"
+	];
+	license = "rights.institute/PROSPER";
+	repository = {
+		"type": "git",
+		"url": "git+https://github.com/OpenSourceAGI/qwksearch-research-agent.git",
+		"directory": "packages/extract-youtube"
+	};
+	dependencies = {
+		"fast-xml-parser": "^5.11.1",
+		"html-entities": "^2.6.0",
+		"https-proxy-agent": "^9.1.0",
+		"youtube-transcript-api": "^3.0.6"
+	};
+	peerDependencies = {
+		"cloud-ytdl": ">=1.0.5-next",
+		"react": ">=18",
+		"react-dom": ">=18",
+		"lucide-react": "^0.300.0 || ^1.0.0"
+	};
+	peerDependenciesMeta = {
+		"cloud-ytdl": { "optional": true },
+		"react": { "optional": true },
+		"react-dom": { "optional": true },
+		"lucide-react": { "optional": true }
+	};
+	devDependencies = {
+		"@types/jest": "^30.0.0",
+		"@types/node": "^26.5.0",
+		"@types/react": "^19.2.18",
+		"@types/react-dom": "^19.2.7",
+		"cloud-ytdl": "^1.0.5-next",
+		"jest": "^30.5.1",
+		"lucide-react": "^1.43.0",
+		"react": "^19.2.8",
+		"react-dom": "^19.2.8",
+		"terser": "^5.51.2",
+		"ts-jest": "^29.4.12",
+		"typescript": "npm:@typescript/typescript6@^6.0.2",
+		"vite": "^8.2.2"
+	};
+	engines = { "node": ">=14.0.0" };
+	package_default = {
+		name,
+		version,
+		description,
+		main: main$1,
+		module: module$1,
+		types,
+		exports: exports$1,
+		"//bin": "Spelled out as an object with a relative path. npm normalizes the string form itself and prints a notice for it on every publish.",
+		bin,
+		"//files": "Publish only what consumers resolve. Without this the tarball also carries test/, jest.config.js, tsconfig*.json and vite.config.ts. Matches extract-webpage and extract-pdf.",
+		files,
+		scripts,
+		keywords,
+		author: "",
+		license,
+		repository,
+		dependencies,
+		"//peerDependencies": "cloud-ytdl backs only the Node-only extract-youtube/download entry (audio/video download, MP3 via ffmpeg); optional so a transcript-only install stays dependency-light and Worker-safe.",
+		peerDependencies,
+		peerDependenciesMeta,
+		devDependencies,
+		engines
+	};
+}));
+// src/cli.ts
+/**
+* @fileoverview CLI for extracting YouTube transcripts
+*/
+function parseArgs() {
+	const args = process.argv.slice(2);
+	const options = { videoId: "" };
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		switch (arg) {
+			case "-h":
+			case "--help":
+				options.help = true;
+				break;
+			case "-v":
+			case "--version":
+				options.version = true;
+				break;
+			case "-l":
+			case "--languages":
+				options.languages = args[++i]?.split(",").map((l) => l.trim());
+				break;
+			case "-f":
+			case "--format":
+				options.format = args[++i];
+				break;
+			case "-p":
+			case "--preserve-formatting":
+				options.preserveFormatting = true;
+				break;
+			case "--proxy":
+				options.proxy = args[++i];
+				break;
+			case "--webshare-user":
+				options.webshareUser = args[++i];
+				break;
+			case "--webshare-pass":
+				options.websharePass = args[++i];
+				break;
+			default: if (!arg.startsWith("-") && !options.videoId) options.videoId = arg;
+		}
+	}
+	return options;
+}
+function showHelp() {
+	console.log(`
+extract-youtube - Extract YouTube video transcripts
+
+USAGE:
+  extract-youtube <video-id> [options]
+
+OPTIONS:
+  -h, --help                    Show this help message
+  -v, --version                 Show version number
+  -l, --languages <codes>       Comma-separated language codes (e.g., en,de,fr)
+  -f, --format <type>           Output format: json, text, srt, webvtt, pretty, speeds (default: json)
+  -p, --preserve-formatting     Preserve text formatting (line breaks, etc.)
+  --proxy <url>                 HTTP/HTTPS proxy URL
+  --webshare-user <username>    Webshare proxy username
+  --webshare-pass <password>    Webshare proxy password
+
+EXAMPLES:
+  # Extract transcript in JSON format
+  extract-youtube jNQXAC9IVRw
+
+  # Extract transcript in SRT format
+  extract-youtube jNQXAC9IVRw -f srt
+
+  # Extract transcript with specific languages
+  extract-youtube jNQXAC9IVRw -l en,de
+
+  # Extract transcript with proxy
+  extract-youtube jNQXAC9IVRw --proxy http://proxy.example.com:8080
+
+  # Extract transcript with Webshare proxy
+  extract-youtube jNQXAC9IVRw --webshare-user myuser --webshare-pass mypass
+
+  # Extract transcript as plain text with preserved formatting
+  extract-youtube jNQXAC9IVRw -f text -p
+
+  # Extract speech speed encoding with joined text and timestamps
+  extract-youtube jNQXAC9IVRw -f speeds
+
+MEDIA (needs the optional peer: npm install cloud-ytdl; MP3 also needs ffmpeg):
+  extract-youtube audio <video-id> [--format mp3|m4a|webm] [--bitrate 64] [--mono] [-o file]
+  extract-youtube serve-media [--port 8787]   # HTTP API; set MEDIA_API_KEY to require a key
+  Cookies for restricted videos: YOUTUBE_COOKIES env var. Proxy: --proxy <url>.
+`);
+}
+function showVersion() {
+	const pkg = (init_package(), __toCommonJS(package_exports).default);
+	console.log(`extract-youtube v${pkg.version}`);
+}
+/** `audio` and `serve-media`: the cloud-ytdl backed `extract-youtube/download` entry. */
+async function runMediaCommand(command, args) {
+	const { createMediaExtractor, serveMediaApi } = await Promise.resolve().then(() => require("./download-CBVykDZQ.js"));
+	const flag = (name) => {
+		const i = args.indexOf(name);
+		return i >= 0 ? args[i + 1] : void 0;
+	};
+	const shared = {
+		cookies: process.env.YOUTUBE_COOKIES,
+		proxy: flag("--proxy")
+	};
+	if (command === "serve-media") {
+		const port = Number(flag("--port") ?? process.env.PORT ?? 8787);
+		await serveMediaApi({
+			...shared,
+			port,
+			apiKey: process.env.MEDIA_API_KEY
+		});
+		console.error(`extract-youtube media API listening on :${port}${process.env.MEDIA_API_KEY ? "" : " (no MEDIA_API_KEY: open to anyone)"}`);
+		return;
+	}
+	const videoId = args.find((a, i) => !a.startsWith("-") && !args[i - 1]?.startsWith("-"));
+	if (!videoId) throw new Error("Usage: extract-youtube audio <video-id> [--format mp3|m4a|webm] [-o file]");
+	const download = await createMediaExtractor(shared).downloadAudio(videoId, {
+		container: flag("--format") ?? "mp3",
+		bitrateKbps: flag("--bitrate") ? Number(flag("--bitrate")) : void 0,
+		mono: args.includes("--mono")
+	});
+	const file = flag("-o") ?? flag("--output") ?? download.filename;
+	const fs = await import("node:fs");
+	const { pipeline } = await import("node:stream/promises");
+	await pipeline(download.stream, fs.createWriteStream(file));
+	console.error(`Saved ${download.info.title} to ${file}`);
+}
+async function main() {
+	const [command, ...rest] = process.argv.slice(2);
+	if (command === "audio" || command === "serve-media") {
+		await runMediaCommand(command, rest);
+		return;
+	}
+	const options = parseArgs();
+	if (options.help) {
+		showHelp();
+		process.exit(0);
+	}
+	if (options.version) {
+		showVersion();
+		process.exit(0);
+	}
+	if (!options.videoId) {
+		console.error("Error: Video ID is required\n");
+		showHelp();
+		process.exit(1);
+	}
+	try {
+		let proxyConfig;
+		if (options.webshareUser && options.websharePass) proxyConfig = new WebshareProxyConfig({
+			proxyUsername: options.webshareUser,
+			proxyPassword: options.websharePass
+		});
+		else if (options.proxy) proxyConfig = new GenericProxyConfig({ httpUrl: options.proxy });
+		const transcript = await new YouTubeTranscriptApi({ proxyConfig }).fetchTranscript(options.videoId, {
+			languages: options.languages,
+			preserveFormatting: options.preserveFormatting
+		});
+		const format = options.format || "json";
+		let output;
+		switch (format) {
+			case "json":
+				output = new JSONFormatter().formatTranscript(transcript);
+				break;
+			case "text":
+				output = new TextFormatter().formatTranscript(transcript);
+				break;
+			case "srt":
+				output = new SRTFormatter().formatTranscript(transcript);
+				break;
+			case "webvtt":
+				output = new WebVTTFormatter().formatTranscript(transcript);
+				break;
+			case "pretty":
+				output = new PrettyPrintFormatter().formatTranscript(transcript);
+				break;
+			case "speeds": {
+				const { html, word_count, speeds } = encodeTranscriptSpeeds(transcript);
+				output = JSON.stringify({
+					html,
+					word_count,
+					speeds
+				});
+				break;
+			}
+			default: throw new Error(`Unknown format: ${format}`);
+		}
+		console.log(output);
+		process.exit(0);
+	} catch (error) {
+		if (error instanceof Error) console.error(`Error: ${error.message}`);
+		else console.error(`Error: ${String(error)}`);
+		process.exit(1);
+	}
+}
+main().catch((error) => {
+	console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+	process.exit(1);
+});
+Object.defineProperty(exports, "__toCommonJS", {
+	enumerable: true,
+	get: function() {
+		return __toCommonJS;
+	}
+});
+
+//# sourceMappingURL=cli-Do33ETWE.js.map