KekikStream 1.9.9__py3-none-any.whl → 2.0.8__py3-none-any.whl

KekikStream/Extractors/YTDLP.py

@@ -1,8 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, get_ytdlp_extractors
 from urllib.parse     import urlparse
-from yt_dlp.extractor import gen_extractors
 import yt_dlp, re, sys, os
 
 class YTDLP(ExtractorBase):
@@ -11,51 +10,120 @@ class YTDLP(ExtractorBase):
 
     _FAST_DOMAIN_RE = None  # compiled mega-regex (host üstünden)
 
+    _POPULAR_TLDS = {
+        "com", "net", "org", "tv", "io", "co", "me", "ly", "ru", "fr", "de", "es", "it",
+        "nl", "be", "ch", "at", "uk", "ca", "au", "jp", "kr", "cn", "in", "br", "mx",
+        "ar", "tr", "gov", "edu", "mil", "int", "info", "biz", "name", "pro", "aero",
+        "coop", "museum", "onion"
+    }
+
+    # 1. Literal TLD Regex: youtube\.com, vimeo\.com
+    # sorted by reverse length to prevent partial matches (e.g. 'co' matching 'com')
+    _LITERAL_TLD_RE = re.compile(
+        rf"([a-z0-9][-a-z0-9]*(?:\\\.[-a-z0-9]+)*\\\.(?:{'|'.join(sorted(_POPULAR_TLDS, key=len, reverse=True))}))",
+        re.IGNORECASE
+    )
+
+    # 2. Regex TLD Regex: dailymotion\.[a-z]{2,3}
+    _REGEX_TLD_RE = re.compile(
+        r"([a-z0-9][-a-z0-9]*)\\\.\[a-z\]\{?\d*,?\d*\}?",
+        re.IGNORECASE
+    )
+
+    # 3. Alternation TLD Regex: \.(?:com|net|org)
+    _ALT_TLD_RE = re.compile(
+        r"\\\.\(\?:([a-z|]+)\)",
+        re.IGNORECASE
+    )
+
+    # Kelime yakalayıcı (domain bulmak için)
+    _DOMAIN_WORD_RE = re.compile(
+        r"([a-z0-9][-a-z0-9]*)",
+        re.IGNORECASE
+    )
+
     @classmethod
-    def _init_fast_domain_regex(cls):
-        if cls._FAST_DOMAIN_RE is not None:
-            return
+    def _extract_literal_domains(cls, valid_url: str) -> set[str]:
+        """Pattern 1: Literal TLD domainlerini (youtube.com) çıkarır."""
+        return {
+            m.replace(r"\.", ".").lower()
+            for m in cls._LITERAL_TLD_RE.findall(valid_url)
+        }
+
+    @classmethod
+    def _extract_regex_tld_domains(cls, valid_url: str) -> set[str]:
+        """Pattern 2: Regex TLD domainlerini (dailymotion.[...]) çıkarır ve popüler TLD'lerle birleştirir."""
+        domains = set()
+        for base in cls._REGEX_TLD_RE.findall(valid_url):
+            base_domain = base.lower()
+            for tld in cls._POPULAR_TLDS:
+                domains.add(f"{base_domain}.{tld}")
+        return domains
 
+    @classmethod
+    def _extract_alternation_domains(cls, valid_url: str) -> set[str]:
+        """Pattern 3: Alternation TLD domainlerini (pornhub.(?:com|net)) çıkarır."""
         domains = set()
+        for m in cls._ALT_TLD_RE.finditer(valid_url):
+            tlds = m.group(1).split("|")
+            start = m.start()
+
+            # Geriye doğru git ve domain'i bul
+            before = valid_url[:start]
+
+            # 1. Named Groups (?P<name> temizle
+            before = re.sub(r"\(\?P<[^>]+>", "", before)
 
