KekikStream 3.4.2__tar.gz → 3.4.4__tar.gz

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Core/Extractor/ExtractorMixins.py

@@ -93,7 +93,7 @@ class SecuredLinkExtractor(ExtractorBase):
         v_id     = self._parse_video_id(url)
         base_url = self._get_base_url(url)
 
-        resp    = await self.httpx.post(
+        resp    = await self.async_cf_post(
             url     = f"{base_url}/player/index.php?data={v_id}&do=getVideo",
             data    = {"hash": v_id, "r": ref},
             headers = {"Referer": ref, "X-Requested-With": "XMLHttpRequest"}
@@ -116,7 +116,7 @@ class SecuredLinkExtractor(ExtractorBase):
         # Bazı hostlar POST yanıtında sadece iframe döndürüyor; ikinci katmanı da çöz.
         if "/player/" in m3u8_url or "/video/" in m3u8_url or "/embed/" in m3u8_url:
             if m3u8_url != url:
-                inner_resp = await self.httpx.get(m3u8_url, headers={"Referer": ref})
+                inner_resp = await self.async_cf_get(m3u8_url, headers={"Referer": ref})
                 if inner_url := self._extract_link_from_text(inner_resp.text):
                     m3u8_url = self.fix_url(inner_url)
 
@@ -221,10 +221,9 @@ class BePlayerExtractor(ExtractorBase):
         return m3u8_url, subtitles, raw_data
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
-        self.httpx.headers.update({"Referer": referer or url})
-
-        resp = await self.httpx.get(url)
-        sel  = HTMLHelper(resp.text)
+        headers = {"Referer": referer or url}
+        resp    = await self.async_cf_get(url, headers=headers)
+        sel     = HTMLHelper(resp.text)
 
         m3u8_url, subtitles, _ = self.decrypt_beplayer(resp.text)
 

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/Abstream.py

@@ -7,7 +7,7 @@ class Abstream(ExtractorBase):
     main_url = "https://abstream.to"
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
-        istek  = await self.httpx.get(
+        istek = await self.async_cf_get(
             url     = url,
             headers = {
                 "Accept-Language" : "en-US,en;q=0.5",

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/Ashdi.py

@@ -4,8 +4,9 @@ from KekikStream.Core import PackedJSExtractor, ExtractResult, HTMLHelper
 import contextlib, json
 
 class Ashdi(PackedJSExtractor):
-    name     = "Ashdi"
-    main_url = "https://ashdi.vip"
+    name              = "Ashdi"
+    main_url          = "https://ashdi.vip"
+    supported_domains = ["ashdi.vip", "ashdi.org"]
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
         # Referer trailing slash fix
@@ -13,7 +14,7 @@ class Ashdi(PackedJSExtractor):
         if ref.endswith("/") and len(ref) > 10:
             ref = ref.rstrip("/")
 
-        resp = await self.httpx.get(
+        resp = await self.async_cf_get(
             url     = url,
             headers = {
                 "Referer"    : ref,

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/BrightPath.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 import re, json, base64, gzip
 
 class BrightPath(ExtractorBase):
@@ -75,12 +75,35 @@ class BrightPath(ExtractorBase):
 
         # Subtitles
         subtitles = []
-        ext_sub   = api_data["data"].get("externalSub") or config.get("externalSub")
+        seen_urls = set()
+
+        def add_subtitle(url, name):
+            full_url = self.fix_url(url)
+            if full_url and full_url not in seen_urls:
+                subtitles.append(Subtitle(url=full_url, name=name))
+                seen_urls.add(full_url)
+
+        # 1. External Subtitle (from data or config)
+        ext_sub = api_data["data"].get("externalSub") or config.get("externalSub")
         if ext_sub and ext_sub.get("file"):
-            subtitles.append(self.new_subtitle(
-                url  = self.fix_url(ext_sub["file"]),
+            add_subtitle(
+                url  = ext_sub["file"],
                 name = ext_sub.get("label") or ext_sub.get("lang") or "Subtitle"
-            ))
+            )
+
+        # 2. Default Subtitles (from root)
+        for sub in api_data.get("default_subs", []):
+            add_subtitle(
+                url  = sub["url"],
+                name = sub.get("lang") or "Subtitle"
+            )
+
+        # 3. Subtitles from data
+        for sub in api_data["data"].get("subtitles", []):
+            add_subtitle(
+                url  = sub.get("file") or sub.get("url"),
+                name = sub.get("label") or sub.get("lang") or "Subtitle"
+            )
 
         for idx, s_url in enumerate(stream_urls, 1):
             # If it's a list, the first item is the name, second is the URL

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/ByseSX.py

@@ -26,6 +26,7 @@ class ByseSX(ExtractorBase):
         "bysebuho.com",
         "bysevepoin.com",
         "byseqekaho.com",
+        "bysesx.com",
     ]
 
     @staticmethod
@@ -34,36 +35,58 @@ class ByseSX(ExtractorBase):
         pad   = (4 - len(fixed) % 4) % 4
         return base64.b64decode(fixed + "=" * pad)
 
-    async def _api_get(self, code: str, host: str):
-        """details API'sini dene; 403 dönerse mirror domain'lere geç."""
-        headers = {"Origin": f"https://{host}", "Referer": f"https://{host}/e/{code}"}
-        resp    = await self.async_cf_get(f"https://{host}/api/videos/{code}/embed/details", headers=headers, timeout=12)
+    async def _api_get(self, code: str, host: str, referer: str = None):
+        """details API'sini dene; 403 dönerse mirror domain'lere veya referer'a göre Origin değiştir."""
+        candidates = [host] + MIRROR_DOMAINS
 
-        if resp.status_code == 200:
-            return resp.json()
+        # Eğer referer varsa, onun domain'ini de Origin olarak denemek isteyebiliriz
+        origin_from_referer = None
+        if referer:
+            ref_parsed          = urlparse(referer)
+            origin_from_referer = f"{ref_parsed.scheme}://{ref_parsed.netloc}"
 
-        if resp.status_code == 404:
-            raise ValueError(f"ByseSX: Video bulunamadı. {code}")
+        for domain in candidates:
+            headers = {"Origin": f"https://{domain}", "Referer": f"https://{domain}/e/{code}"}
+            resp    = await self.async_cf_get(f"https://{domain}/api/videos/{code}/embed/details", headers=headers, timeout=12)
 
-        for mirror in MIRROR_DOMAINS:
-            if mirror == host:
-                continue
-            headers = {"Origin": f"https://{mirror}", "Referer": f"https://{mirror}/e/{code}"}
-            resp    = await self.async_cf_get(f"https://{mirror}/api/videos/{code}/embed/details", headers=headers, timeout=12)
             if resp.status_code == 200:
                 return resp.json()
+
+            # 403 dönerse referer origin'ini dene
+            if resp.status_code == 403 and origin_from_referer:
+                headers["Origin"] = origin_from_referer
+                resp = await self.async_cf_get(f"https://{domain}/api/videos/{code}/embed/details", headers=headers, timeout=12)
+                if resp.status_code == 200:
+                    return resp.json()
+
             if resp.status_code == 404:
                 raise ValueError(f"ByseSX: Video bulunamadı. {code}")
 
-        raise ValueError(f"ByseSX: API erişimi başarısız. {code}")
+        raise ValueError(f"ByseSX: API erişimi başarısız (403/Mirror Fail). {code}")
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
         parsed = urlparse(url)
         host   = parsed.netloc.lstrip("www.")
-        code   = parsed.path.rstrip("/").rsplit("/", 1)[-1]
+
+        # /api/get/ pattern support
+        if "/api/get/" in url:
+            headers = {"Referer": referer or f"https://{host}/"}
+            resp    = await self.async_cf_get(url, headers=headers)
+            if resp.status_code == 200:
+                data    = resp.json()
+                sources = data.get("sources") or data.get("data", {}).get("sources", [])
+                if sources:
+                    best = max(sources, key=lambda s: s.get("bitrate_kbps", 0))
+                    return ExtractResult(
+                        name    = self.name,
+                        url     = best["url"],
+                        referer = url,
+                    )
+
+        code = parsed.path.rstrip("/").rsplit("/", 1)[-1]
 
         # 1) details
-        details         = await self._api_get(code, host)
+        details         = await self._api_get(code, host, referer=referer)
         embed_frame_url = details["embed_frame_url"]
 
         # 2) playback

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/DoodStream.py

@@ -50,13 +50,14 @@ class DoodStream(ExtractorBase):
         # DoodStream token/key parsing
         pass_key = re.search(r"/(?:pass_md5|pass_key)/([^'\"]+)", html)
         if not pass_key:
-            # Try alternative pattern
-            pass_key = re.search(r"\$\.get\(['\"]/([^'\"]+)['\"]", html)
+            pass_key = re.search(r"/(?:pass_md5|pass_key)/([^'\"]+)", html, re.IGNORECASE)
 
         if not pass_key:
-            # /d/ sürümünde bulamazsak /e/ sürümünü dene (tekrar döngüye girme)
-            if "/d/" in url and "/e/" in original_url:
-                raise ValueError(f"{self.name}: Pass key bulunamadı.")
+            # Try finding it in script calls
+            pass_key = re.search(r"\.get\(['\"]/([^'\"]+)['\"]", html)
+
+        if not pass_key:
+            # /d/ sürümünde bulamazsak /e/ sürümünü dene
             if "/d/" in url:
                 return await self.extract(url.replace("/d/", "/e/"), referer=referer)
             if "/e/" in url:
@@ -72,13 +73,15 @@ class DoodStream(ExtractorBase):
         if not pass_resp.text:
              raise ValueError(f"{self.name}: Pass response empty.")
 
-        # Final URL construction: pass_resp.text + some characters + token
-        # DoodStream logic usually: data + "789...?" + token
+        # Final URL construction
         token  = pk_val.split("/")[-1]
         expiry = int(time.time() * 1000)
 
-        # DoodStream usually appends some random characters
-        # The number of characters can vary, but 10 is common
-        final_url = f"{pass_resp.text}1234567890?token={token}&expiry={expiry}"
+        # random characters (usually 10)
+        random_str = "".join(re.findall(r"[a-zA-Z0-9]", pk_val))[:10]
+        if len(random_str) < 10:
+            random_str = "kekikstream"
+
+        final_url = f"{pass_resp.text}{random_str}?token={token}&expiry={expiry}"
 
         return ExtractResult(name=self.name, url=final_url, referer=url)

kekikstream-3.4.4/KekikStream/Extractors/Embedgram.py

@@ -0,0 +1,31 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+
+class Embedgram(ExtractorBase):
+    name              = "Embedgram"
+    main_url          = "https://embedgram.com"
+    supported_domains = ["embedgram.com", "upload.embedgram.com"]
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        istek  = await self.async_cf_get(url, headers={"Referer": referer or self.main_url})
+        secici = HTMLHelper(istek.text)
+
+        # 1. Look for direct file in script or config
+        media_url = secici.regex_first(r'["\'](https?://[^"\']+\.(?:m3u8|mp4)[^"\']*)["\']')
+
+        # 2. Look for iframe
+        if not media_url:
+            iframe = secici.select_attr("iframe", "src")
+            if iframe:
+                # Recursive extraction
+                return await self.extract(self.fix_url(iframe), referer=url)
+
+        if not media_url:
+             raise ValueError(f"Embedgram: Medya bulunamadı. {url}")
+
+        return ExtractResult(
+            name    = self.name,
+            url     = media_url,
+            referer = url
+        )

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/Fembed.py

@@ -7,7 +7,7 @@ import re, json
 class Fembed(ExtractorBase):
     name              = "Fembed"
     main_url          = "https://fembed.online"
-    supported_domains = ["fembed.online", "fembed.net", "fembed.com"]
+    supported_domains = ["fembed.online", "fembed.net", "fembed.com", "tr.fembed.com", "suzihaza.com", "feurl.com"]
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
         headers = {"Referer": referer or self.main_url}

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/Filemoon.py

@@ -86,11 +86,15 @@ class Filemoon(PackedJSExtractor):
 
         try:
             response = await self.httpx.get(api_url, headers=headers)
-            data     = response.json() if "json" in (response.headers.get("content-type") or "").lower() else None
+            if response.status_code == 405:
+                response = await self.httpx.post(api_url, headers=headers)
+            data = response.json() if "json" in (response.headers.get("content-type") or "").lower() else None
         except Exception:
             try:
                 response = await self.async_cf_get(api_url, headers=headers)
-                data     = response.json() if "json" in (response.headers.get("content-type") or "").lower() else None
+                if response.status_code == 405:
+                    response = await self.async_cf_post(api_url, headers=headers)
+                data = response.json() if "json" in (response.headers.get("content-type") or "").lower() else None
             except Exception:
                 return None, root_referer, None
 

kekikstream-3.4.4/KekikStream/Extractors/GoodStream.py

@@ -0,0 +1,65 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+import re
+
+class GoodStream(ExtractorBase):
+    name     = "GoodStream"
+    main_url = "https://goodstream.one"
+
+    supported_domains = ["goodstream.one", "goodstream.tv"]
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        # 1) Get the embed page
+        headers = {
+            "User-Agent" : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+            "Referer"    : referer or self.main_url,
+        }
+        resp = await self.async_cf_get(url, headers=headers)
+
+        # 2) Find the file code and POST to /dl
+        # document.forms['F1'].file_code.value = code;
+        code = self._media_id_from_url(url)
+        if not code:
+            code = HTMLHelper(resp.text).regex_first(r'file_code\.value\s*=\s*["\']([^"\']+)["\']')
+
+        if not code:
+             raise ValueError(f"GoodStream: File code bulunamadı. {url}")
+
+        dl_url = f"{self.get_base_url(url)}/dl"
+        data = {
+            "op"        : "embed",
+            "file_code" : code,
+            "auto"      : "1",
+            "referer"   : referer or "",
+        }
+
+        # We need the same headers for POST
+        headers["Origin"]  = self.get_base_url(url)
+        headers["Referer"] = url
+
+        dl_resp = await self.async_cf_post(dl_url, headers=headers, data=data)
+
+        # 3) Parse the final m3u8 URL from the response
+        # sources: [{file:"..."}]
+        m3u8_url = HTMLHelper(dl_resp.text).regex_first(r'sources:\s*\[{file:["\']([^"\']+)["\']')
+
+        if not m3u8_url:
+            # Fallback for simple file: "..."
+            m3u8_url = HTMLHelper(dl_resp.text).regex_first(r'file\s*:\s*["\']([^"\']+)["\']')
+
+        if not m3u8_url:
+            raise ValueError(f"GoodStream: Video URL bulunamadı. {url}")
+
+        return ExtractResult(
+            name    = self.name,
+            url     = self.fix_url(m3u8_url),
+            referer = url
+        )
+
+    def _media_id_from_url(self, url: str) -> str | None:
+        # Match /e/code or /embed-code or /embed/code
+        match = re.search(r"/(?:e|embed-|embed/|embed)/?([0-9a-zA-Z]+)", url)
+        if match:
+            return match.group(1)
+        return None

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/HDPlayerSystem.py

@@ -3,5 +3,6 @@
 from KekikStream.Core import SecuredLinkExtractor
 
 class HDPlayerSystem(SecuredLinkExtractor):
-    name     = "HDPlayerSystem"
-    main_url = "https://hdplayersystem.com"
+    name              = "HDPlayerSystem"
+    main_url          = "https://hdplayersystem.com"
+    supported_domains = ["hdplayersystem.com"]

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/JFVid.py

@@ -7,10 +7,15 @@ class JFVid(ExtractorBase):
     main_url = "https://jfvid.com"
 
     # Birden fazla domain destekle
-    supported_domains = ["jfvid.com"]
+    supported_domains = ["jfvid.com", "jetvid.top"]
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
         base_url = self.get_base_url(url)
-        v_id     = url.split("/play/")[-1] if "/play/" in url else url.split("/stream/")[-1]
+
+        # Determine ID from path or query
+        if "jetvid.top" in url and "?v=" in url:
+            v_id = url.split("?v=")[1].split("&")[0]
+        else:
+            v_id = url.split("/play/")[-1] if "/play/" in url else url.split("/stream/")[-1]
 
         return ExtractResult(name=self.name, url=f"{base_url}/stream/{v_id}", referer=referer or base_url)

kekikstream-3.4.4/KekikStream/Extractors/JWPlayer.py

@@ -0,0 +1,16 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+
+class JWPlayer(ExtractorBase):
+    name              = "JWPlayer"
+    main_url          = "https://jwplayer.com"
+    supported_domains = ["cdn.jwplayer.com"]
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        # JWPlayer manifests are usually direct m3u8
+        return ExtractResult(
+            name    = self.name,
+            url     = url,
+            referer = referer or self.main_url
+        )

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/KentFilm.py

@@ -12,11 +12,11 @@ class KentFilm(ExtractorBase):
         helper = HTMLHelper(istek.text)
 
         # HTMLHelper.regex_first otomatik olarak ilk grubu döndürür
-        json_str = helper.regex_first(r'FirePlayer\s*\(\s*[^,]+\s*,\s*(\{.*?\})\s*,')
+        json_str = helper.regex_first(r'(?s)FirePlayer\s*\(\s*[^,]+\s*,\s*({.*?})\s*,')
 
         if not json_str:
-            # Fallback regex explicit
-            json_str = helper.regex_first(r'FirePlayer\s*\(\s*[^,]+\s*,\s*(\{.*?\})\s*,\s*false\s*\);')
+            # Alternatif: json direkt değişkende olabilir
+            json_str = helper.regex_first(r'(?s)var\s+playerData\s*=\s*({.*?});')
 
         if not json_str:
             raise ValueError(f"KentFilm: Video bilgisi bulunamadı. {url}")

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/StreamWish.py

@@ -59,6 +59,7 @@ class StreamWish(PackedJSExtractor):
         "vtube.to",
         "vudeo.io",
         "vadshar.com",
+        "happy1de.space",
     ]
 
     _DIRECT_ALIAS_MAP = {

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/VidHide.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import PackedJSExtractor, ExtractResult, HTMLHelper, M3U8_FILE_REGEX
+from KekikStream.Core import PackedJSExtractor, ExtractResult, HTMLHelper, M3U8_FILE_REGEX, Subtitle
 from urllib.parse     import urlparse, urlunparse
 import re
 
@@ -71,6 +71,7 @@ class VidHide(PackedJSExtractor):
         "dhtpre.com",
         "peytonepre.com",
         "minochinos.com",
+        "ag2m4.cfd",
     ]
 
     def get_embed_url(self, url: str) -> str:
@@ -195,6 +196,17 @@ class VidHide(PackedJSExtractor):
         # Packed JS'den m3u8 çıkarmayı dene (unpack_and_find helper)
         m3u8_url = self.unpack_and_find(text)
 
+        # NEW: fetch('/dl?op=get_stream...') pattern
+        if not m3u8_url:
+            fetch_url = sel.regex_first(r"fetch\(['\"]([^'\"]*?/dl\?op=get_stream[^'\"]+)['\"]")
+            if fetch_url:
+                try:
+                    f_resp   = await self.async_cf_get(self.fix_url(fetch_url), headers={"Referer": final_url})
+                    f_data   = f_resp.json()
+                    m3u8_url = f_data.get("url")
+                except Exception:
+                    pass
+
         # Çoklu m3u8 sonucu olabilir (regex ile tüm m3u8'leri bul)
         if not m3u8_url:
             m3u8_matches = re.findall(r'(?:file|src|url)["\']?\s*[:=]\s*["\']([^"\']+\.m3u8[^"\']*)["\']', text)
@@ -204,14 +216,32 @@ class VidHide(PackedJSExtractor):
         else:
             m3u8_matches = [m3u8_url]
 
+        # Altyazıları çıkar (Playerjs formatı)
+        subtitles = []
+        sub_text  = sel.regex_first(r'["\']subtitle["\']\s*:\s*["\']([^"\']+)["\']')
+        if sub_text:
+             for part in sub_text.split(","):
+                 if "[" in part and "]" in part:
+                     s_name = part.split("[")[1].split("]")[0]
+                     s_url  = part.split("]")[1]
+                     subtitles.append(Subtitle(url=self.fix_url(s_url), name=s_name))
+                 else:
+                     subtitles.append(Subtitle(url=self.fix_url(part), name="Bilinmeyen"))
+
         results = []
         for m3u8 in m3u8_matches:
-            results.append(ExtractResult(name=name, url=self.fix_url(m3u8), referer=f"{final_base_url}/", user_agent=self.httpx.headers.get("User-Agent", "")))
+            results.append(ExtractResult(
+                name       = name,
+                url        = self.fix_url(m3u8),
+                referer    = f"{final_base_url}/",
+                user_agent = self.httpx.headers.get("User-Agent", ""),
+                subtitles  = subtitles
+            ))
 
         if not results:
             # Fallback: sources pattern
             if m3u8_url := sel.regex_first(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"'):
-                results.append(ExtractResult(name=name, url=self.fix_url(m3u8_url), referer=f"{final_base_url}/", user_agent=self.httpx.headers.get("User-Agent", "")))
+                results.append(ExtractResult(name=name, url=self.fix_url(m3u8_url), referer=f"{final_base_url}/", user_agent=self.httpx.headers.get("User-Agent", ""), subtitles=subtitles))
 
         if not results:
             raise ValueError(f"{name}: Video URL bulunamadı. {url}")

{kekikstream-3.4.2 → kekikstream-3.4.4}/KekikStream/Extractors/VidStack.py

@@ -4,7 +4,7 @@ from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
 from Crypto.Cipher    import AES
 from Crypto.Util      import Padding
 from urllib.parse     import urlparse, parse_qs
-import re
+import re, base64
 
 class VidStack(ExtractorBase):
     name             = "VidStack"
@@ -12,16 +12,21 @@ class VidStack(ExtractorBase):
     requires_referer = True
 
     supported_domains = [
-        "vidstack.io", "server1.uns.bio", "upns.one", "upn.one",
-        "webdrama.upns.online", "webdrama.playerp2p.com",
-        "player4me.vip", "vidplayer.live", "rpmvid.com", "rpmshare.com",
-        "rpmplayer.com", "ytplay.rpmvid.com", "rpmvip.com"
+        "vidstack.io", "server1.uns.bio", "vids.uns.bio", "upns.one", "upn.one",
+        "webdrama.upns.online", "webdrama.playerp2p.com", "upns.online",
+        "player4me.vip", "player4me.top", "vidplayer.live", "rpmvid.com", "rpmshare.com",
+        "rpmplayer.com", "ytplay.rpmvid.com", "rpmvip.com", "uns.bio"
     ]
 
     def decrypt_aes(self, input_hex: str, key: str, iv: bytes) -> str:
         try:
             cipher    = AES.new(key.encode('utf-8'), AES.MODE_CBC, iv)
-            raw_data  = bytes.fromhex(input_hex)
+            try:
+                raw_data = bytes.fromhex(input_hex)
+            except ValueError:
+                # Try base64 if hex fails
+                raw_data = base64.b64decode(input_hex)
+
             decrypted = cipher.decrypt(raw_data)
             unpadded  = Padding.unpad(decrypted, AES.block_size)
             return unpadded.decode('utf-8')
@@ -88,9 +93,28 @@ class VidStack(ExtractorBase):
         if not encoded_data:
             raise ValueError(f"VidStack: API yanıtı alınamadı. {url}")
 
-        # AES Çözme — sıfır IV (webdrama), ardından bilinen IV'lar
-        keys = ["kiemtienmua911ca", "46ed6256db0ca41ec"]
-        ivs  = [b"\x00" * 16, b"1234567890oiuytr", b"0123456789abcdef"]
+        # AES Çözme — sıfır IV, bilinen IV'lar ve Payload'ın ilk 16 byte'ı
+        keys = [
+            "kiemtienmua911ca",
+            "kiemtienmua911ca123",
+            "kiemtienmua911ca_123",
+            "46ed6256db0ca41ec",
+            "46ed6256db0ca41e",
+            "vidstackio",
+            "vidstack",
+        ]
+
+        try:
+            raw_data = bytes.fromhex(encoded_data)
+        except:
+            try:
+                raw_data = base64.b64decode(encoded_data)
+            except:
+                raw_data = b""
+
+        ivs = [b"\x00" * 16, b"1234567890oiuytr", b"0123456789abcdef"]
+        if len(raw_data) > 16:
+            ivs.append(raw_data[:16])
 
         decrypted_text = None
         for key in keys: