From fbbed00c892d04cd32af1f6091d6a7e549edc4ff Mon Sep 17 00:00:00 2001
From: aka paul <50n50@noreply.localhost>
Date: Sat, 3 Jan 2026 20:28:25 +0000
Subject: [PATCH] Update animepahe/animepahe.js

---
 animepahe/animepahe.js | 60 +++++++++++++++++++++++++++++++++---------
 1 file changed, 47 insertions(+), 13 deletions(-)

diff --git a/animepahe/animepahe.js b/animepahe/animepahe.js
index 14f12cb..29c292f 100644
--- a/animepahe/animepahe.js
+++ b/animepahe/animepahe.js
@@ -56,14 +56,18 @@ async function extractEpisodes(url) {
         const uuidMatch = url.match(/\/anime\/([^\/]+)/);
         if (!uuidMatch) throw new Error("Invalid URL");
         const id = uuidMatch[1];
+        console.log("Episode extraction starting for id:", id);
 
         const ddosInterceptor = new DdosGuardInterceptor();  
 
         let page = 1;
         const apiUrl1 = `https://animepahe.si/api?m=release&id=${id}&sort=episode_asc&page=${page}`;
+        console.log("Fetching page 1...");
         const response1 = await ddosInterceptor.fetchWithBypass(apiUrl1);
         const dataText1 = await response1.text();
+        console.log("Page 1 response length:", dataText1.length);
         const data1 = JSON.parse(dataText1);
+        console.log("Page 1 episodes:", data1.data.length, "Last page:", data1.last_page);
 
         for (const item of data1.data) {
             results.push({
@@ -74,17 +78,21 @@ async function extractEpisodes(url) {
 
         const lastPage = data1.last_page;
         if (lastPage > 1) {
+            console.log("Fetching additional pages from 2 to", lastPage);
             for (let p = 2; p <= lastPage; p++) {
                 let pageData = null;
                 let retries = 0;
                 while (!pageData && retries < 3) {
                     try {
                         const apiUrl = `https://animepahe.si/api?m=release&id=${id}&sort=episode_asc&page=${p}`;
+                        console.log("Fetching page", p, "attempt", retries + 1);
                         const response = await ddosInterceptor.fetchWithBypass(apiUrl);
                         const dataText = await response.text();
                         pageData = JSON.parse(dataText);
+                        console.log("Page", p, "success, episodes:", pageData.data.length);
                     } catch (pageErr) {
                         retries++;
+                        console.log("Page", p, "error:", pageErr.message);
                         if (retries < 3) {
                             await new Promise(resolve => setTimeout(resolve, 1000));
                         }
@@ -101,8 +109,10 @@ async function extractEpisodes(url) {
             }
         }
 
+        console.log("Total episodes fetched:", results.length);
         return JSON.stringify(results);
     } catch (err) {
+        console.log("Episodes error:", err.message);
         return JSON.stringify([{
             href: "Error",
             number: "Error"
@@ -197,25 +207,49 @@ class DdosGuardInterceptor {
     }
 
     async fetchWithBypass(url, options = {}) {
-        let response = await this.fetchWithCookies(url, options);
-
-        const isBlocked = await this.isBlockedResponse(response);
+        let retries = 0;
+        const maxRetries = 10;
         
-        if (!isBlocked) {
-            return response;
-        }
+        while (retries < maxRetries) {
+            try {
+                let response = await this.fetchWithCookies(url, options);
 
+                const isBlocked = await this.isBlockedResponse(response);
+                
+                if (!isBlocked) {
+                    return response;
+                }
 
-        if (this.cookieStore["__ddg2_"]) {
-            return this.fetchWithCookies(url, options);
-        }
+                if (this.cookieStore["__ddg2_"]) {
+                    response = await this.fetchWithCookies(url, options);
+                    if (!await this.isBlockedResponse(response)) {
+                        return response;
+                    }
+                }
 
-        const newCookie = await this.getNewCookie(url);
-        if (!newCookie) {
-            return response;
+                const newCookie = await this.getNewCookie(url);
+                if (newCookie) {
+                    response = await this.fetchWithCookies(url, options);
+                    if (!await this.isBlockedResponse(response)) {
+                        return response;
+                    }
+                }
+                
+                retries++;
+                if (retries < maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                }
+            } catch (e) {
+                retries++;
+                if (retries < maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                } else {
+                    throw e;
+                }
+            }
         }
         
-        return this.fetchWithCookies(url, options);
+        throw new Error("Max retries exceeded for DDoS bypass");
     }
 
     async fetchWithCookies(url, options) {