KekikStream 1.7.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

KekikStream/Extractors/Odnoklassniki.py

@@ -7,6 +7,12 @@ class Odnoklassniki(ExtractorBase):
     name     = "Odnoklassniki"
     main_url = "https://odnoklassniki.ru"
 
+    # Birden fazla domain destekle
+    supported_domains = ["odnoklassniki.ru", "ok.ru"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
     async def extract(self, url, referer=None) -> ExtractResult:
         if "/video/" in url:
             url = url.replace("/video/", "/videoembed/")
@@ -20,7 +26,7 @@ class Odnoklassniki(ExtractorBase):
             "Origin"         : self.main_url,
             "User-Agent"     : "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0",
         }
-        self.cffi.headers.update(headers)
+        self.httpx.headers.update(headers)
 
         try:
             istek = await self.fetch_with_redirects(url)
@@ -82,18 +88,18 @@ class Odnoklassniki(ExtractorBase):
             best_video = f"https:{best_video}"
 
         return ExtractResult(
-            name      = self.name,
-            url       = best_video,
-            referer   = referer,
-            headers   = headers,
-            subtitles = []
+            name       = self.name,
+            url        = best_video,
+            referer    = referer,
+            user_agent = headers.get("User-Agent", None),
+            subtitles  = []
         )
 
     async def fetch_with_redirects(self, url, max_redirects=5):
         """Yönlendirmeleri takip eden bir fonksiyon"""
         redirects = 0
         while redirects < max_redirects:
-            istek = await self.cffi.get(url, allow_redirects=False)
+            istek = await self.httpx.get(url, follow_redirects=False)
 
             if istek.status_code not in [301, 302]:
                 break  # Yönlendirme yoksa çık

KekikStream/Extractors/PeaceMakerst.py

@@ -7,16 +7,22 @@ class PeaceMakerst(ExtractorBase):
     name     = "PeaceMakerst"
     main_url = "https://peacemakerst.com"
 
