Upload

helioscans/helioscans.js

@@ -0,0 +1,232 @@
+async function searchResults(keyword) {
+    try {
+        const encodedKeyword = encodeURIComponent(keyword);
+        const url = `https://helioscans.com/series/?q=${encodedKeyword}`;
+        const response = await soraFetch(url);
+        const html = await response.text();
+
+        const results = [];
+        const regex = /<button[^>]+?title="([^"]+?)"[^>]*?>[\s\S]*?<a href="([^"]+?)"[\s\S]*?background-image:url\(([^)]+)\)/g;
+        let match;
+
+        while ((match = regex.exec(html)) !== null) {
+            const title = match[1];
+            const href = `https://helioscans.com${match[2]}`;
+            const rawImage = match[3].replace(/&amp;/g, "&");
+            const image = rawImage.startsWith("http") ? rawImage : `https:${rawImage}`;
+
+            results.push({ title, href, image });
+        }
+
+        console.log(JSON.stringify(results));
+        return JSON.stringify(results);
+    } catch (error) {
+        console.error("Error fetching or parsing: " + error);
+        return JSON.stringify([{
+            title: "Error",
+            href: "",
+            image: ""
+        }]);
+    }
+}
+extractChapters('https://helioscans.com/series/63a6054296b/');
+
+async function extractDetails(url) {
+  try {
+    const response = await soraFetch(url);
+    const htmlText = await response.text();
+
+    const metaMatch = htmlText.match(/<meta name="description" content="([\s\S]*?)">/i);
+    const description = metaMatch
+      ? metaMatch[1].replace(/\s+/g, ' ').trim()
+      : "No description available";
+
+    const aliases = 'N/A';
+    const airdate = 'N/A';
+
+    const transformedResults = [{
+      description,
+      aliases,
+      airdate
+    }];
+
+    console.log(JSON.stringify(transformedResults));
+    return JSON.stringify(transformedResults);
+
+  } catch (error) {
+    console.log('Details error:' + error);
+    return JSON.stringify([{
+      description: 'Error loading description',
+      aliases: 'N/A',
+      airdate: 'N/A'
+    }]);
+  }
+}
+
+async function extractChapters(url) {
+  try {
+    const response = await soraFetch(url);
+    const htmlText = await response.text();
+    console.log(htmlText);
+
+    const chapters = [];
+    const chapterLinkRegex = /<a\s+[^>]*href="([^"]*\/chapter\/[^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+    let linkMatch;
+
+    while ((linkMatch = chapterLinkRegex.exec(htmlText)) !== null) {
+      const fullLinkHtml = linkMatch[0];
+      const href = `https://helioscans.com${linkMatch[1]}`;
+
+      const titleRegex = /<span[^>]*class="[^"]*\btext-sm\b[^"]*\btruncate\b[^"]*"[^>]*>([^<]+)<\/span>/i;
+      const titleMatch = titleRegex.exec(fullLinkHtml);
+      const rawTitle = titleMatch ? titleMatch[1].trim() : "";
+
+      if (!rawTitle) continue;
+
+      const isLocked = /Coin\.svg/i.test(fullLinkHtml);
+      const title = isLocked ? `${rawTitle} (Locked – 100 credits)` : rawTitle;
+
+      chapters.push({ title, href });
+    }
+
+    chapters.sort((a, b) => {
+      const numA = parseFloat(a.title.match(/Chapter\s+(\d+)/i)?.[1]) || 0;
+      const numB = parseFloat(b.title.match(/Chapter\s+(\d+)/i)?.[1]) || 0;
+      return numA - numB;
+    });
+
+    chapters.forEach((chapter, index) => {
+      chapter.number = index + 1;
+    });
+
+    console.log(JSON.stringify(chapters));
+    return JSON.stringify(chapters);
+  } catch (error) {
+    console.error('Fetch error in extractChapters:', error);
+    return JSON.stringify([{
+      href: url,
+      title: "Error fetching chapters",
+      number: 0
+    }]);
+  }
+}
+
+async function extractText(url) {
+    try {
+        const headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1'
+        };
+        
+        const response = await soraFetch(url, headers);
+        const htmlText = await response.text();
+        
+        const startMarker = '<div id="pages"';
+        const startIndex = htmlText.indexOf(startMarker);
+        if (startIndex === -1) {
+            throw new Error("Pages content div start (<div id=\"pages\") not found");
+        }
+        
+        const startTagEndIndex = htmlText.indexOf('>', startIndex);
+        if (startTagEndIndex === -1) {
+            throw new Error("Could not find the end of the opening <div id=\"pages\"> tag");
+        }
+        
+        const contentStartIndex = startTagEndIndex + 1;
+        let depth = 1;
+        let pos = contentStartIndex;
+        let endIndex = -1;
+        
+        while (depth > 0 && pos < htmlText.length) {
+            const nextOpenDiv = htmlText.indexOf('<div', pos);
+            const nextCloseDiv = htmlText.indexOf('</div', pos);
+            
+            if (nextCloseDiv === -1) {
+                break;
+            }
+            
+            if (nextOpenDiv !== -1 && nextOpenDiv < nextCloseDiv) {
+                depth++;
+                pos = nextOpenDiv + 4;
+            } else {
+                depth--;
+                if (depth === 0) {
+                    endIndex = nextCloseDiv;
+                } else {
+                    pos = nextCloseDiv + 5;
+                }
+            }
+        }
+        
+        if (endIndex === -1) {
+            throw new Error("Matching closing </div> for pages content div not found");
+        }
+        
+        let innerContent = htmlText.substring(contentStartIndex, endIndex);
+        
+        innerContent = innerContent.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '');
+        innerContent = innerContent.replace(/<div[^>]*class="[^"]*fixed[^"]*z-\[60\][^"]*top-0[^"]*left-0[^"]*w-full[^"]*h-full[^"]*bg-black\/90[^"]*flex[^"]*justify-center[^"]*items-center[\s\S]*?<\/div>/gi, '');
+        
+        const paragraphRegex = /<p[^>]*>(.*?)<\/p>/gi;
+        let textContent = '';
+        let match;
+        
+        while ((match = paragraphRegex.exec(innerContent)) !== null) {
+            const paragraphText = match[1].replace(/<[^>]*>/g, '').trim();
+            if (paragraphText) {
+                textContent += paragraphText + '\n';
+            }
+        }
+        
+        innerContent = innerContent.trim();
+        
+        if (!innerContent && !textContent) {
+            throw new Error("Chapter text not found or empty after cleaning");
+        }
+        console.log(innerContent || textContent);
+        return innerContent;
+        
+    } catch (error) {
+        console.error("Fetch error in extractText: " + error.message);
+        return '<p>Error: This is chapter is locked as early access by the website, you will have to pay on the website or wait for the chapter to be released globally</p>';
+    }
+}
+
+async function soraFetch(url, options = {
+    headers: {},
+    method: 'GET',
+    body: null
+}) {
+    try {
+        return await fetchv2(url, options.headers ?? {}, options.method ?? 'GET', options.body ?? null);
+    } catch (e) {
+        try {
+            return await fetch(url, options);
+        } catch (error) {
+            return null;
+        }
+    }
+}
+
+function decodeHtmlEntities(text) {
+    const entities = {
+        '&#x2014;': '—',
+        '&#x2013;': '–',
+        '&amp;': '&',
+        '&lt;': '<',
+        '&gt;': '>',
+        '&quot;': '"',
+        '&#x27;': "'",
+        '&#x2F;': '/',
+        '&#x60;': '`',
+        '&#x3D;': '=',
+        '&nbsp;': ' '
+    };
+
+    return text.replace(/&#x[\dA-Fa-f]+;|&\w+;/g, (match) => {
+        return entities[match] || match;
+    });
+}

helioscans/helioscans.json

@@ -0,0 +1,19 @@
+{
+    "sourceName": "HelioScan",
+    "iconUrl": "https://wsrv.nl/?url=image.meowing.org/uploads/_9FxZ8P7Tik&w=44",
+    "author": {
+        "name": "50/50",
+        "icon": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQ3122kQwublLkZ6rf1fEpUP79BxZOFmH9BSA&s"
+    },
+    "version": "1.0.1",
+    "language": "English",
+    "streamType": "novels",
+    "quality": "N/A",
+    "baseUrl": "https://helioscans.com/",
+    "searchBaseUrl": "https://helioscans.com/%s",
+    "scriptUrl": "https://gitlab.com/50n50/sources/-/raw/main/helioscans/helioscans.js",
+    "type": "novels",
+    "asyncJS": true,
+    "novel": true,
+    "downloadSupport": false
+}