KekikStream 2.3.9__py3-none-any.whl → 2.5.4__py3-none-any.whl

KekikStream/Core/Extractor/ExtractorBase.py

@@ -49,6 +49,7 @@ class ExtractorBase(ABC):
             return ""
 
         if url.startswith("http") or url.startswith("{\""):
-            return url
+            return url.replace("\\", "")
 
-        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        url = f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        return url.replace("\\", "")

KekikStream/Core/Extractor/ExtractorLoader.py

@@ -9,7 +9,7 @@ class ExtractorLoader:
     def __init__(self, extractors_dir: str):
         # Yerel ve global çıkarıcı dizinlerini ayarla
         self.local_extractors_dir  = Path(extractors_dir)
-        self.global_extractors_dir = Path(__file__).parent.parent.parent / extractors_dir
+        self.global_extractors_dir = Path(__file__).parent.parent.parent / "Extractors"
 
         # Dizin kontrolü
         if not self.local_extractors_dir.exists() and not self.global_extractors_dir.exists():
@@ -19,22 +19,16 @@ class ExtractorLoader:
     def load_all(self) -> list[ExtractorBase]:
         extractors = []
 
-        # Eğer yerel dizinde Extractor varsa, sadece onları yükle (eklenti geliştirme modu)
-        if self.local_extractors_dir.exists():
+        # Yerel Extractor'lar varsa önce onları yükle (ek/öncelikli yetenekler)
+        # Eğer yerel dizin global dizinle aynıysa (örn: doğrudan core'da çalışırken) tekrar yükleme yapma
+        if self.local_extractors_dir.exists() and self.local_extractors_dir.resolve() != self.global_extractors_dir.resolve():
             # konsol.log(f"[green][*] Yerel Extractor dizininden yükleniyor: {self.local_extractors_dir}[/green]")
-            local_extractors = self._load_from_directory(self.local_extractors_dir)
-            # konsol.log(f"[green]Yerel Extractor'lar: {[e.__name__ for e in local_extractors]}[/green]")
+            extractors.extend(self._load_from_directory(self.local_extractors_dir))
 
-            if local_extractors:
-                # konsol.log("[cyan][*] Yerel Extractor bulundu, global Extractor'lar atlanıyor (eklenti geliştirme modu)[/cyan]")
-                extractors.extend(local_extractors)
-
-        # Yerel dizinde Extractor yoksa, global'leri yükle
-        if not extractors and self.global_extractors_dir.exists():
+        # Global Extractor'ları her zaman yükle (temel yetenekler)
+        if self.global_extractors_dir.exists():
             # konsol.log(f"[green][*] Global Extractor dizininden yükleniyor: {self.global_extractors_dir}[/green]")
-            global_extractors = self._load_from_directory(self.global_extractors_dir)
-            # konsol.log(f"[green]Global Extractor'lar: {[e.__name__ for e in global_extractors]}[/green]")
-            extractors.extend(global_extractors)
+            extractors.extend(self._load_from_directory(self.global_extractors_dir))
 
         # Benzersizliği sağlama (modül adı + sınıf adı bazında)
         unique_extractors = []

KekikStream/Core/HTMLHelper.py

@@ -1,7 +1,9 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from selectolax.parser import HTMLParser, Node
+from __future__ import annotations
+
 import re
+from selectolax.parser import HTMLParser, Node
 
 
 class HTMLHelper:
@@ -10,96 +12,169 @@ class HTMLHelper:
     """
 
     def __init__(self, html: str):
-        self.parser = HTMLParser(html)
         self.html   = html
+        self.parser = HTMLParser(html)
 
     # ========================
-    # TEMEL SELECTOR İŞLEMLERİ
+    # SELECTOR (CSS) İŞLEMLERİ
     # ========================
 
-    def _target(self, element: Node | None) -> Node | HTMLParser:
+    def _root(self, element: Node | None) -> Node | HTMLParser:
         """İşlem yapılacak temel elementi döndürür."""
         return element if element is not None else self.parser
 
     def select(self, selector: str, element: Node | None = None) -> list[Node]:
         """CSS selector ile tüm eşleşen elementleri döndür."""
-        return self._target(element).css(selector)
+        return self._root(element).css(selector)
 
     def select_first(self, selector: str | None, element: Node | None = None) -> Node | None:
         """CSS selector ile ilk eşleşen elementi döndür."""
         if not selector:
             return element
+        return self._root(element).css_first(selector)
 
-        return self._target(element).css_first(selector)
-
-    def select_text(self, selector: str | None = None, element: Node | None = None, strip: bool = True) -> str | None:
+    def select_text(self, selector: str | None = None, element: Node | None = None) -> str | None:
         """CSS selector ile element bul ve text içeriğini döndür."""
         el = self.select_first(selector, element)
         if not el:
             return None
+        val = el.text(strip=True)
+        return val or None
 
-        val = el.text(strip=strip)
-        return val if val else None
+    def select_texts(self, selector: str, element: Node | None = None) -> list[str] | None:
+        """CSS selector ile tüm eşleşen elementlerin text içeriklerini döndür."""
+        out: list[str] = []
+        for el in self.select(selector, element):
+            txt = el.text(strip=True)
+            if txt:
+                out.append(txt)
+        return out or None
 
     def select_attr(self, selector: str | None, attr: str, element: Node | None = None) -> str | None:
         """CSS selector ile element bul ve attribute değerini döndür."""
         el = self.select_first(selector, element)
         return el.attrs.get(attr) if el else None
 
-    def select_all_text(self, selector: str, element: Node | None = None, strip: bool = True) -> list[str]:
-        """CSS selector ile tüm eşleşen elementlerin text içeriklerini döndür."""
-        return [
-            txt for el in self.select(selector, element)
-                if (txt := el.text(strip=strip))
-        ]
-
-    def select_all_attr(self, selector: str, attr: str, element: Node | None = None) -> list[str]:
+    def select_attrs(self, selector: str, attr: str, element: Node | None = None) -> list[str]:
         """CSS selector ile tüm eşleşen elementlerin attribute değerlerini döndür."""
-        return [
-            val for el in self.select(selector, element)
-                if (val := el.attrs.get(attr))
-        ]
-
-    # ----------------------------------------------
+        out: list[str] = []
+        for el in self.select(selector, element):
+            val = el.attrs.get(attr)
+            if val:
+                out.append(val)
+        return out
 
     def select_poster(self, selector: str = "img", element: Node | None = None) -> str | None:
         """Poster URL'sini çıkar. Önce data-src, sonra src dener."""
         el = self.select_first(selector, element)
         if not el:
             return None
-
         return el.attrs.get("data-src") or el.attrs.get("src")
 
+    def select_direct_text(self, selector: str, element: Node | None = None) -> str | None:
+        """
+        Elementin yalnızca "kendi" düz metnini döndürür (child elementlerin text'ini katmadan).
+        """
+        el = self.select_first(selector, element)
+        if not el:
+            return None
+
+        # type: ignore[call-arg]
+        val = el.text(strip=True, deep=False)
+        return val or None
+
+    # ========================
+    # META (LABEL -> VALUE) İŞLEMLERİ
+    # ========================
+
+    def meta_value(self, label: str, container_selector: str | None = None) -> str | None:
+        """
+        Herhangi bir container içinde: LABEL metnini içeren bir elementten SONRA gelen metni döndürür.
+        label örn: "Oyuncular", "Yapım Yılı", "IMDB"
+        """
+        needle = label.casefold()
+
+        # Belirli bir container varsa içinde ara, yoksa tüm dökümanda
+        targets = self.select(container_selector) if container_selector else [self.parser.body]
+
+        for root in targets:
+            if not root: continue
+
+            # Kalın/vurgulu elementlerde (span, strong, b, label, dt) label'ı ara
+            for label_el in self.select("span, strong, b, label, dt", root):
+                txt = (label_el.text(strip=True) or "").casefold()
+                if needle not in txt:
+                    continue
+
+                # 1) Elementin kendi içindeki text'te LABEL: VALUE formatı olabilir
+                # "Oyuncular: Brad Pitt" gibi. LABEL: sonrasını al.
+                full_txt = label_el.text(strip=True)
+                if ":" in full_txt and needle in full_txt.split(":")[0].casefold():
+                    val = full_txt.split(":", 1)[1].strip()
+                    if val: return val
+
+                # 2) Label sonrası gelen ilk text node'u veya element'i al
+                curr = label_el.next
+                while curr:
+                    if curr.tag == "-text":
+                        val = curr.text(strip=True).strip(" :")
+                        if val: return val
+                    elif curr.tag != "br":
+                        val = curr.text(strip=True).strip(" :")
+                        if val: return val
+                    else: # <br> gördüysek satır bitmiştir
+                        break
+                    curr = curr.next
+
+        return None
+
+    def meta_list(self, label: str, container_selector: str | None = None, sep: str = ",") -> list[str]:
+        """meta_value(...) çıktısını veya label'ın ebeveynindeki linkleri listeye döndürür."""
+        needle = label.casefold()
+        targets = self.select(container_selector) if container_selector else [self.parser.body]
+
+        for root in targets:
+            if not root: continue
+            for label_el in self.select("span, strong, b, label, dt", root):
+                if needle in (label_el.text(strip=True) or "").casefold():
+                    # Eğer elementin ebeveyninde linkler varsa (Kutucuklu yapı), onları al
+                    links = self.select_texts("a", label_el.parent)
+                    if links: return links
+
+                    # Yoksa düz metin olarak meta_value mantığıyla al
+                    raw = self.meta_value(label, container_selector=container_selector)
+                    if not raw: return []
+                    return [x.strip() for x in raw.split(sep) if x.strip()]
+
+        return []
+
     # ========================
     # REGEX İŞLEMLERİ
     # ========================
 