-        # yt-dlp extractor'larının _VALID_URL regex'lerinden domain yakala
-        # Regex metinlerinde domainler genelde "\." şeklinde geçer.
-        domain_pat = re.compile(r"(?:[a-z0-9-]+\\\.)+[a-z]{2,}", re.IGNORECASE)
+            # 2. Simple Non-Capturing Groups (?:xxx)? temizle (sadece alphanumeric ve escape)
+            before = re.sub(r"\(\?:[a-z0-9-]+\)\??", "", before)
 
-        for ie in gen_extractors():
-            # Generic'i fast-path'e dahil etmiyoruz
-            if getattr(ie, "IE_NAME", "").lower() == "generic":
+            # Son domain-like kelimeyi al
+            words = cls._DOMAIN_WORD_RE.findall(before)
+            if not words:
                 continue
 
+            base = words[-1].lower()
+            for tld in tlds:
+                tld = tld.strip().lower()
+                if tld and len(tld) <= 6:
+                    domains.add(f"{base}.{tld}")
+
+        return domains
+
+    @classmethod
+    def _init_fast_domain_regex(cls):
+        """
+        Fast domain regex'i initialize et
+        """
+        if cls._FAST_DOMAIN_RE is not None:
+            return
+
+        domains = set()
+        extractors = get_ytdlp_extractors()
+
+        for ie in extractors:
             valid = getattr(ie, "_VALID_URL", None)
             if not valid or not isinstance(valid, str):
                 continue
 
-            for m in domain_pat.findall(valid):
-                d = m.replace(r"\.", ".").lower()
-
-                # Çok agresif/şüpheli şeyleri elemek istersen burada filtre koyabilirsin
-                # (genelde gerek kalmıyor)
-                domains.add(d)
+            domains |= cls._extract_literal_domains(valid)
+            domains |= cls._extract_regex_tld_domains(valid)
+            domains |= cls._extract_alternation_domains(valid)
 
         # Hiç domain çıkmazsa (çok uç durum) fallback: boş regex
         if not domains:
             cls._FAST_DOMAIN_RE = re.compile(r"$^")  # hiçbir şeye match etmez
             return
 
-        # Host eşleştirmesi: subdomain destekli (m.youtube.com, player.vimeo.com vs.)
-        # (?:^|.*\.) (domain1|domain2|...) $
-        joined = "|".join(sorted(re.escape(d) for d in domains))
-        pattern = rf"(?:^|.*\.)(?:{joined})$"
-        cls._FAST_DOMAIN_RE = re.compile(pattern, re.IGNORECASE)
+        joined = "|".join(re.escape(d) for d in sorted(domains))
+        cls._FAST_DOMAIN_RE = re.compile(rf"(?:^|.*\.)(?:{joined})$", re.IGNORECASE)
 
     def __init__(self):
         self.__class__._init_fast_domain_regex()
 
     def can_handle_url(self, url: str) -> bool:
         """
-        Fast-path: URL host'unu tek mega-regex ile kontrol et (loop yok)
-        Slow-path: gerekirse mevcut extract_info tabanlı kontrolün
+        Fast-path: URL host'unu tek mega-regex ile kontrol et
         """
         # URL parse + host al
         try:
@@ -76,39 +144,8 @@ class YTDLP(ExtractorBase):
         if host and self.__class__._FAST_DOMAIN_RE.search(host):
             return True
 