+    # Birden fazla domain destekle
+    supported_domains = ["peacemakerst.com", "hdstreamable.com"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        self.cffi.headers.update({
+        self.httpx.headers.update({
             "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
             "X-Requested-With" : "XMLHttpRequest"
         })
 
-        response = await self.cffi.post(
+        response = await self.httpx.post(
             url  = f"{url}?do=getVideo",
             data = {
                 "hash" : url.split("video/")[-1],
@@ -33,7 +39,7 @@ class PeaceMakerst(ExtractorBase):
             teve2_id = re.search(r"teve2\.com\.tr\\\/embed\\\/(\d+)", response_text)[1]
             teve2_url = f"https://www.teve2.com.tr/action/media/{teve2_id}"
 
-            teve2_response = await self.cffi.get(teve2_url, headers={"Referer": f"https://www.teve2.com.tr/embed/{teve2_id}"})
+            teve2_response = await self.httpx.get(teve2_url, headers={"Referer": f"https://www.teve2.com.tr/embed/{teve2_id}"})
             teve2_response.raise_for_status()
             teve2_json = teve2_response.json()
 
@@ -53,6 +59,5 @@ class PeaceMakerst(ExtractorBase):
             name      = self.name,
             url       = m3u_link,
             referer   = url,
-            headers   = {},
             subtitles = []
         )

KekikStream/Extractors/PixelDrain.py

@@ -9,7 +9,7 @@ class PixelDrain(ExtractorBase):
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
         pixel_id_match = re.search(r"/u/([^/?]+)|([^\/]+)(?=\?download)", url)
         if not pixel_id_match:
@@ -23,6 +23,5 @@ class PixelDrain(ExtractorBase):
             name      = f"{self.name} - {pixel_id}",
             url       = download_link,
             referer   = referer_link,
-            headers   = {},
             subtitles = []
         )

KekikStream/Extractors/PlayerFilmIzle.py

@@ -0,0 +1,65 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re
+
+class PlayerFilmIzle(ExtractorBase):
+    name     = "PlayerFilmIzle"
+    main_url = "https://player.filmizle.in"
+
+    def can_handle_url(self, url: str) -> bool:
+        return "filmizle.in" in url or "fireplayer" in url.lower()
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        # Kotlin tarafında referer mainUrl olarak zorlanmış
+        ext_ref = self.main_url
+        self.httpx.headers.update({"Referer": ext_ref})
+        
+        istek     = await self.httpx.get(url)
+        video_req = istek.text
+
+        subtitles = []
+        if sub_match := re.search(r'playerjsSubtitle = "([^"]*)"', video_req, re.IGNORECASE):
+            sub_yakala = sub_match.group(1)
+            # Format örneği: [dil]url
+            # Kotlin kodunda: subYakala.substringAfter("]") -> url
+            # subYakala.substringBefore("]").removePrefix("[") -> lang
+            if "]" in sub_yakala:
+                sub_lang_raw, sub_url = sub_yakala.split("]", 1)
+                sub_lang = sub_lang_raw.replace("[", "")
+                subtitles.append(Subtitle(name=sub_lang, url=sub_url))
+
+        # Data yakalama: FirePlayer|DATA|...
+        data_match = re.search(r'FirePlayer\|([^|]+)\|', video_req, re.IGNORECASE)
+        data_val   = data_match.group(1) if data_match else None
+
+        if not data_val:
+             raise ValueError("PlayerFilmIzle: Data bulunamadı")
+
+        url_post = f"{self.main_url}/player/index.php?data={data_val}&do=getVideo"
+
+        post_headers = {
+            "Referer": ext_ref,
+            "X-Requested-With": "XMLHttpRequest"
+        }
+
+        # Kotlin'de post data: "hash" -> data, "r" -> ""
+        post_data = {"hash": data_val, "r": ""}
+
+        response = await self.httpx.post(url_post, data=post_data, headers=post_headers)
+        get_url  = response.text.replace("\\", "")
+
+        m3u8_url = ""
+        if url_yakala := re.search(r'"securedLink":"([^"]*)"', get_url, re.IGNORECASE):
+            m3u8_url = url_yakala.group(1)
+
+        if not m3u8_url:
+            raise ValueError("PlayerFilmIzle: M3U8 linki bulunamadı")
+
+        return ExtractResult(
+            name       = self.name,
+            url        = m3u8_url,
+            referer    = ext_ref,
+            user_agent = self.httpx.headers.get("User-Agent", None),
+            subtitles  = subtitles
+        )

KekikStream/Extractors/RapidVid.py

@@ -1,18 +1,24 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
-from Kekik.Sifreleme  import Packer, HexCodec
+from Kekik.Sifreleme  import Packer, HexCodec, StreamDecoder
 import re, base64
 
 class RapidVid(ExtractorBase):
     name     = "RapidVid"
     main_url = "https://rapidvid.net"
 
+    # Birden fazla domain destekle
+    supported_domains = ["rapidvid.net", "rapid.filmmakinesi.to"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.cffi.get(url)
+        istek = await self.httpx.get(url)
         istek.raise_for_status()
 
         subtitles        = []
@@ -33,15 +39,25 @@ class RapidVid(ExtractorBase):
             subtitles.append(Subtitle(name=decoded_lang, url=sub_url.replace("\\", "")))
 
         try:
+            decoded_url = None
+
+            # Method 1: file": "..." pattern (HexCodec)
             if extracted_value := re.search(r'file": "(.*)",', istek.text):
                 escaped_hex = extracted_value[1]
                 decoded_url = HexCodec.decode(escaped_hex)
-            else:
-                av_encoded = re.search(r"av\('([^']+)'\)", istek.text)
-                if not av_encoded:
-                    raise ValueError("AV encoding not found.")
 
+            # Method 2: av('...') pattern
+            elif av_encoded := re.search(r"av\('([^']+)'\)", istek.text):
                 decoded_url = self.decode_secret(av_encoded[1])
+
+            # Method 3: Packed script with dc_* function (StreamDecoder)
+            elif Packer.detect_packed(istek.text):
+                unpacked    = Packer.unpack(istek.text)
+                decoded_url = StreamDecoder.extract_stream_url(unpacked)
+
+            if not decoded_url:
+                raise ValueError("No valid video URL pattern found.")
+
         except Exception as hata:
             raise RuntimeError(f"Extraction failed: {hata}") from hata
 
@@ -49,7 +65,6 @@ class RapidVid(ExtractorBase):
             name      = self.name,
             url       = decoded_url,
             referer   = self.main_url,
-            headers   = {},
             subtitles = subtitles
         )
 

KekikStream/Extractors/SetPlay.py

@@ -0,0 +1,66 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from urllib.parse import urlparse, parse_qs
+import re
+
+class SetPlay(ExtractorBase):
+    name     = "SetPlay"
+    main_url = "https://setplay.shop"
+
+    # Birden fazla domain destekle
+    supported_domains = ["setplay.cfd", "setplay.shop", "setplay.site"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        ext_ref = referer or ""
+
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        # Dinamik base URL kullan
+        base_url = self.get_base_url(url)
+
+        istek = await self.httpx.get(url)
+        istek.raise_for_status()
+
+        # videoUrl çıkar
+        video_url_match = re.search(r'videoUrl":"([^",]+)"', istek.text)
+        if not video_url_match:
+            raise ValueError("videoUrl not found")
+        video_url = video_url_match[1].replace("\\", "")
+
+        # videoServer çıkar
+        video_server_match = re.search(r'videoServer":"([^",]+)"', istek.text)
+        if not video_server_match:
+            raise ValueError("videoServer not found")
+        video_server = video_server_match[1]
+
+        # title çıkar (opsiyonel)
+        title_match = re.search(r'title":"([^",]+)"', istek.text)
+        title_base = title_match[1].split(".")[-1] if title_match else "Unknown"
+        
+        # partKey logic
+        parsed = urlparse(url)
+        params = parse_qs(parsed.query)
+        part_key = params.get("partKey", [""])[0]
+        
+        name_suffix = ""
+        if "turkcedublaj" in part_key.lower():
+            name_suffix = "Dublaj"
+        elif "turkcealtyazi" in part_key.lower():
+            name_suffix = "Altyazı"
+        else:
+            name_suffix = title_base
+
+        # M3U8 link oluştur - base_url kullan (main_url yerine)
+        m3u_link = f"{base_url}{video_url}?s={video_server}"
+
+        return ExtractResult(
+            name      = f"{self.name} - {name_suffix}",
+            url       = m3u_link,
+            referer   = url,
+            subtitles = []
+        )

KekikStream/Extractors/SetPrime.py

@@ -0,0 +1,45 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from urllib.parse import urlparse, parse_qs
+import re
+
+class SetPrime(ExtractorBase):
+    name     = "SetPrime"
+    main_url = "https://setplay.site"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        # URL parsing
+        parsed = urlparse(url)
+        params = parse_qs(parsed.query)
+        part_key = params.get("partKey", [""])[0].upper()
+        clean_url = url.split("?partKey=")[0]
+        
+        # POST URL: embed?i= -> embed/get?i=
+        post_url = clean_url.replace("embed?i=", "embed/get?i=")
+        
+        response = await self.httpx.post(
+            url     = post_url,
+            headers = {"Referer": clean_url}
+        )
+        response.raise_for_status()
+        
+        # Links parse
+        links_match = re.search(r'Links":\["([^"\]]+)"', response.text)
+        if not links_match:
+            raise ValueError("Links not found in SetPrime response")
+            
+        link_suffix = links_match.group(1)
+        if not link_suffix.startswith("/"):
+            raise ValueError("Links not valid (must start with /)")
+            
+        m3u_link = f"{self.main_url}{link_suffix}"
+        
+        display_name = f"{self.name} - {part_key}" if part_key else self.name
+
+        return ExtractResult(
+            name      = display_name,
+            url       = m3u_link,
+            referer   = clean_url,
+            subtitles = []
+        )

KekikStream/Extractors/SibNet.py

@@ -9,9 +9,9 @@ class SibNet(ExtractorBase):
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        response = await self.cffi.get(url)
+        response = await self.httpx.get(url)
         response.raise_for_status()
 
         match = re.search(r'player\.src\(\[\{src: \"([^\"]+)\"', response.text)
@@ -24,6 +24,5 @@ class SibNet(ExtractorBase):
             name      = self.name,
             url       = m3u_link,
             referer   = url,
-            headers   = {},
             subtitles = []
         )

KekikStream/Extractors/Sobreatsesuyp.py

@@ -9,9 +9,9 @@ class Sobreatsesuyp(ExtractorBase):
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.cffi.get(url)
+        istek = await self.httpx.get(url)
         istek.raise_for_status()
 
         file_match = re.search(r'file\":\"([^\"]+)', istek.text)
@@ -21,7 +21,7 @@ class Sobreatsesuyp(ExtractorBase):
         file_path = file_match[1].replace("\\", "")
         post_link = f"{self.main_url}/{file_path}"
 
-        post_istek = await self.cffi.post(post_link)
+        post_istek = await self.httpx.post(post_link)
         post_istek.raise_for_status()
 
         try:
@@ -41,7 +41,7 @@ class Sobreatsesuyp(ExtractorBase):
                 continue
 
             playlist_url     = f"{self.main_url}/playlist/{file.lstrip('/')}.txt"
-            playlist_request = await self.cffi.post(playlist_url, headers={"Referer": referer or self.main_url})
+            playlist_request = await self.httpx.post(playlist_url, headers={"Referer": referer or self.main_url})
             playlist_request.raise_for_status()
 
             all_results.append(
@@ -49,7 +49,6 @@ class Sobreatsesuyp(ExtractorBase):
                     name      = f"{self.name} - {title}",
                     url       = playlist_request.text,
                     referer   = self.main_url,
-                    headers   = {},
                     subtitles = []
                 )
             )

KekikStream/Extractors/TRsTX.py

@@ -9,9 +9,9 @@ class TRsTX(ExtractorBase):
 
     async def extract(self, url, referer=None) -> list[ExtractResult]:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.cffi.get(url)
+        istek = await self.httpx.get(url)
         istek.raise_for_status()
 
         file_match = re.search(r'file\":\"([^\"]+)', istek.text)
@@ -21,7 +21,7 @@ class TRsTX(ExtractorBase):
         file_path = file_match[1].replace("\\", "")
         post_link = f"{self.main_url}/{file_path}"
 
-        post_istek = await self.cffi.post(post_link)
+        post_istek = await self.httpx.post(post_link)
         post_istek.raise_for_status()
 
         try:
@@ -42,7 +42,7 @@ class TRsTX(ExtractorBase):
                 continue
 
             playlist_url = f"{self.main_url}/playlist/{file.lstrip('/')}.txt"
-            playlist_request = await self.cffi.post(playlist_url, headers={"Referer": referer or self.main_url})
+            playlist_request = await self.httpx.post(playlist_url, headers={"Referer": referer or self.main_url})
             playlist_request.raise_for_status()
 
             video_data = playlist_request.text
@@ -57,7 +57,6 @@ class TRsTX(ExtractorBase):
                     name      = f"{self.name} - {title}",
                     url       = video_data,
                     referer   = self.main_url,
-                    headers   = {},
                     subtitles = []
                 )
             )

KekikStream/Extractors/TauVideo.py

@@ -8,12 +8,12 @@ class TauVideo(ExtractorBase):
 
     async def extract(self, url, referer=None) -> list[ExtractResult]:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
         video_key = url.split("/")[-1]
         api_url   = f"{self.main_url}/api/video/{video_key}"
 
-        response = await self.cffi.get(api_url)
+        response = await self.httpx.get(api_url)
         response.raise_for_status()
 
         api_data = response.json()
@@ -26,7 +26,6 @@ class TauVideo(ExtractorBase):
                     name      = f"{self.name} - {video['label']}",
                     url       = video["url"],
                     referer   = referer or self.main_url,
-                    headers   = {},
                     subtitles = []
                 )
                     for video in api_data["urls"]