-    def _source(self, target: str | int | None) -> str:
+    def _regex_source(self, target: str | int | None) -> str:
         """Regex için kaynak metni döndürür."""
         return target if isinstance(target, str) else self.html
 
-    def _flags(self, target: str | int | None, flags: int) -> int:
-        """Regex flags değerini döndürür."""
-        return target if isinstance(target, int) else flags
-
-    def regex_first(self, pattern: str, target: str | int | None = None, flags: int = 0) -> str | None:
-        """Regex ile arama yap, ilk grubu döndür (grup yoksa tamamını)."""
-        match = re.search(pattern, self._source(target), self._flags(target, flags))
+    def regex_first(self, pattern: str, target: str | int | None = None, group: int | None = 1) -> str | tuple | None:
+        """Regex ile arama yap, istenen grubu döndür (group=None ise tüm grupları tuple olarak döndür)."""
+        match = re.search(pattern, self._regex_source(target))
         if not match:
             return None
-
-        try:
-            return match.group(1)
-        except IndexError:
-            return match.group(0)
-
-    def regex_all(self, pattern: str, target: str | int | None = None, flags: int = 0) -> list[str]:
+            
+        if group is None:
+            return match.groups()
+            
+        last_idx = match.lastindex or 0
+        return match.group(group) if last_idx >= group else match.group(0)
+
+    def regex_all(self, pattern: str, target: str | int | None = None) -> list[str] | list[tuple]:
         """Regex ile tüm eşleşmeleri döndür."""
-        return re.findall(pattern, self._source(target), self._flags(target, flags))
+        return re.findall(pattern, self._regex_source(target))
 
-    def regex_replace(self, pattern: str, repl: str, target: str | int | None = None, flags: int = 0) -> str:
+    def regex_replace(self, pattern: str, repl: str, target: str | int | None = None) -> str:
         """Regex ile replace yap."""
-        return re.sub(pattern, repl, self._source(target), flags)
+        return re.sub(pattern, repl, self._regex_source(target))
 
     # ========================
     # ÖZEL AYIKLAYICILAR
@@ -108,15 +183,12 @@ class HTMLHelper:
     @staticmethod
     def extract_season_episode(text: str) -> tuple[int | None, int | None]:
         """Metin içinden sezon ve bölüm numarasını çıkar."""
-        # S01E05 formatı
         if m := re.search(r"[Ss](\d+)[Ee](\d+)", text):
             return int(m.group(1)), int(m.group(2))
 
-        # Ayrı ayrı ara
-        s = re.search(r"(\d+)\.\s*[Ss]ezon|[Ss]ezon[- ]?(\d+)|-(\d+)-sezon", text, re.I)
-        e = re.search(r"(\d+)\.\s*[Bb]ölüm|[Bb]olum[- ]?(\d+)|-(\d+)-bolum|[Ee](\d+)", text, re.I)
+        s = re.search(r"(\d+)\.\s*[Ss]ezon|[Ss]ezon[- ]?(\d+)|-(\d+)-sezon|S(\d+)|(\d+)\.[Ss]", text, re.I)
+        e = re.search(r"(\d+)\.\s*[Bb][öo]l[üu]m|[Bb][öo]l[üu]m[- ]?(\d+)|-(\d+)-bolum|[Ee](\d+)", text, re.I)
 