-        # SLOW PATH: Diğer siteler için yt-dlp'nin native kontrolü
-        try:
-            # stderr'ı geçici olarak kapat (hata mesajlarını gizle)
-            old_stderr = sys.stderr
-            sys.stderr = open(os.devnull, "w")
-
-            try:
-                ydl_opts = {
-                    "simulate"              : True,  # Download yok, sadece tespit
-                    "quiet"                 : True,  # Log kirliliği yok
-                    "no_warnings"           : True,  # Uyarı mesajları yok
-                    "extract_flat"          : True,  # Minimal işlem
-                    "no_check_certificates" : True,
-                    "ignoreerrors"          : True   # Hataları yoksay
-                }
-
-                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                    # URL'yi işleyebiliyor mu kontrol et
-                    info = ydl.extract_info(url, download=False, process=False)
-
-                    # Generic extractor ise atla
-                    if info and info.get("extractor_key") != "Generic":
-                        return True
-
-                    return False
-            finally:
-                # stderr'ı geri yükle
-                sys.stderr.close()
-                sys.stderr = old_stderr
-
-        except Exception:
-            # yt-dlp işleyemezse False döndür
-            return False
+        # yt-dlp işleyemezse False döndür
+        return False
 
     async def extract(self, url: str, referer: str | None = None) -> ExtractResult:
         ydl_opts = {
@@ -116,7 +153,9 @@ class YTDLP(ExtractorBase):
             "no_warnings"           : True,
             "extract_flat"          : False,   # Tam bilgi al
             "format"                : "best",  # En iyi kalite
-            "no_check_certificates" : True
+            "no_check_certificates" : True,
+            "socket_timeout"        : 3,
+            "retries"               : 1
         }
 
         # Referer varsa header olarak ekle

KekikStream/Plugins/BelgeselX.py

