livefootballtv-tizen 1.0.0

package/app/app-es5.js

@@ -0,0 +1,1976 @@
+// app-es5.js – ES5 Compatible Version for Tizen TV
+// Uses local proxy for merichunidya.com streams (requires proxy running)
+var BASE_URL = "http://api.fksoftapi.com/app2/";
+var API_KEY = "cda11NiPOYcy8KrpZs0w6dD9fbE4JzT32BtIeUQjuARoFxMX1C";
+var AES_KEY = "1g2j4d5rb56s39wc";
+var AES_IV = "g4fst5gpd5f5r7j4";
+
+// PROXY CONFIGURATION
+// Set this to your local proxy address (or remote CORS proxy)
+// For testing: run 'node local_proxy.js' and set to 'http://localhost:8888'
+// For production: use a remote CORS proxy or set to '' to disable
+var PROXY_URL = 'http://localhost:8888';  // Change this as needed
+
+// Domains that require proxy due to Referer header restrictions
+var PROXY_DOMAINS = ['merichunidya.com', 'vividmosaica.com'];
+
+/**
+ * Check if a URL needs to go through the proxy
+ */
+function needsProxy(url) {
+  if (!PROXY_URL || !url) return false;
+  for (var i = 0; i < PROXY_DOMAINS.length; i++) {
+    if (url.indexOf(PROXY_DOMAINS[i]) > -1) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Wrap a URL with the proxy if needed
+ */
+function wrapWithProxy(url) {
+  if (!needsProxy(url)) return url;
+  console.log('[PROXY] Wrapping URL:', url.substring(0, 60) + '...');
+  return PROXY_URL + '/proxy?url=' + encodeURIComponent(url);
+}
+
+
+// --- Polyfills ---
+if (!window.Promise) {
+  window.Promise = function (executor) {
+    var self = this;
+    self.callbacks = [];
+    self.state = 'pending';
+    self.value = null;
+    function resolve(value) {
+      if (self.state !== 'pending') return;
+      self.state = 'fulfilled';
+      self.value = value;
+      self.callbacks.forEach(function (cb) { cb.onResolved(value); });
+    }
+    function reject(reason) {
+      if (self.state !== 'pending') return;
+      self.state = 'rejected';
+      self.value = reason;
+      self.callbacks.forEach(function (cb) { cb.onRejected(reason); });
+    }
+    try { executor(resolve, reject); } catch (e) { reject(e); }
+  };
+  window.Promise.prototype.then = function (onResolved, onRejected) {
+    var self = this;
+    return new Promise(function (resolve, reject) {
+      function handle(cb, val) {
+        try {
+          var res = cb ? cb(val) : val;
+          if (res && typeof res.then === 'function') res.then(resolve, reject);
+          else resolve(res);
+        } catch (e) { reject(e); }
+      }
+      if (self.state === 'pending') {
+        self.callbacks.push({
+          onResolved: function (v) { handle(onResolved, v); },
+          onRejected: function (r) { handle(onRejected || function (e) { throw e; }, r); }
+        });
+      } else if (self.state === 'fulfilled') {
+        setTimeout(function () { handle(onResolved, self.value); }, 0);
+      } else {
+        setTimeout(function () { handle(onRejected || function (e) { throw e; }, self.value); }, 0);
+      }
+    });
+  };
+  window.Promise.prototype.catch = function (onRejected) {
+    return this.then(null, onRejected);
+  };
+  window.Promise.resolve = function (v) { return new Promise(function (r) { r(v); }); };
+  window.Promise.reject = function (v) { return new Promise(function (r, j) { j(v); }); };
+}
+
+// --- Platform Detection ---
+function isTizen() {
+  return typeof tizen !== 'undefined' || (navigator.userAgent && navigator.userAgent.indexOf('Tizen') > -1);
+}
+
+// --- Log Level Setting (0=none, 1=error, 2=full) ---
+var logLevel = parseInt(localStorage.getItem('logLevel') || '0', 10);  // Default: none
+
+// Create debug overlay (hidden by default)
+var debugEl = document.createElement('div');
+debugEl.style.cssText = "position:fixed;bottom:0;left:0;width:100%;height:100px;background:rgba(0,0,0,0.7);color:#0f0;font-size:12px;overflow-y:scroll;z-index:9999;pointer-events:none;display:none;";
+document.body.appendChild(debugEl);
+
+function log(msg) {
+  if (logLevel < 2) return;  // Only show on "full" level
+  console.log(msg);
+  var line = document.createElement('div');
+  line.textContent = "> " + msg;
+  debugEl.appendChild(line);
+  debugEl.scrollTop = debugEl.scrollHeight;
+  debugEl.style.display = 'block';
+}
+
+function error(msg) {
+  if (logLevel < 1) return;  // Only show on "error" or "full" level
+  console.error(msg);
+  var line = document.createElement('div');
+  line.style.color = 'red';
+  line.textContent = "ERR: " + msg;
+  debugEl.appendChild(line);
+  debugEl.scrollTop = debugEl.scrollHeight;
+  debugEl.style.display = 'block';
+}
+
+// User-facing error overlay (dismissible)
+var playerErrorOverlay = null;
+
+function showPlayerError(msg) {
+  if (!playerErrorOverlay) {
+    playerErrorOverlay = document.createElement('div');
+    playerErrorOverlay.id = 'playerErrorOverlay';
+    playerErrorOverlay.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(0,0,0,0.9);display:flex;flex-direction:column;justify-content:center;align-items:center;z-index:5000;';
+
+    var msgEl = document.createElement('div');
+    msgEl.id = 'playerErrorMsg';
+    msgEl.style.cssText = 'color:#ff6b6b;font-size:28px;margin-bottom:30px;text-align:center;padding:20px;';
+    playerErrorOverlay.appendChild(msgEl);
+
+    var okBtn = document.createElement('button');
+    okBtn.id = 'playerErrorOkBtn';
+    okBtn.textContent = 'OK';
+    okBtn.tabIndex = 0;
+    okBtn.style.cssText = 'font-size:24px;padding:15px 60px;background:#3ea6ff;color:#000;border:none;border-radius:8px;cursor:pointer;';
+    okBtn.onfocus = function () { this.style.outline = '4px solid #fff'; };
+    okBtn.onblur = function () { this.style.outline = 'none'; };
+    okBtn.onclick = function () { hidePlayerError(); };
+    playerErrorOverlay.appendChild(okBtn);
+
+    document.body.appendChild(playerErrorOverlay);
+  }
+
+  var msgEl = document.getElementById('playerErrorMsg');
+  if (msgEl) msgEl.textContent = msg;
+
+  playerErrorOverlay.style.display = 'flex';
+
+  // Focus OK button for D-pad navigation
+  setTimeout(function () {
+    var okBtn = document.getElementById('playerErrorOkBtn');
+    if (okBtn) okBtn.focus();
+  }, 100);
+}
+
+function hidePlayerError() {
+  if (playerErrorOverlay) {
+    playerErrorOverlay.style.display = 'none';
+  }
+}
+
+function setLogLevel(level) {
+  logLevel = level;
+  localStorage.setItem('logLevel', String(level));
+  debugEl.style.display = level > 0 ? 'block' : 'none';
+  if (level === 0) debugEl.innerHTML = '';
+}
+
+// --- Settings UI ---
+document.addEventListener('DOMContentLoaded', function () {
+  var settingsBtn = document.getElementById('settingsBtn');
+  var settingsDropdown = document.getElementById('settingsDropdown');
+  var logLevelSelect = document.getElementById('logLevelSelect');
+
+  if (settingsBtn && settingsDropdown) {
+    // Set initial value from localStorage
+    if (logLevelSelect) {
+      logLevelSelect.value = String(logLevel);
+    }
+
+    // Toggle dropdown on button click
+    settingsBtn.onclick = function (e) {
+      e.stopPropagation();
+      var isOpen = settingsDropdown.style.display === 'block';
+      settingsDropdown.style.display = isOpen ? 'none' : 'block';
+    };
+
+    // Handle log level change
+    if (logLevelSelect) {
+      logLevelSelect.onchange = function () {
+        setLogLevel(parseInt(logLevelSelect.value, 10));
+      };
+    }
+
+    // Close dropdown when clicking outside
+    document.addEventListener('click', function (e) {
+      if (!settingsDropdown.contains(e.target) && e.target !== settingsBtn) {
+        settingsDropdown.style.display = 'none';
+      }
+    });
+  }
+});
+
+// --- App Logic ---
+
+function showLoader() {
+  var loader = document.getElementById('loader');
+  if (loader) {
+    loader.hidden = false;
+    loader.setAttribute('aria-hidden', 'false');
+  }
+}
+
+function hideLoader() {
+  var loader = document.getElementById('loader');
+  if (loader) {
+    loader.hidden = true;
+    loader.setAttribute('aria-hidden', 'true');
+  }
+}
+
+function decryptAES(hexString) {
+  try {
+    var ciphertext = CryptoJS.enc.Hex.parse(hexString);
+    var key = CryptoJS.enc.Utf8.parse(AES_KEY);
+    var iv = CryptoJS.enc.Utf8.parse(AES_IV);
+    var decrypted = CryptoJS.AES.decrypt(
+      { ciphertext: ciphertext },
+      key,
+      { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.NoPadding }
+    );
+    return decrypted.toString(CryptoJS.enc.Utf8).replace(/\0+$/, '');
+  } catch (e) {
+    error("Decryption error: " + e.message);
+    return null;
+  }
+}
+
+function decryptUrl(enc) {
+  if (enc.indexOf('http://') === 0 || enc.indexOf('https://') === 0) return enc;
+  return decryptAES(enc) || enc;
+}
+
+// Decrypt binary data (ArrayBuffer) -> String
+function decryptAESBinary(arrayBuffer) {
+  try {
+    var u8 = new Uint8Array(arrayBuffer);
+    var words = [];
+    for (var i = 0; i < u8.length; i += 4) {
+      words.push(
+        (u8[i] << 24) | (u8[i + 1] << 16) | (u8[i + 2] << 8) | (u8[i + 3])
+      );
+    }
+    var ciphertext = CryptoJS.lib.WordArray.create(words, u8.length);
+    var key = CryptoJS.enc.Utf8.parse(AES_KEY);
+    var iv = CryptoJS.enc.Utf8.parse(AES_IV);
+    var decrypted = CryptoJS.AES.decrypt(
+      { ciphertext: ciphertext },
+      key,
+      { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 }
+    );
+    return decrypted.toString(CryptoJS.enc.Utf8);
+  } catch (e) {
+    error("Binary decryption error: " + e.message);
+    return null;
+  }
+}
+
+// Decrypt video segment (ArrayBuffer) -> ArrayBuffer
+// Used for encrypted ZIP/CSS/HTML files in M3U8 manifests
+function decryptSegmentBinary(arrayBuffer, customKey, customIv) {
+  try {
+    log("Decrypting segment (" + arrayBuffer.byteLength + " bytes)");
+
+    var u8 = new Uint8Array(arrayBuffer);
+    var words = [];
+    for (var i = 0; i < u8.length; i += 4) {
+      words.push(
+        (u8[i] << 24) | (u8[i + 1] << 16) | (u8[i + 2] << 8) | (u8[i + 3])
+      );
+    }
+    var ciphertext = CryptoJS.lib.WordArray.create(words, u8.length);
+
+    // Use custom key/iv if provided, otherwise use defaults
+    var key = customKey ? customKey : CryptoJS.enc.Utf8.parse(AES_KEY);
+    var iv = customIv ? customIv : CryptoJS.enc.Utf8.parse(AES_IV);
+
+    var decrypted = CryptoJS.AES.decrypt(
+      { ciphertext: ciphertext },
+      key,
+      { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 }
+    );
+
+    // Convert WordArray back to ArrayBuffer
+    var decryptedWords = decrypted.words;
+    var decryptedSigBytes = decrypted.sigBytes;
+    var decryptedU8 = new Uint8Array(decryptedSigBytes);
+
+    for (var i = 0; i < decryptedSigBytes; i++) {
+      decryptedU8[i] = (decryptedWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+    }
+
+    log("Decrypted successfully (" + decryptedU8.byteLength + " bytes)");
+    return decryptedU8.buffer;
+  } catch (e) {
+    error("Segment decryption error: " + e.message);
+    return null;
+  }
+}
+
+// Encryption key cache for M3U8 segments
+var encryptionKeyCache = {};
+var currentEncryptionKey = null;
+var currentEncryptionIv = null;
+
+// Fetch and cache encryption key from URI
+function fetchEncryptionKey(keyUri, baseUrl) {
+  var absoluteUri;
+  try {
+    absoluteUri = new URL(keyUri, baseUrl).href;
+  } catch (e) {
+    absoluteUri = keyUri;
+  }
+
+  // Check cache first
+  if (encryptionKeyCache[absoluteUri]) {
+    log("Using cached encryption key");
+    return Promise.resolve(encryptionKeyCache[absoluteUri]);
+  }
+
+  log("Fetching encryption key from: " + absoluteUri);
+
+  return smartFetch(absoluteUri, { responseType: 'arraybuffer' })
+    .then(function (result) {
+      // Convert ArrayBuffer to WordArray for CryptoJS
+      var keyData = result.data;
+      var u8 = new Uint8Array(keyData);
+      var words = [];
+      for (var i = 0; i < u8.length; i += 4) {
+        words.push(
+          (u8[i] << 24) | (u8[i + 1] << 16) | (u8[i + 2] << 8) | (u8[i + 3])
+        );
+      }
+      var keyWordArray = CryptoJS.lib.WordArray.create(words, u8.length);
+
+      encryptionKeyCache[absoluteUri] = keyWordArray;
+      log("Encryption key cached (" + u8.length + " bytes)");
+      return keyWordArray;
+    })
+    .catch(function (err) {
+      error("Failed to fetch encryption key: " + err.message);
+      // Fallback to default AES key
+      log("Using default AES key as fallback");
+      var fallbackKey = CryptoJS.enc.Utf8.parse(AES_KEY);
+      encryptionKeyCache[absoluteUri] = fallbackKey;
+      return fallbackKey;
+    });
+}
+
+var categoryListEl = document.getElementById("categoryList");
+var contentAreaEl = document.getElementById("contentArea");
+
+var state = {
+  categories: [],
+  currentCategoryId: null,
+  posts: [],
+  page: 1
+};
+
+// Hybrid Fetch - returns {text/data, finalUrl} to capture redirects
+// Uses XHR when running from file:// origin (Tizen packaged app) for better compatibility
+function smartFetch(url, options) {
+  options = options || {};
+  return new Promise(function (resolve, reject) {
+    var timeout = 15000;
+    var timer = setTimeout(function () {
+      reject(new Error("Timeout"));
+    }, timeout);
+
+    // For Tizen apps (file:// or packaged), use XHR which has no CORS restrictions
+    var isLocalOrigin = !window.location.origin || window.location.origin === 'null' ||
+      window.location.protocol === 'file:';
+
+    if (window.fetch && !isLocalOrigin) {
+      // For JSON/PHP URLs that might return 301 redirects with Location header,
+      // we follow redirects but handle errors specially to extract the redirect URL
+      var mightRedirect = url.indexOf('.json') > -1 || url.indexOf('.php') > -1;
+      var fetchOpts = {
+        method: 'GET'
+      };
+
+      // For CDN URLs, try to set appropriate referrer
+      // Note: browsers may ignore this for cross-origin requests
+      if (url.indexOf('merichunidya.com') > -1 || url.indexOf('techtuner') > -1 || url.indexOf('vividmosaica') > -1) {
+        fetchOpts.referrer = 'https://vividmosaica.com/';
+        fetchOpts.referrerPolicy = 'no-referrer-when-downgrade';
+      }
+
+      var finalUrl = url;
+
+      log("smartFetch: " + url);
+
+      window.fetch(url, fetchOpts)
+        .then(function (res) {
+          clearTimeout(timer);
+
+          finalUrl = res.url || url;  // Capture final URL after redirects
+          log("smartFetch response: status=" + res.status + " finalUrl=" + finalUrl);
+
+          // Special handling: if we followed a redirect to m3u8 but got 403,
+          // return the URL anyway - the player might handle it differently
+          if (!res.ok && mightRedirect && finalUrl.indexOf('.m3u8') > -1) {
+            log("Got " + res.status + " after redirect to M3U8. Returning URL for player to handle.");
+            return { text: '', finalUrl: finalUrl, status: res.status };
+          }
+
+          if (!res.ok) throw new Error("Status " + res.status);
+
+          if (options.responseType === 'arraybuffer') {
+            return res.arrayBuffer().then(function (data) {
+              return { data: data, finalUrl: finalUrl };
+            });
+          }
+          return res.text().then(function (text) {
+            return { text: text, finalUrl: finalUrl };
+          });
+        })
+        .then(resolve)
+        .catch(function (e) {
+          clearTimeout(timer);
+          log("smartFetch error: " + e.message);
+          reject(e);
+        });
+    } else {
+      var xhr = new XMLHttpRequest();
+      xhr.open('GET', url, true);
+      if (options.responseType) xhr.responseType = options.responseType;
+
+      // Add headers for CDN URLs that require them
+      if (url.indexOf('merichunidya.com') > -1 || url.indexOf('vividmosaica') > -1) {
+        try {
+          xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+        } catch (e) { /* ignore */ }
+      }
+
+      xhr.onreadystatechange = function () {
+        if (xhr.readyState === 4) {
+          clearTimeout(timer);
+          var finalUrl = xhr.responseURL || url;
+
+          // Handle successful response
+          if (xhr.status >= 200 && xhr.status < 300) {
+            if (options.responseType === 'arraybuffer') {
+              resolve({ data: xhr.response, finalUrl: finalUrl });
+            } else {
+              resolve({ text: xhr.response || xhr.responseText, finalUrl: finalUrl });
+            }
+          }
+          // Handle 403 on redirect URLs - still return the final URL for the player to handle
+          else if (xhr.status === 403 && finalUrl.indexOf('.m3u8') > -1) {
+            log('XHR 403 on M3U8 redirect, returning URL for player');
+            resolve({ text: '', finalUrl: finalUrl, status: 403 });
+          }
+          else {
+            reject(new Error('XHR Status ' + xhr.status));
+          }
+        }
+      };
+      xhr.onerror = function () {
+        clearTimeout(timer);
+        reject(new Error('XHR Network Error'));
+      };
+      xhr.send();
+    }
+  });
+}
+
+function apiFetch(endpoint, params) {
+  params = params || {};
+  showLoader();
+  log("Fetching " + endpoint);
+
+  var targetUrl = BASE_URL + endpoint + '?api_key=' + API_KEY;
+  for (var k in params) {
+    if (params.hasOwnProperty(k)) {
+      targetUrl += '&' + k + '=' + params[k];
+    }
+  }
+
+  return smartFetch(targetUrl)
+    .then(function (result) {
+      hideLoader();
+      return JSON.parse(result.text);
+    })
+    .catch(function (e) {
+      hideLoader();
+      error("Fetch failed: " + e.message);
+      return Promise.reject(e);
+    });
+}
+
+function loadCategories() {
+  apiFetch("api/get_category_index/").then(function (data) {
+    if (data.categories2) {
+      var decrypted = decryptAES(data.categories2);
+      var parsed = JSON.parse(decrypted);
+      state.categories = Array.isArray(parsed) ? parsed : (parsed.categories || []);
+    } else if (data.categories) {
+      state.categories = data.categories;
+    } else {
+      state.categories = [];
+    }
+    log("Loaded " + state.categories.length + " categories");
+    renderCategories();
+    if (state.categories.length) {
+      selectCategory(state.categories[0].cid || state.categories[0].id);
+    }
+  }).catch(function (err) {
+    error("Load categories fatal: " + err.message);
+  });
+}
+
+function renderCategories() {
+  categoryListEl.innerHTML = "";
+  state.categories.forEach(function (cat) {
+    var div = document.createElement("div");
+    div.className = "category";
+
+    if (cat.category_image) {
+      var img = document.createElement("img");
+      img.src = cat.category_image;
+      div.appendChild(img);
+    }
+
+    var nameSpan = document.createElement("span");
+    nameSpan.textContent = cat.category_name || cat.title || cat.name || "Category";
+    div.appendChild(nameSpan);
+
+    var id = cat.cid || cat.id;
+    div.dataset.id = id;
+    div.tabIndex = 0;
+
+    div.onclick = function () { selectCategory(id); };
+    // Note: Enter key is handled by navigation.js which calls click()
+
+    categoryListEl.appendChild(div);
+  });
+}
+
+function selectCategory(catId) {
+  state.currentCategoryId = catId;
+  state.page = 1;
+
+  var cats = document.querySelectorAll('.category');
+  for (var i = 0; i < cats.length; i++) {
+    cats[i].classList.toggle('active', cats[i].dataset.id == catId);
+  }
+
+  if (window.innerWidth <= 768) {
+    categoryListEl.classList.add('hidden-mobile');
+    contentAreaEl.classList.remove('hidden-mobile');
+  }
+
+  loadPosts();
+}
+
+function loadPosts() {
+  if (!state.currentCategoryId) return;
+
+  var params = { id: state.currentCategoryId, page: state.page, count: 20 };
+
+  apiFetch("api/get_category_posts/", params).then(function (data) {
+    if (data.posts2) {
+      var decrypted = decryptAES(data.posts2);
+      var parsed = JSON.parse(decrypted);
+      state.posts = Array.isArray(parsed) ? parsed : (parsed.posts || []);
+    } else if (data.posts) {
+      state.posts = data.posts;
+    } else {
+      state.posts = [];
+    }
+
+    renderPosts();
+  }).catch(function (err) {
+    error("Load posts failed: " + err.message);
+  });
+}
+
+function renderPosts() {
+  contentAreaEl.innerHTML = "";
+
+  if (window.innerWidth <= 768) {
+    var backBtn = document.createElement("button");
+    backBtn.textContent = "← Back";
+    backBtn.style.cssText = "width:100%;padding:10px;margin-bottom:10px;background:#333;color:#fff;border:none;";
+    backBtn.onclick = function () {
+      categoryListEl.classList.remove('hidden-mobile');
+      contentAreaEl.classList.add('hidden-mobile');
+    };
+    contentAreaEl.appendChild(backBtn);
+  }
+
+  var gridContainer = document.createElement("div");
+  gridContainer.className = "posts-grid";
+
+  state.posts.forEach(function (post, idx) {
+    var div = document.createElement("div");
+    div.className = "post";
+    div.tabIndex = 0;
+
+    var thumbContainer = document.createElement("div");
+    thumbContainer.className = "thumbnail-container";
+
+    var img = document.createElement("img");
+    var imgSrc = post.channel_image || post.thumbnail || post.image || "";
+
+    // Lazy Load
+    img.setAttribute('data-src', imgSrc);
+    img.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"; // Transparent 1x1 GIF
+    img.className = "lazy";
+    img.onerror = function () { this.src = 'https://via.placeholder.com/320x180?text=No+Image'; };
+
+    thumbContainer.appendChild(img);
+    LazyLoader.observe(img);
+
+    var info = document.createElement("div");
+    info.className = "info";
+
+    var title = document.createElement("h3");
+    title.textContent = post.channel_name || post.title || "Untitled";
+
+    info.appendChild(title);
+
+    div.appendChild(thumbContainer);
+    div.appendChild(info);
+
+    div.onclick = function () { openPost(post); };
+    // Note: Enter key is handled by navigation.js which calls click()
+
+    gridContainer.appendChild(div);
+  });
+
+  contentAreaEl.appendChild(gridContainer);
+}
+
+var LazyLoader = (function () {
+  var observer;
+  var isTizenTV = (typeof tizen !== 'undefined') ||
+    (navigator.userAgent && navigator.userAgent.indexOf('Tizen') > -1);
+
+  function init() {
+    // Skip IntersectionObserver on Tizen - it's unreliable on older versions
+    if (!isTizenTV && 'IntersectionObserver' in window) {
+      observer = new IntersectionObserver(function (entries, obs) {
+        entries.forEach(function (entry) {
+          if (entry.isIntersecting) {
+            var img = entry.target;
+            var src = img.getAttribute('data-src');
+            if (src) {
+              img.src = src;
+              img.removeAttribute('data-src');
+              img.classList.remove('lazy');
+            }
+            obs.unobserve(img);
+          }
+        });
+      }, { rootMargin: "200px" });
+    }
+  }
+
+  init();
+
+  return {
+    observe: function (el) {
+      // On Tizen, load images immediately
+      if (isTizenTV || !observer) {
+        var src = el.getAttribute('data-src');
+        if (src) {
+          el.src = src;
+          el.removeAttribute('data-src');
+          el.classList.remove('lazy');
+        }
+      } else {
+        observer.observe(el);
+      }
+    }
+  };
+})();
+
+function isTizen() {
+  var ua = navigator.userAgent;
+  return ua.indexOf('Tizen') > -1 || ua.indexOf('SMART-TV') > -1;
+}
+
+// ========== TECHLYHUB MPD EXTRACTION ==========
+// Detect if URL is a techlyhub embed page (uses embedded Shaka Player with MPD)
+function isTechlyEmbed(url) {
+  return url && (
+    url.indexOf('techlyhub.win') > -1 ||
+    url.indexOf('techlyclub.win') > -1 ||
+    url.indexOf('techlyhub.xyz') > -1 ||
+    url.indexOf('techlyhub.com') > -1
+  );
+}
+
+// Extract MPD URL and DRM info from techlyhub page content
+function extractMpdFromTechly(htmlContent) {
+  var decoded = decodeObfuscatedTechly(htmlContent);
+  if (decoded) {
+    log("Successfully decoded techlyhub script, length: " + decoded.length);
+
+    // Look for the MPD URL variable (format: let VAR = "https://...mpd")
+    var mpdMatch = decoded.match(/let\s+\w+\s*=\s*"(https?:\/\/[^"]+\.mpd)"/);
+    if (mpdMatch) {
+      var mpd = mpdMatch[1];
+      log("Found MPD URL: " + mpd);
+
+      // Also look for ClearKey credentials (format: "keyId:key")
+      var clearkeyMatch = decoded.match(/let\s+\w+\s*=\s*"([0-9a-f]{32}):([0-9a-f]{32})"/);
+      if (clearkeyMatch) {
+        log("Found ClearKey DRM credentials");
+        return {
+          mpd: mpd,
+          clearkey: {
+            keyId: clearkeyMatch[1],
+            key: clearkeyMatch[2]
+          }
+        };
+      }
+
+      return { mpd: mpd };
+    }
+
+    // Fallback: look for any MPD URL in decoded content
+    var anyMpd = decoded.match(/https?:\/\/[^\s"'<>\\]+\.mpd/i);
+    if (anyMpd) {
+      return { mpd: anyMpd[0] };
+    }
+  }
+
+  return null;
+}
+
+// Hunter obfuscation decoder (ES5 compatible)
+// Decodes eval(function(h,u,n,t,e,r){...}("encoded",params)) format
+function decodeObfuscatedTechly(htmlContent) {
+  try {
+    // Extract parameters from the eval pattern
+    var match = htmlContent.match(/eval\(function\s*\(\s*h\s*,\s*u\s*,\s*n\s*,\s*t\s*,\s*e\s*,\s*r\s*\)\s*\{[\s\S]*?\}\s*\(\s*"([^"]+)"\s*,\s*(\d+)\s*,\s*"([^"]+)"\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\)/);
+    if (!match) {
+      log("No Hunter eval pattern found");
+      return null;
+    }
+
+    var h = match[1];  // Encoded string
+    var n = match[3];  // Key string (e.g., "GkcTNOQgK")
+    var t = parseInt(match[4], 10);  // Offset (e.g., 37)
+    var e = parseInt(match[5], 10);  // Base (e.g., 6)
+
+    log("Decoding Hunter obfuscation: encoded=" + h.length + " chars, base=" + e);
+
+    // Character set for base conversion
+    var chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/';
+
+    // Base conversion helper
+    function baseConvert(d, fromBase, toBase) {
+      var fromChars = chars.slice(0, fromBase);
+      var toChars = chars.slice(0, toBase);
+
+      var dArr = d.split('');
+      var j = 0;
+      for (var i = dArr.length - 1; i >= 0; i--) {
+        var pos = fromChars.indexOf(dArr[i]);
+        if (pos !== -1) {
+          j += pos * Math.pow(fromBase, dArr.length - 1 - i);
+        }
+      }
+
+      var k = '';
+      while (j > 0) {
+        k = toChars.charAt(j % toBase) + k;
+        j = Math.floor(j / toBase);
+      }
+      return k || '0';
+    }
+
+    // Decode the encoded string
+    var decoded = '';
+    var i = 0;
+    while (i < h.length) {
+      var s = '';
+      while (i < h.length && h.charAt(i) !== n.charAt(e)) {
+        s += h.charAt(i);
+        i++;
+      }
+      i++;  // Skip the delimiter
+
+      // Replace key characters with their indices
+      for (var j = 0; j < n.length; j++) {
+        s = s.split(n.charAt(j)).join(String(j));
+      }
+
+      // Convert from base e to base 10, subtract offset, get character
+      var charCode = parseInt(baseConvert(s, e, 10), 10) - t;
+      if (charCode > 0 && charCode < 65536) {
+        decoded += String.fromCharCode(charCode);
+      }
+    }
+
+    return decoded;
+  } catch (err) {
+    log("Hunter decode error: " + err.message);
+    return null;
+  }
+}
+// ========== END TECHLYHUB MPD EXTRACTION ==========
+
+function resolveStreamUrl(url) {
+  // Handle techlyhub embed pages - extract MPD and play directly instead of iframe
+  if (isTechlyEmbed(url)) {
+    log("Detected techlyhub embed page, fetching to extract MPD...");
+    return smartFetch(url)
+      .then(function (result) {
+        var extracted = extractMpdFromTechly(result.text);
+        if (extracted && extracted.mpd) {
+          log("Extracted MPD URL from techlyhub: " + extracted.mpd);
+
+          // Return MPD with optional DRM info
+          var response = { url: extracted.mpd };
+          if (extracted.clearkey) {
+            response.clearkey = extracted.clearkey;
+            log("Extracted ClearKey DRM credentials");
+          }
+          return response;
+        }
+        // If we can't extract the MPD, mark it so we know in openPost
+        log("Could not extract MPD from techlyhub page, falling back to iframe");
+        return { url: url, useFallbackIframe: true };
+      })
+      .catch(function (err) {
+        error("Failed to fetch techlyhub page: " + err.message);
+        return { url: url, useFallbackIframe: true };
+      });
+  }
+
+  if (url.indexOf('.json') > -1 || url.indexOf('.php') > -1 || url.indexOf('.js') > -1) {
+    log("Resolving: " + url);
+
+    return smartFetch(url)
+      .then(function (result) {
+        var text = result.text;
+        var finalUrl = result.finalUrl;
+
+        // IMPORTANT: If server redirected to M3U8 URL directly, use that!
+        // This handles viki.json which returns 301 redirect to the actual stream
+        if (finalUrl && finalUrl !== url && finalUrl.indexOf('.m3u8') > -1) {
+          log("Server redirected to M3U8: " + finalUrl);
+          // Wrap with proxy if needed for domains that require Referer header
+          var proxiedUrl = wrapWithProxy(finalUrl);
+          return { url: proxiedUrl };
+        }
+
+
+        try {
+          // Handle JS files that might contain storage.googleapis.com URLs
+          if (url.indexOf('.js') > -1) {
+            // Match https:// or https:\/\/ and allow backslashes in the path for now
+            var match = text.match(/https?:\\?\/\\?\/[a-zA-Z0-9\-\.]*storage\.googleapis\.com[^"'\s]+/);
+            if (match) {
+              var streamUrl = match[0];
+              // Unescape escaped slashes if present
+              streamUrl = streamUrl.replace(/\\\//g, '/');
+              log("Found Google Storage URL in JS: " + streamUrl);
+              return { url: streamUrl };
+            }
+          }
+
+          var data = JSON.parse(text);
+          var stream = data.url || data.stream || data.file || data.source || data.src || data.link || data.hls;
+          if (stream) {
+            log("Found stream in JSON: " + stream);
+
+            if (stream.indexOf('.apk') > -1 || stream.indexOf('.zip') > -1) {
+              log("Detected encrypted stream (.apk/.zip). Downloading...");
+              var apkUrl = stream;
+
+              return smartFetch(apkUrl, { responseType: 'arraybuffer' })
+                .then(function (bufferResult) {
+                  var buffer = bufferResult.data;
+                  log("Downloaded (" + buffer.byteLength + " bytes). Decrypting...");
+                  var decryptedText = decryptAESBinary(buffer);
+                  if (!decryptedText) throw new Error("Decryption returned null");
+
+                  log("Decrypted successfully. Rewriting...");
+                  var rewritten = rewriteM3u8(decryptedText, stream, "");
+                  return { url: "virtual:apk", content: rewritten };
+                });
+            }
+
+            // Wrap with proxy if needed
+            return { url: wrapWithProxy(stream) };
+          }
+        } catch (e) { }
+
+        if (text.indexOf('#EXTM3U') > -1) {
+          log("Found M3U8 text, rewriting...");
+          var rewritten = rewriteM3u8(text, url, "");
+          return { url: "virtual:m3u8", content: rewritten, originalUrl: url };
+        }
+        return { url: url };
+      })
+      .catch(function (err) {
+        error("Resolution failed: " + err.message);
+        return { url: url };
+      });
+  }
+  return Promise.resolve({ url: url });
+}
+
+function rewriteM3u8(text, baseUrl, proxyBase) {
+  var lines = text.split('\n');
+  var newLines = [];
+  var encryptionKeyUri = null;
+  var encryptionIv = null;
+  var hasExtM3u = false;
+
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+
+    // Check if this is the #EXTM3U line
+    if (line.indexOf('#EXTM3U') === 0) {
+      hasExtM3u = true;
+      newLines.push(line);
+      // Add codec hints right after #EXTM3U to help HLS.js know what to expect
+      newLines.push('#EXT-X-INDEPENDENT-SEGMENTS');
+      continue;
+    }
+
+    if (line && line.indexOf('#') !== 0) {
+      try {
+        var absoluteUrl = new URL(line, baseUrl).href;
+        if (proxyBase) {
+          absoluteUrl = proxyBase + encodeURIComponent(absoluteUrl);
+        }
+        line = absoluteUrl;
+      } catch (e) {
+        console.warn("URL resolve error", e);
+      }
+    } else if (line.indexOf('#EXT-X-KEY') === 0) {
+      // Extract encryption key info but DON'T add to output manifest
+      // This prevents HLS.js from trying its own decryption - we handle it in CustomLoader
+      var uriMatch = line.match(/URI="([^"]+)"/);
+      if (uriMatch) {
+        var keyUri = uriMatch[1];
+
+        var ivMatch = line.match(/IV=0[xX]([0-9a-fA-F]+)/);
+        if (ivMatch && ivMatch[1] !== 'null') {
+          encryptionIv = CryptoJS.enc.Hex.parse(ivMatch[1]);
+          log("Found encryption IV: " + ivMatch[1]);
+        }
+
+        try {
+          var absoluteKey = new URL(keyUri, baseUrl).href;
+          if (proxyBase) {
+            absoluteKey = proxyBase + encodeURIComponent(absoluteKey);
+          }
+          encryptionKeyUri = absoluteKey;
+
+          log("Detected encryption key in manifest: " + absoluteKey);
+          fetchEncryptionKey(absoluteKey, baseUrl).then(function (key) {
+            currentEncryptionKey = key;
+            currentEncryptionIv = encryptionIv;
+            log("Encryption key loaded and ready for decryption");
+          });
+        } catch (e) {
+          console.warn("Key resolve error", e);
+        }
+      }
+      // Skip adding this line - don't include #EXT-X-KEY in output
+      continue;
+    }
+    newLines.push(line);
+  }
+
+  return newLines.join('\n');
+
+}
+
+function CustomLoader(config) {
+  // Store the HLS config in the instance
+  var hlsConfig = config;
+
+  this.load = function (context, loadConfig, callbacks) {
+    var url = context.url;
+
+    // Debug ALL requests
+    log("CustomLoader.load called: " + url + " type=" + context.type);
+
+    // Debug log for virtual URLs
+    if (url.indexOf('virtual:') === 0) {
+      console.log("CustomLoader: Loading virtual URL", url, "Has content:", !!hlsConfig.customContent);
+    }
+
+    // Check for virtual content - use hlsConfig from closure
+    if ((url === "virtual:apk" || url === "virtual:m3u8") && hlsConfig.customContent) {
+      var now = performance.now();
+      var stats = {
+        loading: { start: now, first: now, end: now },
+        parsing: { start: now, end: now },
+        buffering: { start: now, first: now, end: now },
+        trequest: now,
+        tfirst: now,
+        tload: now,
+        loaded: hlsConfig.customContent.length,
+        total: hlsConfig.customContent.length
+      };
+      callbacks.onSuccess({ url: url, data: hlsConfig.customContent }, stats, context);
+      return;
+    }
+
+    var responseType = context.responseType;
+
+    // Check if this is an encrypted segment (ZIP/CSS/HTML/JS file from M3U8)
+    // These are disguised video segments that need decryption
+    var looksEncrypted = url.match(/\.(zip|css|html|js)(\?.*)?$/i);
+    var isNotManifest = context.type !== 'manifest' && context.type !== 'level' && context.type !== 'playlist';
+
+    if (looksEncrypted && isNotManifest) {
+      log("Checking segment: " + url);
+
+      // Force binary response for potential encrypted segments
+      smartFetch(url, { responseType: 'arraybuffer' })
+        .then(function (result) {
+          var arrayBuffer = result.data;
+          var data = new Uint8Array(arrayBuffer);
+
+          // Check if segment is already valid MPEG-TS (starts with sync byte 0x47)
+          if (data.length > 0 && data[0] === 0x47) {
+            log("HLS: Segment already valid MPEG-TS, skipping decryption");
+            var now = performance.now();
+            var stats = {
+              loading: { start: now, first: now, end: now },
+              parsing: { start: now, end: now },
+              buffering: { start: now, first: now, end: now },
+              trequest: now,
+              tfirst: now,
+              tload: now,
+              loaded: arrayBuffer.byteLength,
+              total: arrayBuffer.byteLength
+            };
+            callbacks.onSuccess({ url: url, data: arrayBuffer }, stats, context);
+            return;
+          }
+
+          // Only decrypt if we have an encryption key
+          if (!currentEncryptionKey) {
+            log("HLS: No encryption key found, passing through as-is");
+            var now = performance.now();
+            var stats = {
+              loading: { start: now, first: now, end: now },
+              parsing: { start: now, end: now },
+              buffering: { start: now, first: now, end: now },
+              trequest: now,
+              tfirst: now,
+              tload: now,
+              loaded: arrayBuffer.byteLength,
+              total: arrayBuffer.byteLength
+            };
+            callbacks.onSuccess({ url: url, data: arrayBuffer }, stats, context);
+            return;
+          }
+
+          // Decrypt the segment
+          log("Loading encrypted segment: " + url);
+          var decryptedBuffer = decryptSegmentBinary(arrayBuffer, currentEncryptionKey, currentEncryptionIv);
+
+          if (!decryptedBuffer) {
+            throw new Error("Decryption failed");
+          }
+
+          var now = performance.now();
+          var stats = {
+            loading: { start: now, first: now, end: now },
+            parsing: { start: now, end: now },
+            buffering: { start: now, first: now, end: now },
+            trequest: now,
+            tfirst: now,
+            tload: now,
+            loaded: decryptedBuffer.byteLength,
+            total: decryptedBuffer.byteLength
+          };
+
+          callbacks.onSuccess({ url: url, data: decryptedBuffer }, stats, context);
+        })
+        .catch(function (e) {
+          error("Segment load failed: " + e.message);
+          callbacks.onError({ code: 500, text: e.message }, context, e);
+        });
+      return;
+    }
+
+    smartFetch(url, { responseType: responseType })
+      .then(function (result) {
+        // Extract data based on response type
+        var data = responseType === 'arraybuffer' ? result.data : result.text;
+        var now = performance.now();
+        var stats = {
+          loading: { start: now, first: now, end: now },
+          parsing: { start: now, end: now },
+          buffering: { start: now, first: now, end: now },
+          trequest: now,
+          tfirst: now,
+          tload: now,
+          loaded: (data && (data.byteLength || data.length)) || 0,
+          total: (data && (data.byteLength || data.length)) || 0
+        };
+
+        if (context.type === 'manifest' || context.type === 'level' || context.type === 'playlist') {
+          var text = data;
+          if (typeof text === 'string' && text.indexOf('#EXTM3U') > -1) {
+            text = rewriteM3u8(text, url, "");
+          }
+          callbacks.onSuccess({ url: url, data: text }, stats, context);
+        } else {
+          callbacks.onSuccess({ url: url, data: data }, stats, context);
+        }
+      })
+      .catch(function (e) {
+        callbacks.onError({ code: 500, text: e.message }, context, e);
+      });
+  };
+
+  this.abort = function () { };
+  this.destroy = function () { };
+}
+
+function processM3u8(text, baseUrl) {
+  var lines = text.split('\n');
+  var newLines = [];
+
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    if (line && line.indexOf('#') !== 0) {
+      try {
+        var absoluteUrl = new URL(line, baseUrl).href;
+        line = absoluteUrl;
+      } catch (e) {
+        console.warn("URL resolve error", e);
+      }
+    } else if (line.indexOf('#EXT-X-KEY') === 0) {
+      var uriMatch = line.match(/URI="([^"]+)"/);
+      if (uriMatch) {
+        var keyUri = uriMatch[1];
+        try {
+          var absoluteKey = new URL(keyUri, baseUrl).href;
+          line = line.replace(uriMatch[1], absoluteKey);
+        } catch (e) {
+          console.warn("Key resolve error", e);
+        }
+      }
+    }
+    newLines.push(line);
+  }
+  var newText = newLines.join('\n');
+
+  // UTF-8 safe encoding for Data URI
+  return "data:application/vnd.apple.mpegurl;base64," + btoa(unescape(encodeURIComponent(newText)));
+}
+
+function closePlayer() {
+  log("closePlayer() called");
+
+  var modal = document.getElementById('videoPlayerModal');
+  var videoEl = document.getElementById('videoPlayer');
+  var iframeEl = document.getElementById('videoIframe');
+
+  // Hide modal first
+  if (modal) {
+    modal.hidden = true;
+    modal.setAttribute('hidden', '');
+    modal.style.display = 'none';
+    modal.style.visibility = 'hidden';
+    log("Modal hidden");
+  }
+
+  // Cleanup Shaka player FIRST (before clearing video src)
+  if (window.shakaPlayer) {
+    try {
+      window.shakaPlayer.destroy();
+      log("Shaka player destroyed");
+    } catch (e) {
+      log("Shaka destroy error: " + e.message);
+    }
+    window.shakaPlayer = null;
+  }
+
+  // Cleanup Shaka interval
+  if (window.shakaManifestInterval) {
+    clearInterval(window.shakaManifestInterval);
+    window.shakaManifestInterval = null;
+    log("Shaka interval cleared");
+  }
+
+  // Reset debug flag for next player session
+  window.shakaNavDebugLogged = false;
+
+  // Unregister virtual scheme
+  if (typeof shaka !== 'undefined' && shaka.net && shaka.net.NetworkingEngine) {
+    try {
+      shaka.net.NetworkingEngine.unregisterScheme('virtual');
+      log("Virtual scheme unregistered");
+    } catch (e) {
+      // Scheme might not be registered, ignore
+    }
+  }
+
+  // Cleanup AVPlay (Tizen native player)
+  if (window.currentAVPlay && typeof webapis !== 'undefined' && webapis.avplay) {
+    try {
+      webapis.avplay.stop();
+      webapis.avplay.close();
+      log("AVPlay stopped and closed");
+    } catch (e) {
+      log("AVPlay cleanup error: " + e.message);
+    }
+    window.currentAVPlay = false;
+  }
+
+  // Cleanup HLS
+  if (window.hls) {
+    try {
+      window.hls.destroy();
+      log("HLS destroyed");
+    } catch (e) {
+      log("HLS destroy error: " + e.message);
+    }
+    window.hls = null;
+  }
+
+  // Stop and cleanup video element
+  if (videoEl) {
+    try {
+      videoEl.pause();
+      videoEl.src = '';
+      videoEl.removeAttribute('src');
+      videoEl.load(); // Reset the video element
+      log("Video element cleaned");
+    } catch (e) {
+      log("Video cleanup error: " + e.message);
+    }
+  }
+
+  // Stop iframe
+  if (iframeEl) {
+    iframeEl.src = '';
+    log("Iframe cleared");
+  }
+
+  // Exit player mode in navigation
+  if (typeof DPadNavigator !== 'undefined') {
+    DPadNavigator.exitPlayerMode();
+    log("Exited player navigation mode");
+  }
+
+  log("Player closed successfully");
+}
+
+// Expose closePlayer to global window scope for cross-script access
+window.closePlayer = closePlayer;
+
+// Attach close button handler on page load
+document.addEventListener('DOMContentLoaded', function () {
+  var closeBtn = document.getElementById('closePlayer');
+  if (closeBtn) {
+    closeBtn.onclick = function () {
+      closePlayer();
+    };
+  }
+
+  // Global keyboard handler - always close player on Escape/Back when visible
+  document.addEventListener('keydown', function (e) {
+    var modal = document.getElementById('videoPlayerModal');
+
+    // Check if modal is visible using multiple methods
+    var isModalVisible = modal && (
+      modal.style.display === 'flex' ||
+      modal.style.display === 'block' ||
+      (!modal.hidden && modal.style.display !== 'none')
+    );
+
+    if (isModalVisible) {
+      var key = e.key || e.keyCode;
+      var keyName = typeof key === 'string' ? key : '';
+      var keyCode = typeof key === 'number' ? key : e.keyCode;
+
+      log("Key pressed in player: " + keyName + " (code: " + keyCode + ")");
+
+      // Tizen remote back button is code 10009
+      if (keyName === 'Escape' || keyName === 'Back' || keyName === 'Backspace' || keyCode === 10009 || keyCode === 27 || keyCode === 8) {
+        log("Close key detected - closing player");
+        e.preventDefault();
+        e.stopPropagation();
+        e.stopImmediatePropagation();
+        closePlayer();
+        return false;
+      }
+    }
+  }, true);  // Use capture phase to get event first
+});
+
+function openPost(post) {
+  var rawUrl = post.channel_url || post.url || post.link;
+  if (!rawUrl) return;
+
+  var initialUrl = decryptUrl(rawUrl);
+  log("Opening: " + initialUrl);
+
+  // Clear any previous error overlay
+  hidePlayerError();
+
+  var modal = document.getElementById('videoPlayerModal');
+  var videoEl = document.getElementById('videoPlayer');
+  var iframeEl = document.getElementById('videoIframe');
+  var playBtn = document.getElementById('manualPlayBtn');
+
+  if (!playBtn) {
+    playBtn = document.createElement('button');
+    playBtn.id = 'manualPlayBtn';
+    playBtn.textContent = "▶ Click to Play";
+    playBtn.style.cssText = "position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);font-size:24px;padding:15px 30px;background:red;color:white;border:none;border-radius:8px;z-index:100;display:none;cursor:pointer;";
+    modal.querySelector('.video-container').appendChild(playBtn);
+    playBtn.onclick = function () {
+      playBtn.style.display = 'none';
+      videoEl.play().catch(function (e) {
+        error("Manual play failed: " + e.message);
+      });
+    };
+  } else {
+    playBtn.style.display = 'none';
+  }
+
+  if (window.hls) {
+    window.hls.destroy();
+    window.hls = null;
+  }
+  if (window.shakaManifestInterval) {
+    clearInterval(window.shakaManifestInterval);
+    window.shakaManifestInterval = null;
+  }
+  // Unregister virtual scheme so it doesn't affect other streams
+  if (typeof shaka !== 'undefined' && shaka.net && shaka.net.NetworkingEngine) {
+    try {
+      shaka.net.NetworkingEngine.unregisterScheme('virtual');
+    } catch (e) {
+      // Scheme might not be registered, ignore
+    }
+  }
+  videoEl.pause();
+  videoEl.src = "";
+  videoEl.removeAttribute('src');
+  videoEl.style.display = 'none';
+  iframeEl.src = "";
+  iframeEl.style.display = 'none';
+
+  var errs = modal.querySelectorAll('.error-message');
+  for (var i = 0; i < errs.length; i++) errs[i].remove();
+
+  modal.hidden = false;
+  modal.removeAttribute('hidden');  // Ensure hidden attribute is removed
+  modal.style.display = 'flex';  // Force display
+  modal.style.visibility = 'visible';  // Force visibility
+  modal.style.opacity = '1';  // Force opacity
+  modal.style.zIndex = '9999';  // Force to top
+  log("Modal should now be visible. Hidden: " + modal.hidden + ", hasAttribute: " + modal.hasAttribute('hidden') + ", display: " + modal.style.display);
+  showLoader();
+
+  // Enter player navigation mode for D-pad
+  if (typeof DPadNavigator !== 'undefined') {
+    DPadNavigator.enterPlayerMode();
+  }
+
+  resolveStreamUrl(initialUrl).then(function (result) {
+    hideLoader();
+    var url = result.url;
+    var customContent = result.content;
+    var clearkey = result.clearkey;  // ClearKey DRM credentials from techlyhub
+    var useFallbackIframe = result.useFallbackIframe;
+
+    log("Playing: " + url);
+
+    var isVirtual = url.indexOf('virtual:') === 0;
+    var isMpd = url.indexOf('.mpd') > -1;
+    var isStream = isVirtual || isMpd || url.indexOf('.m3u8') > -1 || url.indexOf('.ts') > -1 || url.indexOf('.mp4') > -1 || url.indexOf('blob:') === 0 || url.indexOf('data:') === 0;
+    var isPage = ((url.indexOf('.php') > -1 || url.indexOf('.html') > -1) && !isStream) || useFallbackIframe;
+
+    if (isPage) {
+      useIframe(url);
+      return;
+    }
+
+
+    videoEl.style.display = 'block';
+    videoEl.setAttribute('playsinline', '');
+    videoEl.setAttribute('webkit-playsinline', '');
+
+    if (isTizen()) {
+      if (isVirtual) {
+        // Use Shaka for virtual streams (encrypted M3U8s)
+        if (typeof shaka !== 'undefined' && shaka.Player.isBrowserSupported()) {
+          playShaka(result);
+        } else if (typeof Hls !== 'undefined' && Hls.isSupported()) {
+          playHls(result);
+        } else {
+          error("No player supported for virtual stream");
+        }
+        return;
+      }
+
+      if (url.indexOf('blob:') === 0 || url.indexOf('data:') === 0 || url.indexOf('.m3u8') > -1 || isMpd) {
+        if (typeof shaka !== 'undefined' && shaka.Player.isBrowserSupported()) {
+          playShaka(result);
+        } else if (typeof Hls !== 'undefined' && Hls.isSupported() && !isMpd) {
+          // HLS.js doesn't support MPD, only use for HLS streams
+          playHls(result);
+        } else if (!isMpd) {
+          videoEl.src = url;
+          videoEl.play();
+        } else {
+          error("No player available for MPD stream");
+        }
+      } else {
+
+        videoEl.removeAttribute('crossorigin');
+        videoEl.src = url;
+        videoEl.play().catch(function (e) {
+          log("Native play failed, trying Shaka");
+          if (typeof shaka !== 'undefined' && shaka.Player.isBrowserSupported()) {
+            playShaka(result);
+          } else if (typeof Hls !== 'undefined' && Hls.isSupported()) {
+            playHls(result);
+          }
+        });
+      }
+    } else {
+      // Desktop/non-Tizen - prefer Shaka for better encryption handling
+      if (typeof shaka !== 'undefined' && shaka.Player.isBrowserSupported()) {
+        playShaka(result);
+      } else if (typeof Hls !== 'undefined' && Hls.isSupported()) {
+        playHls(result);
+      } else if (videoEl.canPlayType('application/vnd.apple.mpegurl')) {
+        videoEl.src = url;
+        videoEl.play();
+      } else {
+        openIframe(url);
+      }
+    }
+
+    function playHls(srcObj) {
+      // srcObj may contain {url, content}
+      var src = srcObj.url || srcObj;
+      var customContent = srcObj.content;
+
+      // Configure Hls with custom loader - ALWAYS use it for encrypted segment support
+      var config = {
+        debug: true,
+        pLoader: CustomLoader,  // Playlist loader
+        loader: CustomLoader,   // Manifest loader
+        fLoader: CustomLoader   // Fragment (segment) loader - handles encrypted .js/.zip/.html files
+      };
+
+      if (customContent) {
+        // Store the custom content for virtual manifests
+        config.customContent = customContent;
+        log("Using custom loader for inline manifest");
+      }
+
+      var hls = new Hls(config);
+      window.hls = hls;
+
+      hls.loadSource(src);
+      hls.attachMedia(videoEl);
+
+      hls.on(Hls.Events.MANIFEST_PARSED, function () {
+        videoEl.play().catch(function (e) {
+          log("Autoplay blocked: " + e.message);
+          playBtn.style.display = 'block';
+          playBtn.focus();
+        });
+      });
+
+      hls.on(Hls.Events.ERROR, function (event, data) {
+        if (data.fatal) {
+          log("Hls Error: " + data.type + " " + (data.details || ""));
+          hls.destroy();
+          window.hls = null;
+          // Try AVPlay as last resort on Tizen
+          if (isTizen() && typeof webapis !== 'undefined' && webapis.avplay) {
+            log("Trying AVPlay fallback after HLS.js failure...");
+            playAVPlay(src);
+          } else {
+            showPlayerError("Playback failed. Stream unavailable.");
+          }
+        }
+      });
+    }
+
+    // AVPlay - Tizen native player that can set headers
+    function playAVPlay(url) {
+      if (typeof webapis === 'undefined' || !webapis.avplay) {
+        showPlayerError("AVPlay not available. Cannot play this stream.");
+        return;
+      }
+
+      log("AVPlay: Playing " + url);
+
+      // Hide HTML5 video element
+      videoEl.style.display = 'none';
+
+      try {
+        webapis.avplay.open(url);
+
+        // Set display area to full screen
+        var container = document.getElementById('videoPlayerModal');
+        if (container) {
+          var rect = container.getBoundingClientRect();
+          webapis.avplay.setDisplayRect(0, 0, rect.width || 1920, rect.height || 1080);
+        } else {
+          webapis.avplay.setDisplayRect(0, 0, 1920, 1080);
+        }
+
+        // Note: AVPlay doesn't support custom HTTP headers like Referer
+        // However, Tizen's native networking often bypasses CORS restrictions
+        // so the stream may still work without custom headers
+        log("AVPlay: Attempting playback (custom headers not supported)");
+
+        webapis.avplay.setListener({
+          onbufferingstart: function () { log("AVPlay: Buffering..."); },
+          onbufferingprogress: function (percent) { log("AVPlay: Buffer " + percent + "%"); },
+          onbufferingcomplete: function () { log("AVPlay: Buffering complete"); },
+          oncurrentplaytime: function (time) { /* playback time update */ },
+          onevent: function (eventType, eventData) { log("AVPlay event: " + eventType); },
+          onerror: function (errorType) {
+            showPlayerError("AVPlay error: " + errorType);
+          },
+          onsubtitlechange: function () { },
+          ondrmevent: function () { },
+          onstreamcompleted: function () {
+            log("AVPlay: Stream completed");
+            closePlayer();
+          }
+        });
+
+        webapis.avplay.prepareAsync(function () {
+          log("AVPlay: Prepared, starting playback");
+          webapis.avplay.play();
+          window.currentAVPlay = true;
+        }, function (e) {
+          showPlayerError("AVPlay failed: " + (e.message || e));
+        });
+
+      } catch (e) {
+        showPlayerError("AVPlay error: " + e.message);
+      }
+    }
+
+    function playShaka(srcObj) {
+      var src = srcObj.url || srcObj;
+      var customContent = srcObj.content;
+      var clearkeyInfo = srcObj.clearkey;  // ClearKey DRM credentials from techlyhub
+
+      // Install Shaka polyfills
+      shaka.polyfill.installAll();
+
+      if (!shaka.Player.isBrowserSupported()) {
+        error("Shaka Player not supported in this browser");
+        playHls(srcObj); // Fallback to HLS.js
+        return;
+      }
+
+      // Get the container for Shaka UI
+      var container = videoEl.parentElement;
+
+      // Destroy existing UI if any
+      if (window.shakaUi) {
+        try {
+          window.shakaUi.destroy();
+        } catch (e) { }
+        window.shakaUi = null;
+      }
+      if (window.shakaPlayer) {
+        try {
+          window.shakaPlayer.destroy();
+        } catch (e) { }
+        window.shakaPlayer = null;
+      }
+
+      // Create player
+      var player = new shaka.Player(videoEl);
+      window.shakaPlayer = player;
+
+      // Create Shaka UI overlay for controls (bottom bar, three-dot menu)
+      var ui = new shaka.ui.Overlay(player, container, videoEl);
+      window.shakaUi = ui;
+
+      // Configure UI to show quality selection in overflow menu
+      ui.configure({
+        addBigPlayButton: true,
+        addSeekBar: true,
+        controlPanelElements: [
+          'play_pause',
+          'time_and_duration',
+          'spacer',
+          'mute',
+          'volume',
+          'fullscreen',
+          'overflow_menu'
+        ],
+        overflowMenuButtons: [
+          'quality',
+          'playback_rate',
+          'captions'
+        ]
+      });
+
+      log("Shaka: UI Overlay created with quality menu");
+
+      // Log what UI controls were created (for debugging)
+      setTimeout(function () {
+        var controlPanel = container.querySelector('.shaka-controls-button-panel');
+        var overflowBtn = container.querySelector('.shaka-overflow-menu-button');
+        log("Shaka UI Debug: Control panel found: " + !!controlPanel);
+        log("Shaka UI Debug: Overflow button found: " + !!overflowBtn);
+        if (controlPanel) {
+          var buttons = controlPanel.querySelectorAll('button');
+          log("Shaka UI Debug: Found " + buttons.length + " control buttons");
+        }
+      }, 500);
+
+      // Configure ClearKey DRM if credentials were extracted from techlyhub
+      if (clearkeyInfo && clearkeyInfo.keyId && clearkeyInfo.key) {
+        log("Shaka: Configuring ClearKey DRM for techlyhub stream");
+        var clearKeys = {};
+        clearKeys[clearkeyInfo.keyId] = clearkeyInfo.key;
+        player.configure({
+          drm: {
+            clearKeys: clearKeys
+          }
+        });
+        log("Shaka: ClearKey DRM configured");
+      }
+
+      // Add request filter to inject required headers for M3U8 server
+      // The server checks Referer/Origin and returns 403 if they don't match
+      player.getNetworkingEngine().registerRequestFilter(function (type, request) {
+        // For requests to the M3U8 CDN, add the expected headers
+        if (request.uris && request.uris[0] && request.uris[0].indexOf('merichunidya.com') > -1) {
+          request.headers['Referer'] = 'https://vividmosaica.com/';
+          request.headers['Origin'] = 'https://vividmosaica.com';
+          log("Shaka: Added vividmosaica.com headers for CDN request");
+        }
+      });
+
+
+      // Store manifest info for refreshing live streams
+
+      var storedManifestContent = customContent;
+      var originalSourceUrl = srcObj.originalUrl || null;  // Store original URL for refreshes
+      var isFirstLoad = true;  // Track first load vs refresh
+      var isRefreshing = false;  // Track if background refresh is in progress
+
+      // Background manifest pre-fetcher for smooth live streaming
+      var manifestRefreshInterval = null;
+      if (customContent && originalSourceUrl) {
+        // Pre-fetch manifest every 10 seconds in background
+        manifestRefreshInterval = setInterval(function () {
+          if (isRefreshing) return;  // Skip if already refreshing
+          isRefreshing = true;
+
+          resolveStreamUrl(originalSourceUrl).then(function (result) {
+            if (result && result.content) {
+              storedManifestContent = result.content;
+              // log("Shaka: Background manifest refresh complete");  // Quiet background refresh
+            }
+            isRefreshing = false;
+          }).catch(function (e) {
+            isRefreshing = false;
+          });
+        }, 10000);  // Every 10 seconds
+
+        // Store interval for cleanup
+        window.shakaManifestInterval = manifestRefreshInterval;
+      }
+
+      // Register custom scheme handler for virtual manifests
+      // This intercepts requests BEFORE they go to the network
+      if (customContent) {
+        shaka.net.NetworkingEngine.registerScheme('virtual', function (uri, request, requestType, progressUpdated, headersReceived) {
+          // Return a promise that resolves with the manifest content IMMEDIATELY
+          return new Promise(function (resolve, reject) {
+            // Always serve cached content immediately (background fetcher keeps it fresh)
+            try {
+              var encoder = new TextEncoder();
+              var data = encoder.encode(storedManifestContent);
+
+              resolve({
+                uri: uri,
+                originalUri: uri,
+                data: data.buffer,
+                status: 200,
+                headers: {},
+                timeMs: 0,
+                fromCache: !isFirstLoad
+              });
+
+              if (isFirstLoad) {
+                log("Shaka: Served virtual manifest (first load)");
+                isFirstLoad = false;
+              }
+            } catch (e) {
+              reject(e);
+            }
+          });
+        });
+      }
+
+      // Add response filter for encrypted segments
+      player.getNetworkingEngine().registerResponseFilter(function (type, response) {
+        var url = response.uri;
+
+        // Check if this looks like an encrypted segment (by extension)
+        var looksEncrypted = url.match(/\.(zip|css|html|js|apk|txt|xml)(\?.*)?$/i);
+
+        if (looksEncrypted && type === shaka.net.NetworkingEngine.RequestType.SEGMENT) {
+          // Check if segment is already valid MPEG-TS (starts with sync byte 0x47)
+          var data = new Uint8Array(response.data);
+          if (data.length > 0 && data[0] === 0x47) {
+            log("Shaka: Segment already valid MPEG-TS, skipping decryption");
+            return; // Already valid video, don't decrypt
+          }
+
+          // Only decrypt if we have an encryption key from the manifest
+          if (!currentEncryptionKey) {
+            log("Shaka: No encryption key found in manifest, skipping decryption");
+            return;
+          }
+
+          log("Shaka: Decrypting segment: " + url.substring(0, 60) + "...");
+
+          try {
+            var decrypted = decryptSegmentBinary(response.data, currentEncryptionKey, currentEncryptionIv);
+            if (decrypted) {
+              response.data = decrypted;
+              log("Shaka: Decrypted successfully");
+            }
+          } catch (e) {
+            error("Shaka: Decryption failed: " + e.message);
+          }
+        }
+      });
+
+      // Error handler - ignore manifest refresh errors for live streams
+      player.addEventListener('error', function (event) {
+        var err = event.detail;
+        // Error 1002 is network error - often happens on manifest refresh for blob URLs
+        if (err.code === 1002) {
+          // Check if we need to refresh manifest ourselves
+          log("Shaka: Manifest refresh issue, will try to recover");
+          return; // Don't show error to user
+        }
+        // Error 1003 is BAD_HTTP_STATUS (like 429 Too Many Requests)
+        if (err.code === 1003) {
+          log("Shaka: HTTP error (possibly rate limited), will retry");
+          return; // Let Shaka handle retries
+        }
+        // Error 3014 is MEDIA_SOURCE_OPERATION_THREW - often just means stream ended
+        if (err.code === 3014) {
+          log("Shaka: Media source issue (stream may have ended)");
+          return; // Don't show as error
+        }
+        error("Shaka error: " + err.code + " - " + (err.message || ""));
+      });
+
+      // For virtual manifests, we need to configure Shaka differently
+      var loadUrl = src;
+
+      if (customContent) {
+        // Use virtual:// scheme that will be served by custom scheme handler
+        loadUrl = 'virtual://manifest/playlist.m3u8';
+        log("Shaka: Using virtual scheme for manifest: " + loadUrl);
+
+        // Configure for live stream - reduce refresh frequency to avoid rate limits
+        player.configure({
+          streaming: {
+            retryParameters: {
+              maxAttempts: 2,
+              baseDelay: 2000,  // Wait 2s before retry
+              backoffFactor: 2,
+              fuzzFactor: 0.5
+            },
+            stallEnabled: false,
+            gapDetectionThreshold: 0.5,
+            updateIntervalSeconds: 30  // Update manifest every 30 seconds
+          },
+          manifest: {
+            retryParameters: {
+              maxAttempts: 1,
+              timeout: 10000,
+              baseDelay: 3000  // Wait 3s before retrying manifest
+            },
+            availabilityWindowOverride: 300, // 5 min window
+            defaultPresentationDelay: 10,  // Start 10s from live edge
+            disableVideo: false,
+            disableAudio: false
+          }
+        });
+      } else {
+        // For regular (non-virtual) streams, also configure to avoid rate limits  
+        player.configure({
+          streaming: {
+            updateIntervalSeconds: 15,  // Update every 15 seconds
+            retryParameters: {
+              maxAttempts: 3,
+              baseDelay: 2000,
+              backoffFactor: 2
+            }
+          },
+          manifest: {
+            retryParameters: {
+              maxAttempts: 2,
+              timeout: 10000,
+              baseDelay: 3000
+            }
+          }
+        });
+      }
+
+      // Load and play
+      player.load(loadUrl).then(function () {
+        log("Shaka: Manifest loaded successfully");
+
+
+        videoEl.play().catch(function (e) {
+          log("Autoplay blocked: " + e.message);
+          playBtn.style.display = 'block';
+          playBtn.focus();
+        });
+      }).catch(function (e) {
+        error("Shaka load error: " + e.message);
+        // Try HLS.js as fallback
+        log("Trying HLS.js fallback...");
+        playHls(srcObj);
+      });
+    }
+
+
+
+    function tryNativeFallback(src) {
+      log("Native Fallback");
+      videoEl.removeAttribute('crossorigin');
+      videoEl.src = src;
+      var p = videoEl.play();
+      if (p) {
+        p.catch(function (e) {
+          log("Native failed: " + e.message);
+          playBtn.style.display = 'block';
+          playBtn.focus();
+        });
+      }
+    }
+
+    function fallbackToIframe() {
+      if (isStream) {
+        error("Video playback failed.");
+      } else {
+        videoEl.style.display = 'none';
+        videoEl.pause();
+        videoEl.src = "";
+        useIframe(initialUrl);
+      }
+    }
+
+    function useIframe(src) {
+      log("Iframe Mode");
+      videoEl.style.display = 'none';
+      iframeEl.style.display = 'block';
+      iframeEl.src = src;
+    }
+  });
+
+  document.getElementById('closePlayer').onclick = function () {
+    closePlayer();
+  };
+}
+
+// Start
+loadCategories();
+
+// Initialize D-pad navigation for TV
+if (typeof DPadNavigator !== 'undefined') {
+  DPadNavigator.init();
+}
+
+// ========== PROXY STATUS CHECKING ==========
+var proxyCheckInterval = null;
+
+function checkProxyStatus() {
+  if (typeof window.StreamProxy === 'undefined' || typeof window.StreamProxy.checkProxyHealth !== 'function') {
+    log('[PROXY-STATUS] StreamProxy not available');
+    updateProxyIndicator(false);
+    return;
+  }
+
+  log('[PROXY-STATUS] Checking proxy health...');
+
+  window.StreamProxy.checkProxyHealth(function (isAvailable) {
+    updateProxyIndicator(isAvailable);
+    log('[PROXY-STATUS] Proxy is ' + (isAvailable ? 'RUNNING ✓' : 'NOT RUNNING ✗'));
+  });
+}
+
+function updateProxyIndicator(isAvailable) {
+  var indicator = document.getElementById('proxyStatusIndicator');
+  var dot = document.getElementById('proxyDot');
+
+  if (!indicator || !dot) return;
+
+  if (isAvailable) {
+    dot.style.background = '#4caf50'; // Green
+    indicator.title = 'Proxy Status: Running ✓';
+  } else {
+    dot.style.background = '#f44336'; // Red
+    indicator.title = 'Proxy Status: Not Running ✗';
+  }
+}
+
+// Initialize proxy status check on page load
+document.addEventListener('DOMContentLoaded', function () {
+  log('[PROXY-STATUS] Initializing proxy status check...');
+
+  // Initial check
+  checkProxyStatus();
+
+  // Set up periodic check every 30 seconds
+  if (typeof window.StreamProxy !== 'undefined') {
+    proxyCheckInterval = setInterval(function () {
+      checkProxyStatus();
+    }, 30000);
+  }
+
+  // Add click handler for manual check
+  var proxyIndicator = document.getElementById('proxyStatusIndicator');
+  if (proxyIndicator) {
+    proxyIndicator.onclick = function () {
+      log('[PROXY-STATUS] Manual check triggered');
+      proxyIndicator.title = 'Proxy Status: Checking...';
+      checkProxyStatus();
+    };
+
+    // Add Enter key handler for D-pad navigation
+    proxyIndicator.addEventListener('keydown', function (e) {
+      if (e.key === 'Enter' || e.keyCode === 13) {
+        e.preventDefault();
+        log('[PROXY-STATUS] Manual check triggered (D-pad)');
+        proxyIndicator.title = 'Proxy Status: Checking...';
+        checkProxyStatus();
+      }
+    });
+  }
+});