KekikStream/Extractors/TurboImgz.py

@@ -9,9 +9,9 @@ class TurboImgz(ExtractorBase):
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.cffi.get(url)
+        istek = await self.httpx.get(url)
         istek.raise_for_status()
 
         if video_match := re.search(r'file: "(.*)",', istek.text):
@@ -19,7 +19,6 @@ class TurboImgz(ExtractorBase):
                 name      = self.name,
                 url       = video_match[1],
                 referer   = referer or self.main_url,
-                headers   = {},
                 subtitles = []
             )
         else:

KekikStream/Extractors/TurkeyPlayer.py

@@ -0,0 +1,34 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re, json
+
+class TurkeyPlayer(ExtractorBase):
+    name     = "TurkeyPlayer"
+    main_url = "https://watch.turkeyplayer.com/"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+        
+        istek       = await self.httpx.get(url)
+        page_content = istek.text
+
+        video_json_match = re.search(r'var\s+video\s*=\s*(\{.*?\});', page_content, re.DOTALL)
+        if not video_json_match:
+             raise ValueError("TurkeyPlayer: Video JSON bulunamadı")
+
+        video_data = json.loads(video_json_match.group(1))
+        
+        video_id  = video_data.get("id")
+        video_md5 = video_data.get("md5")
+
+        master_url = f"https://watch.turkeyplayer.com/m3u8/8/{video_md5}/master.txt?s=1&id={video_id}&cache=1"
+        
+        return ExtractResult(
+            name       = self.name,
+            url        = master_url,
+            referer    = referer or url,
+            user_agent = self.httpx.headers.get("User-Agent", ""),
+            subtitles  = []
+        )