@@ -0,0 +1,204 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode
+from parsel           import Selector
+import re
+
+class BelgeselX(PluginBase):
+    name        = "BelgeselX"
+    language    = "tr"
+    main_url    = "https://belgeselx.com"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "2022 yılında son çıkan belgeselleri belgeselx.com'da izle. En yeni belgeseller, türkçe altyazılı yada dublaj olarak 1080p kalitesinde hd belgesel izle."
+
+    main_page   = {
+        f"{main_url}/konu/turk-tarihi-belgeselleri&page=" : "Türk Tarihi",
+        f"{main_url}/konu/tarih-belgeselleri&page="       : "Tarih",
+        f"{main_url}/konu/seyehat-belgeselleri&page="     : "Seyahat",
+        f"{main_url}/konu/seri-belgeseller&page="         : "Seri",
+        f"{main_url}/konu/savas-belgeselleri&page="       : "Savaş",
+        f"{main_url}/konu/sanat-belgeselleri&page="       : "Sanat",
+        f"{main_url}/konu/psikoloji-belgeselleri&page="   : "Psikoloji",
+        f"{main_url}/konu/polisiye-belgeselleri&page="    : "Polisiye",
+        f"{main_url}/konu/otomobil-belgeselleri&page="    : "Otomobil",
+        f"{main_url}/konu/nazi-belgeselleri&page="        : "Nazi",
+        f"{main_url}/konu/muhendislik-belgeselleri&page=" : "Mühendislik",
+        f"{main_url}/konu/kultur-din-belgeselleri&page="  : "Kültür Din",
+        f"{main_url}/konu/kozmik-belgeseller&page="       : "Kozmik",
+        f"{main_url}/konu/hayvan-belgeselleri&page="      : "Hayvan",
+        f"{main_url}/konu/eski-tarih-belgeselleri&page="  : "Eski Tarih",
+        f"{main_url}/konu/egitim-belgeselleri&page="      : "Eğitim",
+        f"{main_url}/konu/dunya-belgeselleri&page="       : "Dünya",
+        f"{main_url}/konu/doga-belgeselleri&page="        : "Doğa",
+        f"{main_url}/konu/bilim-belgeselleri&page="       : "Bilim"
+    }
+
+    @staticmethod
+    def _to_title_case(text: str) -> str:
+        """Türkçe için title case dönüşümü."""
+        return " ".join(
+            word.lower().replace("i", "İ").capitalize() if word.lower().startswith("i") else word.capitalize()
+            for word in text.split()
+        )
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = self.cloudscraper.get(f"{url}{page}")
+        secici = Selector(istek.text)
+
+        results = []
+        for item in secici.css("div.gen-movie-contain > div.gen-info-contain > div.gen-movie-info"):
+            title  = item.css("div.gen-movie-info > h3 a::text").get()
+            href   = item.css("div.gen-movie-info > h3 a::attr(href)").get()
+            parent = item.xpath("../../..")
+            poster = parent.css("div.gen-movie-img > img::attr(src)").get()
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = self._to_title_case(title.strip()),
+                    url      = self.fix_url(href),
+                    poster   = self.fix_url(poster) if poster else None
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        # Google Custom Search API kullanıyor
+        cx = "016376594590146270301:iwmy65ijgrm"
+
+        token_resp = self.cloudscraper.get(f"https://cse.google.com/cse.js?cx={cx}")
+        token_text = token_resp.text
+
+        cse_lib_match = re.search(r'cselibVersion": "(.*)"', token_text)
+        cse_tok_match = re.search(r'cse_token": "(.*)"', token_text)
+
+        if not cse_lib_match or not cse_tok_match:
+            return []
+
+        cse_lib = cse_lib_match.group(1)
+        cse_tok = cse_tok_match.group(1)
+
+        search_url = (
+            f"https://cse.google.com/cse/element/v1?"
+            f"rsz=filtered_cse&num=100&hl=tr&source=gcsc&cselibv={cse_lib}&cx={cx}"
+            f"&q={query}&safe=off&cse_tok={cse_tok}&sort=&exp=cc%2Capo&oq={query}"
+            f"&callback=google.search.cse.api9969&rurl=https%3A%2F%2Fbelgeselx.com%2F"
+        )
+
+        resp = self.cloudscraper.get(search_url)
+        resp_text = resp.text
+
+        titles = re.findall(r'"titleNoFormatting": "(.*?)"', resp_text)
+        urls   = re.findall(r'"url": "(.*?)"', resp_text)
+        images = re.findall(r'"ogImage": "(.*?)"', resp_text)
+
+        results = []
+        for i, title in enumerate(titles):
+            url_val = urls[i] if i < len(urls) else None
+            poster  = images[i] if i < len(images) else None
+
+            if not url_val or "diziresimleri" not in url_val:
+                # URL'den belgesel linkini oluştur
+                if poster and "diziresimleri" in poster:
+                    file_name = poster.rsplit("/", 1)[-1]
+                    file_name = re.sub(r"\.(jpe?g|png|webp)$", "", file_name)
+                    url_val = f"{self.main_url}/belgeseldizi/{file_name}"
+                else:
+                    continue
+
+            clean_title = title.split("İzle")[0].strip()
+            results.append(SearchResult(
+                title  = self._to_title_case(clean_title),
+                url    = url_val,
+                poster = poster
+            ))
+
+        return results
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("h2.gen-title::text").get()
+        poster      = secici.css("div.gen-tv-show-top img::attr(src)").get()
+        description = secici.css("div.gen-single-tv-show-info p::text").get()
+
+        tags = []
+        for tag_link in secici.css("div.gen-socail-share a[href*='belgeselkanali']"):
+            tag_href = tag_link.css("::attr(href)").get()
+            if tag_href:
+                tag_name = tag_href.rsplit("/", 1)[-1].replace("-", " ")
+                tags.append(self._to_title_case(tag_name))
+
+        episodes = []
+        counter  = 0
+        for ep_item in secici.css("div.gen-movie-contain"):
+            ep_name = ep_item.css("div.gen-movie-info h3 a::text").get()
+            ep_href = ep_item.css("div.gen-movie-info h3 a::attr(href)").get()
+
+            if not ep_name or not ep_href:
+                continue
+
+            season_text   = ep_item.css("div.gen-single-meta-holder ul li::text").get() or ""
+            episode_match = re.search(r"Bölüm (\d+)", season_text)
+            season_match  = re.search(r"Sezon (\d+)", season_text)
+
+            ep_episode = int(episode_match.group(1)) if episode_match else counter
+            ep_season  = int(season_match.group(1)) if season_match else 1
+
+            counter += 1
+
+            episodes.append(Episode(
+                season  = ep_season,
+                episode = ep_episode,
+                title   = ep_name.strip(),
+                url     = self.fix_url(ep_href)
+            ))
+
+        return SeriesInfo(
+            url         = url,
+            poster      = self.fix_url(poster) if poster else None,
+            title       = self._to_title_case(title.strip()) if title else None,
+            description = description.strip() if description else None,
+            tags        = tags,
+            episodes    = episodes
+        )
+
+    async def load_links(self, url: str) -> list[dict]:
+        istek = await self.httpx.get(url)
+        text  = istek.text
+
+        # fnc_addWatch div'inden data-episode ID'sini al
+        ep_match = re.search(r'<div[^>]*class=["\'][^"\']*fnc_addWatch[^"\']*["\'][^>]*data-episode=["\'](\d+)["\']', text)
+        if not ep_match:
+            return []
+
+        episode_id  = ep_match.group(1)
+        iframe_url  = f"{self.main_url}/video/data/new4.php?id={episode_id}"
+
+        iframe_resp = await self.httpx.get(iframe_url, headers={"Referer": url})
+        iframe_text = iframe_resp.text
+
+        links = []
+        for match in re.finditer(r'file:"([^"]+)", label: "([^"]+)"', iframe_text):
+            video_url = match.group(1)
+            quality   = match.group(2)
+
+            source_name = "Google" if quality == "FULL" else self.name
+            quality_str = "1080p" if quality == "FULL" else quality
+
+            links.append({
+                "url"     : video_url,
+                "name"    : f"{source_name} | {quality_str}",
+                "referer" : url
+            })
+
+        return links
+
+    async def play(self, **kwargs):
+        extract_result = ExtractResult(**kwargs)
+        self.media_handler.title = kwargs.get("name")
+        if self.name not in self.media_handler.title:
+            self.media_handler.title = f"{self.name} | {self.media_handler.title}"
+
+        self.media_handler.play_media(extract_result)

