@mks2508/bundlp 0.1.1 → 0.1.2

package/dist/index.mjs

@@ -0,0 +1,3072 @@
+import { type } from "arktype";
+import { parse } from "meriyah";
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { JSDOM } from "jsdom";
+import logger from "@mks2508/better-logger";
+
+//#region src/result/result.utils.ts
+/** Create a successful result */
+const ok = (value) => ({
+	ok: true,
+	value
+});
+/** Create an error result */
+const err = (error) => ({
+	ok: false,
+	error
+});
+/** Type guard for successful result */
+const isOk = (result) => result.ok;
+/** Type guard for error result */
+const isErr = (result) => !result.ok;
+/** Pattern match on a Result */
+function match(result, handlers) {
+	return result.ok ? handlers.ok(result.value) : handlers.err(result.error);
+}
+/** Map over a successful result */
+function map(result, fn) {
+	return result.ok ? ok(fn(result.value)) : result;
+}
+/** Map over an error result */
+function mapErr(result, fn) {
+	return result.ok ? result : err(fn(result.error));
+}
+/** Chain Results (flatMap) */
+function andThen(result, fn) {
+	return result.ok ? fn(result.value) : result;
+}
+/** Unwrap with default value */
+function unwrapOr(result, defaultValue) {
+	return result.ok ? result.value : defaultValue;
+}
+/** Unwrap or throw */
+function unwrap(result) {
+	if (result.ok) return result.value;
+	throw new Error(`Unwrap called on Err: ${JSON.stringify(result.error)}`);
+}
+/** Try to execute a function and wrap in Result */
+function tryCatch(fn) {
+	try {
+		return ok(fn());
+	} catch (e) {
+		return err(e);
+	}
+}
+/** Try to execute an async function and wrap in Result */
+async function tryCatchAsync(fn) {
+	try {
+		return ok(await fn());
+	} catch (e) {
+		return err(e);
+	}
+}
+
+//#endregion
+//#region src/utils/constants.ts
+const YOUTUBE_BASE_URL = "https://www.youtube.com";
+const INNER_TUBE_API_URL = `${YOUTUBE_BASE_URL}/youtubei/v1`;
+const VIDEO_ID_LENGTH = 11;
+const RETRY_DEFAULTS = {
+	RETRIES: 3,
+	DELAY: 1e3,
+	BACKOFF: 2,
+	MAX_DELAY: 3e4
+};
+const INNERTUBE_CLIENTS = {
+	WEB: {
+		NAME: "WEB",
+		VERSION: "2.20250222.10.00",
+		CLIENT_ID: 1,
+		API_KEY: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8",
+		INNERTUBE_CONTEXT: { client: {
+			clientName: "WEB",
+			clientVersion: "2.20250222.10.00",
+			platform: "DESKTOP"
+		} },
+		HEADERS: {
+			"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+			"X-YouTube-Client-Name": "1",
+			"X-YouTube-Client-Version": "2.20250222.10.00"
+		}
+	},
+	ANDROID: {
+		NAME: "ANDROID",
+		VERSION: "19.35.36",
+		CLIENT_ID: 3,
+		API_KEY: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8",
+		SDK_VERSION: 33,
+		INNERTUBE_CONTEXT: { client: {
+			clientName: "ANDROID",
+			clientVersion: "19.35.36",
+			androidSdkVersion: 33
+		} },
+		HEADERS: {
+			"User-Agent": "com.google.android.youtube/19.35.36(Linux; U; Android 13; en_US; SM-S908E Build/TP1A.220624.014) gzip",
+			"X-YouTube-Client-Name": "3",
+			"X-YouTube-Client-Version": "19.35.36"
+		}
+	},
+	TV: {
+		NAME: "TVHTML5",
+		VERSION: "7.20250923.13.00",
+		CLIENT_ID: 7,
+		API_KEY: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8",
+		INNERTUBE_CONTEXT: { client: {
+			clientName: "TVHTML5",
+			clientVersion: "7.20250923.13.00",
+			userAgent: "Mozilla/5.0 (ChromiumStylePlatform) Cobalt/Version"
+		} },
+		HEADERS: {
+			"User-Agent": "Mozilla/5.0 (ChromiumStylePlatform) Cobalt/Version",
+			"X-YouTube-Client-Name": "7",
+			"X-YouTube-Client-Version": "7.20250923.13.00"
+		}
+	},
+	IOS: {
+		NAME: "IOS",
+		VERSION: "20.10.4",
+		CLIENT_ID: 5,
+		API_KEY: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8",
+		INNERTUBE_CONTEXT: { client: {
+			clientName: "IOS",
+			clientVersion: "20.10.4",
+			deviceMake: "Apple",
+			deviceModel: "iPhone16,2",
+			osName: "iPhone",
+			osVersion: "18.3.2.22D82"
+		} },
+		HEADERS: {
+			"User-Agent": "com.google.ios.youtube/20.10.4 (iPhone16,2; U; CPU iOS 18_3_2 like Mac OS X;)",
+			"X-YouTube-Client-Name": "5",
+			"X-YouTube-Client-Version": "20.10.4"
+		}
+	},
+	ANDROID_SDKLESS: {
+		NAME: "ANDROID",
+		VERSION: "20.10.38",
+		CLIENT_ID: 3,
+		API_KEY: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8",
+		INNERTUBE_CONTEXT: { client: {
+			clientName: "ANDROID",
+			clientVersion: "20.10.38",
+			osName: "Android",
+			osVersion: "11"
+		} },
+		HEADERS: {
+			"User-Agent": "com.google.android.youtube/20.10.38 (Linux; U; Android 11) gzip",
+			"X-YouTube-Client-Name": "3",
+			"X-YouTube-Client-Version": "20.10.38"
+		}
+	},
+	TV_EMBEDDED: {
+		NAME: "TVHTML5_SIMPLY_EMBEDDED_PLAYER",
+		VERSION: "2.0",
+		CLIENT_ID: 85,
+		API_KEY: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8",
+		INNERTUBE_CONTEXT: {
+			client: {
+				clientName: "TVHTML5_SIMPLY_EMBEDDED_PLAYER",
+				clientVersion: "2.0",
+				clientScreen: "EMBED",
+				platform: "TV"
+			},
+			thirdParty: { embedUrl: "https://www.youtube.com/" }
+		},
+		HEADERS: {
+			"User-Agent": "Mozilla/5.0 (ChromiumStylePlatform) Cobalt/Version",
+			"X-YouTube-Client-Name": "85",
+			"X-YouTube-Client-Version": "2.0"
+		}
+	}
+};
+
+//#endregion
+//#region src/types/error.types.ts
+function createError(code, message, cause) {
+	return {
+		code,
+		message,
+		cause,
+		recoverable: isRecoverable(code)
+	};
+}
+function isRecoverable(code) {
+	return [
+		"RATE_LIMITED",
+		"NETWORK_ERROR",
+		"PO_TOKEN_REQUIRED",
+		"PO_TOKEN_EXPIRED",
+		"BOTGUARD_INIT_FAILED",
+		"ALL_PROVIDERS_FAILED"
+	].includes(code);
+}
+
+//#endregion
+//#region src/http/client.ts
+function parseCookies(setCookieHeaders) {
+	return setCookieHeaders.map((header) => {
+		const [nameValue, ...attributes] = header.split(";").map((p) => p.trim());
+		const [name, value] = nameValue.split("=");
+		const cookie = {
+			name,
+			value
+		};
+		for (const attr of attributes) {
+			const [key, val] = attr.split("=");
+			const keyLower = key.toLowerCase();
+			if (keyLower === "domain") cookie.domain = val;
+			else if (keyLower === "path") cookie.path = val;
+			else if (keyLower === "secure") cookie.secure = true;
+			else if (keyLower === "httponly") cookie.httpOnly = true;
+			else if (keyLower === "expires") cookie.expires = new Date(val);
+		}
+		return cookie;
+	});
+}
+function cookiesToHeader(cookies) {
+	return Array.from(cookies.values()).map((c) => `${c.name}=${c.value}`).join("; ");
+}
+/**
+* HTTP client with cookie jar and controlled redirect handling.
+* Superior to YouTube.js: tracks cookies across redirects, prevents loops.
+*/
+var HttpClient = class {
+	cookies = /* @__PURE__ */ new Map();
+	/**
+	* Performs a fetch request with automatic cookie and redirect handling.
+	* @param url - The URL to fetch
+	* @param options - Fetch options. Use manualRedirects=true for controlled redirects
+	* @returns Result containing the Response or a BundlpError
+	*/
+	async request(url, options = {}) {
+		const { maxRedirects = 10, manualRedirects = false, timeout, ...fetchOptions } = options;
+		if (!manualRedirects) try {
+			return ok(await fetch(url, {
+				...fetchOptions,
+				signal: timeout ? AbortSignal.timeout(timeout) : void 0
+			}));
+		} catch (error) {
+			return err(createError("NETWORK_ERROR", `Request to ${url} failed: ${error.message}`, error));
+		}
+		let currentUrl = url;
+		let redirectCount = 0;
+		const visitedUrls = /* @__PURE__ */ new Set();
+		while (redirectCount <= maxRedirects) {
+			if (visitedUrls.has(currentUrl)) return err(createError("NETWORK_ERROR", `Redirect loop detected at ${currentUrl}`));
+			visitedUrls.add(currentUrl);
+			try {
+				const headers = new Headers(fetchOptions.headers);
+				const cookieHeader = cookiesToHeader(this.cookies);
+				if (cookieHeader) headers.set("Cookie", cookieHeader);
+				const response = await fetch(currentUrl, {
+					...fetchOptions,
+					headers,
+					redirect: "manual",
+					signal: timeout ? AbortSignal.timeout(timeout) : void 0
+				});
+				const setCookies = response.headers.getSetCookie?.() || [];
+				for (const cookie of parseCookies(setCookies)) this.cookies.set(cookie.name, cookie);
+				if (response.status >= 300 && response.status < 400) {
+					const location = response.headers.get("location");
+					if (!location) return ok(response);
+					currentUrl = new URL(location, currentUrl).href;
+					redirectCount++;
+					continue;
+				}
+				return ok(response);
+			} catch (error) {
+				return err(createError("NETWORK_ERROR", `Request to ${currentUrl} failed: ${error.message}`, error));
+			}
+		}
+		return err(createError("NETWORK_ERROR", `Too many redirects (${redirectCount}) for ${url}`));
+	}
+	clearCookies() {
+		this.cookies.clear();
+	}
+	getCookies() {
+		return new Map(this.cookies);
+	}
+	/**
+	* Performs a GET request.
+	* @param url - The URL to fetch
+	* @param options - Optional fetch options
+	* @returns Result containing the Response or a BundlpError
+	*/
+	async get(url, options = {}) {
+		return this.request(url, {
+			...options,
+			method: "GET"
+		});
+	}
+	/**
+	* Performs a POST request with JSON body.
+	* @param url - The URL to post to
+	* @param body - The request body (will be JSON stringified)
+	* @param options - Optional fetch options
+	* @returns Result containing the Response or a BundlpError
+	*/
+	async post(url, body, options = {}) {
+		return this.request(url, {
+			...options,
+			method: "POST",
+			body: JSON.stringify(body),
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+const httpClient = new HttpClient();
+
+//#endregion
+//#region src/validation/schemas.ts
+/**
+* Schema for playability status returned by InnerTube API.
+*/
+const PlayabilityStatusSchema = type({
+	status: "'OK' | 'UNPLAYABLE' | 'LOGIN_REQUIRED' | 'AGE_CHECK_REQUIRED' | 'ERROR'",
+	"reason?": "string",
+	"playableInEmbed?": "boolean",
+	"liveStreamability?": "unknown"
+});
+/**
+* Schema for thumbnail objects.
+*/
+const ThumbnailSchema = type({
+	url: "string",
+	width: "number",
+	height: "number"
+});
+/**
+* Schema for video details from InnerTube response.
+* Some fields are optional as TV and other clients may omit them.
+*/
+const VideoDetailsSchema = type({
+	videoId: "string",
+	"title?": "string",
+	lengthSeconds: "string",
+	channelId: "string",
+	"shortDescription?": "string",
+	"thumbnail?": { thumbnails: ThumbnailSchema.array() },
+	"viewCount?": "string",
+	"author?": "string",
+	isLiveContent: "boolean",
+	"isPrivate?": "boolean",
+	"keywords?": "string[]"
+});
+/**
+* Schema for raw format objects from streaming data.
+*/
+const RawFormatSchema = type({
+	itag: "number",
+	"url?": "string",
+	"signatureCipher?": "string",
+	"cipher?": "string",
+	mimeType: "string",
+	bitrate: "number",
+	"width?": "number",
+	"height?": "number",
+	"fps?": "number",
+	"qualityLabel?": "string",
+	quality: "string",
+	"audioQuality?": "string",
+	"audioSampleRate?": "string",
+	"audioChannels?": "number",
+	"contentLength?": "string",
+	"approxDurationMs?": "string",
+	"initRange?": {
+		start: "string",
+		end: "string"
+	},
+	"indexRange?": {
+		start: "string",
+		end: "string"
+	},
+	"lastModified?": "string",
+	"drmFamilies?": "string[]"
+});
+/**
+* Schema for streaming data section of player response.
+*/
+const StreamingDataSchema = type({
+	expiresInSeconds: "string",
+	"formats?": RawFormatSchema.array(),
+	"adaptiveFormats?": RawFormatSchema.array(),
+	"hlsManifestUrl?": "string",
+	"dashManifestUrl?": "string"
+});
+/**
+* Schema for caption track information.
+* Note: name can be either { simpleText } or { runs } format.
+*/
+const CaptionTrackSchema = type({
+	baseUrl: "string",
+	languageCode: "string",
+	"name?": "unknown",
+	"kind?": "string",
+	"isTranslatable?": "boolean"
+});
+/**
+* Schema for captions data section.
+*/
+const CaptionsDataSchema = type({ "playerCaptionsTracklistRenderer?": { "captionTracks?": CaptionTrackSchema.array() } });
+/**
+* Schema for microformat data section.
+*/
+const MicroformatDataSchema = type({ "playerMicroformatRenderer?": {
+	"uploadDate?": "string",
+	"publishDate?": "string",
+	"category?": "string",
+	"isFamilySafe?": "boolean",
+	"lengthSeconds?": "string"
+} });
+/**
+* Schema for the complete InnerTube player response.
+*/
+const PlayerResponseSchema = type({
+	playabilityStatus: PlayabilityStatusSchema,
+	"videoDetails?": VideoDetailsSchema,
+	"streamingData?": StreamingDataSchema,
+	"captions?": CaptionsDataSchema,
+	"microformat?": MicroformatDataSchema,
+	"storyboards?": "unknown"
+});
+
+//#endregion
+//#region src/streaming/drm.ts
+/**
+* Checks if a format is DRM-protected.
+* @param format - Format to check
+* @returns Whether format has DRM
+*/
+function hasDrm(format) {
+	return !!(format.drmFamilies && format.drmFamilies.length > 0);
+}
+/**
+* Checks if all formats are DRM-only.
+* @param formats - Array of formats
+* @returns Whether all formats have DRM
+*/
+function isDrmOnly(formats) {
+	if (formats.length === 0) return false;
+	return formats.every(hasDrm);
+}
+
+//#endregion
+//#region src/innertube/client.ts
+/**
+* Client for interacting with YouTube's InnerTube API.
+*/
+var InnerTubeClient = class {
+	currentClient;
+	FALLBACK_ORDER = [
+		"ANDROID_SDKLESS",
+		"TV",
+		"WEB"
+	];
+	constructor(config = {}) {
+		this.currentClient = config.initialClient || "WEB";
+	}
+	/**
+	* Sets the client type to use for API requests.
+	* @param client - The client name to use
+	* @returns Result indicating success or error if client is unknown
+	*/
+	setClient(client) {
+		if (!INNERTUBE_CLIENTS[client]) return err(createError("INVALID_CLIENT", `Unknown client: ${client}`));
+		this.currentClient = client;
+		return ok(void 0);
+	}
+	/**
+	* Gets the current client name being used.
+	* @returns The current client name
+	*/
+	getClientName() {
+		return this.currentClient;
+	}
+	getHeaders() {
+		const config = INNERTUBE_CLIENTS[this.currentClient];
+		return {
+			"Content-Type": "application/json",
+			Accept: "*/*",
+			Origin: YOUTUBE_BASE_URL,
+			Referer: `${YOUTUBE_BASE_URL}/`,
+			...config.HEADERS
+		};
+	}
+	buildContext() {
+		const config = INNERTUBE_CLIENTS[this.currentClient];
+		const context = {
+			client: {
+				hl: "en",
+				gl: "US",
+				...config.INNERTUBE_CONTEXT?.client
+			},
+			user: { lockedSafetyMode: false },
+			request: { useSsl: true }
+		};
+		const innertubeContext = config.INNERTUBE_CONTEXT;
+		if (innertubeContext?.thirdParty) context.thirdParty = innertubeContext.thirdParty;
+		return context;
+	}
+	/**
+	* Fetches video player data from the InnerTube API.
+	* @param videoId - The YouTube video ID
+	* @param options - Optional parameters for the request
+	* @returns Result containing PlayerResponse or BundlpError
+	*/
+	async fetchPlayer(videoId, options = {}) {
+		const config = INNERTUBE_CLIENTS[this.currentClient];
+		const payload = {
+			context: this.buildContext(),
+			videoId,
+			contentCheckOk: true,
+			racyCheckOk: true
+		};
+		if (options.signatureTimestamp) payload.playbackContext = { contentPlaybackContext: { signatureTimestamp: options.signatureTimestamp } };
+		if (options.poToken) {
+			if (!payload.serviceIntegrityDimensions) payload.serviceIntegrityDimensions = {};
+			payload.serviceIntegrityDimensions.poToken = options.poToken;
+		}
+		const url = `${INNER_TUBE_API_URL}/player?key=${config.API_KEY || ""}`;
+		const responseResult = await httpClient.post(url, payload, { headers: this.getHeaders() });
+		if (isErr(responseResult)) return responseResult;
+		const response = responseResult.value;
+		if (!response.ok) return err(createError("INNERTUBE_ERROR", `Player request failed with status ${response.status}`));
+		try {
+			const validated = PlayerResponseSchema(await response.json());
+			if (validated instanceof type.errors) return err(createError("PARSE_ERROR", `Invalid player response: ${validated.summary}`));
+			if (validated.playabilityStatus.status === "ERROR") return err(createError("VIDEO_UNAVAILABLE", validated.playabilityStatus.reason || "Video unavailable"));
+			return ok(validated);
+		} catch (error) {
+			return err(createError("PARSE_ERROR", "Failed to parse InnerTube response", error));
+		}
+	}
+	/**
+	* Fetches player data with automatic client fallback.
+	* Tries clients in order: ANDROID_SDKLESS → TV → IOS → WEB
+	* @param videoId - Video ID to fetch
+	* @param options - Fetch options
+	* @returns Result containing player response or error
+	*/
+	async fetchPlayerWithFallback(videoId, options = {}) {
+		const errors = [];
+		for (const clientName of this.FALLBACK_ORDER) {
+			if (isErr(this.setClient(clientName))) continue;
+			const result = await this.fetchPlayer(videoId, options);
+			if (isOk(result)) {
+				if (this.isValidResponse(result.value)) return result;
+				errors.push({
+					client: clientName,
+					error: createError("VIDEO_UNAVAILABLE", "Invalid or DRM-only response")
+				});
+			} else errors.push({
+				client: clientName,
+				error: result.error
+			});
+		}
+		return err(createError("VIDEO_UNAVAILABLE", "All clients failed", errors));
+	}
+	/**
+	* Validates if a player response is usable.
+	* @param response - Player response to validate
+	* @returns Whether response is valid
+	*/
+	isValidResponse(response) {
+		if (response.playabilityStatus.status !== "OK") return false;
+		if (!response.streamingData) return false;
+		if (this.hasDrmOnly(response.streamingData)) return false;
+		return true;
+	}
+	/**
+	* Checks if streaming data contains only DRM-protected formats.
+	* @param streamingData - Streaming data to check
+	* @returns Whether all formats are DRM-protected
+	*/
+	hasDrmOnly(streamingData) {
+		const allFormats = [...streamingData.formats || [], ...streamingData.adaptiveFormats || []];
+		if (allFormats.length === 0) return true;
+		return isDrmOnly(allFormats);
+	}
+};
+
+//#endregion
+//#region src/player/ast/matchers.ts
+const WALK_STOP = Symbol("stop");
+/**
+* Recursively walks an AST tree and applies a callback to each node.
+* Uses iterative approach with explicit stack for better performance on large ASTs.
+*/
+function walkAst(node, callback) {
+	const stack = [node];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		const result = callback(current);
+		if (result === WALK_STOP) return void 0;
+		if (result) return result;
+		for (const key of Object.keys(current)) {
+			const child = current[key];
+			if (child && typeof child === "object") {
+				if (Array.isArray(child)) for (let i = child.length - 1; i >= 0; i--) {
+					const item = child[i];
+					if (item && typeof item === "object" && "type" in item) stack.push(item);
+				}
+				else if ("type" in child) stack.push(child);
+			}
+		}
+	}
+}
+/**
+* Extracts FunctionExpression from either VariableDeclarator or AssignmentExpression
+*/
+function getFunctionExpression(node) {
+	if (node.type === "VariableDeclarator") {
+		const init = node.init;
+		if (init?.type === "FunctionExpression") return init;
+	}
+	if (node.type === "AssignmentExpression") {
+		const right = node.right;
+		if (right?.type === "FunctionExpression") return right;
+	}
+	return null;
+}
+/**
+* Finds the signature decipher function call in YouTube's player.js.
+* Supports multiple patterns:
+* - Pattern 1: LogicalExpression with SequenceExpression (YouTube.js style)
+* - Pattern 2: Direct CallExpression with decodeURIComponent argument
+* - Pattern 3: AssignmentExpression with cipher function call
+*/
+function sigMatcher(node) {
+	const funcExpr = getFunctionExpression(node);
+	if (!funcExpr) return false;
+	const params = funcExpr.params;
+	if (!params || params.length < 1 || params.length > 5) return false;
+	const body = funcExpr.body;
+	if (body?.type !== "BlockStatement") return false;
+	let foundCallExpr = null;
+	walkAst(body, (innerNode) => {
+		if (innerNode.type === "LogicalExpression" && innerNode.operator === "&&") {
+			const right = innerNode.right;
+			if (right?.type === "SequenceExpression") {
+				const expressions = right.expressions;
+				if (expressions?.[0]?.type === "AssignmentExpression") {
+					const assignRight = expressions[0].right;
+					if (assignRight?.type === "CallExpression") {
+						if (assignRight.arguments?.some((arg) => {
+							if (arg.type !== "CallExpression") return false;
+							const callee = arg.callee;
+							return callee?.type === "Identifier" && callee.name === "decodeURIComponent";
+						})) {
+							foundCallExpr = assignRight;
+							return WALK_STOP;
+						}
+					}
+				}
+			}
+		}
+		if (innerNode.type === "CallExpression") {
+			const args = innerNode.arguments;
+			if (!args || args.length !== 2) return void 0;
+			const firstArg = args[0];
+			if (firstArg?.type !== "Literal" || typeof firstArg.value !== "number") return;
+			const secondArg = args[1];
+			if (secondArg?.type !== "CallExpression") return void 0;
+			const secondCallee = secondArg.callee;
+			if (secondCallee?.type !== "Identifier" || secondCallee.name !== "decodeURIComponent") return;
+			if (innerNode.callee?.type === "Identifier") {
+				foundCallExpr = innerNode;
+				return WALK_STOP;
+			}
+		}
+		if (innerNode.type === "AssignmentExpression") {
+			const right = innerNode.right;
+			if (right?.type === "CallExpression") {
+				const args = right.arguments;
+				if (args?.length === 2) {
+					const firstArg = args[0];
+					const secondArg = args[1];
+					if (firstArg?.type === "Literal" && typeof firstArg.value === "number" && secondArg?.type === "CallExpression") {
+						const secondCallee = secondArg.callee;
+						if (secondCallee?.type === "Identifier" && secondCallee.name === "decodeURIComponent") {
+							foundCallExpr = right;
+							return WALK_STOP;
+						}
+					}
+				}
+			}
+		}
+	});
+	return foundCallExpr || false;
+}
+/**
+* Finds all potential 'n' parameter transformation function references.
+* Searches for patterns like: var XX = [functionName] or var XX = [functionName, "string"]
+* YouTube uses both single-element and multi-element arrays.
+* @param ast - Full AST to search
+* @returns Array of candidate function names
+*/
+function findNFunctionCandidates(ast) {
+	const candidates = [];
+	walkAst(ast, (node) => {
+		if (node.type !== "VariableDeclarator") return void 0;
+		const id = node.id;
+		const init = node.init;
+		if (id?.type !== "Identifier") return void 0;
+		if (init?.type !== "ArrayExpression") return void 0;
+		const elements = init.elements;
+		if (!elements || elements.length === 0) return void 0;
+		const firstElement = elements[0];
+		if (firstElement?.type !== "Identifier") return void 0;
+		candidates.push(firstElement.name);
+	});
+	return candidates;
+}
+/**
+* Finds the signatureTimestamp value in player.js.
+* Pattern 1: Direct ObjectExpression property (fastest)
+* Pattern 2: Inside FunctionExpression body (fallback)
+*/
+function timestampMatcher(node) {
+	if (node.type === "ObjectExpression") {
+		const properties = node.properties;
+		if (!properties) return false;
+		for (const prop of properties) {
+			if (prop.type !== "Property") continue;
+			const key = prop.key;
+			if ((key?.type === "Identifier" ? key.name : key?.type === "Literal" ? String(key.value) : null) === "signatureTimestamp") return prop;
+		}
+		return false;
+	}
+	const funcExpr = getFunctionExpression(node);
+	if (!funcExpr) return false;
+	const funcBody = funcExpr.body;
+	if (!funcBody) return false;
+	let foundProperty = null;
+	walkAst(funcBody, (innerNode) => {
+		if (innerNode.type !== "ObjectExpression") return void 0;
+		const properties = innerNode.properties;
+		if (!properties) return void 0;
+		for (const prop of properties) {
+			if (prop.type !== "Property") continue;
+			const key = prop.key;
+			if ((key?.type === "Identifier" ? key.name : key?.type === "Literal" ? String(key.value) : null) === "signatureTimestamp") {
+				foundProperty = prop;
+				return WALK_STOP;
+			}
+		}
+	});
+	return foundProperty || false;
+}
+
+//#endregion
+//#region src/player/ast/analyzer.ts
+const JS_BUILTINS = new Set([
+	"Array",
+	"Object",
+	"String",
+	"Number",
+	"Boolean",
+	"Math",
+	"JSON",
+	"Date",
+	"RegExp",
+	"Error",
+	"TypeError",
+	"RangeError",
+	"SyntaxError",
+	"parseInt",
+	"parseFloat",
+	"isNaN",
+	"isFinite",
+	"eval",
+	"encodeURIComponent",
+	"decodeURIComponent",
+	"encodeURI",
+	"decodeURI",
+	"undefined",
+	"null",
+	"NaN",
+	"Infinity",
+	"console",
+	"window",
+	"document",
+	"navigator",
+	"location",
+	"setTimeout",
+	"setInterval",
+	"clearTimeout",
+	"clearInterval",
+	"Promise",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"Symbol",
+	"Uint8Array",
+	"Int8Array",
+	"Uint16Array",
+	"Int16Array",
+	"Uint32Array",
+	"Int32Array",
+	"Float32Array",
+	"Float64Array",
+	"ArrayBuffer",
+	"DataView",
+	"Blob",
+	"URL",
+	"URLSearchParams",
+	"fetch",
+	"Request",
+	"Response",
+	"Headers",
+	"atob",
+	"btoa",
+	"escape",
+	"unescape",
+	"Proxy",
+	"Reflect",
+	"Function",
+	"this",
+	"arguments",
+	"self"
+]);
+function isBuiltin(name) {
+	return JS_BUILTINS.has(name);
+}
+/**
+* Analyzes a function node to find all external dependencies it references.
+* Recursively discovers nested dependencies.
+* Filters out JavaScript built-ins.
+*/
+const MAX_DEPTH = 4;
+function isLocalParameterVar(name) {
+	if (name.length !== 1) return false;
+	if (name === "z" || name === "g") return false;
+	return true;
+}
+function analyzeDependencies(funcNode, ast, visited = /* @__PURE__ */ new Set(), depth = 0) {
+	const dependencies = /* @__PURE__ */ new Set();
+	if (depth > MAX_DEPTH) return dependencies;
+	const identifiers = extractReferencedIdentifiers(funcNode);
+	for (const identifier of identifiers) {
+		if (isBuiltin(identifier)) continue;
+		if (visited.has(identifier)) continue;
+		if (isLocalParameterVar(identifier)) continue;
+		visited.add(identifier);
+		const definition = findDefinition(identifier, ast);
+		if (definition) {
+			dependencies.add(identifier);
+			const nestedDeps = analyzeDependencies(definition, ast, visited, depth + 1);
+			for (const dep of nestedDeps) dependencies.add(dep);
+		}
+	}
+	return dependencies;
+}
+/**
+* Extracts all identifiers referenced within a node that are not locally declared.
+* @param node - The AST node to scan
+* @returns Set of external identifier names
+*/
+function extractReferencedIdentifiers(node) {
+	const identifiers = /* @__PURE__ */ new Set();
+	const declared = /* @__PURE__ */ new Set();
+	walkAst(node, (innerNode) => {
+		if (innerNode.type === "VariableDeclarator") {
+			const id = innerNode.id;
+			if (id?.type === "Identifier") declared.add(id.name);
+		}
+		if (innerNode.type === "FunctionDeclaration" || innerNode.type === "FunctionExpression") {
+			const params = innerNode.params;
+			if (params) {
+				for (const param of params) if (param.type === "Identifier") declared.add(param.name);
+			}
+		}
+		if (innerNode.type === "MemberExpression") {
+			const object = innerNode.object;
+			if (object?.type === "Identifier") {
+				const name = object.name;
+				if (!declared.has(name)) identifiers.add(name);
+			}
+		}
+		if (innerNode.type === "Identifier") {
+			const parent = getParent(node, innerNode);
+			if (parent?.type === "CallExpression" && parent.callee === innerNode) {
+				const name = innerNode.name;
+				if (!declared.has(name)) identifiers.add(name);
+			}
+			if (parent?.type === "ArrayExpression") {
+				if (parent.elements?.includes(innerNode)) {
+					const name = innerNode.name;
+					if (!declared.has(name)) identifiers.add(name);
+				}
+			}
+			if (parent?.type === "UnaryExpression" && parent.operator === "typeof") {
+				const name = innerNode.name;
+				if (!declared.has(name)) identifiers.add(name);
+			}
+		}
+	});
+	return identifiers;
+}
+/**
+* Finds a variable or function definition by name in the AST.
+* @param name - The identifier name to find
+* @param ast - The AST to search
+* @returns The definition node if found, null otherwise
+*/
+function findDefinition(name, ast) {
+	let found = null;
+	walkAst(ast, (node) => {
+		if (node.type === "VariableDeclarator") {
+			const id = node.id;
+			if (id?.type === "Identifier" && id.name === name) {
+				const init = node.init;
+				if (init) {
+					found = init;
+					return node;
+				}
+			}
+		}
+		if (node.type === "FunctionDeclaration") {
+			const id = node.id;
+			if (id?.type === "Identifier" && id.name === name) {
+				found = node;
+				return node;
+			}
+		}
+		if (node.type === "AssignmentExpression") {
+			const left = node.left;
+			if (left?.type === "Identifier" && left.name === name) {
+				const right = node.right;
+				if (right) {
+					found = right;
+					return node;
+				}
+			}
+		}
+	});
+	return found;
+}
+/**
+* Finds the parent node of a target node within an AST.
+* @param root - The root node to search from
+* @param target - The target node to find the parent of
+* @returns The parent node if found, null otherwise
+*/
+function getParent(root, target) {
+	let parent = null;
+	walkAst(root, (node) => {
+		for (const key of Object.keys(node)) {
+			const child = node[key];
+			if (child === target) {
+				parent = node;
+				return node;
+			}
+			if (Array.isArray(child) && child.includes(target)) {
+				parent = node;
+				return node;
+			}
+		}
+	});
+	return parent;
+}
+
+//#endregion
+//#region src/player/ast/extractor.ts
+/**
+* Finds a function definition by name in the AST.
+* Supports function declarations, variable declarations with function expressions,
+* and assignment expressions.
+* @param ast - The AST root node to search
+* @param functionName - The name of the function to find
+* @returns The function node if found, null otherwise
+*/
+function findFunctionDefinition(ast, functionName) {
+	let definition = null;
+	walkAst(ast, (node) => {
+		const id = node.id;
+		if (node.type === "FunctionDeclaration" && id?.name === functionName) {
+			definition = node;
+			return WALK_STOP;
+		}
+		if (node.type === "VariableDeclarator" && id?.type === "Identifier" && id.name === functionName) {
+			const init = node.init;
+			if (init?.type === "FunctionExpression" || init?.type === "ArrowFunctionExpression") {
+				definition = init;
+				return WALK_STOP;
+			}
+		}
+		const left = node.left;
+		if (node.type === "AssignmentExpression" && left?.type === "Identifier" && left.name === functionName) {
+			const right = node.right;
+			if (right?.type === "FunctionExpression" || right?.type === "ArrowFunctionExpression") {
+				definition = right;
+				return WALK_STOP;
+			}
+		}
+	});
+	return definition;
+}
+/**
+* Extracts the source code for a given AST node.
+* @param code - The full source code string
+* @param node - The AST node with start and end positions
+* @returns The extracted code slice
+*/
+function extractCode(code, node) {
+	const start = node.start;
+	const end = node.end;
+	if (typeof start !== "number" || typeof end !== "number") return "";
+	return code.slice(start, end);
+}
+function isSafeInitializer(node) {
+	if (!node) return true;
+	return true;
+}
+/**
+* Extracts a full declaration (var X = ...) for a given name from the AST.
+* Handles both VariableDeclaration and AssignmentExpression patterns.
+* Only extracts if initializer is "safe" (no side-effects).
+* @param code - The full source code string
+* @param name - The identifier name to find
+* @param ast - The AST root node
+* @returns The complete declaration code, or null if not found
+*/
+function extractFullDeclaration(code, name, ast) {
+	let result = null;
+	walkAst(ast, (node) => {
+		if (node.type === "FunctionDeclaration") {
+			if (node.id?.name === name) {
+				result = extractCode(code, node);
+				return WALK_STOP;
+			}
+		}
+		if (node.type === "VariableDeclaration") {
+			const decls = node.declarations;
+			if (decls) for (const decl of decls) {
+				const id = decl.id;
+				const init = decl.init;
+				if (id?.name === name && init && isSafeInitializer(init)) {
+					result = extractCode(code, node);
+					return WALK_STOP;
+				}
+			}
+		}
+		if (node.type === "ExpressionStatement") {
+			const expr = node.expression;
+			if (expr?.type === "AssignmentExpression") {
+				const left = expr.left;
+				const right = expr.right;
+				if (left?.type === "Identifier" && left.name === name && isSafeInitializer(right)) {
+					const rightCode = extractCode(code, right);
+					if (rightCode) {
+						result = `var ${name} = ${rightCode}`;
+						return WALK_STOP;
+					}
+				}
+			}
+		}
+		if (node.type === "AssignmentExpression") {
+			const left = node.left;
+			if (left?.type === "Identifier" && left.name === name) {
+				const right = node.right;
+				if (isSafeInitializer(right)) {
+					const rightCode = extractCode(code, right);
+					if (rightCode) {
+						result = `var ${name} = ${rightCode}`;
+						return WALK_STOP;
+					}
+				}
+			}
+		}
+	});
+	return result;
+}
+/**
+* Extracts code for a function with a simplified approach.
+* Creates a self-contained IIFE with stubs for globals.
+* @param code - The full source code string
+* @param funcNode - The function AST node
+* @param ast - The full AST for dependency lookup
+* @param funcName - The name of the main function
+* @returns Combined code with dependencies wrapped in IIFE
+*/
+function extractCodeWithDependencies(code, funcNode, ast, funcName) {
+	const dependencies = analyzeDependencies(funcNode, ast);
+	const parts = [];
+	const extracted = /* @__PURE__ */ new Set();
+	const predeclared = /* @__PURE__ */ new Set();
+	for (const depName of dependencies) {
+		if (extracted.has(depName)) continue;
+		const depCode = extractFullDeclaration(code, depName, ast);
+		if (depCode) {
+			parts.push(depCode);
+			extracted.add(depName);
+		} else predeclared.add(depName);
+	}
+	if (!extracted.has(funcName)) {
+		const mainCode = extractFullDeclaration(code, funcName, ast);
+		if (mainCode) parts.push(mainCode);
+	}
+	const stubs = ["var g = { cF: function(a, b) { return b.indexOf(a) >= 0; }, C$: function(a) { return /\\s/.test(a); } };"];
+	const predeclareStmt = predeclared.size > 0 ? `var ${Array.from(predeclared).join(", ")};` : "";
+	const postProcess = "if (typeof z === 'string' && z.indexOf(';') !== -1) z = z.split(';');";
+	return [
+		...stubs,
+		predeclareStmt,
+		parts.join(";\n"),
+		postProcess
+	].filter(Boolean).join("\n");
+}
+
+//#endregion
+//#region src/player/cache.ts
+/**
+* SQLite-based cache for YouTube player.js cipher functions.
+* Stores extracted signature and n-transform functions to avoid re-parsing.
+*/
+var PlayerCache = class {
+	db;
+	ttlMs;
+	/**
+	* Creates a new PlayerCache instance.
+	* @param cachePath - Path to the SQLite database file
+	* @param ttlDays - Time-to-live for cached entries in days
+	*/
+	constructor(cachePath, ttlDays = 7) {
+		mkdirSync(dirname(cachePath), { recursive: true });
+		this.db = new Database(cachePath);
+		this.ttlMs = ttlDays * 24 * 60 * 60 * 1e3;
+		this.initializeSchema();
+	}
+	initializeSchema() {
+		this.db.run(`
+      CREATE TABLE IF NOT EXISTS players (
+        player_id TEXT PRIMARY KEY,
+        code TEXT NOT NULL,
+        sig_function TEXT,
+        n_function TEXT,
+        signature_timestamp INTEGER,
+        cached_at INTEGER NOT NULL
+      )
+    `);
+	}
+	/**
+	* Retrieves a cached player entry.
+	* @param playerId - The player ID to look up
+	* @returns Result containing the cached player or null if not found/expired
+	*/
+	get(playerId) {
+		try {
+			const row = this.db.prepare(`
+        SELECT player_id, code, sig_function, n_function, signature_timestamp, cached_at
+        FROM players
+        WHERE player_id = ?
+      `).get(playerId);
+			if (!row) return ok(null);
+			if (this.isExpired(row.cached_at)) {
+				this.delete(playerId);
+				return ok(null);
+			}
+			return ok({
+				playerId: row.player_id,
+				code: row.code,
+				sigFunction: row.sig_function || "",
+				nFunction: row.n_function || "",
+				signatureTimestamp: row.signature_timestamp || 0,
+				cachedAt: row.cached_at
+			});
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to read from cache", error));
+		}
+	}
+	/**
+	* Stores a player entry in the cache.
+	* @param data - The player data to cache
+	* @returns Result indicating success or failure
+	*/
+	set(data) {
+		try {
+			this.db.prepare(`
+        INSERT OR REPLACE INTO players (
+          player_id, code, sig_function, n_function, signature_timestamp, cached_at
+        ) VALUES (?, ?, ?, ?, ?, ?)
+      `).run(data.playerId, data.code, data.sigFunction, data.nFunction, data.signatureTimestamp, data.cachedAt);
+			return ok(void 0);
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to write to cache", error));
+		}
+	}
+	/**
+	* Deletes a specific player entry from the cache.
+	* @param playerId - The player ID to delete
+	* @returns Result indicating success or failure
+	*/
+	delete(playerId) {
+		try {
+			this.db.prepare("DELETE FROM players WHERE player_id = ?").run(playerId);
+			return ok(void 0);
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to delete from cache", error));
+		}
+	}
+	/**
+	* Clears all entries from the cache.
+	* @returns Result indicating success or failure
+	*/
+	clear() {
+		try {
+			this.db.run("DELETE FROM players");
+			return ok(void 0);
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to clear cache", error));
+		}
+	}
+	/**
+	* Retrieves the most recent valid cached player entry.
+	* Used to avoid re-downloading player.js when we have valid cache.
+	* @returns Result containing the cached player or null if none valid
+	*/
+	getLatest() {
+		try {
+			const row = this.db.prepare(`
+                SELECT player_id, code, sig_function, n_function, signature_timestamp, cached_at
+                FROM players
+                ORDER BY cached_at DESC
+                LIMIT 1
+            `).get();
+			if (!row) return ok(null);
+			if (this.isExpired(row.cached_at)) {
+				this.delete(row.player_id);
+				return ok(null);
+			}
+			return ok({
+				playerId: row.player_id,
+				code: row.code,
+				sigFunction: row.sig_function || "",
+				nFunction: row.n_function || "",
+				signatureTimestamp: row.signature_timestamp || 0,
+				cachedAt: row.cached_at
+			});
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to read latest from cache", error));
+		}
+	}
+	/**
+	* Closes the database connection.
+	*/
+	close() {
+		this.db.close();
+	}
+	isExpired(cachedAt) {
+		return Date.now() - cachedAt > this.ttlMs;
+	}
+};
+
+//#endregion
+//#region src/player/player.ts
+/**
+* Handles YouTube player.js downloading, parsing, and cipher function extraction.
+* Uses AST-based extraction for robustness against YouTube's obfuscation changes.
+*/
+var Player = class {
+	cache = null;
+	playerCode = "";
+	sigFunctionCode = "";
+	nFunctionCode = "";
+	decipherFunc = null;
+	nFunc = null;
+	signatureTimestamp = 0;
+	initialized = false;
+	constructor(cacheDir) {
+		if (cacheDir) this.cache = new PlayerCache(join(cacheDir, "player.db"));
+	}
+	/**
+	* Downloads and parses the YouTube player.js to extract cipher functions.
+	* Uses cache-first strategy to minimize network requests.
+	* @param playerUrl - Optional direct URL to player.js, auto-detected if not provided
+	* @returns Result indicating success or failure
+	*/
+	async initialize(playerUrl) {
+		if (this.initialized) return ok(void 0);
+		if (this.cache && !playerUrl) {
+			const latestResult = this.cache.getLatest();
+			if (isOk(latestResult) && latestResult.value) return this.restoreFromCache(latestResult.value);
+		}
+		if (!playerUrl) {
+			const htmlResult = await httpClient.get(YOUTUBE_BASE_URL);
+			if (!isOk(htmlResult)) return err(htmlResult.error);
+			const match$1 = (await htmlResult.value.text()).match(/\/s\/player\/[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+\/base\.js/);
+			if (!match$1) return err(createError("PLAYER_FETCH_FAILED", "Could not determine player URL"));
+			playerUrl = YOUTUBE_BASE_URL + match$1[0];
+		}
+		const playerId = this.extractPlayerId(playerUrl);
+		if (this.cache && playerId) {
+			const cacheResult = this.cache.get(playerId);
+			if (isOk(cacheResult) && cacheResult.value) return this.restoreFromCache(cacheResult.value);
+		}
+		const codeResult = await httpClient.get(playerUrl);
+		if (!isOk(codeResult)) return err(codeResult.error);
+		this.playerCode = await codeResult.value.text();
+		const processResult = this.processCode(this.playerCode);
+		if (isOk(processResult)) {
+			this.initialized = true;
+			if (this.cache && playerId) this.cache.set({
+				playerId,
+				code: this.playerCode,
+				sigFunction: this.sigFunctionCode,
+				nFunction: this.nFunctionCode,
+				signatureTimestamp: this.signatureTimestamp,
+				cachedAt: Date.now()
+			});
+		}
+		return processResult;
+	}
+	extractPlayerId(playerUrl) {
+		const match$1 = playerUrl.match(/\/s\/player\/([a-zA-Z0-9_-]+)\//);
+		return match$1 ? match$1[1] : null;
+	}
+	restoreFromCache(cached) {
+		try {
+			this.playerCode = cached.code;
+			this.sigFunctionCode = cached.sigFunction;
+			this.nFunctionCode = cached.nFunction;
+			this.signatureTimestamp = cached.signatureTimestamp;
+			if (this.sigFunctionCode) this.decipherFunc = new Function("sig", this.sigFunctionCode);
+			if (this.nFunctionCode) this.nFunc = new Function("n", this.nFunctionCode);
+			this.initialized = true;
+			return ok(void 0);
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to restore from cache", error));
+		}
+	}
+	processCode(code) {
+		try {
+			const ast = parse(code, {
+				ranges: true,
+				next: true
+			});
+			this.extractSignatureTimestamp(ast);
+			this.extractDecipherFunction(ast, code);
+			this.extractNFunction(ast, code);
+			return ok(void 0);
+		} catch (error) {
+			return err(createError("PARSE_ERROR", "Failed to parse player.js", error));
+		}
+	}
+	extractSignatureTimestamp(ast) {
+		const stsNode = walkAst(ast, timestampMatcher);
+		if (stsNode) {
+			const value = stsNode.value;
+			if (value?.type === "Literal" && typeof value.value === "number") this.signatureTimestamp = value.value;
+		}
+	}
+	extractDecipherFunction(ast, code) {
+		const sigCall = walkAst(ast, sigMatcher);
+		if (!sigCall) return;
+		const callee = sigCall.callee;
+		if (callee?.type !== "Identifier") return;
+		const funcName = callee.name;
+		const funcDef = findFunctionDefinition(ast, funcName);
+		if (!funcDef) return;
+		const modeArg = sigCall.arguments?.[0];
+		const modeValue = modeArg?.type === "Literal" && typeof modeArg.value === "number" ? modeArg.value : 83;
+		const funcCode = extractCodeWithDependencies(code, funcDef, ast, funcName);
+		if (!funcCode) return;
+		this.sigFunctionCode = `
+            ${funcCode}
+            function __decipher_wrapper__(input) {
+                var result = ${funcName}(${modeValue}, input);
+                return Array.isArray(result) ? result.join('') : result;
+            }
+            return __decipher_wrapper__(sig);
+        `;
+		try {
+			this.decipherFunc = new Function("sig", this.sigFunctionCode);
+		} catch {
+			this.decipherFunc = null;
+		}
+	}
+	extractNFunction(ast, code) {
+		const candidates = findNFunctionCandidates(ast);
+		let bestCandidate = null;
+		for (const nFuncName of candidates) {
+			const nFuncDef = findFunctionDefinition(ast, nFuncName);
+			if (!nFuncDef) continue;
+			if (nFuncDef.type !== "FunctionExpression" && nFuncDef.type !== "ArrowFunctionExpression" && nFuncDef.type !== "FunctionDeclaration") continue;
+			const nFuncCode = extractCodeWithDependencies(code, nFuncDef, ast, nFuncName);
+			if (!bestCandidate || nFuncCode.length > bestCandidate.size) bestCandidate = {
+				name: nFuncName,
+				code: nFuncCode,
+				size: nFuncCode.length
+			};
+		}
+		if (!bestCandidate) return;
+		this.nFunctionCode = `
+            ${bestCandidate.code}
+            function __n_wrapper__(input) {
+                return ${bestCandidate.name}(input);
+            }
+            return __n_wrapper__(n);
+        `;
+		try {
+			this.nFunc = new Function("n", this.nFunctionCode);
+		} catch {
+			this.nFunc = null;
+		}
+	}
+	/**
+	* Returns the signature timestamp extracted from player.js.
+	* Required for some InnerTube API calls.
+	*/
+	getSignatureTimestamp() {
+		return this.signatureTimestamp;
+	}
+	/**
+	* Deciphers a signature cipher string and constructs the final playback URL.
+	* @param baseUrl - The base URL from the format
+	* @param signatureCipher - The encoded signature cipher string
+	* @returns The deciphered playback URL
+	*/
+	decipher(baseUrl, signatureCipher) {
+		if (!this.decipherFunc) return baseUrl;
+		const params = new URLSearchParams(signatureCipher);
+		const urlParam = params.get("url");
+		const sig = params.get("s");
+		const sp = params.get("sp") || "sig";
+		if (!sig || !urlParam) return baseUrl;
+		try {
+			const decryptedSig = this.decipherFunc(decodeURIComponent(sig));
+			return `${decodeURIComponent(urlParam)}&${sp}=${encodeURIComponent(decryptedSig)}`;
+		} catch {
+			return baseUrl;
+		}
+	}
+	/**
+	* Deobfuscates the 'n' parameter to prevent throttling.
+	* @param nParam - The obfuscated n parameter value
+	* @returns The deobfuscated n parameter value
+	*/
+	deobfuscateN(nParam) {
+		if (!this.nFunc) return nParam;
+		try {
+			return this.nFunc(nParam);
+		} catch {
+			return nParam;
+		}
+	}
+};
+
+//#endregion
+//#region src/http/retry.ts
+/**
+* Retry utilities with exponential backoff.
+* Provides automatic retry logic for transient failures.
+* @module http/retry
+*/
+const NON_RETRYABLE_PATTERNS = [
+	"invalid",
+	"not found",
+	"drm",
+	"private"
+];
+/**
+* Executes a function with automatic retry on failure.
+* @param fn - The async function to execute
+* @param options - Retry configuration options
+* @returns The result of the function if successful
+* @throws The last error if all retries are exhausted
+*/
+async function withRetry(fn, options = {}) {
+	const { retries = RETRY_DEFAULTS.RETRIES, delay = RETRY_DEFAULTS.DELAY, backoff = RETRY_DEFAULTS.BACKOFF, maxDelay = RETRY_DEFAULTS.MAX_DELAY, shouldRetry = defaultShouldRetry, onRetry } = options;
+	let lastError;
+	for (let attempt = 0; attempt <= retries; attempt++) try {
+		return await fn();
+	} catch (error) {
+		lastError = error;
+		if (attempt < retries && shouldRetry(lastError)) {
+			const waitTime = Math.min(delay * Math.pow(backoff, attempt), maxDelay);
+			onRetry?.(lastError, attempt + 1);
+			await sleep(waitTime);
+		}
+	}
+	throw lastError;
+}
+function defaultShouldRetry(error) {
+	const message = error.message.toLowerCase();
+	return !NON_RETRYABLE_PATTERNS.some((pattern) => message.includes(pattern));
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+//#region src/streaming/formats.ts
+/**
+* Parses a raw format object from InnerTube response into a typed Format.
+* @param raw - The raw format object from streaming data
+* @param isAdaptive - Whether this is an adaptive format (video-only or audio-only)
+* @returns Parsed Format object
+*/
+function parseFormat(raw, isAdaptive) {
+	return {
+		itag: raw.itag,
+		url: raw.url || "",
+		mimeType: raw.mimeType,
+		codecs: extractCodecs(raw.mimeType),
+		bitrate: raw.bitrate,
+		width: raw.width,
+		height: raw.height,
+		fps: raw.fps,
+		qualityLabel: raw.qualityLabel,
+		audioSampleRate: raw.audioSampleRate ? parseInt(raw.audioSampleRate, 10) : void 0,
+		audioChannels: raw.audioChannels,
+		contentLength: raw.contentLength ? parseInt(raw.contentLength, 10) : void 0,
+		hasDrm: !!raw.drmFamilies,
+		isAdaptive
+	};
+}
+/**
+* Extracts codec strings from a mimeType.
+* @param mimeType - The mimeType string containing codec info
+* @returns Array of codec strings
+*/
+function extractCodecs(mimeType) {
+	const match$1 = mimeType.match(/codecs="([^"]+)"/);
+	if (!match$1) return [];
+	return match$1[1].split(", ");
+}
+/**
+* Categorizes formats into combined (progressive), video-only, and audio-only.
+* @param formats - Array of all formats
+* @returns Object with categorized formats
+*/
+function categorizeFormats(formats) {
+	const combined = [];
+	const video = [];
+	const audio = [];
+	for (const format of formats) if (!format.isAdaptive) combined.push(format);
+	else if (format.mimeType.includes("video")) video.push(format);
+	else if (format.mimeType.includes("audio")) audio.push(format);
+	return {
+		combined,
+		video,
+		audio
+	};
+}
+
+//#endregion
+//#region src/streaming/decipher.ts
+/**
+* Handles deciphering of YouTube format URLs.
+* Processes signature ciphers and n-parameter obfuscation.
+*/
+var FormatDecipher = class {
+	constructor(player) {
+		this.player = player;
+	}
+	/**
+	* Deciphers a single format's URL.
+	* @param format - The raw format with potentially ciphered URL
+	* @returns Format with deciphered URL
+	*/
+	decipher(format) {
+		if (format.url && !format.signatureCipher && !format.cipher) return format;
+		let url = format.url || "";
+		if (format.signatureCipher || format.cipher) url = this.player.decipher(url, format.signatureCipher || format.cipher || "");
+		if (url && url.includes("n=")) url = this.deobfuscateNParam(url);
+		return {
+			...format,
+			url
+		};
+	}
+	/**
+	* Deciphers a batch of formats.
+	* @param formats - Array of raw formats
+	* @returns Array of formats with deciphered URLs
+	*/
+	decipherBatch(formats) {
+		return formats.map((format) => this.decipher(format));
+	}
+	deobfuscateNParam(url) {
+		try {
+			const urlObj = new URL(url);
+			const nParam = urlObj.searchParams.get("n");
+			if (nParam) {
+				const deobfuscatedN = this.player.deobfuscateN(nParam);
+				urlObj.searchParams.set("n", deobfuscatedN);
+				return urlObj.toString();
+			}
+		} catch {
+			return url;
+		}
+		return url;
+	}
+};
+
+//#endregion
+//#region src/utils/m3u8.ts
+/**
+* Parses an M3U8 playlist.
+* @param content - M3U8 file content
+* @returns Result containing parsed playlist or error
+*/
+function parseM3u8(content) {
+	try {
+		const lines = content.split("\n").map((line) => line.trim()).filter((line) => line);
+		if (!lines[0]?.startsWith("#EXTM3U")) return err(createError("PARSE_ERROR", "Invalid M3U8 file: missing #EXTM3U header"));
+		const version = extractVersion(lines);
+		if (lines.some((line) => line.includes("#EXT-X-STREAM-INF"))) return ok({
+			type: "master",
+			version,
+			variants: parseMasterPlaylist(lines)
+		});
+		return ok({
+			type: "media",
+			version,
+			segments: parseMediaPlaylist(lines),
+			targetDuration: extractTargetDuration(lines)
+		});
+	} catch (error) {
+		return err(createError("PARSE_ERROR", "Failed to parse M3U8", error));
+	}
+}
+/**
+* Extracts version from M3U8 playlist.
+* @param lines - Playlist lines
+* @returns Version number
+*/
+function extractVersion(lines) {
+	const versionLine = lines.find((line) => line.startsWith("#EXT-X-VERSION:"));
+	if (!versionLine) return 3;
+	const version = parseInt(versionLine.split(":")[1], 10);
+	return isNaN(version) ? 3 : version;
+}
+/**
+* Extracts target duration from media playlist.
+* @param lines - Playlist lines
+* @returns Target duration in seconds
+*/
+function extractTargetDuration(lines) {
+	const targetLine = lines.find((line) => line.startsWith("#EXT-X-TARGETDURATION:"));
+	if (!targetLine) return void 0;
+	const duration = parseInt(targetLine.split(":")[1], 10);
+	return isNaN(duration) ? void 0 : duration;
+}
+/**
+* Parses master playlist variants.
+* @param lines - Playlist lines
+* @returns Array of HLS variants
+*/
+function parseMasterPlaylist(lines) {
+	const variants = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.startsWith("#EXT-X-STREAM-INF:")) {
+			const attributes = parseStreamInf(line);
+			const url = lines[i + 1];
+			if (url && !url.startsWith("#")) variants.push({
+				url,
+				bandwidth: attributes.bandwidth,
+				resolution: attributes.resolution,
+				codecs: attributes.codecs,
+				frameRate: attributes.frameRate
+			});
+		}
+	}
+	return variants;
+}
+/**
+* Parses #EXT-X-STREAM-INF attributes.
+* @param line - Stream info line
+* @returns Parsed attributes
+*/
+function parseStreamInf(line) {
+	const attrs = line.split(":")[1];
+	const bandwidth = extractAttribute(attrs, "BANDWIDTH");
+	const resolution = extractAttribute(attrs, "RESOLUTION");
+	const codecs = extractAttribute(attrs, "CODECS");
+	const frameRateStr = extractAttribute(attrs, "FRAME-RATE");
+	return {
+		bandwidth: parseInt(bandwidth || "0", 10),
+		resolution: resolution || void 0,
+		codecs: codecs || void 0,
+		frameRate: frameRateStr ? parseFloat(frameRateStr) : void 0
+	};
+}
+/**
+* Parses media playlist segments.
+* @param lines - Playlist lines
+* @returns Array of HLS segments
+*/
+function parseMediaPlaylist(lines) {
+	const segments = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.startsWith("#EXTINF:")) {
+			const duration = parseFloat(line.split(":")[1].split(",")[0]);
+			const url = lines[i + 1];
+			if (url && !url.startsWith("#")) {
+				const byteRange = parseByteRange(lines[i - 1]);
+				segments.push({
+					url,
+					duration,
+					byteRange
+				});
+			}
+		}
+	}
+	return segments;
+}
+/**
+* Parses #EXT-X-BYTERANGE directive.
+* @param line - Byte range line
+* @returns Byte range object or undefined
+*/
+function parseByteRange(line) {
+	if (!line?.startsWith("#EXT-X-BYTERANGE:")) return void 0;
+	const parts = line.split(":")[1].split("@");
+	if (parts.length !== 2) return void 0;
+	const length = parseInt(parts[0], 10);
+	const start = parseInt(parts[1], 10);
+	if (isNaN(length) || isNaN(start)) return void 0;
+	return {
+		start,
+		length
+	};
+}
+/**
+* Extracts attribute value from M3U8 attribute string.
+* @param attrs - Attribute string
+* @param name - Attribute name
+* @returns Attribute value or undefined
+*/
+function extractAttribute(attrs, name) {
+	const regex = /* @__PURE__ */ new RegExp(`${name}=([^,]+)`);
+	const match$1 = attrs.match(regex);
+	if (!match$1) return void 0;
+	let value = match$1[1].trim();
+	if (value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
+	return value;
+}
+
+//#endregion
+//#region src/streaming/hls/parser.ts
+/**
+* Fetches and parses an HLS manifest.
+* @param manifestUrl - URL to HLS manifest
+* @returns Result containing parsed playlist or error
+*/
+async function fetchHlsManifest(manifestUrl) {
+	const response = await httpClient.get(manifestUrl);
+	if (!isOk(response)) return err(response.error);
+	try {
+		return parseM3u8(await response.value.text());
+	} catch (error) {
+		return err(createError("PARSE_ERROR", "Failed to fetch HLS manifest", error));
+	}
+}
+
+//#endregion
+//#region src/utils/xml.ts
+/**
+* Parses XML string into a simple node tree.
+* @param xml - XML string to parse
+* @returns Root XML node
+*/
+function parseXml(xml) {
+	const root = {
+		type: "element",
+		name: "root",
+		children: []
+	};
+	const stack = [root];
+	const tagRegex = /<\/?([a-zA-Z0-9_-]+)([^>]*)>/g;
+	let lastIndex = 0;
+	let match$1;
+	while ((match$1 = tagRegex.exec(xml)) !== null) {
+		const textBefore = xml.slice(lastIndex, match$1.index).trim();
+		if (textBefore && stack.length > 0) {
+			const parent = stack[stack.length - 1];
+			if (parent.children) parent.children.push({
+				type: "text",
+				text: textBefore
+			});
+		}
+		const fullTag = match$1[0];
+		const tagName = match$1[1];
+		const attributes = match$1[2];
+		if (fullTag.startsWith("</")) stack.pop();
+		else {
+			const node = {
+				type: "element",
+				name: tagName,
+				attributes: parseAttributes(attributes),
+				children: []
+			};
+			const parent = stack[stack.length - 1];
+			if (parent.children) parent.children.push(node);
+			if (!fullTag.endsWith("/>")) stack.push(node);
+		}
+		lastIndex = tagRegex.lastIndex;
+	}
+	return root;
+}
+/**
+* Parses XML attributes from a string.
+* @param attrString - Attribute string from XML tag
+* @returns Record of attribute name-value pairs
+*/
+function parseAttributes(attrString) {
+	const attrs = {};
+	const attrRegex = /([a-zA-Z0-9_-]+)="([^"]*)"/g;
+	let match$1;
+	while ((match$1 = attrRegex.exec(attrString)) !== null) attrs[match$1[1]] = match$1[2];
+	return attrs;
+}
+/**
+* Finds all nodes matching a tag name.
+* @param node - Root node to search
+* @param tagName - Tag name to match
+* @returns Array of matching nodes
+*/
+function findAll(node, tagName) {
+	const results = [];
+	if (node.type === "element" && node.name === tagName) results.push(node);
+	if (node.children) for (const child of node.children) results.push(...findAll(child, tagName));
+	return results;
+}
+/**
+* Finds the first node matching a tag name.
+* @param node - Root node to search
+* @param tagName - Tag name to match
+* @returns First matching node or undefined
+*/
+function findFirst(node, tagName) {
+	if (node.type === "element" && node.name === tagName) return node;
+	if (node.children) for (const child of node.children) {
+		const found = findFirst(child, tagName);
+		if (found) return found;
+	}
+}
+/**
+* Gets attribute value from a node.
+* @param node - XML node
+* @param attrName - Attribute name
+* @returns Attribute value or undefined
+*/
+function getAttribute(node, attrName) {
+	return node.attributes?.[attrName];
+}
+/**
+* Gets text content from a node.
+* @param node - XML node
+* @returns Text content or empty string
+*/
+function getTextContent(node) {
+	if (node.type === "text") return node.text || "";
+	if (node.children) return node.children.map((child) => getTextContent(child)).join("");
+	return "";
+}
+
+//#endregion
+//#region src/streaming/dash/parser.ts
+/**
+* Parses a DASH manifest XML string.
+* @param xml - DASH manifest XML
+* @returns Result containing parsed manifest or error
+*/
+function parseDashManifest(xml) {
+	try {
+		const mpd = findFirst(parseXml(xml), "MPD");
+		if (!mpd) return err(createError("PARSE_ERROR", "Invalid DASH manifest: missing MPD element"));
+		const duration = parseDuration(getAttribute(mpd, "mediaPresentationDuration"));
+		const periods = findAll(mpd, "Period");
+		const adaptationSets = [];
+		for (const period of periods) {
+			const sets = findAll(period, "AdaptationSet");
+			for (const set of sets) {
+				const parsed = parseAdaptationSet(set);
+				if (parsed) adaptationSets.push(parsed);
+			}
+		}
+		return ok({
+			duration,
+			adaptationSets
+		});
+	} catch (error) {
+		return err(createError("PARSE_ERROR", "Failed to parse DASH manifest", error));
+	}
+}
+/**
+* Parses an AdaptationSet element.
+* @param node - AdaptationSet XML node
+* @returns Parsed adaptation set or undefined
+*/
+function parseAdaptationSet(node) {
+	const id = getAttribute(node, "id") || "";
+	const mimeType = getAttribute(node, "mimeType") || "";
+	const contentType = mimeType.startsWith("video") ? "video" : "audio";
+	const representations = findAll(node, "Representation");
+	const parsedReps = [];
+	for (const rep of representations) {
+		const parsed = parseRepresentation(rep);
+		if (parsed) parsedReps.push(parsed);
+	}
+	if (parsedReps.length === 0) return void 0;
+	return {
+		id,
+		mimeType,
+		contentType,
+		representations: parsedReps
+	};
+}
+/**
+* Parses a Representation element.
+* @param node - Representation XML node
+* @returns Parsed representation or undefined
+*/
+function parseRepresentation(node) {
+	const id = getAttribute(node, "id") || "";
+	const bandwidthStr = getAttribute(node, "bandwidth");
+	const codecs = getAttribute(node, "codecs") || "";
+	if (!bandwidthStr) return void 0;
+	const bandwidth = parseInt(bandwidthStr, 10);
+	if (isNaN(bandwidth)) return void 0;
+	const widthStr = getAttribute(node, "width");
+	const heightStr = getAttribute(node, "height");
+	const frameRateStr = getAttribute(node, "frameRate");
+	const audioSampleRateStr = getAttribute(node, "audioSampleRate");
+	const baseUrlNode = findFirst(node, "BaseURL");
+	const baseUrl = baseUrlNode ? getTextContent(baseUrlNode) : "";
+	const initRange = parseRange(findFirst(node, "Initialization"));
+	const indexRange = parseRange(findFirst(node, "SegmentBase"));
+	return {
+		id,
+		bandwidth,
+		codecs,
+		width: widthStr ? parseInt(widthStr, 10) : void 0,
+		height: heightStr ? parseInt(heightStr, 10) : void 0,
+		frameRate: frameRateStr ? parseFloat(frameRateStr) : void 0,
+		audioSampleRate: audioSampleRateStr ? parseInt(audioSampleRateStr, 10) : void 0,
+		baseUrl,
+		initRange,
+		indexRange
+	};
+}
+/**
+* Parses range attribute from a node.
+* @param node - XML node with range attribute
+* @returns Range object or undefined
+*/
+function parseRange(node) {
+	if (!node) return void 0;
+	const range = getAttribute(node, "range");
+	if (!range) return void 0;
+	const parts = range.split("-");
+	if (parts.length !== 2) return void 0;
+	const start = parseInt(parts[0], 10);
+	const end = parseInt(parts[1], 10);
+	if (isNaN(start) || isNaN(end)) return void 0;
+	return {
+		start,
+		end
+	};
+}
+/**
+* Parses ISO 8601 duration string.
+* @param duration - ISO 8601 duration string (e.g., "PT1H2M3S")
+* @returns Duration in seconds
+*/
+function parseDuration(duration) {
+	if (!duration) return 0;
+	const match$1 = duration.match(/PT(?:(\d+)H)?(?:(\d+)M)?(?:([\d.]+)S)?/);
+	if (!match$1) return 0;
+	const hours = parseInt(match$1[1] || "0", 10);
+	const minutes = parseInt(match$1[2] || "0", 10);
+	const seconds = parseFloat(match$1[3] || "0");
+	return hours * 3600 + minutes * 60 + seconds;
+}
+
+//#endregion
+//#region src/streaming/hls/segments.ts
+/**
+* Resolves a potentially relative URL against a base URL.
+* @param baseUrl - Base URL from manifest location
+* @param path - Relative or absolute path
+* @returns Resolved absolute URL
+*/
+function resolveUrl(baseUrl, path) {
+	if (path.startsWith("http://") || path.startsWith("https://")) return path;
+	const url = new URL(baseUrl);
+	if (path.startsWith("/")) return `${url.protocol}//${url.host}${path}`;
+	const basePath = url.pathname.substring(0, url.pathname.lastIndexOf("/") + 1);
+	return `${url.protocol}//${url.host}${basePath}${path}`;
+}
+/**
+* Resolves all variant URLs in a master playlist.
+* @param playlist - Parsed HLS master playlist
+* @param manifestUrl - Original manifest URL
+* @returns Playlist with resolved variant URLs
+*/
+function resolveVariantUrls(playlist, manifestUrl) {
+	if (playlist.type !== "master" || !playlist.variants) return playlist;
+	return {
+		...playlist,
+		variants: playlist.variants.map((variant) => ({
+			...variant,
+			url: resolveUrl(manifestUrl, variant.url)
+		}))
+	};
+}
+
+//#endregion
+//#region src/streaming/dash/segments.ts
+/**
+* Extracts stream information from a DASH manifest.
+* @param manifest - Parsed DASH manifest
+* @returns Extracted stream information
+*/
+function extractDashStreams(manifest) {
+	const videoStreams = [];
+	const audioStreams = [];
+	for (const adaptationSet of manifest.adaptationSets) {
+		const streams = adaptationSet.contentType === "video" ? videoStreams : audioStreams;
+		for (const rep of adaptationSet.representations) streams.push(representationToStreamInfo(rep, adaptationSet));
+	}
+	videoStreams.sort((a, b) => b.bandwidth - a.bandwidth);
+	audioStreams.sort((a, b) => b.bandwidth - a.bandwidth);
+	return {
+		duration: manifest.duration,
+		videoStreams,
+		audioStreams
+	};
+}
+/**
+* Converts a DASH representation to stream info.
+* @param rep - DASH representation
+* @param adaptationSet - Parent adaptation set
+* @returns Stream info
+*/
+function representationToStreamInfo(rep, adaptationSet) {
+	return {
+		representationId: rep.id,
+		bandwidth: rep.bandwidth,
+		mimeType: adaptationSet.mimeType,
+		codecs: rep.codecs,
+		width: rep.width,
+		height: rep.height,
+		baseUrl: rep.baseUrl,
+		initRange: rep.initRange,
+		indexRange: rep.indexRange
+	};
+}
+
+//#endregion
+//#region src/streaming/processor.ts
+/**
+* Processes streaming data from InnerTube API responses.
+* Handles format parsing, deciphering, and categorization.
+*/
+var StreamingDataProcessor = class {
+	decipher;
+	constructor(player) {
+		this.decipher = new FormatDecipher(player);
+	}
+	/**
+	* Processes streaming data into a categorized FormatCollection.
+	* @param streamingData - Raw streaming data from player response
+	* @returns Categorized format collection with deciphered URLs
+	*/
+	async process(streamingData) {
+		const rawFormats = streamingData.formats || [];
+		const rawAdaptive = streamingData.adaptiveFormats || [];
+		const decipheredFormats = this.decipher.decipherBatch(rawFormats);
+		const decipheredAdaptive = this.decipher.decipherBatch(rawAdaptive);
+		const formats = decipheredFormats.map((f) => parseFormat(f, false));
+		const adaptiveFormats = decipheredAdaptive.map((f) => parseFormat(f, true));
+		const categorized = categorizeFormats([...formats, ...adaptiveFormats]);
+		const [hls, dash] = await Promise.all([this.extractHlsInfo(streamingData), this.extractDashInfo(streamingData)]);
+		return {
+			combined: categorized.combined,
+			video: categorized.video,
+			audio: categorized.audio,
+			hls,
+			dash
+		};
+	}
+	async extractHlsInfo(streamingData) {
+		if (!streamingData.hlsManifestUrl) return void 0;
+		const manifestUrl = streamingData.hlsManifestUrl;
+		const result = await fetchHlsManifest(manifestUrl);
+		if (!isOk(result)) return {
+			manifestUrl,
+			variants: []
+		};
+		const playlist = result.value;
+		if (playlist.type !== "master" || !playlist.variants) return {
+			manifestUrl,
+			variants: []
+		};
+		return {
+			manifestUrl,
+			variants: (resolveVariantUrls(playlist, manifestUrl).variants || []).map((v) => ({
+				url: v.url,
+				bandwidth: v.bandwidth,
+				resolution: v.resolution,
+				codecs: v.codecs
+			}))
+		};
+	}
+	async extractDashInfo(streamingData) {
+		if (!streamingData.dashManifestUrl) return void 0;
+		const manifestUrl = streamingData.dashManifestUrl;
+		const response = await httpClient.get(manifestUrl);
+		if (!isOk(response)) return {
+			manifestUrl,
+			duration: 0
+		};
+		try {
+			const parseResult = parseDashManifest(await response.value.text());
+			if (!isOk(parseResult)) return {
+				manifestUrl,
+				duration: 0
+			};
+			return {
+				manifestUrl,
+				duration: extractDashStreams(parseResult.value).duration
+			};
+		} catch {
+			return {
+				manifestUrl,
+				duration: 0
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/core/extractor.ts
+const VIDEO_ID_PATTERNS = [
+	/(?:youtube\.com\/watch\?v=|youtu\.be\/)([a-zA-Z0-9_-]{11})/,
+	/youtube\.com\/embed\/([a-zA-Z0-9_-]{11})/,
+	/youtube\.com\/shorts\/([a-zA-Z0-9_-]{11})/,
+	/youtube\.com\/live\/([a-zA-Z0-9_-]{11})/,
+	/youtube\.com\/v\/([a-zA-Z0-9_-]{11})/,
+	/youtube-nocookie\.com\/embed\/([a-zA-Z0-9_-]{11})/,
+	/m\.youtube\.com\/watch\?v=([a-zA-Z0-9_-]{11})/,
+	/music\.youtube\.com\/watch\?v=([a-zA-Z0-9_-]{11})/
+];
+/**
+* Main YouTube video extractor class.
+* Handles video information extraction using InnerTube API.
+*/
+var YouTubeExtractor = class {
+	client;
+	player;
+	config;
+	constructor(config = {}) {
+		this.config = config;
+		this.client = new InnerTubeClient({ initialClient: config.preferredClient });
+		this.player = new Player(config.cacheDir);
+	}
+	/**
+	* Extracts video information from a YouTube URL or video ID.
+	* @param url - YouTube URL or video ID
+	* @returns Result containing VideoInfo or BundlpError
+	*/
+	async extract(url) {
+		const videoIdResult = this.parseVideoId(url);
+		if (isErr(videoIdResult)) return videoIdResult;
+		return withRetry(() => this.realExtract(videoIdResult.value), {
+			retries: RETRY_DEFAULTS.RETRIES,
+			delay: RETRY_DEFAULTS.DELAY,
+			backoff: RETRY_DEFAULTS.BACKOFF
+		});
+	}
+	parseVideoId(url) {
+		for (const pattern of VIDEO_ID_PATTERNS) {
+			const match$1 = url.match(pattern);
+			if (match$1) return ok(match$1[1]);
+		}
+		if ((/* @__PURE__ */ new RegExp(`^[a-zA-Z0-9_-]{${VIDEO_ID_LENGTH}}$`)).test(url)) return ok(url);
+		return err(createError("INVALID_URL", `Could not extract video ID from: ${url}`));
+	}
+	async realExtract(videoId) {
+		const playerResult = await this.player.initialize();
+		if (isErr(playerResult)) return err(playerResult.error);
+		const responseResult = await this.client.fetchPlayerWithFallback(videoId, {
+			signatureTimestamp: this.player.getSignatureTimestamp(),
+			poToken: this.config.poToken
+		});
+		if (isErr(responseResult)) return err(responseResult.error);
+		const playerResponse = responseResult.value;
+		if (playerResponse.playabilityStatus.status === "ERROR") return err(createError("VIDEO_UNAVAILABLE", playerResponse.playabilityStatus.reason || "Video unavailable"));
+		if (!playerResponse.streamingData) return err(createError("VIDEO_UNAVAILABLE", "No streaming data found"));
+		const formats = await this.processFormats(playerResponse.streamingData);
+		return ok(this.assembleVideoInfo(videoId, playerResponse, formats));
+	}
+	async processFormats(streamingData) {
+		return new StreamingDataProcessor(this.player).process(streamingData);
+	}
+	assembleVideoInfo(videoId, playerResponse, formats) {
+		const details = playerResponse.videoDetails;
+		const microformat = playerResponse.microformat?.playerMicroformatRenderer;
+		return {
+			id: videoId,
+			title: details.title,
+			description: details.shortDescription,
+			duration: parseInt(details.lengthSeconds, 10),
+			uploadDate: microformat?.uploadDate,
+			channel: {
+				id: details.channelId,
+				name: details.author,
+				url: `${YOUTUBE_BASE_URL}/channel/${details.channelId}`
+			},
+			viewCount: parseInt(details.viewCount, 10),
+			thumbnails: details.thumbnail.thumbnails,
+			formats,
+			subtitles: /* @__PURE__ */ new Map(),
+			isLive: details.isLiveContent,
+			isPrivate: details.isPrivate
+		};
+	}
+};
+
+//#endregion
+//#region src/utils/headers.ts
+/**
+* HTTP Headers Utilities for YouTube Downloads
+*
+* Provides headers needed for downloading from deciphered YouTube URLs.
+* These headers are extracted from bundlp's InnerTube client configurations.
+*/
+/**
+* Get HTTP headers for downloading from deciphered YouTube URLs
+* Based on the client type used for extraction
+*
+* @param clientType - The client type to use (WEB, ANDROID, TV, IOS)
+* @returns Object with required HTTP headers for YouTube CDN requests
+*/
+function getDownloadHeaders(clientType = "ANDROID") {
+	const client = INNERTUBE_CLIENTS[clientType];
+	return {
+		"User-Agent": client.HEADERS["User-Agent"],
+		"Accept": "*/*",
+		"Accept-Encoding": "identity",
+		"Referer": "https://www.youtube.com/",
+		"Origin": "https://www.youtube.com",
+		"Sec-Fetch-Mode": "no-cors"
+	};
+}
+/**
+* Get minimal headers that work for most YouTube CDN requests
+* Use this as a fallback if full headers cause issues
+*
+* @returns Minimal set of headers needed for YouTube downloads
+*/
+function getMinimalDownloadHeaders() {
+	return {
+		"User-Agent": "Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36",
+		"Referer": "https://www.youtube.com/"
+	};
+}
+
+//#endregion
+//#region src/po-token/policies.ts
+/**
+* PO Token policies for each InnerTube client.
+* Defines when PO tokens are required for different endpoints.
+*/
+const PO_TOKEN_POLICIES = {
+	WEB: {
+		GVS: {
+			HTTPS: "required",
+			DASH: "required",
+			HLS: "recommended"
+		},
+		PLAYER: "not_required",
+		SUBS: "not_required",
+		notRequiredForPremium: true
+	},
+	ANDROID_SDKLESS: {
+		GVS: "not_required",
+		PLAYER: "not_required",
+		SUBS: "not_required"
+	},
+	ANDROID: {
+		GVS: "not_required",
+		PLAYER: "not_required",
+		SUBS: "not_required"
+	},
+	TV: {
+		GVS: "not_required",
+		PLAYER: "not_required",
+		SUBS: "not_required"
+	},
+	TV_EMBEDDED: {
+		GVS: "not_required",
+		PLAYER: "not_required",
+		SUBS: "not_required"
+	},
+	IOS: {
+		GVS: {
+			HTTPS: "required",
+			DASH: "required",
+			HLS: "recommended"
+		},
+		PLAYER: "recommended",
+		SUBS: "not_required"
+	}
+};
+
+//#endregion
+//#region src/po-token/botguard/challenge.ts
+const WAA_CREATE_ENDPOINT = "https://jnn-pa.googleapis.com/$rpc/google.internal.waa.v1.Waa/Create";
+const INNERTUBE_ATT_ENDPOINT = "https://www.youtube.com/youtubei/v1/att/get";
+const GOOG_API_KEY$1 = "AIzaSyDyT5W0Jh49F30Pqqtyfdf7pDLFKLJoAnw";
+const REQUEST_KEY$1 = "O43z0dpjhgX20SCx4KAo";
+var ChallengeFetcher = class {
+	timeout;
+	constructor(options = {}) {
+		this.timeout = options.timeout ?? 15e3;
+	}
+	async fetchAttestation() {
+		const payload = { context: { client: {
+			clientName: "WEB",
+			clientVersion: "2.20250222.10.00",
+			hl: "en",
+			gl: "US"
+		} } };
+		try {
+			const response = await fetch(INNERTUBE_ATT_ENDPOINT, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+					"Origin": "https://www.youtube.com",
+					"Referer": "https://www.youtube.com/"
+				},
+				body: JSON.stringify(payload),
+				signal: AbortSignal.timeout(this.timeout)
+			});
+			if (!response.ok) return err(createError("BOTGUARD_INIT_FAILED", `Attestation request failed with status ${response.status}`));
+			const data = await response.json();
+			return this.parseAttestationResponse(data);
+		} catch (error) {
+			if (error instanceof Error && error.name === "TimeoutError") return err(createError("BOTGUARD_INIT_FAILED", "Attestation fetch timeout"));
+			return err(createError("BOTGUARD_INIT_FAILED", "Failed to fetch attestation", error));
+		}
+	}
+	parseAttestationResponse(data) {
+		if (!data || typeof data !== "object") return err(createError("PARSE_ERROR", "Invalid attestation response"));
+		const response = data;
+		const responseContext = response.responseContext;
+		const botguardData = response.botguardData;
+		const challenge = response.challenge;
+		if (!responseContext?.visitorData) return err(createError("PARSE_ERROR", "Missing visitorData in response"));
+		if (!challenge || typeof challenge !== "string") return err(createError("PARSE_ERROR", "Missing challenge in response"));
+		if (!botguardData?.program) return err(createError("PARSE_ERROR", "Missing botguardData.program in response"));
+		return ok({
+			visitorData: responseContext.visitorData,
+			challenge,
+			program: botguardData.program
+		});
+	}
+	async fetchWaaChallenge() {
+		try {
+			const response = await fetch(WAA_CREATE_ENDPOINT, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json+protobuf",
+					"x-goog-api-key": GOOG_API_KEY$1
+				},
+				body: JSON.stringify([REQUEST_KEY$1]),
+				signal: AbortSignal.timeout(this.timeout)
+			});
+			if (!response.ok) return err(createError("BOTGUARD_INIT_FAILED", `WAA Create request failed with status ${response.status}`));
+			const encoded = (await response.json())[1];
+			if (!encoded || typeof encoded !== "string") return err(createError("PARSE_ERROR", "Invalid WAA response format"));
+			return this.descrambleWaaResponse(encoded);
+		} catch (error) {
+			if (error instanceof Error && error.name === "TimeoutError") return err(createError("BOTGUARD_INIT_FAILED", "WAA Create fetch timeout"));
+			return err(createError("BOTGUARD_INIT_FAILED", "Failed to fetch WAA challenge", error));
+		}
+	}
+	descrambleWaaResponse(encoded) {
+		try {
+			const decoded = atob(encoded);
+			const bytes = new Uint8Array(decoded.length);
+			for (let i = 0; i < decoded.length; i++) bytes[i] = decoded.charCodeAt(i) + 97 & 255;
+			const descrambled = new TextDecoder("utf-8").decode(bytes);
+			const parsed = JSON.parse(descrambled);
+			const messageId = parsed[0];
+			const interpreterArray = parsed[1];
+			const interpreterHash = parsed[3];
+			const program = parsed[4];
+			const globalName = parsed[5];
+			if (!program || !globalName) return err(createError("PARSE_ERROR", "Missing required fields in WAA response"));
+			let interpreterScript = "";
+			if (Array.isArray(interpreterArray) && interpreterArray.length >= 6) interpreterScript = interpreterArray[5];
+			if (!interpreterScript || typeof interpreterScript !== "string") return err(createError("PARSE_ERROR", "Failed to extract interpreter script"));
+			return ok({
+				messageId: messageId || "",
+				interpreterScript,
+				interpreterHash: interpreterHash || "",
+				program,
+				globalName
+			});
+		} catch (error) {
+			return err(createError("PARSE_ERROR", "Failed to descramble WAA response", error));
+		}
+	}
+	async fetchFullChallenge() {
+		return this.fetchWaaChallenge();
+	}
+	async fetch() {
+		return this.fetchAttestation();
+	}
+};
+
+//#endregion
+//#region src/po-token/botguard/client.ts
+var DeferredPromise = class {
+	promise;
+	resolve;
+	reject;
+	constructor() {
+		this.promise = new Promise((resolve, reject) => {
+			this.resolve = resolve;
+			this.reject = reject;
+		});
+	}
+};
+var BotGuardClient = class BotGuardClient {
+	dom = null;
+	vm = null;
+	program;
+	globalName;
+	deferredVmFunctions = new DeferredPromise();
+	syncSnapshotFunction;
+	initTimeout;
+	snapshotTimeout;
+	constructor(challenge, options = {}) {
+		this.program = challenge.program;
+		this.globalName = challenge.globalName;
+		this.initTimeout = options.timeout ?? 1e4;
+		this.snapshotTimeout = 5e3;
+	}
+	static async create(challenge, options = {}) {
+		const client = new BotGuardClient(challenge, options);
+		const loadResult = await client.load(challenge);
+		if (!isOk(loadResult)) return loadResult;
+		return ok(client);
+	}
+	async load(challenge) {
+		try {
+			this.dom = new JSDOM("<!DOCTYPE html><html><head></head><body></body></html>", {
+				url: "https://www.youtube.com/",
+				runScripts: "dangerously",
+				pretendToBeVisual: true
+			});
+			const window = this.dom.window;
+			window.trustedTypes = { createPolicy: (name, rules) => ({
+				name,
+				createHTML: rules?.createHTML || ((s) => s),
+				createScript: rules?.createScript || ((s) => s),
+				createScriptURL: rules?.createScriptURL || ((s) => s)
+			}) };
+			window.fetch = globalThis.fetch;
+			window.Request = globalThis.Request;
+			window.Response = globalThis.Response;
+			window.Headers = globalThis.Headers;
+			const evalFn = window.eval;
+			evalFn(challenge.interpreterScript);
+			this.vm = window[this.globalName];
+			if (!this.vm) return err(createError("BOTGUARD_INIT_FAILED", `VM not found at globalName: ${this.globalName}`));
+			if (typeof this.vm.a !== "function") return err(createError("BOTGUARD_INIT_FAILED", "VM init function (a) not found"));
+			const loadResult = await this.loadProgram();
+			if (!isOk(loadResult)) return loadResult;
+			return ok(void 0);
+		} catch (error) {
+			return err(createError("BOTGUARD_INIT_FAILED", `Failed to load BotGuard: ${error.message}`, error));
+		}
+	}
+	async loadProgram() {
+		return new Promise((resolve) => {
+			const timeoutId = setTimeout(() => {
+				resolve(err(createError("BOTGUARD_INIT_FAILED", "Program load timeout")));
+			}, this.initTimeout);
+			try {
+				const vmFunctionsCallback = (asyncSnapshotFunction, shutdownFunction, passEventFunction, checkCameraFunction) => {
+					this.deferredVmFunctions.resolve({
+						asyncSnapshotFunction,
+						shutdownFunction,
+						passEventFunction,
+						checkCameraFunction
+					});
+				};
+				const initFn = this.vm.a;
+				const result = initFn(this.program, vmFunctionsCallback, true, void 0, () => {}, [[], []]);
+				clearTimeout(timeoutId);
+				if (Array.isArray(result) && result[0]) this.syncSnapshotFunction = result[0];
+				resolve(ok(void 0));
+			} catch (error) {
+				clearTimeout(timeoutId);
+				resolve(err(createError("BOTGUARD_INIT_FAILED", `Program load error: ${error.message}`, error)));
+			}
+		});
+	}
+	async snapshot(binding) {
+		const snapshotArgs = [
+			binding,
+			Date.now(),
+			[],
+			false
+		];
+		try {
+			let result;
+			if (this.syncSnapshotFunction) result = await this.syncSnapshotFunction(snapshotArgs);
+			else {
+				const vmFunctions = await Promise.race([this.deferredVmFunctions.promise, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout waiting for VM functions")), this.snapshotTimeout))]);
+				if (!vmFunctions.asyncSnapshotFunction) return err(createError("BOTGUARD_SNAPSHOT_FAILED", "No snapshot function available"));
+				result = await new Promise((resolve, reject) => {
+					const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("Snapshot timeout")), this.snapshotTimeout);
+					vmFunctions.asyncSnapshotFunction((response) => {
+						clearTimeout(timeout);
+						resolve(response);
+					}, snapshotArgs);
+				});
+			}
+			return ok(result);
+		} catch (error) {
+			return err(createError("BOTGUARD_SNAPSHOT_FAILED", `Snapshot failed: ${error.message}`, error));
+		}
+	}
+	async snapshotWithSignalOutput(binding) {
+		const webPoSignalOutput = [];
+		const snapshotArgs = [
+			binding,
+			Date.now(),
+			webPoSignalOutput,
+			false
+		];
+		try {
+			let snapshot;
+			if (this.syncSnapshotFunction) snapshot = await this.syncSnapshotFunction(snapshotArgs);
+			else {
+				const vmFunctions = await Promise.race([this.deferredVmFunctions.promise, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout waiting for VM functions")), this.snapshotTimeout))]);
+				if (!vmFunctions.asyncSnapshotFunction) return err(createError("BOTGUARD_SNAPSHOT_FAILED", "No snapshot function available"));
+				snapshot = await new Promise((resolve, reject) => {
+					const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("Snapshot timeout")), this.snapshotTimeout);
+					vmFunctions.asyncSnapshotFunction((response) => {
+						clearTimeout(timeout);
+						resolve(response);
+					}, snapshotArgs);
+				});
+			}
+			return ok({
+				snapshot,
+				webPoSignalOutput
+			});
+		} catch (error) {
+			return err(createError("BOTGUARD_SNAPSHOT_FAILED", `Snapshot failed: ${error.message}`, error));
+		}
+	}
+	shutdown() {
+		this.deferredVmFunctions.promise.then((vmFunctions) => {
+			if (vmFunctions.shutdownFunction) try {
+				vmFunctions.shutdownFunction();
+			} catch {}
+		}).catch(() => {});
+		if (this.dom) {
+			this.dom.window.close();
+			this.dom = null;
+		}
+	}
+};
+function generateColdStartToken(identifier, clientState = 1) {
+	const encodedIdentifier = new TextEncoder().encode(identifier);
+	if (encodedIdentifier.length > 118) throw new Error("Content binding is too long");
+	const timestamp = Math.floor(Date.now() / 1e3);
+	const randomKeys = [Math.floor(Math.random() * 256), Math.floor(Math.random() * 256)];
+	const header = new Uint8Array([
+		randomKeys[0],
+		randomKeys[1],
+		0,
+		clientState,
+		timestamp >> 24 & 255,
+		timestamp >> 16 & 255,
+		timestamp >> 8 & 255,
+		timestamp & 255
+	]);
+	const packet = new Uint8Array(2 + header.length + encodedIdentifier.length);
+	packet[0] = 34;
+	packet[1] = header.length + encodedIdentifier.length;
+	packet.set(header, 2);
+	packet.set(encodedIdentifier, 2 + header.length);
+	const payload = packet.subarray(2);
+	const keyLength = randomKeys.length;
+	for (let i = keyLength; i < payload.length; i++) payload[i] ^= payload[i % keyLength];
+	return u8ToBase64Url$1(packet);
+}
+function u8ToBase64Url$1(u8) {
+	return btoa(String.fromCharCode(...u8)).replace(/\+/g, "-").replace(/\//g, "_");
+}
+
+//#endregion
+//#region src/po-token/minter/web-minter.ts
+const WAA_GENERATE_IT_ENDPOINT = "https://jnn-pa.googleapis.com/$rpc/google.internal.waa.v1.Waa/GenerateIT";
+const GOOG_API_KEY = "AIzaSyDyT5W0Jh49F30Pqqtyfdf7pDLFKLJoAnw";
+const REQUEST_KEY = "O43z0dpjhgX20SCx4KAo";
+var WebPoMinter = class WebPoMinter {
+	mintCallback;
+	constructor(mintCallback) {
+		this.mintCallback = mintCallback;
+	}
+	static async create(integrityTokenData, webPoSignalOutput) {
+		const getMinter = webPoSignalOutput[0];
+		if (!getMinter || typeof getMinter !== "function") return err(createError("INTEGRITY_TOKEN_FAILED", "Minter function not found in webPoSignalOutput"));
+		if (!integrityTokenData.integrityToken) return err(createError("INTEGRITY_TOKEN_FAILED", "No integrity token provided"));
+		try {
+			const mintCallback = await getMinter(base64ToU8(integrityTokenData.integrityToken));
+			if (typeof mintCallback !== "function") return err(createError("INTEGRITY_TOKEN_FAILED", "Invalid mint callback returned"));
+			return ok(new WebPoMinter(mintCallback));
+		} catch (error) {
+			return err(createError("INTEGRITY_TOKEN_FAILED", `Failed to create minter: ${error.message}`, error));
+		}
+	}
+	async mint(identifier) {
+		try {
+			const identifierBytes = new TextEncoder().encode(identifier);
+			const result = await this.mintCallback(identifierBytes);
+			if (!result) return err(createError("INTEGRITY_TOKEN_FAILED", "Mint returned undefined"));
+			if (result instanceof Uint8Array) return ok(result);
+			if (ArrayBuffer.isView(result)) return ok(new Uint8Array(result.buffer));
+			if (Array.isArray(result)) return ok(new Uint8Array(result));
+			return err(createError("INTEGRITY_TOKEN_FAILED", `Mint returned invalid type: ${typeof result}`));
+		} catch (error) {
+			return err(createError("INTEGRITY_TOKEN_FAILED", `Mint failed: ${error.message}`, error));
+		}
+	}
+	async mintAsWebsafeString(identifier) {
+		const mintResult = await this.mint(identifier);
+		if (!isOk(mintResult)) return mintResult;
+		return ok(u8ToBase64Url(mintResult.value));
+	}
+};
+async function fetchIntegrityToken(botguardResponse, options = {}) {
+	const timeout = options.timeout ?? 1e4;
+	try {
+		const response = await fetch(WAA_GENERATE_IT_ENDPOINT, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json+protobuf",
+				"x-goog-api-key": GOOG_API_KEY
+			},
+			body: JSON.stringify([REQUEST_KEY, botguardResponse]),
+			signal: AbortSignal.timeout(timeout)
+		});
+		if (!response.ok) return err(createError("INTEGRITY_TOKEN_FAILED", `GenerateIT request failed with status ${response.status}`));
+		const json = await response.json();
+		const integrityToken = json[0];
+		const estimatedTtlSecs = json[1];
+		const mintRefreshThreshold = json[2];
+		const websafeFallbackToken = json[3];
+		if (!integrityToken) return err(createError("INTEGRITY_TOKEN_FAILED", "No integrity token in response"));
+		return ok({
+			integrityToken,
+			estimatedTtlSecs: estimatedTtlSecs ?? 3600,
+			mintRefreshThreshold: mintRefreshThreshold ?? 300,
+			websafeFallbackToken
+		});
+	} catch (error) {
+		if (error instanceof Error && error.name === "TimeoutError") return err(createError("INTEGRITY_TOKEN_FAILED", "GenerateIT request timeout"));
+		return err(createError("INTEGRITY_TOKEN_FAILED", "Failed to fetch integrity token", error));
+	}
+}
+function base64ToU8(base64) {
+	const base64Normalized = base64.replace(/-/g, "+").replace(/_/g, "/").replace(/\./g, "=");
+	const binary = atob(base64Normalized);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+function u8ToBase64Url(u8) {
+	return btoa(String.fromCharCode(...u8)).replace(/\+/g, "-").replace(/\//g, "_");
+}
+
+//#endregion
+//#region src/po-token/providers/local.provider.ts
+const REFRESH_MARGIN_MS = 600 * 1e3;
+var LocalBotGuardProvider = class {
+	name = "local-botguard";
+	priority = 100;
+	options;
+	challengeFetcher;
+	client = null;
+	challenge = null;
+	attestation = null;
+	integrityData = null;
+	minter = null;
+	initPromise = null;
+	createdAt = 0;
+	constructor(options = {}) {
+		this.options = options;
+		this.challengeFetcher = new ChallengeFetcher({ timeout: options.timeout });
+	}
+	async isAvailable() {
+		try {
+			await import("jsdom");
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async generate(identifier, _binding) {
+		const initResult = await this.ensureInitialized();
+		if (!isOk(initResult)) return initResult;
+		if (!this.minter || !this.integrityData) return err(createError("BOTGUARD_INIT_FAILED", "Minter not initialized"));
+		const tokenResult = await this.minter.mintAsWebsafeString(identifier);
+		if (!isOk(tokenResult)) return tokenResult;
+		const now = Date.now();
+		const ttlMs = (this.integrityData.estimatedTtlSecs ?? 43200) * 1e3;
+		return ok({
+			token: tokenResult.value,
+			createdAt: now,
+			expiresAt: now + ttlMs,
+			refreshAt: now + ttlMs - REFRESH_MARGIN_MS,
+			bindingType: "session",
+			bindingValue: identifier,
+			client: "WEB",
+			context: "GVS"
+		});
+	}
+	async ensureInitialized() {
+		if (this.minter && this.integrityData) {
+			const now = Date.now();
+			const refreshThresholdMs = (this.integrityData.mintRefreshThreshold ?? 100) * 1e3;
+			if (now - this.createdAt < refreshThresholdMs * 1e3) return ok(void 0);
+			this.reset();
+		}
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this.initialize();
+		const result = await this.initPromise;
+		this.initPromise = null;
+		return result;
+	}
+	async initialize() {
+		const challengeResult = await this.challengeFetcher.fetchFullChallenge();
+		if (!isOk(challengeResult)) return challengeResult;
+		this.challenge = challengeResult.value;
+		const attResult = await this.challengeFetcher.fetchAttestation();
+		if (!isOk(attResult)) return attResult;
+		this.attestation = attResult.value;
+		const clientResult = await BotGuardClient.create(this.challenge, { timeout: this.options.timeout });
+		if (!isOk(clientResult)) return clientResult;
+		this.client = clientResult.value;
+		const snapshotResult = await this.client.snapshotWithSignalOutput();
+		if (!isOk(snapshotResult)) return snapshotResult;
+		const { snapshot, webPoSignalOutput } = snapshotResult.value;
+		const integrityResult = await fetchIntegrityToken(snapshot, { timeout: this.options.timeout });
+		if (!isOk(integrityResult)) return integrityResult;
+		this.integrityData = integrityResult.value;
+		this.createdAt = Date.now();
+		const minterResult = await WebPoMinter.create(this.integrityData, webPoSignalOutput);
+		if (!isOk(minterResult)) return minterResult;
+		this.minter = minterResult.value;
+		return ok(void 0);
+	}
+	reset() {
+		if (this.client) {
+			this.client.shutdown();
+			this.client = null;
+		}
+		this.challenge = null;
+		this.attestation = null;
+		this.integrityData = null;
+		this.minter = null;
+	}
+	shutdown() {
+		this.reset();
+	}
+	getVisitorData() {
+		return this.attestation?.visitorData;
+	}
+};
+
+//#endregion
+//#region src/po-token/cache/token-cache.ts
+var TokenCache = class {
+	db;
+	constructor(cachePath) {
+		mkdirSync(dirname(cachePath), { recursive: true });
+		this.db = new Database(cachePath);
+		this.initializeSchema();
+	}
+	initializeSchema() {
+		this.db.run(`
+            CREATE TABLE IF NOT EXISTS tokens (
+                id TEXT PRIMARY KEY,
+                token TEXT NOT NULL,
+                integrity_token TEXT,
+                binding_type TEXT NOT NULL,
+                binding_value TEXT NOT NULL,
+                client TEXT NOT NULL,
+                context TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                expires_at INTEGER NOT NULL,
+                refresh_at INTEGER NOT NULL
+            )
+        `);
+		this.db.run(`
+            CREATE INDEX IF NOT EXISTS idx_tokens_lookup
+            ON tokens(binding_value, client, context)
+        `);
+		this.db.run(`
+            CREATE INDEX IF NOT EXISTS idx_tokens_expires
+            ON tokens(expires_at)
+        `);
+		this.db.run(`
+            CREATE INDEX IF NOT EXISTS idx_tokens_refresh
+            ON tokens(refresh_at)
+        `);
+	}
+	get(bindingValue, client, context) {
+		try {
+			const row = this.db.prepare(`
+                SELECT * FROM tokens
+                WHERE binding_value = ? AND client = ? AND context = ?
+                AND expires_at > ?
+                ORDER BY created_at DESC
+                LIMIT 1
+            `).get(bindingValue, client, context, Date.now());
+			if (!row) return ok(null);
+			return ok(this.rowToTokenData(row));
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to read token from cache", error));
+		}
+	}
+	getByClient(client) {
+		try {
+			return ok(this.db.prepare(`
+                SELECT * FROM tokens
+                WHERE client = ? AND expires_at > ?
+                ORDER BY created_at DESC
+            `).all(client, Date.now()).map(this.rowToTokenData));
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to get tokens by client", error));
+		}
+	}
+	getExpiringSoon(marginMs) {
+		try {
+			const refreshThreshold = Date.now() + marginMs;
+			return ok(this.db.prepare(`
+                SELECT * FROM tokens
+                WHERE refresh_at <= ? AND expires_at > ?
+                ORDER BY refresh_at ASC
+            `).all(refreshThreshold, Date.now()).map(this.rowToTokenData));
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to get expiring tokens", error));
+		}
+	}
+	set(data) {
+		try {
+			const id = `${data.bindingValue}:${data.client}:${data.context}`;
+			this.db.prepare(`
+                INSERT OR REPLACE INTO tokens (
+                    id, token, integrity_token, binding_type, binding_value,
+                    client, context, created_at, expires_at, refresh_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(id, data.token, data.integrityToken ?? null, data.bindingType, data.bindingValue, data.client, data.context, data.createdAt, data.expiresAt, data.refreshAt);
+			return ok(void 0);
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to write token to cache", error));
+		}
+	}
+	delete(bindingValue, client, context) {
+		try {
+			const id = `${bindingValue}:${client}:${context}`;
+			this.db.prepare("DELETE FROM tokens WHERE id = ?").run(id);
+			return ok(void 0);
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to delete token", error));
+		}
+	}
+	deleteExpired() {
+		try {
+			return ok(this.db.prepare("DELETE FROM tokens WHERE expires_at <= ?").run(Date.now()).changes);
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to delete expired tokens", error));
+		}
+	}
+	clear() {
+		try {
+			this.db.run("DELETE FROM tokens");
+			return ok(void 0);
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to clear token cache", error));
+		}
+	}
+	getStats() {
+		try {
+			const now = Date.now();
+			const total = this.db.prepare("SELECT COUNT(*) as count FROM tokens").get().count;
+			const valid = this.db.prepare("SELECT COUNT(*) as count FROM tokens WHERE expires_at > ?").get(now).count;
+			return ok({
+				total,
+				valid,
+				expired: total - valid
+			});
+		} catch (error) {
+			return err(createError("CACHE_ERROR", "Failed to get cache stats", error));
+		}
+	}
+	close() {
+		this.db.close();
+	}
+	rowToTokenData(row) {
+		return {
+			token: row.token,
+			integrityToken: row.integrity_token ?? void 0,
+			bindingType: row.binding_type,
+			bindingValue: row.binding_value,
+			client: row.client,
+			context: row.context,
+			createdAt: row.created_at,
+			expiresAt: row.expires_at,
+			refreshAt: row.refresh_at
+		};
+	}
+};
+
+//#endregion
+//#region src/po-token/manager.ts
+var PoTokenManager = class {
+	staticToken;
+	policies;
+	providers;
+	cache = null;
+	constructor(config = {}) {
+		this.staticToken = config.token;
+		this.policies = PO_TOKEN_POLICIES;
+		if (config.providers) this.providers = [...config.providers].sort((a, b) => b.priority - a.priority);
+		else this.providers = [new LocalBotGuardProvider({ timeout: config.timeout })];
+		if (config.cacheEnabled !== false && config.cachePath) this.cache = new TokenCache(config.cachePath);
+	}
+	async getToken(identifier, client = "WEB", binding) {
+		if (this.staticToken) return ok(this.staticToken);
+		if (!this.isRequired(client)) return ok("");
+		const context = binding ? "GVS" : "GVS";
+		if (this.cache) {
+			const cachedResult = this.cache.get(identifier, client, context);
+			if (isOk(cachedResult) && cachedResult.value && cachedResult.value.expiresAt > Date.now()) return ok(cachedResult.value.token);
+		}
+		for (const provider of this.providers) {
+			if (!await provider.isAvailable()) continue;
+			const result = await provider.generate(identifier, binding);
+			if (isOk(result)) {
+				if (this.cache) this.cache.set(result.value);
+				return ok(result.value.token);
+			}
+		}
+		return ok(generateColdStartToken(identifier));
+	}
+	async getTokenData(identifier, client = "WEB", binding) {
+		if (this.staticToken) return ok({
+			token: this.staticToken,
+			createdAt: Date.now(),
+			expiresAt: Date.now() + 36e5,
+			refreshAt: Date.now() + 3e6,
+			bindingType: "session",
+			bindingValue: identifier,
+			client,
+			context: "GVS"
+		});
+		if (!this.isRequired(client)) return err(createError("PO_TOKEN_EXPIRED", `PO Token not required for client ${client}`));
+		const context = binding ? "GVS" : "GVS";
+		if (this.cache) {
+			const cachedResult = this.cache.get(identifier, client, context);
+			if (isOk(cachedResult) && cachedResult.value && cachedResult.value.expiresAt > Date.now()) return ok(cachedResult.value);
+		}
+		for (const provider of this.providers) {
+			if (!await provider.isAvailable()) continue;
+			const result = await provider.generate(identifier, binding);
+			if (isOk(result)) {
+				if (this.cache) this.cache.set(result.value);
+				return result;
+			}
+		}
+		return err(createError("ALL_PROVIDERS_FAILED", "All PO Token providers failed"));
+	}
+	getColdStartToken(identifier) {
+		return generateColdStartToken(identifier);
+	}
+	isRequired(client) {
+		const policy = this.policies[client];
+		if (!policy) return false;
+		if (typeof policy.GVS === "string") return policy.GVS === "required";
+		return policy.GVS.HTTPS === "required" || policy.GVS.DASH === "required";
+	}
+	needsTokenForGvs(client) {
+		const policy = this.policies[client];
+		if (!policy) return false;
+		if (typeof policy.GVS === "string") return policy.GVS !== "not_required";
+		return policy.GVS.HTTPS !== "not_required" || policy.GVS.DASH !== "not_required" || policy.GVS.HLS !== "not_required";
+	}
+	getPolicy(client) {
+		return this.policies[client];
+	}
+	getVisitorData() {
+		for (const provider of this.providers) if (provider instanceof LocalBotGuardProvider) return provider.getVisitorData();
+	}
+	shutdown() {
+		for (const provider of this.providers) provider.shutdown();
+		if (this.cache) this.cache.deleteExpired();
+	}
+	getCacheStats() {
+		if (!this.cache) return null;
+		const result = this.cache.getStats();
+		if (isOk(result)) return result.value;
+		return null;
+	}
+};
+
+//#endregion
+//#region src/utils/logger.ts
+logger.preset("cyberpunk");
+logger.showTimestamp();
+logger.showLocation();
+logger.addSerializer(Error, (err$1) => ({
+	name: err$1.name,
+	message: err$1.message,
+	stack: err$1.stack?.split("\n").slice(0, 5).join("\n")
+}));
+const bundlpLogger = logger.scope("Bundlp");
+const extractorLogger = logger.component("Extractor");
+const cipherLogger = logger.component("Cipher");
+const decoderLogger = logger.component("Decoder");
+const innertubeLogger = logger.api("InnerTube");
+const httpLogger = logger.api("HTTP");
+const playerLogger = logger.scope("Bundlp:Player");
+const streamingLogger = logger.scope("Bundlp:Streaming");
+const poTokenLogger = logger.scope("Bundlp:PoToken");
+const cacheLogger = logger.scope("Bundlp:Cache");
+
+//#endregion
+//#region src/index.ts
+/**
+* Appends po_token to a download URL
+*/
+function appendPoToken(url, poToken) {
+	if (!url || !poToken) return url;
+	return `${url}${url.includes("?") ? "&" : "?"}pot=${encodeURIComponent(poToken)}`;
+}
+
+//#endregion
+export { LocalBotGuardProvider, PoTokenManager, YouTubeExtractor, andThen, appendPoToken, bundlpLogger, err, extractorLogger, getDownloadHeaders, getMinimalDownloadHeaders, isErr, isOk, map, mapErr, match, ok, tryCatch, tryCatchAsync, unwrap, unwrapOr };
+//# sourceMappingURL=index.mjs.map