KekikStream/Extractors/VCTPlay.py

@@ -0,0 +1,41 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from urllib.parse     import urlparse, parse_qs
+
+class VCTPlay(ExtractorBase):
+    name     = "VCTPlay"
+    main_url = "https://vctplay.site"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        # URL'den video ID'sini çıkar
+        # https://vctplay.site/video/2hjDGco5exdv -> 2hjDGco5exdv
+        video_id = url.split("/")[-1]
+        if "?" in video_id:
+            video_id = video_id.split("?")[0]
+
+        # Manifests URL oluştur
+        master_url = f"{self.main_url}/manifests/{video_id}/master.txt"
+
+        # partKey'den isim belirle
+        parsed   = urlparse(url)
+        params   = parse_qs(parsed.query)
+        part_key = params.get("partKey", [""])[0]
+
+        name_suffix = ""
+        if "turkcedublaj" in part_key.lower():
+            name_suffix = "Dublaj"
+        elif "turkcealtyazi" in part_key.lower():
+            name_suffix = "Altyazı"
+
+        display_name = f"{self.name} - {name_suffix}" if name_suffix else self.name
+
+        return ExtractResult(
+            name      = display_name,
+            url       = master_url,
+            referer   = f"{self.main_url}/",
+            subtitles = []
+        )