KekikStream/Plugins/Dizilla.py

@@ -137,7 +137,7 @@ class Dizilla(PluginBase):
         year        = veri.get("datePublished").split("-")[0]
         
         # Tags extraction from page content (h3 tag)
-        tags_raw = secici.css("h3.text-white.opacity-60::text").get()
+        tags_raw = secici.css("div.poster.poster h3::text").get()
         tags     = [t.strip() for t in tags_raw.split(",")] if tags_raw else []
 
         rating = veri.get("aggregateRating", {}).get("ratingValue")
@@ -179,17 +179,25 @@ class Dizilla(PluginBase):
         decrypted   = await self.decrypt_response(secure_data)
         results     = decrypted.get("RelatedResults", {}).get("getEpisodeSources", {}).get("result", [])
 
-        links = []
-        for result in results:
-            iframe_src = Selector(result.get("source_content")).css("iframe::attr(src)").get()
-            iframe_url = self.fix_url(iframe_src)
-            if not iframe_url:
-                continue
+        if not results:
+            return []
 
-            extractor = self.ex_manager.find_extractor(iframe_url)
-            links.append({
-                "url"  : iframe_url,
-                "name" : f"{extractor.name if extractor else 'Main Player'} | {result.get('language_name')}",
-            })
-
-        return links
+        # Get first source (matching Kotlin)
+        first_result = results[0]
+        source_content = first_result.get("source_content", "")
+        
+        # Clean the source_content string (matching Kotlin: .replace("\"", "").replace("\\", ""))
+        cleaned_source = source_content.replace('"', '').replace('\\', '')
+        
+        # Parse cleaned HTML
+        iframe_src = Selector(cleaned_source).css("iframe::attr(src)").get()
+        iframe_url = self.fix_url(iframe_src)
+        
+        if not iframe_url:
+            return []
+
+        extractor = self.ex_manager.find_extractor(iframe_url)
+        return [{
+            "url"  : iframe_url,
+            "name" : f"{extractor.name if extractor else 'Main Player'} | {first_result.get('language_name', 'Unknown')}",
+        }]

KekikStream/Plugins/FilmMakinesi.py