-        # İlk bulunan grubu al (None değilse)
         s_val = next((int(g) for g in s.groups() if g), None) if s else None
         e_val = next((int(g) for g in e.groups() if g), None) if e else None
 
@@ -131,4 +203,3 @@ class HTMLHelper:
 
         val = self.regex_first(pattern)
         return int(val) if val and val.isdigit() else None
-

KekikStream/Core/Plugin/PluginBase.py

@@ -25,7 +25,7 @@ class PluginBase(ABC):
         self.main_page = {url.replace(self.main_url, new_url): category for url, category in self.main_page.items()}
         self.main_url  = new_url
 
-    def __init__(self, proxy: str | dict | None = None):
+    def __init__(self, proxy: str | dict | None = None, ex_manager: str | ExtractorManager = "Extractors"):
         # cloudscraper - for bypassing Cloudflare
         self.cloudscraper = CloudScraper()
         if proxy:
@@ -50,7 +50,12 @@ class PluginBase(ABC):
         })
 
         self.media_handler = MediaHandler()
-        self.ex_manager    = ExtractorManager()
+        
+        # If an instance is passed, use it; otherwise create a new one
+        if isinstance(ex_manager, ExtractorManager):
+            self.ex_manager = ex_manager
+        else:
+            self.ex_manager = ExtractorManager(extractor_dir=ex_manager)
 
     @abstractmethod
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
@@ -101,11 +106,18 @@ class PluginBase(ABC):
             return ""
 
         if url.startswith("http") or url.startswith("{\""):
