@jburnhams/tube-ts 0.1.0

package/dist/index.js

@@ -0,0 +1,841 @@
+import shaka2 from 'shaka-player/dist/shaka-player.ui';
+import { Platform, Innertube, UniversalCache, Utils, YT, Constants } from 'youtubei.js/web';
+import { SabrUmpProcessor, SabrStreamingAdapter } from 'googlevideo/sabr-streaming-adapter';
+import { FormatKeyUtils, isGoogleVideoURL, buildSabrFormat } from 'googlevideo/utils';
+import { GOOG_API_KEY, buildURL, BG } from 'bgutils-js';
+import 'shaka-player/dist/controls.css';
+
+// src/TubePlayer.ts
+function asMap(object) {
+  const map = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(object)) {
+    map.set(key, object[key]);
+  }
+  return map;
+}
+function createRecoverableError(message, info) {
+  return new shaka2.util.Error(
+    shaka2.util.Error.Severity.RECOVERABLE,
+    shaka2.util.Error.Category.NETWORK,
+    shaka2.util.Error.Code.HTTP_ERROR,
+    message,
+    { info }
+  );
+}
+function headersToGenericObject(headers) {
+  const headersObj = {};
+  headers.forEach((value, key) => {
+    headersObj[key.trim()] = value;
+  });
+  return headersObj;
+}
+function makeResponse(headers, data, status, uri, responseURL, request, requestType) {
+  if (status >= 200 && status <= 299 && status !== 202) {
+    return {
+      uri: responseURL || uri,
+      originalUri: uri,
+      data,
+      status,
+      headers,
+      originalRequest: request,
+      fromCache: !!headers["x-shaka-from-cache"]
+    };
+  }
+  let responseText = null;
+  try {
+    responseText = shaka2.util.StringUtils.fromBytesAutoDetect(data);
+  } catch {
+  }
+  const severity = status === 401 || status === 403 ? shaka2.util.Error.Severity.CRITICAL : shaka2.util.Error.Severity.RECOVERABLE;
+  throw new shaka2.util.Error(
+    severity,
+    shaka2.util.Error.Category.NETWORK,
+    shaka2.util.Error.Code.BAD_HTTP_STATUS,
+    uri,
+    status,
+    responseText,
+    headers,
+    requestType,
+    responseURL || uri
+  );
+}
+async function fetchFunction(input, init) {
+  const url = input instanceof URL ? input : new URL(typeof input === "string" ? input : input.url);
+  const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+  if (url.pathname.includes("v1/player")) {
+    url.searchParams.set("$fields", "playerConfig,storyboards,captions,playabilityStatus,streamingData,responseContext.mainAppWebResponseContext.datasyncId,videoDetails.isLive,videoDetails.isLiveContent,videoDetails.title,videoDetails.author,videoDetails.thumbnail");
+  }
+  let skipProxy = false;
+  try {
+    if (typeof process !== "undefined" && process.env && process.env.SKIP_PROXY === "true") {
+      skipProxy = true;
+    }
+  } catch (e) {
+  }
+  if (skipProxy) {
+    const requestInit2 = {
+      ...init,
+      headers
+    };
+    if (input instanceof Request && !requestInit2.method) {
+      requestInit2.method = input.method;
+    }
+    return fetch(url.toString(), requestInit2);
+  }
+  const proxyUrl = new URL(url.pathname + url.search, "https://vps.jonathanburnhams.com/");
+  if (url.pathname.includes("/s/player/") || url.pathname.includes("/yts/jsbin/")) {
+    proxyUrl.searchParams.set("__host", "www.youtube.com");
+    const scriptPathIndex = url.pathname.indexOf("/s/player/");
+    if (scriptPathIndex > -1) {
+      proxyUrl.pathname = url.pathname.substring(scriptPathIndex);
+    } else {
+      const jsbinIndex = url.pathname.indexOf("/yts/jsbin/");
+      if (jsbinIndex > -1) {
+        proxyUrl.pathname = url.pathname.substring(jsbinIndex);
+      }
+    }
+  } else {
+    proxyUrl.searchParams.set("__host", url.host);
+  }
+  try {
+    let sessionId = null;
+    if (typeof process !== "undefined" && process.env && process.env.PROXY_SESSION_ID) {
+      sessionId = process.env.PROXY_SESSION_ID;
+    } else if (typeof window !== "undefined" && window.localStorage) {
+      sessionId = window.localStorage.getItem("tube-ts-session-id");
+    }
+    if (sessionId) {
+      proxyUrl.searchParams.set("session", sessionId);
+    }
+  } catch {
+  }
+  const headersObj = {};
+  headers.forEach((value, key) => {
+    headersObj[key] = value;
+  });
+  proxyUrl.searchParams.set("__headers", JSON.stringify(headersObj));
+  const requestInit = {
+    ...init,
+    headers
+  };
+  if (input instanceof Request) {
+    if (!requestInit.method) {
+      requestInit.method = input.method;
+    }
+  }
+  const response = await fetch(proxyUrl, requestInit);
+  const contentType = response.headers.get("content-type");
+  if (contentType && contentType.includes("text/html")) {
+    const text = await response.text();
+    throw new Error(`Proxy returned HTML (likely error page): ${response.status} ${response.statusText} - ${text.substring(0, 100)}`);
+  }
+  return response;
+}
+
+// src/ShakaPlayerAdapter.ts
+var ShakaPlayerAdapter = class {
+  player = null;
+  requestMetadataManager;
+  cacheManager;
+  abortController;
+  requestFilter;
+  responseFilter;
+  initialize(player, requestMetadataManager, cacheManager) {
+    this.player = player;
+    this.requestMetadataManager = requestMetadataManager;
+    this.cacheManager = cacheManager;
+    const networkingEngine = shaka2.net.NetworkingEngine;
+    const schemes = ["http", "https"];
+    if (!shaka2.net.HttpFetchPlugin.isSupported())
+      throw new Error("The Fetch API is not supported in this browser.");
+    schemes.forEach((scheme) => {
+      networkingEngine.registerScheme(
+        scheme,
+        this.parseRequest.bind(this),
+        networkingEngine.PluginPriority.PREFERRED
+      );
+    });
+  }
+  parseRequest(uri, request, requestType, progressUpdated, headersReceived, config) {
+    const headers = new Headers();
+    asMap(request.headers).forEach((value, key) => {
+      headers.append(key, value);
+    });
+    const controller = new AbortController();
+    this.abortController = controller;
+    const init = {
+      body: request.body || void 0,
+      headers,
+      method: request.method,
+      signal: this.abortController.signal,
+      credentials: request.allowCrossSiteCredentials ? "include" : void 0
+    };
+    const abortStatus = { canceled: false, timedOut: false };
+    const minBytes = config.minBytesForProgressEvents || 0;
+    const pendingRequest = this.request(uri, request, requestType, init, controller, abortStatus, progressUpdated, headersReceived, minBytes);
+    const operation = new shaka2.util.AbortableOperation(
+      pendingRequest,
+      () => {
+        abortStatus.canceled = true;
+        controller.abort();
+        return Promise.resolve();
+      }
+    );
+    const timeoutMs = request.retryParameters.timeout;
+    if (timeoutMs) {
+      const timer = new shaka2.util.Timer(() => {
+        abortStatus.timedOut = true;
+        controller.abort();
+        console.warn("[ShakaPlayerAdapter]", "Request aborted due to timeout:", uri, requestType);
+      });
+      timer.tickAfter(timeoutMs / 1e3);
+      operation.finally(() => timer.stop());
+    }
+    return operation;
+  }
+  async handleCachedRequest(requestMetadata, uri, request, progressUpdated, headersReceived, requestType) {
+    if (!requestMetadata.byteRange || !this.cacheManager) {
+      return null;
+    }
+    const segmentKey = FormatKeyUtils.createSegmentCacheKeyFromMetadata(requestMetadata);
+    let arrayBuffer = (requestMetadata.isInit ? this.cacheManager.getInitSegment(segmentKey) : this.cacheManager.getSegment(segmentKey))?.buffer;
+    if (!arrayBuffer) {
+      return null;
+    }
+    if (requestMetadata.isInit) {
+      arrayBuffer = arrayBuffer.slice(
+        requestMetadata.byteRange.start,
+        requestMetadata.byteRange.end + 1
+      );
+    }
+    const headers = {
+      "content-type": requestMetadata.format?.mimeType?.split(";")[0] || "",
+      "content-length": arrayBuffer.byteLength.toString(),
+      "x-shaka-from-cache": "true"
+    };
+    headersReceived(headers);
+    progressUpdated(0, arrayBuffer.byteLength, 0);
+    return makeResponse(headers, arrayBuffer, 200, uri, uri, request, requestType);
+  }
+  async handleUmpResponse(response, requestMetadata, uri, request, requestType, progressUpdated, abortController, minBytes) {
+    let lastTime = Date.now();
+    const sabrUmpReader = new SabrUmpProcessor(requestMetadata, this.cacheManager);
+    const checkResultIntegrity = (result) => {
+      if (!result.data && ((!!requestMetadata.error || requestMetadata.streamInfo?.streamProtectionStatus?.status === 3) && !requestMetadata.streamInfo?.sabrContextUpdate)) {
+        throw createRecoverableError("Server streaming error", requestMetadata);
+      }
+    };
+    const shouldReturnEmptyResponse = () => {
+      return requestMetadata.isSABR && (requestMetadata.streamInfo?.redirect || requestMetadata.streamInfo?.sabrContextUpdate);
+    };
+    if (!response.body) {
+      const arrayBuffer = await response.arrayBuffer();
+      const currentTime = Date.now();
+      progressUpdated(currentTime - lastTime, arrayBuffer.byteLength, 0);
+      const result = await sabrUmpReader.processChunk(new Uint8Array(arrayBuffer));
+      if (result) {
+        checkResultIntegrity(result);
+        return this.createShakaResponse({ uri, request, requestType, response, arrayBuffer: result.data });
+      }
+      if (shouldReturnEmptyResponse()) {
+        return this.createShakaResponse({ uri, request, requestType, response, arrayBuffer: void 0 });
+      }
+      throw createRecoverableError("Empty response with no redirect information", requestMetadata);
+    } else {
+      const reader = response.body.getReader();
+      let loaded = 0;
+      let lastLoaded = 0;
+      let contentLength;
+      while (!abortController.signal.aborted) {
+        let readObj;
+        try {
+          readObj = await reader.read();
+        } catch {
+          break;
+        }
+        const { value, done } = readObj;
+        if (done) {
+          if (shouldReturnEmptyResponse()) {
+            return this.createShakaResponse({ uri, request, requestType, response, arrayBuffer: void 0 });
+          }
+          throw createRecoverableError("Empty response with no redirect information", requestMetadata);
+        }
+        const result = await sabrUmpReader.processChunk(value);
+        const segmentInfo = sabrUmpReader.getSegmentInfo();
+        if (segmentInfo) {
+          if (!contentLength) {
+            contentLength = segmentInfo.mediaHeader.contentLength?.toString();
+          }
+          loaded += segmentInfo.lastChunkSize || 0;
+          segmentInfo.lastChunkSize = 0;
+        }
+        const currentTime = Date.now();
+        const chunkSize = loaded - lastLoaded;
+        if (currentTime - lastTime > 100 && chunkSize >= minBytes || result) {
+          if (result) checkResultIntegrity(result);
+          if (contentLength) {
+            const numBytesRemaining = result ? 0 : parseInt(contentLength) - loaded;
+            try {
+              progressUpdated(currentTime - lastTime, chunkSize, numBytesRemaining);
+            } catch {
+            } finally {
+              lastLoaded = loaded;
+              lastTime = currentTime;
+            }
+          }
+        }
+        if (result) {
+          abortController.abort();
+          return this.createShakaResponse({ uri, request, requestType, response, arrayBuffer: result.data });
+        }
+      }
+      throw createRecoverableError("UMP stream processing was aborted but did not produce a result.", requestMetadata);
+    }
+  }
+  async request(uri, request, requestType, init, abortController, abortStatus, progressUpdated, headersReceived, minBytes) {
+    try {
+      const requestMetadata = this.requestMetadataManager?.getRequestMetadata(uri);
+      if (requestMetadata) {
+        const cachedResponse = await this.handleCachedRequest(requestMetadata, uri, request, progressUpdated, headersReceived, requestType);
+        if (cachedResponse) {
+          return cachedResponse;
+        }
+      }
+      const fetchFn = fetchFunction;
+      const response = await fetchFn(uri, init);
+      headersReceived(headersToGenericObject(response.headers));
+      if (requestMetadata && init.method !== "HEAD" && response.headers.get("content-type") === "application/vnd.yt-ump") {
+        return this.handleUmpResponse(response, requestMetadata, uri, request, requestType, progressUpdated, abortController, minBytes);
+      }
+      const lastTime = Date.now();
+      const arrayBuffer = await response.arrayBuffer();
+      const currentTime = Date.now();
+      progressUpdated(currentTime - lastTime, arrayBuffer.byteLength, 0);
+      return this.createShakaResponse({
+        uri,
+        request,
+        requestType,
+        response,
+        arrayBuffer
+      });
+    } catch (error) {
+      if (abortStatus.canceled) {
+        throw new shaka2.util.Error(
+          shaka2.util.Error.Severity.RECOVERABLE,
+          shaka2.util.Error.Category.NETWORK,
+          shaka2.util.Error.Code.OPERATION_ABORTED,
+          uri,
+          requestType
+        );
+      } else if (abortStatus.timedOut) {
+        throw new shaka2.util.Error(
+          shaka2.util.Error.Severity.RECOVERABLE,
+          shaka2.util.Error.Category.NETWORK,
+          shaka2.util.Error.Code.TIMEOUT,
+          uri,
+          requestType
+        );
+      }
+      throw new shaka2.util.Error(
+        shaka2.util.Error.Severity.RECOVERABLE,
+        shaka2.util.Error.Category.NETWORK,
+        shaka2.util.Error.Code.HTTP_ERROR,
+        uri,
+        error,
+        requestType
+      );
+    }
+  }
+  checkPlayerStatus() {
+    if (!this.player) {
+      throw new Error("Player not initialized");
+    }
+  }
+  getPlayerTime() {
+    this.checkPlayerStatus();
+    return this.player.getMediaElement()?.currentTime || 0;
+  }
+  getPlaybackRate() {
+    this.checkPlayerStatus();
+    return this.player.getPlaybackRate();
+  }
+  getBandwidthEstimate() {
+    this.checkPlayerStatus();
+    return this.player.getStats().estimatedBandwidth;
+  }
+  getActiveTrackFormats(activeFormat, sabrFormats) {
+    this.checkPlayerStatus();
+    const activeVariant = this.player.getVariantTracks().find(
+      (track) => FormatKeyUtils.getUniqueFormatId(activeFormat) === (activeFormat.width ? track.originalVideoId : track.originalAudioId)
+    );
+    if (!activeVariant) {
+      return { videoFormat: void 0, audioFormat: void 0 };
+    }
+    const formatMap = new Map(sabrFormats.map((format) => [FormatKeyUtils.getUniqueFormatId(format), format]));
+    return {
+      videoFormat: activeVariant.originalVideoId ? formatMap.get(activeVariant.originalVideoId) : void 0,
+      audioFormat: activeVariant.originalAudioId ? formatMap.get(activeVariant.originalAudioId) : void 0
+    };
+  }
+  registerRequestInterceptor(interceptor) {
+    this.checkPlayerStatus();
+    const networkingEngine = this.player.getNetworkingEngine();
+    if (!networkingEngine)
+      return;
+    this.requestFilter = async (type, request, context) => {
+      if (type !== shaka2.net.NetworkingEngine.RequestType.SEGMENT || !isGoogleVideoURL(request.uris[0])) return;
+      const modifiedRequest = await interceptor({
+        headers: request.headers,
+        url: request.uris[0],
+        method: request.method,
+        segment: {
+          getStartTime: () => context?.segment?.getStartTime() ?? null,
+          isInit: () => !context?.segment
+        },
+        body: request.body
+      });
+      if (modifiedRequest) {
+        request.uris = modifiedRequest.url ? [modifiedRequest.url] : request.uris;
+        request.method = modifiedRequest.method || request.method;
+        request.headers = modifiedRequest.headers || request.headers;
+        request.body = modifiedRequest.body || request.body;
+      }
+    };
+    networkingEngine.registerRequestFilter(this.requestFilter);
+  }
+  registerResponseInterceptor(interceptor) {
+    this.checkPlayerStatus();
+    const networkingEngine = this.player.getNetworkingEngine();
+    if (!networkingEngine) return;
+    this.responseFilter = async (type, response, context) => {
+      if (type !== shaka2.net.NetworkingEngine.RequestType.SEGMENT || !isGoogleVideoURL(response.uri)) return;
+      const modifiedResponse = await interceptor({
+        url: response.originalRequest.uris[0],
+        method: response.originalRequest.method,
+        headers: response.headers,
+        data: response.data,
+        makeRequest: async (url, headers) => {
+          const retryParameters = this.player.getConfiguration().streaming.retryParameters;
+          const redirectRequest = shaka2.net.NetworkingEngine.makeRequest([url], retryParameters);
+          Object.assign(redirectRequest.headers, headers);
+          const requestOperation = networkingEngine.request(type, redirectRequest, context);
+          const redirectResponse = await requestOperation.promise;
+          return {
+            url: redirectResponse.uri,
+            method: redirectResponse.originalRequest.method,
+            headers: redirectResponse.headers,
+            data: redirectResponse.data
+          };
+        }
+      });
+      if (modifiedResponse) {
+        response.data = modifiedResponse.data ?? response.data;
+        Object.assign(response.headers, modifiedResponse.headers);
+      }
+    };
+    networkingEngine.registerResponseFilter(this.responseFilter);
+  }
+  createShakaResponse(args) {
+    return makeResponse(
+      headersToGenericObject(args.response.headers),
+      args.arrayBuffer || new ArrayBuffer(0),
+      args.response.status,
+      args.uri,
+      args.response.url,
+      args.request,
+      args.requestType
+    );
+  }
+  dispose() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = void 0;
+    }
+    if (this.player) {
+      const networkingEngine = this.player.getNetworkingEngine();
+      if (networkingEngine && this.requestFilter && this.responseFilter) {
+        networkingEngine.unregisterRequestFilter(this.requestFilter);
+        networkingEngine.unregisterResponseFilter(this.responseFilter);
+      }
+      shaka2.net.NetworkingEngine.unregisterScheme("http");
+      shaka2.net.NetworkingEngine.unregisterScheme("https");
+      this.player = null;
+    }
+  }
+};
+var BotguardService = class {
+  waaRequestKey = "O43z0dpjhgX20SCx4KAo";
+  botguardClient;
+  initializationPromise = null;
+  integrityTokenBasedMinter;
+  bgChallenge;
+  async init() {
+    if (this.initializationPromise) {
+      return await this.initializationPromise;
+    }
+    return this.setup();
+  }
+  async setup() {
+    if (this.initializationPromise)
+      return await this.initializationPromise;
+    this.initializationPromise = this._initBotguard();
+    try {
+      this.botguardClient = await this.initializationPromise;
+      return this.botguardClient;
+    } finally {
+      this.initializationPromise = null;
+    }
+  }
+  async _initBotguard() {
+    const challengeResponse = await fetchFunction(buildURL("Create", true), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json+protobuf",
+        "x-goog-api-key": GOOG_API_KEY,
+        "x-user-agent": "grpc-web-javascript/0.1"
+      },
+      body: JSON.stringify([this.waaRequestKey])
+    });
+    const challengeResponseData = await challengeResponse.json();
+    this.bgChallenge = BG.Challenge.parseChallengeData(challengeResponseData);
+    if (!this.bgChallenge)
+      return;
+    const interpreterJavascript = this.bgChallenge.interpreterJavascript.privateDoNotAccessOrElseSafeScriptWrappedValue;
+    if (!interpreterJavascript) {
+      console.error("[BotguardService]", "Could not get interpreter javascript. Interpreter Hash:", this.bgChallenge.interpreterHash);
+      return;
+    }
+    if (!document.getElementById(this.bgChallenge.interpreterHash)) {
+      const script = document.createElement("script");
+      script.type = "text/javascript";
+      script.id = this.bgChallenge.interpreterHash;
+      script.textContent = interpreterJavascript;
+      document.head.appendChild(script);
+    }
+    this.botguardClient = await BG.BotGuardClient.create({
+      globalObj: globalThis,
+      globalName: this.bgChallenge.globalName,
+      program: this.bgChallenge.program
+    });
+    if (this.bgChallenge) {
+      const webPoSignalOutput = [];
+      const botguardResponse = await this.botguardClient.snapshot({ webPoSignalOutput });
+      const integrityTokenResponse = await fetchFunction(buildURL("GenerateIT", true), {
+        method: "POST",
+        headers: {
+          "content-type": "application/json+protobuf",
+          "x-goog-api-key": GOOG_API_KEY,
+          "x-user-agent": "grpc-web-javacript/0.1"
+        },
+        body: JSON.stringify([this.waaRequestKey, botguardResponse])
+      });
+      const integrityTokenResponseData = await integrityTokenResponse.json();
+      const integrityToken = integrityTokenResponseData[0];
+      if (!integrityToken) {
+        console.error("[BotguardService]", "Could not get integrity token. Interpreter Hash:", this.bgChallenge.interpreterHash);
+        return;
+      }
+      this.integrityTokenBasedMinter = await BG.WebPoMinter.create({ integrityToken }, webPoSignalOutput);
+    }
+    return this.botguardClient;
+  }
+  mintColdStartToken(contentBinding) {
+    return BG.PoToken.generateColdStartToken(contentBinding);
+  }
+  isInitialized() {
+    return !!this.botguardClient && !!this.integrityTokenBasedMinter;
+  }
+  dispose() {
+    if (this.botguardClient && this.bgChallenge) {
+      this.botguardClient.shutdown();
+      this.botguardClient = void 0;
+      this.integrityTokenBasedMinter = void 0;
+      const script = document.getElementById(this.bgChallenge.interpreterHash);
+      if (script) {
+        script.remove();
+      }
+    }
+  }
+  async reinit() {
+    if (this.initializationPromise)
+      return this.initializationPromise;
+    this.dispose();
+    return this.setup();
+  }
+};
+var botguardService = new BotguardService();
+Platform.shim.eval = async (data, env) => {
+  const properties = [];
+  if (data.output && data.output.length < 1e3) {
+    console.log("[TubePlayer] Short code received:", data.output);
+  } else {
+    console.log(`[TubePlayer] Code received, length: ${data.output?.length}`);
+  }
+  if (env.n) {
+    if (data.exported?.includes("nFunction")) {
+      properties.push(`n: exportedVars.nFunction(${JSON.stringify(String(env.n))})`);
+    } else {
+      console.warn("[TubePlayer] nFunction not exported. Available exports:", data.exported);
+      throw new Error(`[TubePlayer] nFunction not exported. Available: ${data.exported?.join(", ")}`);
+    }
+  }
+  if (env.sig) {
+    if (data.exported?.includes("sigFunction")) {
+      properties.push(`sig: exportedVars.sigFunction(${JSON.stringify(String(env.sig))})`);
+    } else {
+      console.warn("[TubePlayer] sigFunction not exported, skipping sig transformation");
+    }
+  }
+  const code = `${data.output}
+return { ${properties.join(", ")} }`;
+  try {
+    return new Function(code)();
+  } catch (e) {
+    console.error("[TubePlayer] Shim evaluation failed:", e);
+    console.error("[TubePlayer] Code preview:", code.substring(0, 200));
+    throw e;
+  }
+};
+var TubePlayer = class {
+  player;
+  ui;
+  sabrAdapter;
+  innertube;
+  playbackWebPoTokenContentBinding;
+  playbackWebPoTokenCreationLock = false;
+  playbackWebPoToken;
+  coldStartToken;
+  container;
+  videoElement;
+  constructor(containerId) {
+    const container = document.getElementById(containerId);
+    if (!container) throw new Error(`Container element with ID ${containerId} not found.`);
+    this.container = container;
+    this.videoElement = document.createElement("video");
+    this.videoElement.style.width = "100%";
+    this.videoElement.style.height = "100%";
+    this.videoElement.controls = false;
+    this.container.appendChild(this.videoElement);
+    shaka2.polyfill.installAll();
+    if (!shaka2.Player.isBrowserSupported()) {
+      console.warn("Shaka Player is not supported on this browser.");
+    }
+    this.player = new shaka2.Player();
+    this.ui = new shaka2.ui.Overlay(this.player, this.container, this.videoElement);
+  }
+  // Store initialization options for retry logic
+  initOptions;
+  async initialize(options) {
+    this.initOptions = options;
+    let retryCount = 0;
+    const maxRetries = 3;
+    const useProxy = options?.useProxy ?? true;
+    const enableCache = options?.cache ?? true;
+    while (retryCount < maxRetries) {
+      try {
+        const fetchWrapper = async (input, init) => {
+          let urlStr = typeof input === "string" ? input : input instanceof Request ? input.url : input.toString();
+          const urlObj = new URL(urlStr);
+          if (urlStr.includes("player") || urlStr.includes("base.js")) {
+            urlObj.searchParams.set("t", String(Date.now()));
+            console.log("[TubePlayer] Fetching player script from:", urlObj.toString());
+            let modifiedInit = init;
+            if (input instanceof Request) {
+              modifiedInit = {
+                method: input.method,
+                ...init
+              };
+            }
+            if (!useProxy) return fetch(urlObj.toString(), modifiedInit);
+            return fetchFunction(urlObj.toString(), modifiedInit);
+          }
+          if (!useProxy) {
+            return fetch(input, init);
+          }
+          return fetchFunction(input, init);
+        };
+        this.innertube = await Innertube.create({
+          // Create cache: persistent if enabled AND first try. 
+          // If we are retrying internally here (retryCount > 0), we disable it.
+          // If enableCache is passed as false (from loadVideo retry), we disable it.
+          cache: new UniversalCache(enableCache && retryCount === 0),
+          fetch: fetchWrapper
+        });
+        break;
+      } catch (error) {
+        console.error("Innertube init failed", error);
+        retryCount++;
+        if (retryCount >= maxRetries) throw error;
+        console.log(`Retrying Innertube init (attempt ${retryCount + 1})...`);
+      }
+    }
+    await botguardService.init();
+    this.player.configure({
+      abr: { enabled: true },
+      streaming: {
+        bufferingGoal: 120,
+        rebufferingGoal: 2
+      }
+    });
+    await this.player.attach(this.videoElement);
+    this.ui.configure({
+      addBigPlayButton: false,
+      overflowMenuButtons: [
+        "captions",
+        "quality",
+        "language",
+        "chapter",
+        "picture_in_picture",
+        "playback_rate",
+        "loop",
+        "recenter_vr",
+        "toggle_stereoscopic",
+        "save_video_frame"
+      ],
+      customContextMenu: true
+    });
+  }
+  async loadVideo(videoId) {
+    if (!this.innertube) {
+      throw new Error("TubePlayer not initialized. Call initialize() first.");
+    }
+    if (!videoId) {
+      throw new Error("Please enter a video ID.");
+    }
+    this.playbackWebPoToken = void 0;
+    this.playbackWebPoTokenContentBinding = videoId;
+    try {
+      await this.player.unload();
+      if (this.sabrAdapter) {
+        this.sabrAdapter.dispose();
+      }
+      const playerResponse = await this.innertube.actions.execute("/player", {
+        videoId,
+        contentCheckOk: true,
+        racyCheckOk: true,
+        playbackContext: {
+          adPlaybackContext: {
+            pyv: true
+          },
+          contentPlaybackContext: {
+            signatureTimestamp: this.innertube.session.player?.signature_timestamp
+          }
+        }
+      });
+      const cpn = Utils.generateRandomString(16);
+      const videoInfo = new YT.VideoInfo([playerResponse], this.innertube.actions, cpn);
+      if (videoInfo.playability_status?.status !== "OK") {
+        throw new Error(`Cannot play video: ${videoInfo.playability_status?.reason}`);
+      }
+      const isLive = videoInfo.basic_info.is_live;
+      const isPostLiveDVR = !!videoInfo.basic_info.is_post_live_dvr || videoInfo.basic_info.is_live_content && !!(videoInfo.streaming_data?.dash_manifest_url || videoInfo.streaming_data?.hls_manifest_url);
+      this.sabrAdapter = new SabrStreamingAdapter({
+        playerAdapter: new ShakaPlayerAdapter(),
+        clientInfo: {
+          osName: this.innertube.session.context.client.osName,
+          osVersion: this.innertube.session.context.client.osVersion,
+          clientName: parseInt(Constants.CLIENT_NAME_IDS[this.innertube.session.context.client.clientName]),
+          clientVersion: this.innertube.session.context.client.clientVersion
+        }
+      });
+      this.sabrAdapter.onMintPoToken(async () => {
+        if (!this.playbackWebPoToken) {
+          if (isLive) {
+            await this.mintContentWebPO();
+          } else {
+            this.mintContentWebPO().then();
+          }
+        }
+        return this.playbackWebPoToken || this.coldStartToken || "";
+      });
+      this.sabrAdapter.onReloadPlayerResponse(async (reloadContext) => {
+        const reloadedInfo = await this.innertube.actions.execute("/player", {
+          videoId,
+          contentCheckOk: true,
+          racyCheckOk: true,
+          playbackContext: {
+            adPlaybackContext: {
+              pyv: true
+            },
+            contentPlaybackContext: {
+              signatureTimestamp: this.innertube.session.player?.signature_timestamp
+            },
+            reloadPlaybackContext: reloadContext
+          }
+        });
+        const parsedInfo = new YT.VideoInfo([reloadedInfo], this.innertube.actions, cpn);
+        this.sabrAdapter.setStreamingURL(await this.innertube.session.player.decipher(parsedInfo.streaming_data?.server_abr_streaming_url));
+        this.sabrAdapter.setUstreamerConfig(videoInfo.player_config?.media_common_config.media_ustreamer_request_config?.video_playback_ustreamer_config);
+      });
+      this.sabrAdapter.attach(this.player);
+      if (videoInfo.streaming_data && !isPostLiveDVR && !isLive) {
+        this.sabrAdapter.setStreamingURL(await this.innertube.session.player.decipher(videoInfo.streaming_data?.server_abr_streaming_url));
+        this.sabrAdapter.setUstreamerConfig(videoInfo.player_config?.media_common_config.media_ustreamer_request_config?.video_playback_ustreamer_config);
+        this.sabrAdapter.setServerAbrFormats(videoInfo.streaming_data.adaptive_formats.map(buildSabrFormat));
+      }
+      let manifestUri;
+      if (videoInfo.streaming_data) {
+        if (isLive) {
+          manifestUri = videoInfo.streaming_data.dash_manifest_url ? `${videoInfo.streaming_data.dash_manifest_url}/mpd_version/7` : videoInfo.streaming_data.hls_manifest_url;
+        } else if (isPostLiveDVR) {
+          manifestUri = videoInfo.streaming_data.hls_manifest_url || `${videoInfo.streaming_data.dash_manifest_url}/mpd_version/7`;
+        } else {
+          manifestUri = `data:application/dash+xml;base64,${btoa(await videoInfo.toDash({
+            manifest_options: {
+              is_sabr: true,
+              captions_format: "vtt",
+              include_thumbnails: false
+            }
+          }))}`;
+        }
+      }
+      if (!manifestUri)
+        throw new Error("Could not find a valid manifest URI.");
+      await this.player.load(manifestUri);
+      return videoInfo.basic_info;
+    } catch (e) {
+      console.error("[TubePlayer]", "Error loading video:", e);
+      if (!this.isRetrying && this.initOptions) {
+        console.warn("[TubePlayer] Load failed. Retrying with cache disabled to fetch fresh player script...");
+        this.isRetrying = true;
+        try {
+          await this.initialize({ ...this.initOptions, cache: false });
+          return this.loadVideo(videoId);
+        } catch (retryError) {
+          console.error("[TubePlayer] Retry failed:", retryError);
+        } finally {
+          this.isRetrying = false;
+        }
+      }
+      throw e;
+    }
+  }
+  // Track retry state to prevent infinite loops
+  isRetrying = false;
+  async mintContentWebPO() {
+    if (!this.playbackWebPoTokenContentBinding || this.playbackWebPoTokenCreationLock) return;
+    this.playbackWebPoTokenCreationLock = true;
+    try {
+      this.coldStartToken = botguardService.mintColdStartToken(this.playbackWebPoTokenContentBinding);
+      if (!botguardService.isInitialized()) await botguardService.reinit();
+      if (botguardService.integrityTokenBasedMinter) {
+        this.playbackWebPoToken = await botguardService.integrityTokenBasedMinter.mintAsWebsafeString(decodeURIComponent(this.playbackWebPoTokenContentBinding));
+      }
+    } catch (err) {
+      console.error("[TubePlayer]", "Error minting WebPO token", err);
+    } finally {
+      this.playbackWebPoTokenCreationLock = false;
+    }
+  }
+  destroy() {
+    this.player.destroy();
+    this.sabrAdapter?.dispose();
+    botguardService.dispose();
+    this.ui.destroy();
+    this.videoElement.remove();
+  }
+};
+
+export { ShakaPlayerAdapter, TubePlayer, asMap, botguardService, createRecoverableError, fetchFunction, headersToGenericObject, makeResponse };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map