KekikStream/Extractors/VidHide.py

@@ -0,0 +1,81 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from Kekik.Sifreleme  import Packer
+from parsel           import Selector
+import re
+
+class VidHide(ExtractorBase):
+    name     = "VidHide"
+    main_url = "https://vidhidepro.com"
+
+    # Birden fazla domain destekle
+    supported_domains = ["vidhidepro.com", "vidhide.com", "rubyvidhub.com"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
+    def get_embed_url(self, url: str) -> str:
+        if "/d/" in url:
+            return url.replace("/d/", "/v/")
+        elif "/download/" in url:
+            return url.replace("/download/", "/v/")
+        elif "/file/" in url:
+            return url.replace("/file/", "/v/")
+        else:
+            return url.replace("/f/", "/v/")
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        # Dinamik base URL kullan
+        base_url = self.get_base_url(url)
+
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        self.httpx.headers.update({
+            "Sec-Fetch-Dest" : "empty",
+            "Sec-Fetch-Mode" : "cors",
+            "Sec-Fetch-Site" : "cross-site",
+            "Origin"         : base_url,
+        })
+        
+        embed_url = self.get_embed_url(url)
+        istek     = await self.httpx.get(embed_url)
+        response  = istek.text
+
+        script = None
+        if "eval(function" in response:
+            try:
+                unpacked = Packer.unpack(response)
+                if "var links" in unpacked:
+                    script = unpacked.split("var links")[1]
+                else:
+                    script = unpacked
+            except Exception:
+                pass
+        
+        if not script:
+             if matches := re.search(r'sources:\s*(\[.*?\])', response, re.DOTALL):
+                 script = matches.group(1)
+
+        m3u8_url = None
+        if script:
+            # m3u8 urls could be prefixed by 'file:', 'hls2:' or 'hls4:', so we just match ':'
+            if match := re.search(r':\s*"([^"]*?m3u8[^"]*?)"', script):
+                 m3u8_url = match.group(1)
+
+        if not m3u8_url:
+            # Fallback direct search in response if unpacking failed or structure changed
+            if match := re.search(r'file:"(.*?\.m3u8.*?)"', response):
+                m3u8_url = match.group(1)
+        
+        if not m3u8_url:
+            raise ValueError(f"VidHide: Video URL bulunamadı. {url}")
+
+        return ExtractResult(
+            name       = self.name,
+            url        = self.fix_url(m3u8_url),
+            referer    = f"{base_url}/",
+            user_agent = self.httpx.headers.get("User-Agent", ""),
+            subtitles  = []
+        )