@@ -8,7 +8,7 @@ class FilmMakinesi(PluginBase):
     language    = "tr"
     main_url    = "https://filmmakinesi.to"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Film Makinesi, en yeni ve en güncel filmleri sitemizde full HD kalite farkı ile izleyebilirsiniz. HD film izle denildiğinde akla gelen en kaliteli film izleme sitesi."
+    description = "Film Makinesi ile en yeni ve güncel filmleri Full HD kalite farkı ile izleyebilirsiniz. Film izle denildiğinde akla gelen en kaliteli film sitesi."
 
     main_page   = {
         f"{main_url}/filmler-1/"                : "Son Filmler",
@@ -83,6 +83,7 @@ class FilmMakinesi(PluginBase):
             rating = rating.strip().split()[0]
         year        = secici.css("span.date a::text").get().strip()
         actors      = secici.css("div.cast-name::text").getall()
+        tags        = secici.css("div.genre a::text").getall()
         duration    = secici.css("div.time::text").get()
         if duration:
             duration = duration.split()[1].strip()
@@ -92,6 +93,7 @@ class FilmMakinesi(PluginBase):
             poster      = self.fix_url(poster),
             title       = self.clean_title(title),
             description = description,
+            tags        = tags,
             rating      = rating,
             year        = year,
             actors      = actors,

KekikStream/Plugins/FilmModu.py

@@ -9,7 +9,7 @@ class FilmModu(PluginBase):
     language    = "tr"
     main_url    = "https://www.filmmodu.ws"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "HD Film izle, Türkçe Dublaj ve Altyazılı filmler."
+    description = "Film modun geldiyse yüksek kalitede yeni filmleri izle, 1080p izleyebileceğiniz reklamsız tek film sitesi."
 
     main_page   = {
         f"{main_url}/hd-film-kategori/4k-film-izle?page=SAYFA"          : "4K",
@@ -91,9 +91,13 @@ class FilmModu(PluginBase):
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
+        alternates = secici.css("div.alternates a")
+        if not alternates:
+            return []  # No alternates available
+
         results = []
 
-        for alternatif in secici.css("div.alternates a"):
+        for alternatif in alternates:
             alt_link = self.fix_url(alternatif.css("::attr(href)").get())
             alt_name = alternatif.css("::text").get()
 

KekikStream/Plugins/FullHDFilmizlesene.py

@@ -10,7 +10,7 @@ class FullHDFilmizlesene(PluginBase):
     language    = "tr"
     main_url    = "https://www.fullhdfilmizlesene.tv"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Sinema zevkini evinize kadar getirdik. Türkiye'nin lider Film sitesinde, en yeni filmleri Full HD izleyin."
+    description = "Türkiye'nin ilk ve lider HD film izleme platformu, kaliteli ve sorunsuz hizmetiyle sinema keyfini zirveye taşır."
 
     main_page   = {
         f"{main_url}/en-cok-izlenen-hd-filmler/"            : "En Çok izlenen Filmler",

KekikStream/Plugins/HDFilmCehennemi.py

@@ -3,14 +3,14 @@
 from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, Subtitle
 from parsel           import Selector
 from Kekik.Sifreleme  import Packer, StreamDecoder
-import random, string, re
+import random, string, re, base64
 
 class HDFilmCehennemi(PluginBase):
     name        = "HDFilmCehennemi"
     language    = "tr"
     main_url    = "https://www.hdfilmcehennemi.ws"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Türkiye'nin en hızlı hd film izleme sitesi"
+    description = "Türkiye'nin en hızlı hd film izleme sitesi. Tek ve gerçek hdfilmcehennemi sitesi."
     
 
 
@@ -146,17 +146,85 @@ class HDFilmCehennemi(PluginBase):
 
         return results
 
+    def hdch_decode(self, value_parts: list[str]) -> str:
+        """
+        HDFilmCehennemi için özel decoder.
+        JavaScript sırası: join -> reverse -> atob -> atob -> shift_back
+        """
+        try:
+            # 1. Parçaları birleştir
+            joined = ''.join(value_parts)
+            
+            # 2. Ters çevir (REV)
+            result = StreamDecoder._reverse(joined)
+            
+            # 3. İlk base64 decode (B64D)
+            result = StreamDecoder._base64_decode(result)
+            if result is None:
+                return ""
+            
+            # 4. İkinci base64 decode (B64D) - JavaScript'te iki kez atob yapılıyor!
+            result = StreamDecoder._base64_decode(result)
+            if result is None:
+                return ""
+            
+            # 5. Shift back (SHF)
+            result = StreamDecoder._shift_back(result)
+            
+            return result
+        except Exception:
+            return ""
+
+    def extract_hdch_url(self, unpacked: str) -> str:
+        """HDFilmCehennemi unpacked script'ten video URL'sini çıkar"""
+        # 1) Decode fonksiyonunun adını bul: function <NAME>(value_parts)
+        match_fn = re.search(r'function\s+(\w+)\s*\(\s*value_parts\s*\)', unpacked)
+        if not match_fn:
+            return ""
+        
+        fn_name = match_fn.group(1)
+        
+        # 2) Bu fonksiyonun array ile çağrıldığı yeri bul: <NAME>([ ... ])
+        array_call_regex = re.compile(rf'{re.escape(fn_name)}\(\s*\[(.*?)\]\s*\)', re.DOTALL)
+        match_call = array_call_regex.search(unpacked)
+        if not match_call:
+            return ""
+        
+        array_body = match_call.group(1)
+        
+        # 3) Array içindeki string parçalarını topla
+        parts = re.findall(r'["\']([^"\']+)["\']', array_body)
+        if not parts:
+            return ""
+        
+        # 4) Özel decoder ile çöz
+        return self.hdch_decode(parts)
+
     async def invoke_local_source(self, iframe: str, source: str, url: str):
-        self.httpx.headers.update({"Referer": f"{self.main_url}/"})
+        self.httpx.headers.update({
+            "Referer": f"{self.main_url}/",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0"
+        })
         istek = await self.httpx.get(iframe)
 
+        if not istek.text:
+            return await self.cehennempass(iframe.split("/")[-1])
+
+        # eval(function...) içeren packed script bul
+        eval_match = re.search(r'(eval\(function[\s\S]+)', istek.text)
+        if not eval_match:
+            return await self.cehennempass(iframe.split("/")[-1])
+
         try:
-            eval_func = re.compile(r'\s*(eval\(function[\s\S].*)\s*').findall(istek.text)[0]
+            unpacked = Packer.unpack(eval_match.group(1))
         except Exception:
             return await self.cehennempass(iframe.split("/")[-1])
 
-        unpacked  = Packer.unpack(eval_func)
-        video_url = StreamDecoder.extract_stream_url(unpacked)
+        # HDFilmCehennemi özel decoder ile video URL'sini çıkar
+        video_url = self.extract_hdch_url(unpacked)
+        
+        if not video_url:
+            return await self.cehennempass(iframe.split("/")[-1])
 
         subtitles = []
         try:
@@ -200,8 +268,15 @@ class HDFilmCehennemi(PluginBase):
                 match  = re.search(r'data-src=\\\"([^"]+)', api_get.text)
                 iframe = match[1].replace("\\", "") if match else None
 
-                if iframe and "?rapidrame_id=" in iframe:
-                    iframe = f"{self.main_url}/playerr/{iframe.split('?rapidrame_id=')[1]}"
+                if not iframe:
+                    continue
+
+                # mobi URL'si varsa direkt kullan (query string'i kaldır)
+                if "mobi" in iframe:
+                    iframe = iframe.split("?")[0]  # rapidrame_id query param'ı kaldır
+                # mobi değilse ve rapidrame varsa rplayer kullan
+                elif "rapidrame" in iframe and "?rapidrame_id=" in iframe:
+                    iframe = f"{self.main_url}/rplayer/{iframe.split('?rapidrame_id=')[1]}"
 
                 video_data_list = await self.invoke_local_source(iframe, source, url)
                 if not video_data_list: