adgent-sdk 0.1.1

package/dist/adgent-sdk.es.js

@@ -0,0 +1,1420 @@
+var R = Object.defineProperty;
+var S = (i, e, r) => e in i ? R(i, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : i[e] = r;
+var l = (i, e, r) => S(i, typeof e != "symbol" ? e + "" : e, r);
+import { XMLParser as T } from "fast-xml-parser";
+var d = /* @__PURE__ */ ((i) => (i.Idle = "idle", i.Loading = "loading", i.Ready = "ready", i.Playing = "playing", i.Paused = "paused", i.Completed = "completed", i.Error = "error", i.WaitingForInteraction = "waiting_for_interaction", i))(d || {}), u = /* @__PURE__ */ ((i) => (i[i.XML_PARSING_ERROR = 100] = "XML_PARSING_ERROR", i[i.VAST_SCHEMA_VALIDATION_ERROR = 101] = "VAST_SCHEMA_VALIDATION_ERROR", i[i.VAST_VERSION_NOT_SUPPORTED = 102] = "VAST_VERSION_NOT_SUPPORTED", i[i.GENERAL_WRAPPER_ERROR = 300] = "GENERAL_WRAPPER_ERROR", i[i.WRAPPER_TIMEOUT = 301] = "WRAPPER_TIMEOUT", i[i.WRAPPER_LIMIT_REACHED = 302] = "WRAPPER_LIMIT_REACHED", i[i.NO_VAST_RESPONSE = 303] = "NO_VAST_RESPONSE", i[i.GENERAL_LINEAR_ERROR = 400] = "GENERAL_LINEAR_ERROR", i[i.FILE_NOT_FOUND = 401] = "FILE_NOT_FOUND", i[i.MEDIA_TIMEOUT = 402] = "MEDIA_TIMEOUT", i[i.MEDIA_NOT_SUPPORTED = 403] = "MEDIA_NOT_SUPPORTED", i[i.GENERAL_COMPANION_ERROR = 600] = "GENERAL_COMPANION_ERROR", i[i.UNDEFINED_ERROR = 900] = "UNDEFINED_ERROR", i))(u || {});
+class A {
+  constructor(e = {}) {
+    l(this, "config");
+    l(this, "xmlParser");
+    this.config = {
+      maxWrapperDepth: e.maxWrapperDepth ?? 5,
+      timeout: e.timeout ?? 1e4,
+      debug: e.debug ?? !1,
+      fetchFn: e.fetchFn ?? fetch.bind(globalThis)
+    }, this.xmlParser = new T({
+      ignoreAttributes: !1,
+      attributeNamePrefix: "@_",
+      textNodeName: "#text",
+      parseAttributeValue: !0,
+      trimValues: !0
+    });
+  }
+  /**
+   * Parse a VAST URL and resolve all wrappers
+   * @param vastUrl - URL to the VAST document
+   */
+  async parse(e) {
+    try {
+      return { success: !0, response: await this.fetchAndParse(e, 0) };
+    } catch (r) {
+      const t = r instanceof Error ? r.message : "Unknown error";
+      return {
+        success: !1,
+        error: {
+          code: u.GENERAL_WRAPPER_ERROR,
+          message: t
+        }
+      };
+    }
+  }
+  /**
+   * Fetch and parse VAST document with wrapper resolution
+   */
+  async fetchAndParse(e, r) {
+    if (r >= this.config.maxWrapperDepth)
+      throw new Error(
+        `Wrapper limit exceeded (max: ${this.config.maxWrapperDepth})`
+      );
+    this.log(`Fetching VAST (depth: ${r}): ${e}`);
+    const t = await this.fetchWithTimeout(e), s = this.parseXml(t), a = await Promise.all(
+      s.ads.map(async (n) => {
+        var h;
+        return (h = n.wrapper) != null && h.vastAdTagURI ? this.resolveWrapper(n, r + 1) : n;
+      })
+    );
+    return {
+      ...s,
+      ads: a.flat()
+    };
+  }
+  /**
+   * Resolve a wrapper ad by fetching the nested VAST
+   */
+  async resolveWrapper(e, r) {
+    var t;
+    if (!((t = e.wrapper) != null && t.vastAdTagURI))
+      return [e];
+    try {
+      return (await this.fetchAndParse(
+        e.wrapper.vastAdTagURI,
+        r
+      )).ads.map(
+        (a) => this.mergeWrapperTracking(e, a)
+      );
+    } catch (s) {
+      if (this.log(`Wrapper resolution failed: ${s}`), e.wrapper.fallbackOnNoAd)
+        return [];
+      throw s;
+    }
+  }
+  /**
+   * Merge tracking events from wrapper into nested ad
+   */
+  mergeWrapperTracking(e, r) {
+    return {
+      ...r,
+      impressions: [
+        ...e.impressions,
+        ...r.impressions
+      ],
+      errors: [...e.errors, ...r.errors],
+      creatives: r.creatives.map((t) => ({
+        ...t,
+        linear: t.linear ? {
+          ...t.linear,
+          trackingEvents: [
+            ...this.getWrapperTrackingEvents(e),
+            ...t.linear.trackingEvents
+          ]
+        } : void 0
+      }))
+    };
+  }
+  /**
+   * Extract tracking events from wrapper creatives
+   */
+  getWrapperTrackingEvents(e) {
+    var t;
+    const r = [];
+    for (const s of e.creatives)
+      (t = s.linear) != null && t.trackingEvents && r.push(...s.linear.trackingEvents);
+    return r;
+  }
+  /**
+   * Fetch URL with timeout
+   */
+  async fetchWithTimeout(e) {
+    const r = new AbortController(), t = setTimeout(
+      () => r.abort(),
+      this.config.timeout
+    );
+    try {
+      const s = await this.config.fetchFn(e, {
+        signal: r.signal
+      });
+      if (!s.ok)
+        throw new Error(`HTTP ${s.status}: ${s.statusText}`);
+      return s.text();
+    } finally {
+      clearTimeout(t);
+    }
+  }
+  /**
+   * Parse raw VAST XML into structured response
+   */
+  parseXml(e) {
+    const t = this.xmlParser.parse(e).VAST;
+    if (!t)
+      throw new Error("Invalid VAST: missing VAST element");
+    const s = t["@_version"] || "4.0", a = this.parseAds(t.Ad);
+    return {
+      version: s,
+      ads: a,
+      errors: this.parseErrors(t.Error)
+    };
+  }
+  /**
+   * Parse Ad elements
+   */
+  parseAds(e) {
+    return e ? (Array.isArray(e) ? e : [e]).map((t) => this.parseAd(t)) : [];
+  }
+  /**
+   * Parse a single Ad element
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parseAd(e) {
+    var s, a, n;
+    const r = !!e.Wrapper, t = e.InLine || e.Wrapper;
+    return {
+      id: e["@_id"] || "",
+      sequence: e["@_sequence"],
+      adSystem: t != null && t.AdSystem ? {
+        name: typeof t.AdSystem == "string" ? t.AdSystem : t.AdSystem["#text"] || "",
+        version: (s = t.AdSystem) == null ? void 0 : s["@_version"]
+      } : void 0,
+      adTitle: t == null ? void 0 : t.AdTitle,
+      impressions: this.parseImpressions(t == null ? void 0 : t.Impression),
+      errors: this.parseErrors(t == null ? void 0 : t.Error),
+      creatives: this.parseCreatives((a = t == null ? void 0 : t.Creatives) == null ? void 0 : a.Creative),
+      wrapper: r ? {
+        vastAdTagURI: t.VASTAdTagURI,
+        followAdditionalWrappers: t["@_followAdditionalWrappers"] !== !1,
+        allowMultipleAds: t["@_allowMultipleAds"],
+        fallbackOnNoAd: t["@_fallbackOnNoAd"]
+      } : void 0,
+      inLine: r ? void 0 : {
+        adTitle: (t == null ? void 0 : t.AdTitle) || "",
+        description: t == null ? void 0 : t.Description,
+        advertiser: t == null ? void 0 : t.Advertiser,
+        creatives: this.parseCreatives((n = t == null ? void 0 : t.Creatives) == null ? void 0 : n.Creative)
+      }
+    };
+  }
+  /**
+   * Parse Impression elements
+   */
+  parseImpressions(e) {
+    return e ? (Array.isArray(e) ? e : [e]).map((t) => ({
+      id: t["@_id"],
+      url: typeof t == "string" ? t : t["#text"] || ""
+    })) : [];
+  }
+  /**
+   * Parse Creative elements
+   */
+  parseCreatives(e) {
+    return e ? (Array.isArray(e) ? e : [e]).map((t) => ({
+      id: t["@_id"],
+      sequence: t["@_sequence"],
+      adId: t["@_adId"],
+      linear: t.Linear ? this.parseLinear(t.Linear) : void 0
+    })) : [];
+  }
+  /**
+   * Parse Linear element
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parseLinear(e) {
+    var r, t;
+    return {
+      duration: this.parseDuration(e.Duration),
+      skipOffset: e["@_skipoffset"] ? this.parseDuration(e["@_skipoffset"]) : void 0,
+      mediaFiles: this.parseMediaFiles((r = e.MediaFiles) == null ? void 0 : r.MediaFile),
+      trackingEvents: this.parseTrackingEvents(
+        (t = e.TrackingEvents) == null ? void 0 : t.Tracking
+      ),
+      videoClicks: e.VideoClicks ? {
+        clickThrough: e.VideoClicks.ClickThrough ? {
+          id: e.VideoClicks.ClickThrough["@_id"],
+          url: typeof e.VideoClicks.ClickThrough == "string" ? e.VideoClicks.ClickThrough : e.VideoClicks.ClickThrough["#text"] || ""
+        } : void 0
+      } : void 0,
+      adParameters: e.AdParameters
+    };
+  }
+  /**
+   * Parse MediaFile elements
+   */
+  parseMediaFiles(e) {
+    return e ? (Array.isArray(e) ? e : [e]).map((t) => ({
+      id: t["@_id"],
+      url: typeof t == "string" ? t : t["#text"] || "",
+      delivery: t["@_delivery"] || "progressive",
+      type: t["@_type"] || "video/mp4",
+      width: parseInt(t["@_width"], 10) || 0,
+      height: parseInt(t["@_height"], 10) || 0,
+      bitrate: t["@_bitrate"] ? parseInt(t["@_bitrate"], 10) : void 0,
+      codec: t["@_codec"],
+      scalable: t["@_scalable"],
+      maintainAspectRatio: t["@_maintainAspectRatio"]
+    })) : [];
+  }
+  /**
+   * Parse Tracking elements
+   */
+  parseTrackingEvents(e) {
+    return e ? (Array.isArray(e) ? e : [e]).map((t) => ({
+      event: t["@_event"],
+      url: typeof t == "string" ? t : t["#text"] || "",
+      offset: t["@_offset"] ? this.parseDuration(t["@_offset"]) : void 0
+    })) : [];
+  }
+  /**
+   * Parse Error elements
+   */
+  parseErrors(e) {
+    return e ? (Array.isArray(e) ? e : [e]).map((t) => typeof t == "string" ? t : t["#text"] || "") : [];
+  }
+  /**
+   * Parse duration string (HH:MM:SS or seconds) to seconds
+   */
+  parseDuration(e) {
+    if (typeof e == "number") return e;
+    if (typeof e != "string") return 0;
+    if (e.endsWith("%"))
+      return parseFloat(e) / 100;
+    const r = e.match(/(\d+):(\d+):(\d+(?:\.\d+)?)/);
+    if (r) {
+      const [, t, s, a] = r;
+      return parseInt(t, 10) * 3600 + parseInt(s, 10) * 60 + parseFloat(a);
+    }
+    return parseFloat(e) || 0;
+  }
+  /**
+   * Select the best media file based on target bitrate
+   * Prefers 1080p/720p over 4K for TV compatibility
+   */
+  selectBestMediaFile(e, r = 2500) {
+    if (e.length === 0) return null;
+    const t = e.filter(
+      (n) => n.type.includes("mp4") || n.type.includes("video/mp4")
+    );
+    return [...t.length > 0 ? t : e].sort((n, h) => {
+      const p = n.bitrate || 0, f = h.bitrate || 0, E = n.height > 1080 ? 1e4 : 0, k = h.height > 1080 ? 1e4 : 0, w = Math.abs(p - r) + E, b = Math.abs(f - r) + k;
+      return w - b;
+    })[0] || null;
+  }
+  /**
+   * Aggregate all tracking events from parsed ads
+   */
+  aggregateTrackingEvents(e) {
+    var t;
+    const r = [];
+    for (const s of e)
+      for (const a of s.creatives)
+        (t = a.linear) != null && t.trackingEvents && r.push(...a.linear.trackingEvents);
+    return r;
+  }
+  /**
+   * Get all impression URLs from parsed ads
+   */
+  aggregateImpressions(e) {
+    const r = [];
+    for (const t of e)
+      for (const s of t.impressions)
+        r.push(s.url);
+    return r;
+  }
+  /**
+   * Debug logging
+   */
+  log(e) {
+    this.config.debug && console.log(`[VASTParser] ${e}`);
+  }
+}
+function m(i, e = {}) {
+  let r = i;
+  return r = r.replace(/\[TIMESTAMP\]/g, Date.now().toString()), r = r.replace(
+    /\[CACHEBUSTING\]/g,
+    Math.random().toString(36).substring(2, 15)
+  ), e.assetUri && (r = r.replace(
+    /\[ASSETURI\]/g,
+    encodeURIComponent(e.assetUri)
+  )), e.contentPlayhead !== void 0 && (r = r.replace(
+    /\[CONTENTPLAYHEAD\]/g,
+    v(e.contentPlayhead)
+  )), e.adPlayhead !== void 0 && (r = r.replace(
+    /\[ADPLAYHEAD\]/g,
+    v(e.adPlayhead)
+  )), e.errorCode !== void 0 && (r = r.replace(/\[ERRORCODE\]/g, e.errorCode.toString())), e.breakPosition !== void 0 && (r = r.replace(
+    /\[BREAKPOSITION\]/g,
+    e.breakPosition.toString()
+  )), e.adType && (r = r.replace(/\[ADTYPE\]/g, e.adType)), r;
+}
+function v(i) {
+  const e = Math.floor(i / 3600), r = Math.floor(i % 3600 / 60), t = Math.floor(i % 60), s = Math.floor(i % 1 * 1e3);
+  return e.toString().padStart(2, "0") + ":" + r.toString().padStart(2, "0") + ":" + t.toString().padStart(2, "0") + "." + s.toString().padStart(3, "0");
+}
+var o = /* @__PURE__ */ ((i) => (i.WebOS = "webos", i.Tizen = "tizen", i.Vidaa = "vidaa", i.WhaleOS = "whaleos", i.FireTV = "firetv", i.Roku = "roku", i.Xbox = "xbox", i.PlayStation = "playstation", i.AndroidTV = "androidtv", i.Vizio = "vizio", i.Generic = "generic", i))(o || {}), c = /* @__PURE__ */ ((i) => (i.Enter = "enter", i.Back = "back", i.Left = "left", i.Right = "right", i.Up = "up", i.Down = "down", i.Play = "play", i.Pause = "pause", i.PlayPause = "playPause", i.Stop = "stop", i.FastForward = "fastForward", i.Rewind = "rewind", i.Menu = "menu", i.Info = "info", i.Red = "red", i.Green = "green", i.Yellow = "yellow", i.Blue = "blue", i.ChannelUp = "channelUp", i.ChannelDown = "channelDown", i.VolumeUp = "volumeUp", i.VolumeDown = "volumeDown", i.Mute = "mute", i))(c || {});
+const _ = {
+  webos: {
+    13: "enter",
+    461: "back",
+    // WebOS specific
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down",
+    415: "play",
+    19: "pause",
+    413: "stop",
+    417: "fastForward",
+    412: "rewind",
+    457: "info",
+    403: "red",
+    404: "green",
+    405: "yellow",
+    406: "blue",
+    33: "channelUp",
+    34: "channelDown"
+    /* ChannelDown */
+  },
+  tizen: {
+    13: "enter",
+    10009: "back",
+    // Tizen specific
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down",
+    415: "play",
+    19: "pause",
+    10252: "playPause",
+    413: "stop",
+    417: "fastForward",
+    412: "rewind",
+    457: "info",
+    403: "red",
+    404: "green",
+    405: "yellow",
+    406: "blue",
+    427: "channelUp",
+    428: "channelDown",
+    447: "volumeUp",
+    448: "volumeDown",
+    449: "mute"
+    /* Mute */
+  },
+  vidaa: {
+    13: "enter",
+    8: "back",
+    27: "back",
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down",
+    415: "play",
+    19: "pause",
+    413: "stop",
+    417: "fastForward",
+    412: "rewind"
+    /* Rewind */
+  },
+  whaleos: {
+    13: "enter",
+    27: "back",
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down",
+    415: "play",
+    19: "pause",
+    413: "stop"
+    /* Stop */
+  },
+  firetv: {
+    13: "enter",
+    4: "back",
+    // Android back
+    27: "back",
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down",
+    85: "playPause",
+    126: "play",
+    127: "pause",
+    89: "rewind",
+    90: "fastForward",
+    82: "menu"
+    /* Menu */
+  },
+  roku: {
+    13: "enter",
+    27: "back",
+    8: "back",
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down",
+    179: "playPause",
+    178: "stop",
+    228: "fastForward",
+    227: "rewind"
+    /* Rewind */
+  },
+  xbox: {
+    13: "enter",
+    // A button
+    27: "back",
+    // B button
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down",
+    195: "menu",
+    // Menu button
+    196: "menu"
+    /* Menu */
+    // View button
+  },
+  playstation: {
+    13: "enter",
+    // X button
+    27: "back",
+    // Circle button
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down"
+    /* Down */
+  },
+  androidtv: {
+    13: "enter",
+    4: "back",
+    // Android back
+    27: "back",
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down",
+    85: "playPause",
+    126: "play",
+    127: "pause",
+    89: "rewind",
+    90: "fastForward",
+    82: "menu"
+    /* Menu */
+  },
+  vizio: {
+    13: "enter",
+    27: "back",
+    8: "back",
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down",
+    415: "play",
+    19: "pause"
+    /* Pause */
+  },
+  generic: {
+    13: "enter",
+    27: "back",
+    // Escape
+    8: "back",
+    // Backspace
+    37: "left",
+    38: "up",
+    39: "right",
+    40: "down",
+    32: "playPause",
+    // Space
+    80: "play",
+    // P key
+    83: "stop",
+    // S key
+    77: "mute"
+    /* Mute */
+    // M key
+  }
+}, P = {
+  tizen: [
+    /Tizen/i,
+    /SMART-TV.*Samsung/i
+  ],
+  webos: [
+    /Web0S/i,
+    /WebOS/i,
+    /LG.*NetCast/i,
+    /LGE.*TV/i
+  ],
+  vidaa: [
+    /Vidaa/i,
+    /VIDAA/i,
+    /Hisense/i
+  ],
+  whaleos: [
+    /WhaleTV/i,
+    /Whale/i
+  ],
+  firetv: [
+    /AFT/i,
+    // Amazon Fire TV
+    /AFTS/i,
+    // Fire TV Stick
+    /AFTM/i,
+    // Fire TV specific models
+    /Amazon.*Fire/i
+  ],
+  roku: [
+    /Roku/i
+  ],
+  xbox: [
+    /Xbox/i,
+    /Edge.*Xbox/i
+  ],
+  playstation: [
+    /PlayStation/i,
+    /PS4/i,
+    /PS5/i
+  ],
+  androidtv: [
+    /Android.*TV/i,
+    /Chromecast/i,
+    /BRAVIA/i,
+    // Sony
+    /SHIELD/i
+    // NVIDIA Shield
+  ],
+  vizio: [
+    /VIZIO/i,
+    /SmartCast/i
+  ],
+  generic: []
+};
+class O {
+  constructor() {
+    l(this, "platform");
+    l(this, "capabilities");
+    l(this, "deviceInfo");
+    l(this, "keyMap");
+    l(this, "reverseKeyMap");
+    this.platform = this.detectPlatform(), this.keyMap = _[this.platform], this.reverseKeyMap = this.buildReverseKeyMap(), this.capabilities = this.detectCapabilities(), this.deviceInfo = this.detectDeviceInfo();
+  }
+  /**
+   * Detect the current Smart TV platform using userAgent and global objects
+   */
+  detectPlatform() {
+    if (typeof window > "u" || typeof navigator > "u")
+      return o.Generic;
+    const e = navigator.userAgent, r = window;
+    if (r.tizen)
+      return o.Tizen;
+    if (r.webOS || r.PalmSystem)
+      return o.WebOS;
+    for (const [t, s] of Object.entries(P))
+      if (t !== o.Generic) {
+        for (const a of s)
+          if (a.test(e))
+            return t;
+      }
+    return o.Generic;
+  }
+  /**
+   * Detect platform capabilities
+   */
+  detectCapabilities() {
+    const e = typeof navigator < "u", r = typeof document < "u", t = typeof window < "u", s = {
+      sendBeacon: e && "sendBeacon" in navigator,
+      fetchKeepalive: typeof fetch < "u",
+      mutedAutoplayRequired: !0,
+      fullscreen: r && ("fullscreenEnabled" in document || "webkitFullscreenEnabled" in document),
+      hardwareDecodeInfo: !1,
+      hdr: !1,
+      hdr10Plus: !1,
+      dolbyVision: !1,
+      dolbyAtmos: !1,
+      hevc: this.isCodecSupported('video/mp4; codecs="hvc1"'),
+      vp9: this.isCodecSupported('video/webm; codecs="vp9"'),
+      av1: this.isCodecSupported('video/mp4; codecs="av01.0.05M.08"'),
+      maxResolution: this.detectMaxResolution(),
+      touch: t && "ontouchstart" in window,
+      voice: !1
+    };
+    switch (this.platform) {
+      case o.Tizen:
+        return {
+          ...s,
+          hardwareDecodeInfo: !0,
+          hdr: !0,
+          hevc: !0,
+          voice: !0
+        };
+      case o.WebOS:
+        return {
+          ...s,
+          hardwareDecodeInfo: !0,
+          hdr: !0,
+          dolbyVision: !0,
+          dolbyAtmos: !0,
+          hevc: !0,
+          voice: !0
+        };
+      case o.FireTV:
+        return {
+          ...s,
+          hdr: !0,
+          hdr10Plus: !0,
+          dolbyVision: !0,
+          hevc: !0,
+          voice: !0
+        };
+      case o.Roku:
+        return {
+          ...s,
+          hdr: !0,
+          dolbyVision: !0,
+          hevc: !0,
+          voice: !0
+        };
+      case o.Xbox:
+        return {
+          ...s,
+          hdr: !0,
+          dolbyVision: !0,
+          dolbyAtmos: !0,
+          hevc: !0,
+          av1: !0,
+          voice: !0
+        };
+      case o.PlayStation:
+        return {
+          ...s,
+          hdr: !0,
+          hevc: !0
+        };
+      case o.AndroidTV:
+        return {
+          ...s,
+          hdr: !0,
+          dolbyVision: !0,
+          hevc: !0,
+          vp9: !0,
+          voice: !0
+        };
+      default:
+        return s;
+    }
+  }
+  /**
+   * Detect device information
+   */
+  detectDeviceInfo() {
+    var t, s, a;
+    const e = {
+      platform: this.platform
+    };
+    typeof window < "u" && (e.screenWidth = (t = window.screen) == null ? void 0 : t.width, e.screenHeight = (s = window.screen) == null ? void 0 : s.height, e.devicePixelRatio = window.devicePixelRatio);
+    const r = window;
+    if (this.platform === o.Tizen && ((a = r.tizen) != null && a.systeminfo))
+      try {
+        r.tizen.systeminfo.getPropertyValue("BUILD", (n) => {
+          e.model = n.model, e.manufacturer = n.manufacturer || "Samsung";
+        });
+      } catch {
+        e.manufacturer = "Samsung";
+      }
+    if (this.platform === o.WebOS && r.webOSSystem)
+      try {
+        const n = r.webOSSystem.deviceInfo;
+        e.model = n == null ? void 0 : n.modelName, e.manufacturer = "LG", e.osVersion = n == null ? void 0 : n.version;
+      } catch {
+        e.manufacturer = "LG";
+      }
+    return e;
+  }
+  /**
+   * Detect maximum supported resolution
+   */
+  detectMaxResolution() {
+    var s, a;
+    if (typeof window > "u") return "unknown";
+    const e = ((s = window.screen) == null ? void 0 : s.width) || 0, r = ((a = window.screen) == null ? void 0 : a.height) || 0, t = Math.max(e, r);
+    return t >= 3840 ? "4k" : t >= 1920 ? "1080p" : t >= 1280 ? "720p" : "unknown";
+  }
+  /**
+   * Build reverse mapping from KeyAction to key codes
+   */
+  buildReverseKeyMap() {
+    const e = /* @__PURE__ */ new Map();
+    for (const [r, t] of Object.entries(this.keyMap)) {
+      const s = parseInt(r, 10), a = e.get(t) || [];
+      a.push(s), e.set(t, a);
+    }
+    return e;
+  }
+  /**
+   * Normalize a raw key code to a KeyAction
+   * @param keyCode - Raw keyboard/remote key code
+   * @returns KeyAction or null if not mapped
+   */
+  normalizeKeyCode(e) {
+    return this.keyMap[e] ?? null;
+  }
+  /**
+   * Get all key codes that map to a specific action
+   * @param action - The key action
+   * @returns Array of key codes
+   */
+  getKeyCodesForAction(e) {
+    return this.reverseKeyMap.get(e) || [];
+  }
+  /**
+   * Check if a specific codec is supported
+   * @param codec - MIME type with codec string
+   * @returns true if codec is supported
+   */
+  isCodecSupported(e) {
+    if (typeof document > "u") return !1;
+    try {
+      const t = document.createElement("video").canPlayType(e);
+      return t === "probably" || t === "maybe";
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Register Tizen-specific key handlers
+   * Must be called for Tizen apps to receive media keys
+   */
+  registerTizenKeys() {
+    if (this.platform !== o.Tizen) return;
+    const e = window.tizen;
+    e != null && e.tvinputdevice && [
+      "MediaPlay",
+      "MediaPause",
+      "MediaStop",
+      "MediaFastForward",
+      "MediaRewind",
+      "MediaPlayPause",
+      "ColorF0Red",
+      "ColorF1Green",
+      "ColorF2Yellow",
+      "ColorF3Blue",
+      "Info"
+    ].forEach((t) => {
+      try {
+        e.tvinputdevice.registerKey(t);
+      } catch {
+      }
+    });
+  }
+  /**
+   * Register WebOS-specific key handlers
+   */
+  registerWebOSKeys() {
+    this.platform, o.WebOS;
+  }
+  /**
+   * Get platform-specific video element attributes
+   * @returns Object of attributes to set on video element
+   */
+  getVideoAttributes() {
+    const e = {
+      muted: !0,
+      playsinline: !0,
+      autoplay: !0,
+      "webkit-playsinline": !0
+    };
+    switch (this.platform) {
+      case o.Tizen:
+        e["data-samsung-immersive"] = "true";
+        break;
+      case o.WebOS:
+        e["data-lg-immersive"] = "true";
+        break;
+      case o.FireTV:
+      case o.AndroidTV:
+        e["x-webkit-airplay"] = "allow";
+        break;
+    }
+    return e;
+  }
+  /**
+   * Get recommended video settings for this platform
+   */
+  getRecommendedVideoSettings() {
+    switch (this.platform) {
+      case o.Tizen:
+      case o.WebOS:
+        return {
+          maxBitrate: 15e3,
+          // 15 Mbps for high-end TVs
+          preferredCodec: "hevc",
+          maxResolution: "4k"
+        };
+      case o.FireTV:
+        return {
+          maxBitrate: 1e4,
+          // 10 Mbps
+          preferredCodec: "hevc",
+          maxResolution: "4k"
+        };
+      case o.Roku:
+        return {
+          maxBitrate: 8e3,
+          // 8 Mbps
+          preferredCodec: "h264",
+          // Roku has variable HEVC support
+          maxResolution: "4k"
+        };
+      case o.Xbox:
+      case o.PlayStation:
+        return {
+          maxBitrate: 2e4,
+          // 20 Mbps for game consoles
+          preferredCodec: "hevc",
+          maxResolution: "4k"
+        };
+      default:
+        return {
+          maxBitrate: 5e3,
+          // 5 Mbps safe default
+          preferredCodec: "h264",
+          maxResolution: "1080p"
+        };
+    }
+  }
+}
+let g = null;
+function y() {
+  return g || (g = new O()), g;
+}
+class x {
+  constructor(e = [], r = {}) {
+    l(this, "config");
+    l(this, "trackingEvents");
+    l(this, "firedEvents");
+    l(this, "macroContext");
+    this.config = {
+      debug: r.debug ?? !1,
+      retry: r.retry ?? !1,
+      maxRetries: r.maxRetries ?? 3
+    }, this.trackingEvents = this.groupEventsByType(e), this.firedEvents = /* @__PURE__ */ new Set(), this.macroContext = {};
+  }
+  /**
+   * Group tracking events by their event type
+   */
+  groupEventsByType(e) {
+    const r = /* @__PURE__ */ new Map();
+    for (const t of e) {
+      const s = r.get(t.event) || [];
+      s.push(t), r.set(t.event, s);
+    }
+    return r;
+  }
+  /**
+   * Update macro context for URL replacement
+   */
+  updateMacroContext(e) {
+    this.macroContext = { ...this.macroContext, ...e };
+  }
+  /**
+   * Track a specific event type
+   * @param eventType - The VAST event type to track
+   * @param once - Only fire once per event type (default: true)
+   */
+  track(e, r = !0) {
+    const t = this.trackingEvents.get(e);
+    if (!t) {
+      this.log(`No tracking URLs for event: ${e}`);
+      return;
+    }
+    for (const s of t) {
+      const a = `${e}:${s.url}`;
+      if (r && this.firedEvents.has(a)) {
+        this.log(`Skipping duplicate event: ${e}`);
+        continue;
+      }
+      const n = m(s.url, this.macroContext);
+      this.firePixel(n), r && this.firedEvents.add(a);
+    }
+  }
+  /**
+   * Fire a single tracking pixel (fire-and-forget)
+   * Uses sendBeacon when available, falls back to fetch with keepalive
+   */
+  firePixel(e) {
+    const r = y();
+    this.log(`Firing pixel: ${e}`);
+    try {
+      if (r.capabilities.sendBeacon && navigator.sendBeacon(e))
+        return;
+      if (r.capabilities.fetchKeepalive) {
+        fetch(e, {
+          method: "GET",
+          keepalive: !0,
+          mode: "no-cors",
+          credentials: "omit"
+        }).catch(() => {
+        });
+        return;
+      }
+      this.fireImageBeacon(e);
+    } catch {
+      this.log(`Failed to fire pixel: ${e}`);
+    }
+  }
+  /**
+   * Image beacon fallback
+   */
+  fireImageBeacon(e) {
+    const r = new Image(1, 1);
+    r.src = e;
+  }
+  /**
+   * Fire impression pixels
+   * @param impressionUrls - Array of impression URLs
+   */
+  fireImpressions(e) {
+    for (const r of e) {
+      const t = m(r, this.macroContext);
+      this.firePixel(t);
+    }
+  }
+  /**
+   * Fire error tracking with error code
+   * @param errorUrls - Array of error tracking URLs
+   * @param errorCode - VAST error code
+   */
+  fireError(e, r) {
+    const t = { ...this.macroContext, errorCode: r };
+    for (const s of e) {
+      const a = m(s, t);
+      this.firePixel(a);
+    }
+  }
+  /**
+   * Reset fired events (for replay scenarios)
+   */
+  reset() {
+    this.firedEvents.clear();
+  }
+  /**
+   * Debug logging
+   */
+  log(e) {
+    this.config.debug && console.log(`[AdTracker] ${e}`);
+  }
+}
+const I = {
+  targetBitrate: 2500,
+  maxWrapperDepth: 5,
+  timeout: 1e4,
+  debug: !1,
+  skipButtonText: "Skip Ad"
+};
+class N {
+  constructor(e) {
+    l(this, "config");
+    l(this, "platform");
+    l(this, "parser");
+    l(this, "videoElement", null);
+    l(this, "overlayElement", null);
+    l(this, "skipButtonElement", null);
+    l(this, "tracker", null);
+    l(this, "state");
+    l(this, "ads", []);
+    l(this, "listeners", /* @__PURE__ */ new Set());
+    l(this, "quartilesFired", /* @__PURE__ */ new Set());
+    l(this, "boundKeyHandler", null);
+    l(this, "focusTrap", null);
+    if (this.config = { ...I, ...e }, !this.config.container)
+      throw new Error("Container element is required");
+    this.platform = y(), this.parser = new A({
+      maxWrapperDepth: this.config.maxWrapperDepth,
+      timeout: this.config.timeout,
+      debug: this.config.debug
+    }), this.state = {
+      status: d.Idle,
+      currentTime: 0,
+      duration: 0,
+      muted: !0,
+      volume: 1,
+      canSkip: !1,
+      skipCountdown: 0,
+      mediaFile: null,
+      error: null
+    }, this.platform.platform === "tizen" && this.platform.registerTizenKeys();
+  }
+  /**
+   * Initialize the SDK: fetch VAST, create video element, attempt autoplay
+   */
+  async init() {
+    var e, r;
+    if (!this.config.container)
+      throw new Error("Container element not found");
+    this.updateState({ status: d.Loading });
+    try {
+      const t = await this.parser.parse(this.config.vastUrl);
+      if (!t.success || !t.response)
+        throw this.createError(
+          ((e = t.error) == null ? void 0 : e.code) || u.NO_VAST_RESPONSE,
+          ((r = t.error) == null ? void 0 : r.message) || "Failed to parse VAST"
+        );
+      if (this.ads = t.response.ads, this.ads.length === 0)
+        throw this.createError(
+          u.NO_VAST_RESPONSE,
+          "No ads in VAST response"
+        );
+      const s = this.getFirstLinearCreative();
+      if (!s)
+        throw this.createError(
+          u.GENERAL_LINEAR_ERROR,
+          "No linear creative found"
+        );
+      const a = this.parser.selectBestMediaFile(
+        s.mediaFiles,
+        this.config.targetBitrate
+      );
+      if (!a)
+        throw this.createError(
+          u.FILE_NOT_FOUND,
+          "No suitable media file found"
+        );
+      this.updateState({ mediaFile: a });
+      const n = this.parser.aggregateTrackingEvents(this.ads);
+      this.tracker = new x(n, { debug: this.config.debug }), this.tracker.updateMacroContext({ assetUri: a.url }), this.createVideoElement(a), this.setupFocusManagement(), await this.attemptAutoplay();
+    } catch (t) {
+      const s = t instanceof Error ? this.createError(u.UNDEFINED_ERROR, t.message) : t;
+      this.handleError(s);
+    }
+  }
+  /**
+   * Get the first linear creative from parsed ads
+   */
+  getFirstLinearCreative() {
+    for (const e of this.ads)
+      for (const r of e.creatives)
+        if (r.linear)
+          return r.linear;
+    return null;
+  }
+  /**
+   * Create video element with "Nuclear Mute" strategy
+   * Applies muted, playsinline, autoplay for maximum TV compatibility
+   */
+  createVideoElement(e) {
+    const r = document.createElement("video"), t = this.platform.getVideoAttributes();
+    Object.entries(t).forEach(([s, a]) => {
+      typeof a == "boolean" ? a && r.setAttribute(s, "") : r.setAttribute(s, a);
+    }), r.src = e.url, r.style.cssText = `
+      width: 100%;
+      height: 100%;
+      object-fit: contain;
+      background: #000;
+    `, r.addEventListener("loadedmetadata", () => {
+      this.updateState({
+        duration: r.duration,
+        status: d.Ready
+      }), this.emit({ type: "loaded" });
+    }), r.addEventListener("timeupdate", () => {
+      this.handleTimeUpdate(r);
+    }), r.addEventListener("ended", () => {
+      this.handleComplete();
+    }), r.addEventListener("error", () => {
+      const s = r.error;
+      this.handleError(
+        this.createError(
+          u.MEDIA_NOT_SUPPORTED,
+          (s == null ? void 0 : s.message) || "Video playback error"
+        )
+      );
+    }), r.addEventListener("play", () => {
+      this.updateState({ status: d.Playing });
+    }), r.addEventListener("pause", () => {
+      var s;
+      this.state.status !== d.Completed && (this.updateState({ status: d.Paused }), this.emit({ type: "pause" }), (s = this.tracker) == null || s.track("pause"));
+    }), this.config.container.appendChild(r), this.videoElement = r, this.log(`Video element created with src: ${e.url}`);
+  }
+  /**
+   * Attempt autoplay with soft-fail handling
+   * If play() rejects (common on TVs), show interactive overlay
+   */
+  async attemptAutoplay() {
+    if (this.videoElement)
+      try {
+        await this.videoElement.play(), this.handlePlaybackStart();
+      } catch (e) {
+        this.log(`Autoplay failed: ${e}`), this.showStartOverlay();
+      }
+  }
+  /**
+   * Show interactive overlay for manual ad start (autoplay fallback)
+   */
+  showStartOverlay() {
+    if (this.updateState({ status: d.WaitingForInteraction }), this.config.customStartOverlay) {
+      this.overlayElement = this.config.customStartOverlay, this.config.container.appendChild(this.overlayElement);
+      return;
+    }
+    const e = document.createElement("div");
+    e.innerHTML = `
+      <div style="
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        background: rgba(0, 0, 0, 0.7);
+        z-index: 100;
+      ">
+        <button id="adgent-start-btn" style="
+          padding: 20px 40px;
+          font-size: 24px;
+          background: #fff;
+          color: #000;
+          border: none;
+          border-radius: 8px;
+          cursor: pointer;
+          font-weight: bold;
+        ">
+          ▶ Start Ad
+        </button>
+      </div>
+    `, e.style.cssText = "position: absolute; top: 0; left: 0; width: 100%; height: 100%;";
+    const r = e.querySelector("#adgent-start-btn");
+    r == null || r.addEventListener("click", () => this.onStartClick()), this.config.container.style.position = "relative", this.config.container.appendChild(e), this.overlayElement = e, r == null || r.focus();
+  }
+  /**
+   * Handle start button click (from overlay)
+   */
+  async onStartClick() {
+    if (this.removeOverlay(), this.videoElement)
+      try {
+        await this.videoElement.play(), this.handlePlaybackStart();
+      } catch (e) {
+        this.handleError(
+          this.createError(
+            u.GENERAL_LINEAR_ERROR,
+            `Playback failed: ${e}`
+          )
+        );
+      }
+  }
+  /**
+   * Remove the start overlay
+   */
+  removeOverlay() {
+    this.overlayElement && (this.overlayElement.remove(), this.overlayElement = null);
+  }
+  /**
+   * Handle successful playback start
+   */
+  handlePlaybackStart() {
+    var r, t, s, a, n;
+    this.updateState({ status: d.Playing }), this.emit({ type: "start" }), (t = (r = this.config).onStart) == null || t.call(r);
+    const e = this.parser.aggregateImpressions(this.ads);
+    (s = this.tracker) == null || s.fireImpressions(e), (a = this.tracker) == null || a.track("start"), (n = this.tracker) == null || n.track("creativeView"), this.setupSkipButton(), this.log("Playback started");
+  }
+  /**
+   * Handle time updates for progress tracking
+   */
+  handleTimeUpdate(e) {
+    var h, p, f;
+    const r = e.currentTime, t = e.duration;
+    if (!t || isNaN(t)) return;
+    const s = r / t * 100, a = this.calculateQuartile(s);
+    this.updateState({
+      currentTime: r,
+      duration: t
+    }), this.updateSkipCountdown(r), (h = this.tracker) == null || h.updateMacroContext({ adPlayhead: r });
+    const n = {
+      currentTime: r,
+      duration: t,
+      percentage: s,
+      quartile: a
+    };
+    this.emit({ type: "progress", data: n }), (f = (p = this.config).onProgress) == null || f.call(p, n), this.fireQuartileEvents(s);
+  }
+  /**
+   * Calculate current quartile (0-4)
+   */
+  calculateQuartile(e) {
+    return e >= 100 ? 4 : e >= 75 ? 3 : e >= 50 ? 2 : e >= 25 ? 1 : 0;
+  }
+  /**
+   * Fire quartile tracking events
+   */
+  fireQuartileEvents(e) {
+    var t;
+    const r = [
+      { threshold: 25, event: "firstQuartile" },
+      { threshold: 50, event: "midpoint" },
+      { threshold: 75, event: "thirdQuartile" }
+    ];
+    for (const { threshold: s, event: a } of r)
+      e >= s && !this.quartilesFired.has(s) && (this.quartilesFired.add(s), (t = this.tracker) == null || t.track(a), this.emit({ type: "quartile", data: { quartile: a } }), this.log(`Quartile fired: ${a}`));
+  }
+  /**
+   * Set up skip button
+   */
+  setupSkipButton() {
+    const e = this.getFirstLinearCreative(), r = this.config.skipOffset ?? (e == null ? void 0 : e.skipOffset);
+    if (!r || r <= 0)
+      return;
+    this.updateState({ skipCountdown: r, canSkip: !1 });
+    const t = document.createElement("button");
+    t.id = "adgent-skip-btn", t.style.cssText = `
+      position: absolute;
+      bottom: 20px;
+      right: 20px;
+      padding: 12px 24px;
+      font-size: 16px;
+      background: rgba(0, 0, 0, 0.7);
+      color: #fff;
+      border: 2px solid #fff;
+      border-radius: 4px;
+      cursor: pointer;
+      z-index: 101;
+      transition: opacity 0.3s;
+    `, t.textContent = `Skip in ${r}s`, t.addEventListener("click", () => this.skip()), this.config.container.appendChild(t), this.skipButtonElement = t;
+  }
+  /**
+   * Update skip countdown
+   */
+  updateSkipCountdown(e) {
+    const r = this.getFirstLinearCreative(), t = this.config.skipOffset ?? (r == null ? void 0 : r.skipOffset);
+    if (!t || !this.skipButtonElement) return;
+    const s = Math.max(0, t - e);
+    this.updateState({ skipCountdown: s }), s <= 0 && !this.state.canSkip ? (this.updateState({ canSkip: !0 }), this.skipButtonElement.textContent = this.config.skipButtonText, this.skipButtonElement.style.opacity = "1") : s > 0 && (this.skipButtonElement.textContent = `Skip in ${Math.ceil(s)}s`, this.skipButtonElement.style.opacity = "0.6");
+  }
+  /**
+   * Skip the ad
+   */
+  skip() {
+    var e, r, t;
+    if (!this.state.canSkip) {
+      this.log("Skip not available yet");
+      return;
+    }
+    (e = this.tracker) == null || e.track("skip"), this.emit({ type: "skip" }), (t = (r = this.config).onSkip) == null || t.call(r), this.destroy(), this.log("Ad skipped");
+  }
+  /**
+   * Handle ad completion
+   */
+  handleComplete() {
+    var e, r, t;
+    this.updateState({ status: d.Completed }), (e = this.tracker) == null || e.track("complete"), this.emit({ type: "complete" }), (t = (r = this.config).onComplete) == null || t.call(r), this.log("Ad completed");
+  }
+  /**
+   * Handle errors with recovery attempt or callback
+   */
+  handleError(e) {
+    var t, s, a;
+    this.updateState({
+      status: d.Error,
+      error: e
+    });
+    const r = [];
+    for (const n of this.ads)
+      r.push(...n.errors);
+    (t = this.tracker) == null || t.fireError(r, e.code), this.emit({ type: "error", data: e }), (a = (s = this.config).onError) == null || a.call(s, e), this.log(`Error: ${e.message}`);
+  }
+  /**
+   * Set up focus management to capture remote keys
+   */
+  setupFocusManagement() {
+    this.focusTrap = document.createElement("div"), this.focusTrap.tabIndex = 0, this.focusTrap.style.cssText = "position: absolute; opacity: 0; width: 0; height: 0;", this.config.container.appendChild(this.focusTrap), this.focusTrap.focus(), this.boundKeyHandler = (e) => {
+      const r = this.platform.normalizeKeyCode(e.keyCode);
+      r && (e.preventDefault(), e.stopPropagation(), this.handleKeyAction(r));
+    }, document.addEventListener("keydown", this.boundKeyHandler, !0);
+  }
+  /**
+   * Handle key actions from remote control
+   */
+  handleKeyAction(e) {
+    var r, t;
+    switch (this.log(`Key action: ${e}`), e) {
+      case c.Enter:
+        this.state.status === d.WaitingForInteraction ? this.onStartClick() : this.state.canSkip && this.skip();
+        break;
+      case c.Back:
+        this.log("Back pressed - ignoring during ad");
+        break;
+      case c.Play:
+        (r = this.videoElement) == null || r.play();
+        break;
+      case c.Pause:
+        (t = this.videoElement) == null || t.pause();
+        break;
+      case c.Left:
+      case c.Right:
+      case c.Up:
+      case c.Down:
+        break;
+    }
+  }
+  /**
+   * Unmute video (call after playback starts if needed)
+   */
+  unmute() {
+    var e;
+    this.videoElement && (this.videoElement.muted = !1, this.updateState({ muted: !1 }), (e = this.tracker) == null || e.track("unmute"), this.emit({ type: "unmute" }));
+  }
+  /**
+   * Mute video
+   */
+  mute() {
+    var e;
+    this.videoElement && (this.videoElement.muted = !0, this.updateState({ muted: !0 }), (e = this.tracker) == null || e.track("mute"), this.emit({ type: "mute" }));
+  }
+  /**
+   * Add event listener
+   */
+  on(e) {
+    return this.listeners.add(e), () => this.listeners.delete(e);
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Clean up all resources
+   */
+  destroy() {
+    var e, r, t, s, a;
+    this.boundKeyHandler && (document.removeEventListener("keydown", this.boundKeyHandler, !0), this.boundKeyHandler = null), (e = this.videoElement) == null || e.remove(), (r = this.overlayElement) == null || r.remove(), (t = this.skipButtonElement) == null || t.remove(), (s = this.focusTrap) == null || s.remove(), this.videoElement = null, this.overlayElement = null, this.skipButtonElement = null, this.focusTrap = null, (a = this.tracker) == null || a.reset(), this.quartilesFired.clear(), this.listeners.clear(), this.ads = [], this.emit({ type: "destroy" }), this.log("Player destroyed");
+  }
+  /**
+   * Update internal state
+   */
+  updateState(e) {
+    this.state = { ...this.state, ...e };
+  }
+  /**
+   * Emit event to listeners
+   */
+  emit(e) {
+    for (const r of this.listeners)
+      try {
+        r(e);
+      } catch (t) {
+        this.log(`Listener error: ${t}`);
+      }
+  }
+  /**
+   * Create error object
+   */
+  createError(e, r, t = !1) {
+    return { code: e, message: r, recoverable: t };
+  }
+  /**
+   * Debug logging
+   */
+  log(e) {
+    this.config.debug && console.log(`[AdPlayer] ${e}`);
+  }
+}
+export {
+  N as AdPlayer,
+  x as AdTracker,
+  N as AdgentSDK,
+  _ as DEFAULT_KEY_CODES,
+  c as KeyAction,
+  P as PLATFORM_DETECTION_PATTERNS,
+  o as Platform,
+  O as PlatformAdapter,
+  d as PlaybackStatus,
+  u as VASTErrorCode,
+  A as VASTParser,
+  y as getPlatformAdapter,
+  m as replaceMacros
+};