stormcloud-video-player 0.2.11 → 0.2.13

package/lib/ui/StormcloudVideoPlayer.cjs

@@ -36,7 +36,166 @@ module.exports = __toCommonJS(StormcloudVideoPlayer_exports);
 var import_react = __toESM(require("react"), 1);
 
 // src/player/StormcloudVideoPlayer.ts
-var import_hls = __toESM(require("hls.js"), 1);
+var import_hls2 = __toESM(require("hls.js"), 1);
+
+// src/utils/browserCompat.ts
+function getChromeVersion(ua) {
+  const match = ua.match(/Chrome\/(\d+)/);
+  return match && match[1] ? parseInt(match[1], 10) : 0;
+}
+function getWebKitVersion(ua) {
+  const match = ua.match(/AppleWebKit\/(\d+)/);
+  return match && match[1] ? parseInt(match[1], 10) : 0;
+}
+function getPlatform() {
+  if ("userAgentData" in navigator && navigator.userAgentData?.platform) {
+    return navigator.userAgentData.platform;
+  }
+  const ua = navigator.userAgent;
+  if (/Mac|iPhone|iPad|iPod/i.test(ua)) {
+    return /iPhone|iPad|iPod/i.test(ua) ? "iPhone" : "MacIntel";
+  }
+  if (/Win/i.test(ua)) {
+    return "Win32";
+  }
+  if (/Linux/i.test(ua)) {
+    return /Android/i.test(ua) ? "Linux armv8l" : "Linux x86_64";
+  }
+  if (/CrOS/i.test(ua)) {
+    return "CrOS";
+  }
+  return navigator.platform || "Unknown";
+}
+function detectBrowser() {
+  const ua = navigator.userAgent;
+  const platform = getPlatform();
+  let name = "Unknown";
+  let version = "0";
+  let majorVersion = 0;
+  let isSmartTV = false;
+  let isLegacyTV = false;
+  let supportsIMA = true;
+  let supportsModernJS = true;
+  let recommendedAdPlayer = "ima";
+  if (/Web0S|webOS/i.test(ua)) {
+    name = "LG WebOS";
+    isSmartTV = true;
+    const match = ua.match(/Web0S[/\s]*([\d.]+)/i);
+    version = match && match[1] ? match[1] : "Unknown";
+    if (version !== "Unknown") {
+      const parts = version.split(".");
+      majorVersion = parts[0] ? parseInt(parts[0], 10) : 0;
+    }
+  } else if (/Tizen/i.test(ua)) {
+    name = "Samsung Tizen";
+    isSmartTV = true;
+    const match = ua.match(/Tizen[/\s]*([\d.]+)/i);
+    version = match && match[1] ? match[1] : "Unknown";
+    if (version !== "Unknown") {
+      const parts = version.split(".");
+      majorVersion = parts[0] ? parseInt(parts[0], 10) : 0;
+    }
+  } else if (/SMART-TV|SmartTV/i.test(ua)) {
+    name = "Smart TV";
+    isSmartTV = true;
+  } else if (/NetCast/i.test(ua)) {
+    name = "LG NetCast";
+    isSmartTV = true;
+    isLegacyTV = true;
+  } else if (/BRAVIA/i.test(ua)) {
+    name = "Sony BRAVIA";
+    isSmartTV = true;
+  }
+  const chromeVersion = getChromeVersion(ua);
+  const webkitVersion = getWebKitVersion(ua);
+  if (chromeVersion > 0) {
+    if (!isSmartTV) {
+      name = "Chrome";
+      version = chromeVersion.toString();
+      majorVersion = chromeVersion;
+    }
+    if (chromeVersion < 50) {
+      supportsIMA = false;
+      supportsModernJS = false;
+      isLegacyTV = true;
+      recommendedAdPlayer = "hls";
+    }
+  }
+  if (webkitVersion > 0 && webkitVersion < 600) {
+    supportsModernJS = false;
+    if (isSmartTV) {
+      isLegacyTV = true;
+      supportsIMA = false;
+      recommendedAdPlayer = "hls";
+    }
+  }
+  if (typeof Promise === "undefined" || typeof Map === "undefined" || typeof Set === "undefined") {
+    supportsModernJS = false;
+    supportsIMA = false;
+    recommendedAdPlayer = "hls";
+  }
+  if (typeof URLSearchParams === "undefined") {
+    supportsModernJS = false;
+  }
+  return {
+    name,
+    version,
+    majorVersion,
+    isSmartTV,
+    isLegacyTV,
+    platform,
+    supportsIMA,
+    supportsModernJS,
+    recommendedAdPlayer
+  };
+}
+function supportsGoogleIMA() {
+  const browser = detectBrowser();
+  if (browser.isLegacyTV) {
+    return false;
+  }
+  if (typeof document === "undefined" || typeof document.createElement !== "function") {
+    return false;
+  }
+  try {
+    const video = document.createElement("video");
+    if (!video) {
+      return false;
+    }
+  } catch (e) {
+    return false;
+  }
+  if (typeof Promise === "undefined") {
+    return false;
+  }
+  return browser.supportsIMA;
+}
+function logBrowserInfo(debug = false) {
+  if (!debug) return;
+  const browser = detectBrowser();
+  const imaSupport = supportsGoogleIMA();
+  console.log("[StormcloudVideoPlayer] Browser Compatibility Info:", {
+    browser: `${browser.name} ${browser.version}`,
+    platform: browser.platform,
+    isSmartTV: browser.isSmartTV,
+    isLegacyTV: browser.isLegacyTV,
+    supportsIMA: imaSupport,
+    supportsModernJS: browser.supportsModernJS,
+    recommendedAdPlayer: browser.recommendedAdPlayer,
+    userAgent: navigator.userAgent
+  });
+}
+function getBrowserConfigOverrides() {
+  const browser = detectBrowser();
+  const overrides = {};
+  if (browser.isLegacyTV || !browser.supportsIMA) {
+    overrides.adPlayerType = "hls";
+  }
+  if (browser.isSmartTV) {
+    overrides.allowNativeHls = true;
+  }
+  return overrides;
+}
 
 // src/sdk/ima.ts
 function createImaController(video, options) {
@@ -54,6 +213,14 @@ function createImaController(video, options) {
     }
   }
   function ensureImaLoaded() {
+    if (!supportsGoogleIMA()) {
+      console.warn(
+        "[IMA] Google IMA SDK is not supported on this browser. Please use HLS ad player instead."
+      );
+      return Promise.reject(
+        new Error("Google IMA SDK not supported on this browser")
+      );
+    }
     try {
       const frameEl = window.frameElement;
       const sandboxAttr = frameEl?.getAttribute?.("sandbox") || "";
@@ -549,6 +716,456 @@ function createImaController(video, options) {
   };
 }
 
+// src/sdk/hlsAdPlayer.ts
+var import_hls = __toESM(require("hls.js"), 1);
+function createHlsAdPlayer(contentVideo, options) {
+  let adPlaying = false;
+  let originalMutedState = false;
+  const listeners = /* @__PURE__ */ new Map();
+  const licenseKey = options?.licenseKey;
+  let adVideoElement;
+  let adHls;
+  let adContainerEl;
+  let currentAd;
+  let sessionId;
+  let trackingFired = {
+    impression: false,
+    start: false,
+    firstQuartile: false,
+    midpoint: false,
+    thirdQuartile: false,
+    complete: false
+  };
+  function emit(event, payload) {
+    const set = listeners.get(event);
+    if (!set) return;
+    for (const fn of Array.from(set)) {
+      try {
+        fn(payload);
+      } catch (error) {
+        console.warn(`[HlsAdPlayer] Error in event listener for ${event}:`, error);
+      }
+    }
+  }
+  function generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  function fireTrackingPixels(urls) {
+    if (!urls || urls.length === 0) return;
+    urls.forEach((url) => {
+      try {
+        let trackingUrl = url;
+        if (sessionId) {
+          trackingUrl = `${trackingUrl}${trackingUrl.includes("?") ? "&" : "?"}session_id=${sessionId}`;
+        }
+        if (licenseKey) {
+          trackingUrl = `${trackingUrl}${trackingUrl.includes("?") ? "&" : "?"}license_key=${licenseKey}`;
+        }
+        const img = new Image(1, 1);
+        img.src = trackingUrl;
+        console.log(`[HlsAdPlayer] Fired tracking pixel: ${trackingUrl}`);
+      } catch (error) {
+        console.warn(`[HlsAdPlayer] Error firing tracking pixel:`, error);
+      }
+    });
+  }
+  function parseVastXml(xmlString) {
+    try {
+      const parser = new DOMParser();
+      const xmlDoc = parser.parseFromString(xmlString, "text/xml");
+      const parserError = xmlDoc.querySelector("parsererror");
+      if (parserError) {
+        console.error("[HlsAdPlayer] XML parsing error:", parserError.textContent);
+        return null;
+      }
+      const adElement = xmlDoc.querySelector("Ad");
+      if (!adElement) {
+        console.warn("[HlsAdPlayer] No Ad element found in VAST XML");
+        return null;
+      }
+      const adId = adElement.getAttribute("id") || "unknown";
+      const title = xmlDoc.querySelector("AdTitle")?.textContent || "Ad";
+      const durationText = xmlDoc.querySelector("Duration")?.textContent || "00:00:30";
+      const durationParts = durationText.split(":");
+      const duration = parseInt(durationParts[0] || "0", 10) * 3600 + parseInt(durationParts[1] || "0", 10) * 60 + parseInt(durationParts[2] || "0", 10);
+      const mediaFileElements = xmlDoc.querySelectorAll("MediaFile");
+      const mediaFiles = [];
+      mediaFileElements.forEach((mf) => {
+        const type = mf.getAttribute("type") || "";
+        if (type === "application/x-mpegURL" || type.includes("m3u8")) {
+          const bitrateAttr = mf.getAttribute("bitrate");
+          const bitrateValue = bitrateAttr ? parseInt(bitrateAttr, 10) : void 0;
+          mediaFiles.push({
+            url: mf.textContent?.trim() || "",
+            type,
+            width: parseInt(mf.getAttribute("width") || "1920", 10),
+            height: parseInt(mf.getAttribute("height") || "1080", 10),
+            bitrate: bitrateValue && bitrateValue > 0 ? bitrateValue : void 0
+          });
+        }
+      });
+      if (mediaFiles.length === 0) {
+        console.warn("[HlsAdPlayer] No HLS media files found in VAST XML");
+        return null;
+      }
+      const trackingUrls = {
+        impression: [],
+        start: [],
+        firstQuartile: [],
+        midpoint: [],
+        thirdQuartile: [],
+        complete: [],
+        mute: [],
+        unmute: [],
+        pause: [],
+        resume: [],
+        fullscreen: [],
+        exitFullscreen: [],
+        skip: [],
+        error: []
+      };
+      xmlDoc.querySelectorAll("Impression").forEach((el) => {
+        const url = el.textContent?.trim();
+        if (url) trackingUrls.impression.push(url);
+      });
+      xmlDoc.querySelectorAll("Tracking").forEach((el) => {
+        const event = el.getAttribute("event");
+        const url = el.textContent?.trim();
+        if (event && url) {
+          const eventKey = event;
+          if (trackingUrls[eventKey]) {
+            trackingUrls[eventKey].push(url);
+          }
+        }
+      });
+      const clickThrough = xmlDoc.querySelector("ClickThrough")?.textContent?.trim();
+      return {
+        id: adId,
+        title,
+        duration,
+        mediaFiles,
+        trackingUrls,
+        clickThrough
+      };
+    } catch (error) {
+      console.error("[HlsAdPlayer] Error parsing VAST XML:", error);
+      return null;
+    }
+  }
+  function createAdVideoElement() {
+    const video = document.createElement("video");
+    video.style.position = "absolute";
+    video.style.left = "0";
+    video.style.top = "0";
+    video.style.width = "100%";
+    video.style.height = "100%";
+    video.style.objectFit = "contain";
+    video.style.backgroundColor = "#000";
+    video.playsInline = true;
+    video.muted = false;
+    return video;
+  }
+  function setupAdEventListeners() {
+    if (!adVideoElement || !currentAd) return;
+    adVideoElement.addEventListener("timeupdate", () => {
+      if (!currentAd || !adVideoElement) return;
+      const progress = adVideoElement.currentTime / currentAd.duration;
+      if (progress >= 0.25 && !trackingFired.firstQuartile) {
+        trackingFired.firstQuartile = true;
+        fireTrackingPixels(currentAd.trackingUrls.firstQuartile);
+      }
+      if (progress >= 0.5 && !trackingFired.midpoint) {
+        trackingFired.midpoint = true;
+        fireTrackingPixels(currentAd.trackingUrls.midpoint);
+      }
+      if (progress >= 0.75 && !trackingFired.thirdQuartile) {
+        trackingFired.thirdQuartile = true;
+        fireTrackingPixels(currentAd.trackingUrls.thirdQuartile);
+      }
+    });
+    adVideoElement.addEventListener("playing", () => {
+      if (!currentAd || trackingFired.start) return;
+      trackingFired.start = true;
+      fireTrackingPixels(currentAd.trackingUrls.start);
+      console.log("[HlsAdPlayer] Ad started playing");
+    });
+    adVideoElement.addEventListener("ended", () => {
+      if (!currentAd || trackingFired.complete) return;
+      trackingFired.complete = true;
+      fireTrackingPixels(currentAd.trackingUrls.complete);
+      console.log("[HlsAdPlayer] Ad completed");
+      handleAdComplete();
+    });
+    adVideoElement.addEventListener("error", (e) => {
+      console.error("[HlsAdPlayer] Ad video error:", e);
+      if (currentAd) {
+        fireTrackingPixels(currentAd.trackingUrls.error);
+      }
+      handleAdError();
+    });
+    adVideoElement.addEventListener("volumechange", () => {
+      if (!currentAd) return;
+      if (adVideoElement.muted) {
+        fireTrackingPixels(currentAd.trackingUrls.mute);
+      } else {
+        fireTrackingPixels(currentAd.trackingUrls.unmute);
+      }
+    });
+    adVideoElement.addEventListener("pause", () => {
+      if (currentAd && !adVideoElement.ended) {
+        fireTrackingPixels(currentAd.trackingUrls.pause);
+      }
+    });
+    adVideoElement.addEventListener("play", () => {
+      if (currentAd && adVideoElement.currentTime > 0) {
+        fireTrackingPixels(currentAd.trackingUrls.resume);
+      }
+    });
+  }
+  function handleAdComplete() {
+    console.log("[HlsAdPlayer] Handling ad completion");
+    adPlaying = false;
+    contentVideo.muted = originalMutedState;
+    if (adContainerEl) {
+      adContainerEl.style.display = "none";
+      adContainerEl.style.pointerEvents = "none";
+    }
+    if (!options?.continueLiveStreamDuringAds) {
+      contentVideo.play().catch(() => {
+      });
+      console.log("[HlsAdPlayer] Content resumed (VOD mode)");
+    } else {
+      console.log("[HlsAdPlayer] Content unmuted (Live mode)");
+    }
+    emit("content_resume");
+    emit("all_ads_completed");
+  }
+  function handleAdError() {
+    console.log("[HlsAdPlayer] Handling ad error");
+    adPlaying = false;
+    contentVideo.muted = originalMutedState;
+    if (adContainerEl) {
+      adContainerEl.style.display = "none";
+      adContainerEl.style.pointerEvents = "none";
+    }
+    if (!options?.continueLiveStreamDuringAds) {
+      if (contentVideo.paused) {
+        contentVideo.play().catch(() => {
+        });
+      }
+    }
+    emit("ad_error");
+  }
+  return {
+    initialize() {
+      console.log("[HlsAdPlayer] Initializing");
+      if (!adContainerEl) {
+        const container = document.createElement("div");
+        container.style.position = "absolute";
+        container.style.left = "0";
+        container.style.top = "0";
+        container.style.right = "0";
+        container.style.bottom = "0";
+        container.style.display = "none";
+        container.style.alignItems = "center";
+        container.style.justifyContent = "center";
+        container.style.pointerEvents = "none";
+        container.style.zIndex = "2";
+        container.style.backgroundColor = "#000";
+        contentVideo.parentElement?.appendChild(container);
+        adContainerEl = container;
+      }
+    },
+    async requestAds(vastTagUrl) {
+      console.log("[HlsAdPlayer] Requesting ads:", vastTagUrl);
+      if (adPlaying) {
+        console.warn("[HlsAdPlayer] Cannot request new ads while an ad is playing");
+        return Promise.reject(new Error("Ad already playing"));
+      }
+      try {
+        sessionId = generateSessionId();
+        const response = await fetch(vastTagUrl);
+        if (!response.ok) {
+          throw new Error(`Failed to fetch VAST: ${response.statusText}`);
+        }
+        const vastXml = await response.text();
+        console.log("[HlsAdPlayer] VAST XML received");
+        const ad = parseVastXml(vastXml);
+        if (!ad) {
+          throw new Error("Failed to parse VAST XML or no ads available");
+        }
+        currentAd = ad;
+        console.log(`[HlsAdPlayer] Ad parsed: ${ad.title}, duration: ${ad.duration}s`);
+        fireTrackingPixels(ad.trackingUrls.impression);
+        trackingFired.impression = true;
+        return Promise.resolve();
+      } catch (error) {
+        console.error("[HlsAdPlayer] Error requesting ads:", error);
+        emit("ad_error");
+        return Promise.reject(error);
+      }
+    },
+    async play() {
+      if (!currentAd) {
+        console.warn("[HlsAdPlayer] Cannot play: No ad loaded");
+        return Promise.reject(new Error("No ad loaded"));
+      }
+      console.log("[HlsAdPlayer] Starting ad playback");
+      try {
+        if (!adVideoElement) {
+          adVideoElement = createAdVideoElement();
+          adContainerEl?.appendChild(adVideoElement);
+          setupAdEventListeners();
+        }
+        trackingFired = {
+          impression: trackingFired.impression,
+          start: false,
+          firstQuartile: false,
+          midpoint: false,
+          thirdQuartile: false,
+          complete: false
+        };
+        if (!options?.continueLiveStreamDuringAds) {
+          contentVideo.pause();
+          console.log("[HlsAdPlayer] Content paused (VOD mode)");
+        } else {
+          console.log("[HlsAdPlayer] Content continues (Live mode)");
+        }
+        contentVideo.muted = true;
+        adPlaying = true;
+        if (adContainerEl) {
+          adContainerEl.style.display = "flex";
+          adContainerEl.style.pointerEvents = "auto";
+        }
+        emit("content_pause");
+        const mediaFile = currentAd.mediaFiles[0];
+        if (!mediaFile) {
+          throw new Error("No media file available for ad");
+        }
+        console.log(`[HlsAdPlayer] Loading ad from: ${mediaFile.url}`);
+        if (import_hls.default.isSupported()) {
+          if (adHls) {
+            adHls.destroy();
+          }
+          adHls = new import_hls.default({
+            enableWorker: true,
+            lowLatencyMode: false
+          });
+          adHls.loadSource(mediaFile.url);
+          adHls.attachMedia(adVideoElement);
+          adHls.on(import_hls.default.Events.MANIFEST_PARSED, () => {
+            console.log("[HlsAdPlayer] HLS manifest parsed, starting playback");
+            adVideoElement.play().catch((error) => {
+              console.error("[HlsAdPlayer] Error starting ad playback:", error);
+              handleAdError();
+            });
+          });
+          adHls.on(import_hls.default.Events.ERROR, (event, data) => {
+            console.error("[HlsAdPlayer] HLS error:", data);
+            if (data.fatal) {
+              handleAdError();
+            }
+          });
+        } else if (adVideoElement.canPlayType("application/vnd.apple.mpegurl")) {
+          adVideoElement.src = mediaFile.url;
+          adVideoElement.play().catch((error) => {
+            console.error("[HlsAdPlayer] Error starting ad playback:", error);
+            handleAdError();
+          });
+        } else {
+          throw new Error("HLS not supported");
+        }
+        return Promise.resolve();
+      } catch (error) {
+        console.error("[HlsAdPlayer] Error playing ad:", error);
+        handleAdError();
+        return Promise.reject(error);
+      }
+    },
+    async stop() {
+      console.log("[HlsAdPlayer] Stopping ad");
+      adPlaying = false;
+      contentVideo.muted = originalMutedState;
+      if (adContainerEl) {
+        adContainerEl.style.display = "none";
+        adContainerEl.style.pointerEvents = "none";
+      }
+      if (adHls) {
+        adHls.destroy();
+        adHls = void 0;
+      }
+      if (adVideoElement) {
+        adVideoElement.pause();
+        adVideoElement.src = "";
+      }
+      if (!options?.continueLiveStreamDuringAds) {
+        contentVideo.play().catch(() => {
+        });
+      }
+      currentAd = void 0;
+    },
+    destroy() {
+      console.log("[HlsAdPlayer] Destroying");
+      adPlaying = false;
+      contentVideo.muted = originalMutedState;
+      if (adHls) {
+        adHls.destroy();
+        adHls = void 0;
+      }
+      if (adVideoElement) {
+        adVideoElement.pause();
+        adVideoElement.src = "";
+        adVideoElement.remove();
+        adVideoElement = void 0;
+      }
+      if (adContainerEl?.parentElement) {
+        adContainerEl.parentElement.removeChild(adContainerEl);
+      }
+      adContainerEl = void 0;
+      currentAd = void 0;
+      listeners.clear();
+    },
+    isAdPlaying() {
+      return adPlaying;
+    },
+    resize(width, height) {
+      console.log(`[HlsAdPlayer] Resizing to ${width}x${height}`);
+      if (adContainerEl) {
+        adContainerEl.style.width = `${width}px`;
+        adContainerEl.style.height = `${height}px`;
+      }
+      if (adVideoElement) {
+        adVideoElement.style.width = `${width}px`;
+        adVideoElement.style.height = `${height}px`;
+      }
+    },
+    on(event, listener) {
+      if (!listeners.has(event)) listeners.set(event, /* @__PURE__ */ new Set());
+      listeners.get(event).add(listener);
+    },
+    off(event, listener) {
+      listeners.get(event)?.delete(listener);
+    },
+    updateOriginalMutedState(muted) {
+      originalMutedState = muted;
+    },
+    getOriginalMutedState() {
+      return originalMutedState;
+    },
+    setAdVolume(volume) {
+      if (adVideoElement && adPlaying) {
+        adVideoElement.volume = Math.max(0, Math.min(1, volume));
+      }
+    },
+    getAdVolume() {
+      if (adVideoElement && adPlaying) {
+        return adVideoElement.volume;
+      }
+      return 1;
+    }
+  };
+}
+
 // src/utils/tracking.ts
 var cachedBrowserId = null;
 function getClientInfo() {
@@ -700,10 +1317,18 @@ async function getBrowserID(clientInfo) {
   if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.digest) {
     try {
       await crypto.subtle.digest("SHA-256", new Uint8Array([1, 2, 3]));
-      const hashBuffer = await crypto.subtle.digest(
-        "SHA-256",
-        new TextEncoder().encode(fingerprintString)
-      );
+      let encodedData;
+      if (typeof TextEncoder !== "undefined") {
+        encodedData = new TextEncoder().encode(fingerprintString);
+      } else {
+        const utf8 = unescape(encodeURIComponent(fingerprintString));
+        const buffer = new Uint8Array(utf8.length);
+        for (let i = 0; i < utf8.length; i++) {
+          buffer[i] = utf8.charCodeAt(i);
+        }
+        encodedData = buffer;
+      }
+      const hashBuffer = await crypto.subtle.digest("SHA-256", encodedData);
       const hashArray = Array.from(new Uint8Array(hashBuffer));
       const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
       cachedBrowserId = hashHex;
@@ -790,6 +1415,215 @@ async function sendHeartbeat(licenseKey) {
   }
 }
 
+// src/utils/polyfills.ts
+function polyfillURLSearchParams() {
+  if (typeof URLSearchParams !== "undefined") {
+    return;
+  }
+  class URLSearchParamsPolyfill {
+    constructor(init) {
+      this.params = /* @__PURE__ */ new Map();
+      if (typeof init === "string") {
+        this.parseQueryString(init);
+      } else if (init instanceof URLSearchParamsPolyfill) {
+        init.forEach((value, key) => {
+          this.append(key, value);
+        });
+      }
+    }
+    parseQueryString(query) {
+      const cleanQuery = query.startsWith("?") ? query.slice(1) : query;
+      if (!cleanQuery) return;
+      cleanQuery.split("&").forEach((param) => {
+        const [key, value] = param.split("=");
+        if (key) {
+          const decodedKey = this.safeDecodeURIComponent(key);
+          const decodedValue = value ? this.safeDecodeURIComponent(value) : "";
+          this.append(decodedKey, decodedValue);
+        }
+      });
+    }
+    safeDecodeURIComponent(str) {
+      try {
+        return decodeURIComponent(str.replace(/\+/g, " "));
+      } catch (e) {
+        return str;
+      }
+    }
+    append(name, value) {
+      const values = this.params.get(name) || [];
+      values.push(String(value));
+      this.params.set(name, values);
+    }
+    delete(name) {
+      this.params.delete(name);
+    }
+    get(name) {
+      const values = this.params.get(name);
+      return values && values.length > 0 && values[0] !== void 0 ? values[0] : null;
+    }
+    getAll(name) {
+      return this.params.get(name) || [];
+    }
+    has(name) {
+      return this.params.has(name);
+    }
+    set(name, value) {
+      this.params.set(name, [String(value)]);
+    }
+    forEach(callback) {
+      this.params.forEach((values, key) => {
+        values.forEach((value) => {
+          callback(value, key, this);
+        });
+      });
+    }
+    toString() {
+      const parts = [];
+      this.params.forEach((values, key) => {
+        values.forEach((value) => {
+          parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+        });
+      });
+      return parts.join("&");
+    }
+  }
+  window.URLSearchParams = URLSearchParamsPolyfill;
+}
+function polyfillTextEncoder() {
+  if (typeof TextEncoder !== "undefined") {
+    return;
+  }
+  class TextEncoderPolyfill {
+    constructor() {
+      this.encoding = "utf-8";
+    }
+    encode(str) {
+      const utf8 = [];
+      for (let i = 0; i < str.length; i++) {
+        let charcode = str.charCodeAt(i);
+        if (charcode < 128) {
+          utf8.push(charcode);
+        } else if (charcode < 2048) {
+          utf8.push(192 | charcode >> 6, 128 | charcode & 63);
+        } else if (charcode < 55296 || charcode >= 57344) {
+          utf8.push(
+            224 | charcode >> 12,
+            128 | charcode >> 6 & 63,
+            128 | charcode & 63
+          );
+        } else {
+          i++;
+          charcode = 65536 + ((charcode & 1023) << 10 | str.charCodeAt(i) & 1023);
+          utf8.push(
+            240 | charcode >> 18,
+            128 | charcode >> 12 & 63,
+            128 | charcode >> 6 & 63,
+            128 | charcode & 63
+          );
+        }
+      }
+      return new Uint8Array(utf8);
+    }
+  }
+  window.TextEncoder = TextEncoderPolyfill;
+}
+function polyfillPromiseFinally() {
+  if (typeof Promise !== "undefined" && !Promise.prototype.finally) {
+    Promise.prototype.finally = function(callback) {
+      const constructor = this.constructor;
+      return this.then(
+        (value) => constructor.resolve(callback()).then(() => value),
+        (reason) => constructor.resolve(callback()).then(() => {
+          throw reason;
+        })
+      );
+    };
+  }
+}
+function polyfillObjectAssign() {
+  if (typeof Object.assign !== "function") {
+    Object.assign = function(target, ...sources) {
+      if (target == null) {
+        throw new TypeError("Cannot convert undefined or null to object");
+      }
+      const to = Object(target);
+      for (let i = 0; i < sources.length; i++) {
+        const nextSource = sources[i];
+        if (nextSource != null) {
+          for (const nextKey in nextSource) {
+            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+              to[nextKey] = nextSource[nextKey];
+            }
+          }
+        }
+      }
+      return to;
+    };
+  }
+}
+function polyfillArrayFrom() {
+  if (!Array.from) {
+    Array.from = function(arrayLike, mapFn, thisArg) {
+      const items = Object(arrayLike);
+      if (arrayLike == null) {
+        throw new TypeError("Array.from requires an array-like object");
+      }
+      const len = items.length >>> 0;
+      const result = new Array(len);
+      for (let i = 0; i < len; i++) {
+        if (mapFn) {
+          result[i] = mapFn.call(thisArg, items[i], i);
+        } else {
+          result[i] = items[i];
+        }
+      }
+      return result;
+    };
+  }
+}
+function polyfillStringStartsWith() {
+  if (!String.prototype.startsWith) {
+    String.prototype.startsWith = function(search, pos) {
+      pos = !pos || pos < 0 ? 0 : +pos;
+      return this.substring(pos, pos + search.length) === search;
+    };
+  }
+}
+function polyfillStringEndsWith() {
+  if (!String.prototype.endsWith) {
+    String.prototype.endsWith = function(search, length) {
+      if (length === void 0 || length > this.length) {
+        length = this.length;
+      }
+      return this.substring(length - search.length, length) === search;
+    };
+  }
+}
+function polyfillStringIncludes() {
+  if (!String.prototype.includes) {
+    String.prototype.includes = function(search, start) {
+      if (typeof start !== "number") {
+        start = 0;
+      }
+      if (start + search.length > this.length) {
+        return false;
+      }
+      return this.indexOf(search, start) !== -1;
+    };
+  }
+}
+function initializePolyfills() {
+  polyfillObjectAssign();
+  polyfillArrayFrom();
+  polyfillStringStartsWith();
+  polyfillStringEndsWith();
+  polyfillStringIncludes();
+  polyfillURLSearchParams();
+  polyfillTextEncoder();
+  polyfillPromiseFinally();
+}
+
 // src/player/StormcloudVideoPlayer.ts
 var StormcloudVideoPlayer = class {
   constructor(config) {
@@ -802,11 +1636,40 @@ var StormcloudVideoPlayer = class {
     this.totalAdsInBreak = 0;
     this.showAds = false;
     this.isLiveStream = false;
-    this.config = config;
+    initializePolyfills();
+    const browserOverrides = getBrowserConfigOverrides();
+    this.config = { ...config, ...browserOverrides };
     this.video = config.videoElement;
-    this.ima = createImaController(this.video, {
-      continueLiveStreamDuringAds: false
-    });
+    logBrowserInfo(config.debugAdTiming);
+    this.ima = this.createAdPlayer(false);
+  }
+  createAdPlayer(continueLiveStreamDuringAds) {
+    const vastMode = this.config.vastMode || "default";
+    let adPlayerType = this.config.adPlayerType || (vastMode === "adstorm" ? "hls" : "ima");
+    if (adPlayerType === "ima" && !supportsGoogleIMA()) {
+      if (this.config.debugAdTiming) {
+        console.warn(
+          "[StormcloudVideoPlayer] Google IMA SDK not supported on this browser, falling back to HLS ad player"
+        );
+      }
+      adPlayerType = "hls";
+    }
+    if (adPlayerType === "hls") {
+      if (this.config.debugAdTiming) {
+        console.log("[StormcloudVideoPlayer] Creating HLS ad player (AdStorm mode)");
+      }
+      return createHlsAdPlayer(this.video, {
+        continueLiveStreamDuringAds,
+        ...this.config.licenseKey ? { licenseKey: this.config.licenseKey } : {}
+      });
+    } else {
+      if (this.config.debugAdTiming) {
+        console.log("[StormcloudVideoPlayer] Creating Google IMA ad player (Default mode)");
+      }
+      return createImaController(this.video, {
+        continueLiveStreamDuringAds
+      });
+    }
   }
   async load() {
     if (!this.attached) {
@@ -837,9 +1700,7 @@ var StormcloudVideoPlayer = class {
         );
       }
       this.ima.destroy();
-      this.ima = createImaController(this.video, {
-        continueLiveStreamDuringAds: false
-      });
+      this.ima = this.createAdPlayer(false);
       this.ima.initialize();
       if (this.config.autoplay) {
         await this.video.play()?.catch(() => {
@@ -847,7 +1708,7 @@ var StormcloudVideoPlayer = class {
       }
       return;
     }
-    this.hls = new import_hls.default({
+    this.hls = new import_hls2.default({
       enableWorker: true,
       backBufferLength: 30,
       liveDurationInfinity: true,
@@ -855,10 +1716,10 @@ var StormcloudVideoPlayer = class {
       maxLiveSyncPlaybackRate: this.config.lowLatencyMode ? 1.5 : 1,
       ...this.config.lowLatencyMode ? { liveSyncDuration: 2 } : {}
     });
-    this.hls.on(import_hls.default.Events.MEDIA_ATTACHED, () => {
+    this.hls.on(import_hls2.default.Events.MEDIA_ATTACHED, () => {
       this.hls?.loadSource(this.config.src);
     });
-    this.hls.on(import_hls.default.Events.MANIFEST_PARSED, async (_, data) => {
+    this.hls.on(import_hls2.default.Events.MANIFEST_PARSED, async (_, data) => {
       this.isLiveStream = this.hls?.levels?.some(
         (level) => level?.details?.live === true || level?.details?.type === "LIVE"
       ) ?? false;
@@ -871,16 +1732,14 @@ var StormcloudVideoPlayer = class {
         });
       }
       this.ima.destroy();
-      this.ima = createImaController(this.video, {
-        continueLiveStreamDuringAds: this.shouldContinueLiveStreamDuringAds()
-      });
+      this.ima = this.createAdPlayer(this.shouldContinueLiveStreamDuringAds());
       this.ima.initialize();
       if (this.config.autoplay) {
         await this.video.play()?.catch(() => {
         });
       }
     });
-    this.hls.on(import_hls.default.Events.FRAG_PARSING_METADATA, (_evt, data) => {
+    this.hls.on(import_hls2.default.Events.FRAG_PARSING_METADATA, (_evt, data) => {
       const id3Tags = (data?.samples || []).map((s) => ({
         key: "ID3",
         value: s?.data,
@@ -888,7 +1747,7 @@ var StormcloudVideoPlayer = class {
       }));
       id3Tags.forEach((tag) => this.onId3Tag(tag));
     });
-    this.hls.on(import_hls.default.Events.FRAG_CHANGED, (_evt, data) => {
+    this.hls.on(import_hls2.default.Events.FRAG_CHANGED, (_evt, data) => {
       const frag = data?.frag;
       const tagList = frag?.tagList;
       if (!Array.isArray(tagList)) return;
@@ -948,13 +1807,13 @@ var StormcloudVideoPlayer = class {
         }
       }
     });
-    this.hls.on(import_hls.default.Events.ERROR, (_evt, data) => {
+    this.hls.on(import_hls2.default.Events.ERROR, (_evt, data) => {
       if (data?.fatal) {
         switch (data.type) {
-          case import_hls.default.ErrorTypes.NETWORK_ERROR:
+          case import_hls2.default.ErrorTypes.NETWORK_ERROR:
             this.hls?.startLoad();
             break;
-          case import_hls.default.ErrorTypes.MEDIA_ERROR:
+          case import_hls2.default.ErrorTypes.MEDIA_ERROR:
             this.hls?.recoverMediaError();
             break;
           default:
@@ -1465,6 +2324,42 @@ var StormcloudVideoPlayer = class {
     }
   }
   async fetchAdConfiguration() {
+    const vastMode = this.config.vastMode || "default";
+    if (this.config.debugAdTiming) {
+      console.log(
+        "[StormcloudVideoPlayer] VAST mode:",
+        vastMode
+      );
+    }
+    if (vastMode === "adstorm") {
+      if (!this.config.licenseKey) {
+        if (this.config.debugAdTiming) {
+          console.warn(
+            "[StormcloudVideoPlayer] AdStorm mode requires a license key"
+          );
+        }
+        return;
+      }
+      const vastEndpoint = `https://adstorm.co/api-adstorm-dev/adstorm/vast/${this.config.licenseKey}`;
+      this.apiVastTagUrl = vastEndpoint;
+      if (this.config.debugAdTiming) {
+        console.log(
+          "[StormcloudVideoPlayer] Using AdStorm VAST endpoint:",
+          vastEndpoint
+        );
+      }
+      return;
+    }
+    if (this.config.vastTagUrl) {
+      this.apiVastTagUrl = this.config.vastTagUrl;
+      if (this.config.debugAdTiming) {
+        console.log(
+          "[StormcloudVideoPlayer] Using custom VAST tag URL:",
+          this.apiVastTagUrl
+        );
+      }
+      return;
+    }
     const apiUrl = "https://adstorm.co/api-adstorm-dev/adstorm/ads/web";
     if (this.config.debugAdTiming) {
       console.log(
@@ -1478,7 +2373,12 @@ var StormcloudVideoPlayer = class {
     }
     const response = await fetch(apiUrl, { headers });
     if (!response.ok) {
-      throw new Error(`Failed to fetch ad configuration: ${response.status}`);
+      if (this.config.debugAdTiming) {
+        console.warn(
+          `[StormcloudVideoPlayer] Failed to fetch ad configuration: ${response.status}`
+        );
+      }
+      return;
     }
     const data = await response.json();
     const imaPayload = data.response?.ima?.["publisherdesk.ima"]?.payload;
@@ -1486,17 +2386,16 @@ var StormcloudVideoPlayer = class {
       this.apiVastTagUrl = decodeURIComponent(imaPayload);
       if (this.config.debugAdTiming) {
         console.log(
-          "[StormcloudVideoPlayer] Extracted VAST tag URL:",
+          "[StormcloudVideoPlayer] Extracted VAST tag URL from /ads/web:",
           this.apiVastTagUrl
         );
       }
-    }
-    this.vastConfig = data.response?.options?.vast;
-    if (this.config.debugAdTiming) {
-      console.log("[StormcloudVideoPlayer] Ad configuration loaded:", {
-        vastTagUrl: this.apiVastTagUrl,
-        vastConfig: this.vastConfig
-      });
+    } else {
+      if (this.config.debugAdTiming) {
+        console.warn(
+          "[StormcloudVideoPlayer] No VAST tag URL found in /ads/web response"
+        );
+      }
     }
   }
   getCurrentAdIndex() {
@@ -1540,23 +2439,14 @@ var StormcloudVideoPlayer = class {
     );
     const tags = this.selectVastTagsForBreak(scheduled);
     let vastTagUrl;
-    let adsNumber = 1;
     if (this.apiVastTagUrl) {
       vastTagUrl = this.apiVastTagUrl;
-      if (this.vastConfig) {
-        const isHls = this.config.src.includes(".m3u8") || this.config.src.includes("hls");
-        if (isHls && this.vastConfig.cue_tones?.number_ads) {
-          adsNumber = this.vastConfig.cue_tones.number_ads;
-        } else if (!isHls && this.vastConfig.timer_vod?.number_ads) {
-          adsNumber = this.vastConfig.timer_vod.number_ads;
-        }
-      }
-      this.adPodQueue = new Array(adsNumber - 1).fill(vastTagUrl);
+      this.adPodQueue = [];
       this.currentAdIndex = 0;
-      this.totalAdsInBreak = adsNumber;
+      this.totalAdsInBreak = 1;
       if (this.config.debugAdTiming) {
         console.log(
-          `[StormcloudVideoPlayer] Using API VAST tag with ${adsNumber} ads:`,
+          "[StormcloudVideoPlayer] Using VAST endpoint:",
           vastTagUrl
         );
       }