-            return url
-
-        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
-
-    async def extract(self, url: str, referer: str = None, prefix: str | None = None) -> ExtractResult | None:
+            return url.replace("\\", "")
+
+        url = f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        return url.replace("\\", "")
+
+    async def extract(
+        self, 
+        url: str, 
+        referer: str = None, 
+        prefix: str | None = None, 
+        name_override: str | None = None
+    ) -> ExtractResult | list[ExtractResult] | None:
         """
         Extractor ile video URL'sini çıkarır.
 
@@ -113,6 +125,7 @@ class PluginBase(ABC):
             url: Iframe veya video URL'si
             referer: Referer header (varsayılan: plugin main_url)
             prefix: İsmin başına eklenecek opsiyonel etiket (örn: "Türkçe Dublaj")
+            name_override: İsmi tamamen değiştirecek opsiyonel etiket (Extractor adını ezer)
 
         Returns:
             ExtractResult: Extractor sonucu (name prefix ile birleştirilmiş) veya None
@@ -130,16 +143,26 @@ class PluginBase(ABC):
         try:
             data = await extractor.extract(url, referer=referer)
 
-            # Liste ise her bir öğe için prefix ekle
+            # Liste ise her bir öğe için prefix/override ekle
             if isinstance(data, list):
                 for item in data:
-                    if prefix and item.name:
-                        item.name = f"{prefix} | {item.name}"
+                    if name_override:
+                        item.name = name_override
+                    elif prefix and item.name:
+                        if item.name.lower() in prefix.lower():
+                            item.name = prefix
+                        else:
+                            item.name = f"{prefix} | {item.name}"
                 return data
 
             # Tekil öğe ise
-            if prefix and data.name:
-                data.name = f"{prefix} | {data.name}"
+            if name_override:
+                data.name = name_override
+            elif prefix and data.name:
+                if data.name.lower() in prefix.lower():
+                    data.name = prefix
+                else:
+                    data.name = f"{prefix} | {data.name}"
 
             return data
         except Exception as hata:

KekikStream/Core/Plugin/PluginLoader.py

@@ -6,11 +6,12 @@ from pathlib     import Path
 import os, importlib.util, traceback
 
 class PluginLoader:
-    def __init__(self, plugins_dir: str, proxy: str | dict | None = None):
+    def __init__(self, plugins_dir: str, proxy: str | dict | None = None, ex_manager: str | ExtractorManager = "Extractors"):
         # Yerel ve global eklenti dizinlerini ayarla
         self.proxy = proxy
+        self.ex_manager = ex_manager
         self.local_plugins_dir  = Path(plugins_dir).resolve()
-        self.global_plugins_dir = Path(__file__).parent.parent.parent / plugins_dir
+        self.global_plugins_dir = Path(__file__).parent.parent.parent / "Plugins"
 
         # Dizin kontrolü
         if not self.local_plugins_dir.exists() and not self.global_plugins_dir.exists():
@@ -18,19 +19,16 @@ class PluginLoader:
             cikis_yap(False)
 
     def load_all(self) -> dict[str, PluginBase]:
-        plugins = {}
+        plugins         = {}
+        local_dir_exists = self.local_plugins_dir.exists() and self.local_plugins_dir.resolve() != self.global_plugins_dir.resolve()
 
-        # Eğer yerel dizinde Plugin varsa, sadece onları yükle (eklenti geliştirme modu)
-        if self.local_plugins_dir.exists():
+        # Eğer yerel dizin varsa, sadece oradan yükle (eklenti geliştirme/yayınlama modu)
+        if local_dir_exists:
             # konsol.log(f"[green][*] Yerel Eklenti dizininden yükleniyor: {self.local_plugins_dir}[/green]")
-            local_plugins = self._load_from_directory(self.local_plugins_dir)
-
-            if local_plugins:
-                # konsol.log("[cyan][*] Yerel Plugin bulundu, global Plugin'ler atlanıyor (eklenti geliştirme modu)[/cyan]")
-                plugins |= local_plugins
-
-        # Yerel dizinde Plugin yoksa, global'leri yükle
-        if not plugins and self.global_plugins_dir.exists():
+            plugins |= self._load_from_directory(self.local_plugins_dir)
+        
+        # Yerel dizin yoksa (veya core ile aynı yerse), global'leri yükle
+        else:
             # konsol.log(f"[green][*] Global Eklenti dizininden yükleniyor: {self.global_plugins_dir}[/green]")
             plugins |= self._load_from_directory(self.global_plugins_dir)
 
@@ -71,7 +69,7 @@ class PluginLoader:
                 obj = getattr(module, attr)
                 if isinstance(obj, type) and issubclass(obj, PluginBase) and obj is not PluginBase:
                     # konsol.log(f"[yellow]Yüklenen sınıf\t\t: {module_name}.{obj.__name__} ({obj.__module__}.{obj.__name__})[/yellow]")
-                    return obj(proxy=self.proxy)
+                    return obj(proxy=self.proxy, ex_manager=self.ex_manager)
 
         except Exception as hata:
             konsol.print(f"[red][!] Eklenti yüklenirken hata oluştu: {module_name}\nHata: {hata}")

KekikStream/Core/Plugin/PluginManager.py

@@ -4,9 +4,9 @@ from .PluginLoader import PluginLoader
 from .PluginBase   import PluginBase
 
 class PluginManager:
-    def __init__(self, plugin_dir="Plugins", proxy: str | dict | None = None):
+    def __init__(self, plugin_dir="Plugins", proxy: str | dict | None = None, ex_manager: str | ExtractorManager = "Extractors"):
         # Eklenti yükleyiciyi başlat ve tüm eklentileri yükle
-        self.plugin_loader = PluginLoader(plugin_dir, proxy=proxy)
+        self.plugin_loader = PluginLoader(plugin_dir, proxy=proxy, ex_manager=ex_manager)
         self.plugins       = self.plugin_loader.load_all()
 
     def get_plugin_names(self):

KekikStream/Core/Plugin/PluginModels.py

@@ -51,9 +51,6 @@ class Episode(BaseModel):
         if not self.title:
             self.title = ""
 
-        if any(keyword in self.title.lower() for keyword in ["bölüm", "sezon", "episode"]):
-            self.title = ""
-
         return self
 
 class SeriesInfo(BaseModel):

KekikStream/Extractors/Abstream.py

@@ -0,0 +1,27 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+
+class Abstream(ExtractorBase):
+    name     = "Abstream"
+    main_url = "https://abstream.to"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        istek  = await self.httpx.get(
+            url     = url,
+            headers = {
+                "Accept-Language" : "en-US,en;q=0.5",
+                "Referer"         : referer or self.main_url,
+            }
+        )
+        secici    = HTMLHelper(istek.text)
+        video_url = secici.regex_first(r'file:"([^"]*)"')
+
+        if not video_url:
+            raise ValueError(f"Abstream: Video URL bulunamadı. {url}")
+
+        return ExtractResult(
+            name    = self.name,
+            url     = video_url,
+            referer = referer or self.main_url
+        )

KekikStream/Extractors/CloseLoad.py

@@ -2,75 +2,51 @@
 
 from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 from Kekik.Sifreleme   import Packer, StreamDecoder
-import json
+import json, contextlib
 
-class CloseLoadExtractor(ExtractorBase):
+class CloseLoad(ExtractorBase):
     name     = "CloseLoad"
     main_url = "https://closeload.filmmakinesi.to"
 
-    def _extract_from_json_ld(self, html: str) -> str | None:
-        """JSON-LD script tag'inden contentUrl'i çıkar (Kotlin versiyonundaki gibi)"""
-        secici = HTMLHelper(html)
-        for script in secici.select("script[type='application/ld+json']"):
-            try:
-                data = json.loads(script.text(strip=True))
-                if content_url := data.get("contentUrl"):
-                    if content_url.startswith("http"):
-                        return content_url
-            except (json.JSONDecodeError, TypeError):
-                # Regex ile contentUrl'i çıkarmayı dene
-                if content_url := secici.regex_first(r'"contentUrl"\s*:\s*"([^\"]+)"', script.text()):
-                    if content_url.startswith("http"):
-                        return content_url
-        return None
-
-    def _extract_from_packed(self, html: str) -> str | None:
-        """Packed JavaScript'ten video URL'sini çıkar (fallback)"""
-        try:
-            packed = HTMLHelper(html).regex_all(r'\s*(eval\(function[\s\S].*)')
-            if packed:
-                return StreamDecoder.extract_stream_url(Packer.unpack(packed[0]))
-        except Exception:
-            pass
-        return None
-
-    async def extract(self, url, referer=None) -> ExtractResult:
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-        
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
         self.httpx.headers.update({
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0",
-            "Origin": self.main_url
+            "Referer" : referer or self.main_url,
+            "Origin"  : self.main_url
         })
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        # Önce JSON-LD'den dene (daha güvenilir - Kotlin versiyonu gibi)
-        m3u_link = self._extract_from_json_ld(istek.text)
+        # 1. JSON-LD'den Dene
+        m3u8_url = None
+        for script in sel.select("script[type='application/ld+json']"):
+            with contextlib.suppress(Exception):
+                data = json.loads(script.text(strip=True))
+                if content_url := data.get("contentUrl"):
+                    if content_url.startswith("http"):
+                        m3u8_url = content_url
+                        break
         
-        # Fallback: Packed JavaScript'ten çıkar
-        if not m3u_link:
-            m3u_link = self._extract_from_packed(istek.text)
+        # 2. Packed Script Fallback
+        if not m3u8_url:
+            if packed := sel.regex_first(r"(eval\(function\(p,a,c,k,e,d\).+?)\s*</script>"):
+                m3u8_url = StreamDecoder.extract_stream_url(Packer.unpack(packed))
 
-        if not m3u_link:
-            raise Exception("Video URL bulunamadı (ne JSON-LD ne de packed script'ten)")
+        if not m3u8_url:
+            raise ValueError(f"CloseLoad: Video URL bulunamadı. {url}")
 
-        # Subtitle'ları parse et (Kotlin referansı: track elementleri)
         subtitles = []
-        secici = HTMLHelper(istek.text)
-        for track in secici.select("track"):
-            raw_src = track.attrs.get("src") or ""
-            raw_src = raw_src.strip()
-            label   = track.attrs.get("label") or track.attrs.get("srclang") or "Altyazı"
-            
-            if raw_src:
-                full_url = raw_src if raw_src.startswith("http") else f"{self.main_url}{raw_src}"
-                subtitles.append(Subtitle(name=label, url=full_url))
+        for track in sel.select("track"):
+            src = track.attrs.get("src")
+            if src:
+                subtitles.append(Subtitle(
+                    name = track.attrs.get("label") or track.attrs.get("srclang") or "Altyazı",
+                    url  = self.fix_url(src)
+                ))
 
         return ExtractResult(
             name      = self.name,
-            url       = m3u_link,
+            url       = m3u8_url,
             referer   = self.main_url,
             subtitles = subtitles
         )