Spaces:

devusman
/

test

Running

App Files Files Community

devusman commited on Aug 16, 2025

Commit

63bdb43

1 Parent(s): f46a3f8

update

Browse files

Files changed (4) hide show

.vscode/settings.json +3 -0
index.html +287 -0
server copy.js +691 -0
server.js +269 -163

.vscode/settings.json ADDED Viewed

	@@ -0,0 +1,3 @@

+{
+  "liveServer.settings.port": 5501
+}

index.html ADDED Viewed

	@@ -0,0 +1,287 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>StuDocu Downloader</title>
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;600&display=swap" rel="stylesheet">
+    <style>
+        body {
+            font-family: 'Poppins', sans-serif;
+            background-color: #f0f2f5;
+            margin: 0;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            min-height: 100vh;
+            padding: 20px;
+            box-sizing: border-box;
+        }
+        .container {
+            background-color: #ffffff;
+            padding: 30px 40px;
+            border-radius: 12px;
+            box-shadow: 0 8px 30px rgba(0, 0, 0, 0.08);
+            width: 100%;
+            max-width: 650px;
+            text-align: center;
+            transition: all 0.3s ease;
+        }
+        .header .logo {
+            width: 40px;
+            height: 40px;
+            color: #007bff;
+            margin-bottom: 10px;
+        }
+        .header h1 {
+            color: #2c3e50;
+            margin: 0 0 10px;
+            font-weight: 600;
+        }
+        .header p {
+            color: #7f8c8d;
+            margin-bottom: 30px;
+            font-size: 1rem;
+        }
+        .form-container {
+            display: flex;
+            margin-bottom: 20px;
+        }
+        #studocu-url {
+            flex-grow: 1;
+            padding: 14px 18px;
+            border: 1px solid #dfe4ea;
+            border-radius: 8px 0 0 8px;
+            font-size: 16px;
+            outline: none;
+            transition: border-color 0.3s ease, box-shadow 0.3s ease;
+        }
+        #studocu-url:focus {
+            border-color: #007bff;
+            box-shadow: 0 0 0 3px rgba(0, 123, 255, 0.15);
+        }
+        #download-btn {
+            padding: 14px 25px;
+            border: none;
+            background-color: #007bff;
+            color: white;
+            font-size: 16px;
+            font-weight: 600;
+            border-radius: 0 8px 8px 0;
+            cursor: pointer;
+            outline: none;
+            position: relative;
+            transition: background-color 0.3s ease;
+        }
+        #download-btn:hover {
+            background-color: #0056b3;
+        }
+        #download-btn:disabled {
+            background-color: #5a9eeb;
+            cursor: not-allowed;
+        }
+        /* Loader animation */
+        .btn-loader {
+            display: none;
+            border: 3px solid #f3f3f3;
+            border-top: 3px solid #0056b3;
+            border-radius: 50%;
+            width: 20px;
+            height: 20px;
+            animation: spin 1s linear infinite;
+        }
+        #download-btn.loading .btn-text {
+            display: none;
+        }
+        #download-btn.loading .btn-loader {
+            display: block;
+            margin: 0 auto;
+        }
+        @keyframes spin {
+            0% {
+                transform: rotate(0deg);
+            }
+            100% {
+                transform: rotate(360deg);
+            }
+        }
+        .status-indicator {
+            padding: 12px;
+            border-radius: 8px;
+            margin-top: 20px;
+            font-size: 0.95rem;
+            display: block;
+        }
+        .status-indicator.success {
+            background-color: #d4edda;
+            color: #155724;
+            border: 1px solid #c3e6cb;
+        }
+        .status-indicator.error {
+            background-color: #f8d7da;
+            color: #721c24;
+            border: 1px solid #f5c6cb;
+        }
+        .status-indicator.info {
+            background-color: #cce5ff;
+            color: #004085;
+            border: 1px solid #b8daff;
+        }
+        .footer {
+            margin-top: 30px;
+            font-size: 0.8rem;
+            color: #95a5a6;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <svg class="logo" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor">
+                <path
+                    d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 14h-2v-2h2v2zm0-4h-2V7h2v5z" />
+            </svg>
+            <h1>StuDocu Document Downloader</h1>
+            <p>Paste a valid StuDocu document URL to generate and download a PDF.</p>
+        </div>
+        <div class="main-content">
+            <div class="form-container">
+                <input type="text" id="studocu-url" placeholder="https://www.studocu.com/en-us/document/...">
+                <button id="download-btn">
+                    <span class="btn-text">Download</span>
+                    <span class="btn-loader"></span>
+                </button>
+            </div>
+            <div class="status-indicator" id="status-indicator" style="display: none;">
+                <!-- Messages will be displayed here by JavaScript -->
+            </div>
+        </div>
+        <div class="footer">
+            <p>Powered by the Heart by Us</p>
+        </div>
+    </div>
+    <script>document.addEventListener('DOMContentLoaded', () => {
+            const downloadBtn = document.getElementById('download-btn');
+            const urlInput = document.getElementById('studocu-url');
+            const statusIndicator = document.getElementById('status-indicator');
+            const API_ENDPOINT = 'https://devusman-test.hf.space/api/download';
+            downloadBtn.addEventListener('click', async () => {
+                const url = urlInput.value.trim();
+                // 1. Validate the input URL
+                if (!url) {
+                    showStatus('Please paste a URL first.', 'error');
+                    return;
+                }
+                if (!url.includes('studocu.com')) {
+                    showStatus('Please provide a valid StuDocu URL.', 'error');
+                    return;
+                }
+                // 2. Update UI to show loading state
+                setLoading(true);
+                showStatus('Request sent. Please wait, this can take up to a minute...', 'info');
+                try {
+                    // 3. Send the POST request to the API
+                    const response = await fetch(API_ENDPOINT, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({ url: url }),
+                    });
+                    // 4. Handle the response
+                    if (response.ok) {
+                        // If successful, the response body is the PDF file
+                        showStatus('Success! Your download will start now.', 'success');
+                        const blob = await response.blob();
+                        // Create a temporary link to trigger the download
+                        const downloadUrl = window.URL.createObjectURL(blob);
+                        const a = document.createElement('a');
+                        a.style.display = 'none';
+                        a.href = downloadUrl;
+                        // Suggest a filename for the download
+                        a.download = 'studocu-document.pdf';
+                        document.body.appendChild(a);
+                        a.click();
+                        // Clean up the temporary URL and link
+                        window.URL.revokeObjectURL(downloadUrl);
+                        a.remove();
+                    } else {
+                        // If there's an error, parse the JSON to get the error message
+                        const errorData = await response.json();
+                        showStatus(`Error: ${errorData.error || 'An unknown error occurred.'}`, 'error');
+                    }
+                } catch (error) {
+                    // Handle network errors or other exceptions
+                    console.error('Download failed:', error);
+                    showStatus('Failed to connect to the server. Please check your connection and try again.', 'error');
+                } finally {
+                    // 5. Reset the UI from the loading state
+                    setLoading(false);
+                }
+            });
+            /**
+             * Updates the button and input field to reflect the loading state.
+             * @param {boolean} isLoading - Whether the app is in a loading state.
+             */
+            function setLoading(isLoading) {
+                if (isLoading) {
+                    downloadBtn.classList.add('loading');
+                    downloadBtn.disabled = true;
+                    urlInput.disabled = true;
+                } else {
+                    downloadBtn.classList.remove('loading');
+                    downloadBtn.disabled = false;
+                    urlInput.disabled = false;
+                }
+            }
+            /**
+             * Displays a status message to the user.
+             * @param {string} message - The message to display.
+             * @param {'info'|'success'|'error'} type - The type of message.
+             */
+            function showStatus(message, type) {
+                statusIndicator.style.display = 'block';
+                statusIndicator.textContent = message;
+                statusIndicator.className = `status-indicator ${type}`;
+            }
+        });</script>
+</body>
+</html>

server copy.js ADDED Viewed

	@@ -0,0 +1,691 @@

+const express = require('express');
+const puppeteer = require('puppeteer');
+const cors = require('cors');
+const app = express();
+const port = 7860;
+app.use(cors());
+app.use(express.json());
+/**
+ * Advanced cookie banner and content bypass for StuDocu
+ */
+const bypassCookiesAndRestrictions = async (page) => {
+    console.log("🍪 Starting comprehensive cookie and restriction bypass...");
+    // Step 1: Set cookies before page load
+    const preCookies = [
+        { name: 'cookieConsent', value: 'accepted', domain: '.studocu.com' },
+        { name: 'cookie_consent', value: 'true', domain: '.studocu.com' },
+        { name: 'gdpr_consent', value: 'accepted', domain: '.studocu.com' },
+        { name: 'privacy_policy_accepted', value: 'true', domain: '.studocu.com' },
+        { name: 'user_consent', value: '1', domain: '.studocu.com' },
+        { name: 'analytics_consent', value: 'false', domain: '.studocu.com' },
+        { name: 'marketing_consent', value: 'false', domain: '.studocu.com' },
+        { name: 'functional_consent', value: 'true', domain: '.studocu.com' },
+    ];
+    for (const cookie of preCookies) {
+        try {
+            await page.setCookie(cookie);
+        } catch (e) {
+            console.log(`Failed to set cookie ${cookie.name}:`, e.message);
+        }
+    }
+    // Step 2: Inject CSS to hide cookie banners immediately
+    await page.addStyleTag({
+        content: `
+      /* Hide all possible cookie banners */
+      [id*="cookie" i]:not(img):not(input),
+      [class*="cookie" i]:not(img):not(input),
+      [data-testid*="cookie" i],
+      [aria-label*="cookie" i],
+      .gdpr-banner, .gdpr-popup, .gdpr-modal,
+      .consent-banner, .consent-popup, .consent-modal,
+      .privacy-banner, .privacy-popup, .privacy-modal,
+      .cookie-law, .cookie-policy, .cookie-compliance,
+      .onetrust-banner-sdk, #onetrust-consent-sdk,
+      .cmp-banner, .cmp-popup, .cmp-modal,
+      [class*="CookieBanner"], [class*="CookieNotice"],
+      [class*="ConsentBanner"], [class*="ConsentManager"],
+      .cc-banner, .cc-window, .cc-compliance,
+      div[style*="position: fixed"]:has-text("cookie"),
+      div[style*="position: fixed"]:has-text("consent"),
+      .fixed:has-text("cookie"), .fixed:has-text("consent") {
+        display: none !important;
+        visibility: hidden !important;
+        opacity: 0 !important;
+        z-index: -9999 !important;
+        pointer-events: none !important;
+      }
+      /* Remove blur and premium overlays */
+      [class*="blur" i], [class*="premium" i],
+      [class*="paywall" i], [class*="sample-preview-blur" i] {
+        filter: none !important;
+        backdrop-filter: none !important;
+        opacity: 1 !important;
+        visibility: visible !important;
+      }
+      /* Ensure document content is visible */
+      .document-content, .page-content, [data-page] {
+        filter: none !important;
+        opacity: 1 !important;
+        visibility: visible !important;
+        pointer-events: auto !important;
+      }
+      /* Remove fixed overlays */
+      .fixed-overlay, .sticky-overlay, .content-overlay {
+        display: none !important;
+      }
+      /* Restore scrolling */
+      html, body {
+        overflow: auto !important;
+        position: static !important;
+      }
+    `
+    });
+    // Step 3: Inject JavaScript to handle dynamic cookie banners
+    await page.evaluateOnNewDocument(() => {
+        // Override common cookie consent functions
+        window.cookieConsent = { accepted: true };
+        window.gtag = () => { };
+        window.ga = () => { };
+        window.dataLayer = [];
+        // Mutation observer to catch dynamically added cookie banners
+        const observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                mutation.addedNodes.forEach((node) => {
+                    if (node.nodeType === 1) { // Element node
+                        const element = node;
+                        const text = element.textContent || '';
+                        const className = element.className || '';
+                        const id = element.id || '';
+                        // Check if this looks like a cookie banner
+                        if (
+                            text.toLowerCase().includes('cookie') ||
+                            text.toLowerCase().includes('consent') ||
+                            text.toLowerCase().includes('privacy policy') ||
+                            className.toLowerCase().includes('cookie') ||
+                            className.toLowerCase().includes('consent') ||
+                            className.toLowerCase().includes('gdpr') ||
+                            id.toLowerCase().includes('cookie') ||
+                            id.toLowerCase().includes('consent')
+                        ) {
+                            console.log('Removing detected cookie banner:', element);
+                            element.remove();
+                        }
+                    }
+                });
+            });
+        });
+        observer.observe(document.body, { childList: true, subtree: true });
+        // Set up periodic cleanup
+        setInterval(() => {
+            const cookieElements = document.querySelectorAll(`
+        [id*="cookie" i]:not(img):not(input),
+        [class*="cookie" i]:not(img):not(input),
+        [data-testid*="cookie" i],
+        .gdpr-banner, .consent-banner, .privacy-banner,
+        .onetrust-banner-sdk, #onetrust-consent-sdk,
+        .cmp-banner, .cc-banner
+      `);
+            cookieElements.forEach(el => el.remove());
+            // Restore body scroll
+            document.body.style.overflow = 'auto';
+            document.documentElement.style.overflow = 'auto';
+        }, 1000);
+    });
+    return true;
+};
+/**
+ * Enhanced content unblurring and premium bypass (integrated from extension script)
+ */
+const unblurContent = async (page) => {
+    console.log("🔓 Unblurring content and bypassing premium restrictions...");
+    await page.evaluate(() => {
+        // Function to remove all visual restrictions
+        const removeRestrictions = () => {
+            const removeBySelector = (selector) => {
+                document.querySelectorAll(selector).forEach(el => el.remove());
+            };
+            // Remove ads by known class or ID
+            removeBySelector("#adbox");
+            removeBySelector(".adsbox");
+            removeBySelector(".ad-box");
+            removeBySelector(".banner-ads");
+            removeBySelector(".advert");
+            // Remove premium banner container
+            removeBySelector(".PremiumBannerBlobWrapper_overflow-wrapper__xsaS8");
+            // Enhanced blur removal
+            const removeBlur = (element = document) => {
+                element.querySelectorAll("*").forEach(el => {
+                    const style = window.getComputedStyle(el);
+                    // Check for blur via filter, backdrop-filter, or class names
+                    if (
+                        style.filter?.includes("blur") ||
+                        style.backdropFilter?.includes("blur") ||
+                        parseFloat(style.opacity) < 1 ||
+                        (el.className && el.className.toString().toLowerCase().includes("blur")) ||
+                        (el.className && el.className.toString().toLowerCase().includes("premium"))
+                    ) {
+                        el.style.filter = "none !important";
+                        el.style.backdropFilter = "none !important";
+                        el.style.opacity = "1 !important";
+                        if (el.classList) {
+                            el.classList.remove("blur", "blurred", "premium-blur");
+                        }
+                    }
+                    // Check parent elements for blur-inducing styles
+                    const parent = el.parentElement;
+                    if (parent) {
+                        const parentStyle = window.getComputedStyle(parent);
+                        if (
+                            parentStyle.filter?.includes("blur") ||
+                            parentStyle.backdropFilter?.includes("blur") ||
+                            parseFloat(parentStyle.opacity) < 1
+                        ) {
+                            parent.style.filter = "none !important";
+                            parent.style.backdropFilter = "none !important";
+                            parent.style.opacity = "1 !important";
+                        }
+                    }
+                });
+            };
+            // Remove dark overlays and paywall-like elements
+            document.querySelectorAll("div, section, aside").forEach(el => {
+                const style = window.getComputedStyle(el);
+                if (
+                    style.backgroundColor.includes("rgba") &&
+                    (style.backgroundColor.includes("0.5") || parseFloat(style.zIndex) > 1000) ||
+                    (el.className && el.className.toString().toLowerCase().includes("overlay")) ||
+                    (el.className && el.className.toString().toLowerCase().includes("paywall"))
+                ) {
+                    el.remove();
+                }
+            });
+            removeBlur();
+            // Remove other restrictions
+            removeBySelector('[class*="blur" i], [class*="premium" i], [class*="paywall" i], [class*="sample-preview-blur" i]');
+            // Ensure document content is visible
+            const contentSelectors = [
+                '.document-content', '.page-content', '.content',
+                '[data-page]', '[data-testid*="document"]', '[data-testid*="page"]',
+                '.page', '.document-page', 'main', 'article'
+            ];
+            contentSelectors.forEach(selector => {
+                document.querySelectorAll(selector).forEach(el => {
+                    el.style.setProperty('filter', 'none', 'important');
+                    el.style.setProperty('opacity', '1', 'important');
+                    el.style.setProperty('visibility', 'visible', 'important');
+                    el.style.setProperty('display', 'block', 'important');
+                    el.style.setProperty('pointer-events', 'auto', 'important');
+                });
+            });
+            // Remove overlay divs that might be blocking content
+            const overlays = document.querySelectorAll(`
+        [class*="overlay" i], [class*="modal" i], [class*="popup" i],
+        [class*="banner" i], [style*="position: fixed"],
+        [style*="position: absolute"][style*="z-index"]
+      `);
+            overlays.forEach(overlay => {
+                const text = overlay.textContent || '';
+                if (text.includes('premium') || text.includes('unlock') || text.includes('subscribe') ||
+                    text.includes('cookie') || text.includes('consent') || text.includes('login')) {
+                    overlay.remove();
+                }
+            });
+        };
+        // Run immediately
+        removeRestrictions();
+        // Run periodically
+        const intervalId = setInterval(removeRestrictions, 2000);
+        // Clean up after 60 seconds
+        setTimeout(() => {
+            clearInterval(intervalId);
+        }, 60000);
+    });
+};
+/**
+ * Apply print styles for clean PDF output (integrated from extension script with improvements)
+ */
+const applyPrintStyles = async (page) => {
+    console.log("🖨️ Applying print styles for clean PDF...");
+    await page.evaluate(() => {
+        const style = document.createElement("style");
+        style.id = "print-style-extension";
+        style.innerHTML = `
+      @page {
+        size: A4 portrait;
+        margin: 5mm;
+      }
+      @media print {
+        html, body {
+          margin: 0 !important;
+          padding: 0 !important;
+          overflow: visible !important;
+        }
+        header, footer, nav, aside, .no-print, .ads, .sidebar,
+        .premium-banner, .ViewerToolbar, .Layout_info-bar-wrapper__He0Ho,
+        .Sidebar_sidebar-scrollable__kqeBZ, .HeaderWrapper_header-wrapper__mCmf3,
+        .Layout_visible-content-bottom-wrapper-sticky__yaaAB,
+        .Layout_bottom-section-wrapper__yBWWk, .Layout_footer-wrapper__bheJQ,
+        .InlineBanner_inline-banner-wrapper__DAi5X, .banner-wrapper,
+        #top-bar-wrapper, .Layout_sidebar-wrapper__unavM,
+        .Layout_is-open__9DQr4 {
+          display: none !important;
+        }
+        body {
+          background: white !important;
+          color: black !important;
+        }
+        * {
+          box-shadow: none !important;
+          background: transparent !important;
+        }
+        .Viewer_document-wrapper__JPBWQ, .Viewer_document-wrapper__LXzoQ,
+        .Viewer_document-wrapper__XsO4j, .page-content {
+          display: flex !important;
+          flex-direction: column !important;
+          width: 100% !important;
+          max-width: 210mm !important;
+          margin: 0 auto !important;
+        }
+        [data-page], .page, .document-page, img {
+          page-break-after: always !important;
+          page-break-inside: avoid !important;
+          page-break-before: avoid !important;
+          width: 100% !important;
+          max-width: 100% !important;
+          height: auto !important;
+        }
+      }
+    `;
+        document.head.appendChild(style);
+    });
+};
+/**
+ * Enhanced StuDocu downloader with comprehensive bypasses and login support
+ */
+const studocuDownloader = async (url, options = {}) => {
+    let browser;
+    try {
+        console.log("🚀 Launching browser with stealth configuration...");
+        // Replace this part in your server.js (around line 343)
+        browser = await puppeteer.launch({
+            headless: "new", // Use new headless mode
+            args: [
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-accelerated-2d-canvas',
+                '--no-first-run',
+                '--no-zygote',
+                '--disable-gpu',
+                '--disable-features=VizDisplayCompositor',
+                '--disable-background-networking',
+                '--disable-background-timer-throttling',
+                '--disable-renderer-backgrounding',
+                '--disable-backgrounding-occluded-windows',
+                '--disable-ipc-flooding-protection',
+                '--disable-web-security',
+                '--disable-features=site-per-process',
+                '--disable-blink-features=AutomationControlled',
+                '--disable-extensions',
+                '--single-process', // Important for containers
+                '--disable-background-tasks',
+                '--disable-default-apps',
+                '--disable-sync',
+                '--metrics-recording-only',
+                '--no-default-browser-check',
+                '--no-pings',
+                '--password-store=basic',
+                '--use-mock-keychain',
+                '--disable-gpu-sandbox'
+            ],
+            timeout: 300000,
+            executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/google-chrome-stable'
+        });
+        const page = await browser.newPage();
+        // Set realistic browser characteristics
+        await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
+        await page.setViewport({ width: 794, height: 1122 });
+        // Hide webdriver property
+        await page.evaluateOnNewDocument(() => {
+            Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+            Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] });
+            Object.defineProperty(navigator, 'plugins', { get: () => [1, 2, 3, 4, 5] });
+        });
+        // Set up cookie and content bypass
+        await bypassCookiesAndRestrictions(page);
+        // Block unnecessary resources
+        await page.setRequestInterception(true);
+        page.on('request', (req) => {
+            const resourceType = req.resourceType();
+            const reqUrl = req.url();
+            // Block trackers, ads, and analytics
+            if (
+                reqUrl.includes('doubleclick') ||
+                reqUrl.includes('googletagmanager') ||
+                reqUrl.includes('facebook.com') ||
+                reqUrl.includes('twitter.com') ||
+                reqUrl.includes('analytics') ||
+                reqUrl.includes('gtm') ||
+                reqUrl.includes('hotjar') ||
+                reqUrl.includes('mixpanel') ||
+                reqUrl.includes('onetrust') ||
+                reqUrl.includes('cookielaw') ||
+                resourceType === 'other' && reqUrl.includes('track')
+            ) {
+                req.abort();
+            } else {
+                req.continue();
+            }
+        });
+        // Login if credentials provided (for premium content)
+        if (options.email && options.password) {
+            console.log("🔑 Logging in to StuDocu...");
+            await page.goto('https://www.studocu.com/en-us/login', { waitUntil: 'domcontentloaded', timeout: 60000 });
+            await page.waitForSelector('#email', { timeout: 15000 });
+            await page.type('#email', options.email);
+            await page.type('#password', options.password);
+            await page.click('button[type="submit"]');
+            try {
+                await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 30000 });
+                // Additional check for successful login
+                await page.waitForSelector('.user-profile, [data-testid="user-menu"]', { timeout: 10000 });
+                console.log("✅ Login successful.");
+            } catch (e) {
+                console.error("❌ Login failed:", e.message);
+                throw new Error("Login failed. Check credentials, if CAPTCHA is present, or try again.");
+            }
+        } else {
+            console.log("⚠️ No login credentials provided. Full unblurred content requires premium account.");
+        }
+        console.log(`📄 Navigating to ${url}...`);
+        // Navigate with retry logic
+        let navigationSuccess = false;
+        let attempts = 0;
+        const maxAttempts = 3;
+        while (!navigationSuccess && attempts < maxAttempts) {
+            try {
+                attempts++;
+                console.log(`Navigation attempt ${attempts}/${maxAttempts}`);
+                await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
+                navigationSuccess = true;
+            } catch (e) {
+                console.log(`Navigation attempt ${attempts} failed:`, e.message);
+                if (attempts >= maxAttempts) throw e;
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
+        }
+        // Wait for initial load
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        // Apply content unblurring
+        await unblurContent(page);
+        // Wait for document content with multiple selectors
+        console.log("⏳ Waiting for document content to load...");
+        const contentSelectors = [
+            '.document-content', '.page-content', '[data-page]',
+            '[data-testid*="document"]', 'img[src*="document"]',
+            'img[src*="page"]', '.page', 'main img', 'article img'
+        ];
+        let contentFound = false;
+        for (const selector of contentSelectors) {
+            try {
+                await page.waitForSelector(selector, { timeout: 20000 });
+                console.log(`✅ Found content with selector: ${selector}`);
+                contentFound = true;
+                break;
+            } catch (e) {
+                console.log(`❌ Selector ${selector} not found, trying next...`);
+            }
+        }
+        if (!contentFound) {
+            console.log("⚠️ No specific content selector found, proceeding with page content...");
+        }
+        // Enhanced scrolling to load all content with loop for stability
+        console.log("📜 Loading all document pages with enhanced slow scroll...");
+        await page.evaluate(async () => {
+            const delay = (ms) => new Promise((res) => setTimeout(res, ms));
+            let scrollHeight = document.body.scrollHeight;
+            while (true) {
+                let totalHeight = 0;
+                const distance = 300;
+                while (totalHeight < scrollHeight) {
+                    window.scrollBy(0, distance);
+                    totalHeight += distance;
+                    await delay(500); // Increased delay for better loading
+                }
+                await delay(2000); // Extra wait after reaching bottom
+                const newHeight = document.body.scrollHeight;
+                if (newHeight === scrollHeight) break;
+                scrollHeight = newHeight;
+            }
+            // Scroll to top
+            window.scrollTo({ top: 0, behavior: "smooth" });
+            await delay(1000);
+        });
+        // Re-apply unblur after loading new content
+        await unblurContent(page);
+        // Wait for all images to load
+        console.log("🖼️ Waiting for all images to load...");
+        await page.evaluate(async () => {
+            const images = Array.from(document.querySelectorAll('img'));
+            await Promise.all(images.map(img => {
+                if (img.complete) return Promise.resolve();
+                return new Promise((resolve) => {
+                    img.addEventListener('load', resolve);
+                    img.addEventListener('error', resolve);
+                    setTimeout(resolve, 15000);
+                });
+            }));
+        });
+        // Additional wait for any lazy loading
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        // Set exact height to avoid extra blank pages
+        console.log("📏 Setting exact document height...");
+        await page.evaluate(() => {
+            const getDocumentHeight = () => Math.max(
+                document.body.scrollHeight, document.body.offsetHeight,
+                document.documentElement.clientHeight, document.documentElement.scrollHeight,
+                document.documentElement.offsetHeight
+            );
+            const height = getDocumentHeight();
+            document.body.style.height = `${height}px !important`;
+            document.documentElement.style.height = `${height}px !important`;
+            document.body.style.overflow = 'hidden !important';
+        });
+        // Final content verification
+        const contentCheck = await page.evaluate(() => {
+            const textContent = document.body.textContent || '';
+            const images = document.querySelectorAll('img');
+            const documentImages = Array.from(images).filter(img =>
+                img.src.includes('document') || img.src.includes('page') ||
+                img.alt.includes('document') || img.alt.includes('page')
+            );
+            return {
+                totalText: textContent.length,
+                totalImages: images.length,
+                documentImages: documentImages.length,
+                hasDocumentContent: documentImages.length > 0 || textContent.length > 1000,
+                sampleText: textContent.substring(0, 300)
+            };
+        });
+        console.log("📊 Content verification:", {
+            textLength: contentCheck.totalText,
+            images: contentCheck.totalImages,
+            documentImages: contentCheck.documentImages,
+            hasContent: contentCheck.hasDocumentContent
+        });
+        if (!contentCheck.hasDocumentContent) {
+            console.warn("⚠️ Warning: Limited document content detected. Use premium credentials for full access.");
+        }
+        // Apply print styles
+        await applyPrintStyles(page);
+        // Emulate print media
+        await page.emulateMediaType('print');
+        // Generate PDF
+        console.log("🔄 Generating PDF...");
+        const pdfBuffer = await page.pdf({
+            printBackground: true,
+            preferCSSPageSize: true,
+            displayHeaderFooter: false,
+            timeout: 180000,
+            scale: 1,
+            omitBackground: false
+        });
+        console.log(`✅ PDF generated successfully! Size: ${(pdfBuffer.length / 1024 / 1024).toFixed(2)} MB`);
+        return pdfBuffer;
+    } catch (error) {
+        console.error("❌ Error during PDF generation:", error);
+        if (error.message.includes('timeout')) {
+            throw new Error("Request timed out. The document may be taking too long to load. Please try again.");
+        } else if (error.message.includes('net::')) {
+            throw new Error("Network error. Please check the URL and your internet connection.");
+        } else if (error.message.includes('ERR_BLOCKED')) {
+            throw new Error("Access blocked. Try again or check if the document is publicly accessible.");
+        } else {
+            throw new Error(`Failed to generate PDF: ${error.message}`);
+        }
+    } finally {
+        if (browser) {
+            console.log("🔒 Closing browser...");
+            try {
+                await browser.close();
+            } catch (e) {
+                console.log("Error closing browser:", e.message);
+            }
+        }
+    }
+};
+// API Routes
+app.post('/api/download', async (req, res) => {
+    const { url, filename, email, password } = req.body;
+    if (!url) {
+        return res.status(400).json({ error: 'URL is required.' });
+    }
+    if (!url.includes('studocu.com')) {
+        return res.status(400).json({ error: 'Please provide a valid StuDocu URL.' });
+    }
+    let normalizedUrl = url.trim();
+    if (!normalizedUrl.startsWith('http')) {
+        normalizedUrl = 'https://' + normalizedUrl;
+    }
+    console.log(`🎯 Processing request for: ${normalizedUrl}`);
+    try {
+        const startTime = Date.now();
+        const pdfBuffer = await studocuDownloader(normalizedUrl, { filename, email, password });
+        const processingTime = ((Date.now() - startTime) / 1000).toFixed(2);
+        res.setHeader('Content-Type', 'application/pdf');
+        res.setHeader('Content-Disposition', 'attachment; filename=studocu-document.pdf');
+        res.setHeader('Content-Length', pdfBuffer.length);
+        res.send(pdfBuffer);
+        console.log(`🎉 Request completed successfully in ${processingTime}s`);
+    } catch (error) {
+        console.error(`❌ Failed to process ${normalizedUrl}:`, error.message);
+        res.status(500).json({ error: error.message });
+    }
+});
+app.get('/health', (req, res) => {
+    res.json({ status: 'healthy', timestamp: new Date().toISOString(), uptime: process.uptime() });
+});
+app.get('/', (req, res) => {
+    res.json({
+        message: '🚀 Enhanced StuDocu Downloader API v5.3 - Advanced Bypass with Print Styles',
+        version: '5.3',
+        features: [
+            '🍪 Advanced cookie banner bypass',
+            '🔓 Premium content unblurring (client-side only; server-side blur requires premium login)',
+            '🔑 Login support for full unblurred content access',
+            '🤖 Anti-bot detection evasion',
+            '📄 Full document content extraction with print styles for clean PDF'
+        ],
+        endpoints: {
+            download: 'POST /api/download (body: {url, filename?, email?, password?})',
+            health: 'GET /health'
+        },
+        note: 'For full unblurred content, provide premium email and password. Blurring is often server-side, so CSS bypass may not suffice without login.'
+    });
+});
+process.on('SIGTERM', () => {
+    console.log('SIGTERM received, shutting down gracefully...');
+    process.exit(0);
+});
+process.on('SIGINT', () => {
+    console.log('SIGINT received, shutting down gracefully...');
+    process.exit(0);
+});
+app.listen(port, () => {
+    console.log(`🚀 Enhanced StuDocu Downloader v5.3 running on http://localhost:${port}`);
+    console.log(`✨ Features: Advanced cookie bypass, content unblurring, login support, print styles, anti-detection`);
+});

server.js CHANGED Viewed

@@ -12,7 +12,6 @@ app.use(express.json());
  */
 const bypassCookiesAndRestrictions = async (page) => {
     console.log("🍪 Starting comprehensive cookie and restriction bypass...");
     // Step 1: Set cookies before page load
     const preCookies = [
         { name: 'cookieConsent', value: 'accepted', domain: '.studocu.com' },
@@ -24,7 +23,6 @@ const bypassCookiesAndRestrictions = async (page) => {
         { name: 'marketing_consent', value: 'false', domain: '.studocu.com' },
         { name: 'functional_consent', value: 'true', domain: '.studocu.com' },
     ];
     for (const cookie of preCookies) {
         try {
             await page.setCookie(cookie);
@@ -36,58 +34,42 @@ const bypassCookiesAndRestrictions = async (page) => {
     // Step 2: Inject CSS to hide cookie banners immediately
     await page.addStyleTag({
         content: `
-      /* Hide all possible cookie banners */
-      [id*="cookie" i]:not(img):not(input),
-      [class*="cookie" i]:not(img):not(input),
-      [data-testid*="cookie" i],
-      [aria-label*="cookie" i],
-      .gdpr-banner, .gdpr-popup, .gdpr-modal,
-      .consent-banner, .consent-popup, .consent-modal,
-      .privacy-banner, .privacy-popup, .privacy-modal,
-      .cookie-law, .cookie-policy, .cookie-compliance,
-      .onetrust-banner-sdk, #onetrust-consent-sdk,
-      .cmp-banner, .cmp-popup, .cmp-modal,
-      [class*="CookieBanner"], [class*="CookieNotice"],
-      [class*="ConsentBanner"], [class*="ConsentManager"],
-      .cc-banner, .cc-window, .cc-compliance,
-      div[style*="position: fixed"]:has-text("cookie"),
-      div[style*="position: fixed"]:has-text("consent"),
-      .fixed:has-text("cookie"), .fixed:has-text("consent") {
-        display: none !important;
-        visibility: hidden !important;
-        opacity: 0 !important;
-        z-index: -9999 !important;
-        pointer-events: none !important;
-      }
-      /* Remove blur and premium overlays */
-      [class*="blur" i], [class*="premium" i],
-      [class*="paywall" i], [class*="sample-preview-blur" i] {
-        filter: none !important;
-        backdrop-filter: none !important;
-        opacity: 1 !important;
-        visibility: visible !important;
-      }
-      /* Ensure document content is visible */
-      .document-content, .page-content, [data-page] {
-        filter: none !important;
-        opacity: 1 !important;
-        visibility: visible !important;
-        pointer-events: auto !important;
-      }
-      /* Remove fixed overlays */
-      .fixed-overlay, .sticky-overlay, .content-overlay {
-        display: none !important;
-      }
-      /* Restore scrolling */
-      html, body {
-        overflow: auto !important;
-        position: static !important;
-      }
-    `
     });
     // Step 3: Inject JavaScript to handle dynamic cookie banners
@@ -107,7 +89,6 @@ const bypassCookiesAndRestrictions = async (page) => {
                         const text = element.textContent || '';
                         const className = element.className || '';
                         const id = element.id || '';
                         // Check if this looks like a cookie banner
                         if (
                             text.toLowerCase().includes('cookie') ||
@@ -126,21 +107,16 @@ const bypassCookiesAndRestrictions = async (page) => {
                 });
             });
         });
         observer.observe(document.body, { childList: true, subtree: true });
         // Set up periodic cleanup
         setInterval(() => {
             const cookieElements = document.querySelectorAll(`
-        [id*="cookie" i]:not(img):not(input),
-        [class*="cookie" i]:not(img):not(input),
-        [data-testid*="cookie" i],
-        .gdpr-banner, .consent-banner, .privacy-banner,
-        .onetrust-banner-sdk, #onetrust-consent-sdk,
-        .cmp-banner, .cc-banner
-      `);
             cookieElements.forEach(el => el.remove());
             // Restore body scroll
             document.body.style.overflow = 'auto';
             document.documentElement.style.overflow = 'auto';
@@ -155,7 +131,6 @@ const bypassCookiesAndRestrictions = async (page) => {
  */
 const unblurContent = async (page) => {
     console.log("🔓 Unblurring content and bypassing premium restrictions...");
     await page.evaluate(() => {
         // Function to remove all visual restrictions
         const removeRestrictions = () => {
@@ -177,7 +152,6 @@ const unblurContent = async (page) => {
             const removeBlur = (element = document) => {
                 element.querySelectorAll("*").forEach(el => {
                     const style = window.getComputedStyle(el);
                     // Check for blur via filter, backdrop-filter, or class names
                     if (
                         style.filter?.includes("blur") ||
@@ -193,7 +167,6 @@ const unblurContent = async (page) => {
                             el.classList.remove("blur", "blurred", "premium-blur");
                         }
                     }
                     // Check parent elements for blur-inducing styles
                     const parent = el.parentElement;
                     if (parent) {
@@ -215,8 +188,7 @@ const unblurContent = async (page) => {
             document.querySelectorAll("div, section, aside").forEach(el => {
                 const style = window.getComputedStyle(el);
                 if (
-                    style.backgroundColor.includes("rgba") &&
-                    (style.backgroundColor.includes("0.5") || parseFloat(style.zIndex) > 1000) ||
                     (el.className && el.className.toString().toLowerCase().includes("overlay")) ||
                     (el.className && el.className.toString().toLowerCase().includes("paywall"))
                 ) {
@@ -231,9 +203,8 @@ const unblurContent = async (page) => {
             // Ensure document content is visible
             const contentSelectors = [
-                '.document-content', '.page-content', '.content',
-                '[data-page]', '[data-testid*="document"]', '[data-testid*="page"]',
-                '.page', '.document-page', 'main', 'article'
             ];
             contentSelectors.forEach(selector => {
                 document.querySelectorAll(selector).forEach(el => {
@@ -247,14 +218,12 @@ const unblurContent = async (page) => {
             // Remove overlay divs that might be blocking content
             const overlays = document.querySelectorAll(`
-        [class*="overlay" i], [class*="modal" i], [class*="popup" i],
-        [class*="banner" i], [style*="position: fixed"],
-        [style*="position: absolute"][style*="z-index"]
-      `);
             overlays.forEach(overlay => {
                 const text = overlay.textContent || '';
-                if (text.includes('premium') || text.includes('unlock') || text.includes('subscribe') ||
-                    text.includes('cookie') || text.includes('consent') || text.includes('login')) {
                     overlay.remove();
                 }
             });
@@ -278,57 +247,53 @@ const unblurContent = async (page) => {
  */
 const applyPrintStyles = async (page) => {
     console.log("🖨️ Applying print styles for clean PDF...");
     await page.evaluate(() => {
         const style = document.createElement("style");
         style.id = "print-style-extension";
         style.innerHTML = `
-      @page {
-        size: A4 portrait;
-        margin: 5mm;
-      }
-      @media print {
-        html, body {
-          margin: 0 !important;
-          padding: 0 !important;
-          overflow: visible !important;
-        }
-        header, footer, nav, aside, .no-print, .ads, .sidebar,
-        .premium-banner, .ViewerToolbar, .Layout_info-bar-wrapper__He0Ho,
-        .Sidebar_sidebar-scrollable__kqeBZ, .HeaderWrapper_header-wrapper__mCmf3,
-        .Layout_visible-content-bottom-wrapper-sticky__yaaAB,
-        .Layout_bottom-section-wrapper__yBWWk, .Layout_footer-wrapper__bheJQ,
-        .InlineBanner_inline-banner-wrapper__DAi5X, .banner-wrapper,
-        #top-bar-wrapper, .Layout_sidebar-wrapper__unavM,
-        .Layout_is-open__9DQr4 {
-          display: none !important;
-        }
-        body {
-          background: white !important;
-          color: black !important;
-        }
-        * {
-          box-shadow: none !important;
-          background: transparent !important;
-        }
-        .Viewer_document-wrapper__JPBWQ, .Viewer_document-wrapper__LXzoQ,
-        .Viewer_document-wrapper__XsO4j, .page-content {
-          display: flex !important;
-          flex-direction: column !important;
-          width: 100% !important;
-          max-width: 210mm !important;
-          margin: 0 auto !important;
-        }
-        [data-page], .page, .document-page, img {
-          page-break-after: always !important;
-          page-break-inside: avoid !important;
-          page-break-before: avoid !important;
-          width: 100% !important;
-          max-width: 100% !important;
-          height: auto !important;
-        }
-      }
-    `;
         document.head.appendChild(style);
     });
 };
@@ -340,9 +305,8 @@ const studocuDownloader = async (url, options = {}) => {
     let browser;
     try {
         console.log("🚀 Launching browser with stealth configuration...");
-        // Replace this part in your server.js (around line 343)
         browser = await puppeteer.launch({
-            headless: "new", // Use new headless mode
             args: [
                 '--no-sandbox',
                 '--disable-setuid-sandbox',
@@ -360,20 +324,9 @@ const studocuDownloader = async (url, options = {}) => {
                 '--disable-web-security',
                 '--disable-features=site-per-process',
                 '--disable-blink-features=AutomationControlled',
-                '--disable-extensions',
-                '--single-process', // Important for containers
-                '--disable-background-tasks',
-                '--disable-default-apps',
-                '--disable-sync',
-                '--metrics-recording-only',
-                '--no-default-browser-check',
-                '--no-pings',
-                '--password-store=basic',
-                '--use-mock-keychain',
-                '--disable-gpu-sandbox'
             ],
             timeout: 300000,
-            executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/google-chrome-stable'
         });
         const page = await browser.newPage();
@@ -397,7 +350,6 @@ const studocuDownloader = async (url, options = {}) => {
         page.on('request', (req) => {
             const resourceType = req.resourceType();
             const reqUrl = req.url();
             // Block trackers, ads, and analytics
             if (
                 reqUrl.includes('doubleclick') ||
@@ -410,7 +362,7 @@ const studocuDownloader = async (url, options = {}) => {
                 reqUrl.includes('mixpanel') ||
                 reqUrl.includes('onetrust') ||
                 reqUrl.includes('cookielaw') ||
-                resourceType === 'other' && reqUrl.includes('track')
             ) {
                 req.abort();
             } else {
@@ -440,7 +392,6 @@ const studocuDownloader = async (url, options = {}) => {
         }
         console.log(`📄 Navigating to ${url}...`);
         // Navigate with retry logic
         let navigationSuccess = false;
         let attempts = 0;
@@ -467,9 +418,8 @@ const studocuDownloader = async (url, options = {}) => {
         // Wait for document content with multiple selectors
         console.log("⏳ Waiting for document content to load...");
         const contentSelectors = [
-            '.document-content', '.page-content', '[data-page]',
-            '[data-testid*="document"]', 'img[src*="document"]',
-            'img[src*="page"]', '.page', 'main img', 'article img'
         ];
         let contentFound = false;
         for (const selector of contentSelectors) {
@@ -482,6 +432,7 @@ const studocuDownloader = async (url, options = {}) => {
                 console.log(`❌ Selector ${selector} not found, trying next...`);
             }
         }
         if (!contentFound) {
             console.log("⚠️ No specific content selector found, proceeding with page content...");
         }
@@ -490,7 +441,6 @@ const studocuDownloader = async (url, options = {}) => {
         console.log("📜 Loading all document pages with enhanced slow scroll...");
         await page.evaluate(async () => {
             const delay = (ms) => new Promise((res) => setTimeout(res, ms));
             let scrollHeight = document.body.scrollHeight;
             while (true) {
                 let totalHeight = 0;
@@ -500,14 +450,11 @@ const studocuDownloader = async (url, options = {}) => {
                     totalHeight += distance;
                     await delay(500); // Increased delay for better loading
                 }
                 await delay(2000); // Extra wait after reaching bottom
                 const newHeight = document.body.scrollHeight;
                 if (newHeight === scrollHeight) break;
                 scrollHeight = newHeight;
             }
             // Scroll to top
             window.scrollTo({ top: 0, behavior: "smooth" });
             await delay(1000);
@@ -538,8 +485,7 @@ const studocuDownloader = async (url, options = {}) => {
         await page.evaluate(() => {
             const getDocumentHeight = () => Math.max(
                 document.body.scrollHeight, document.body.offsetHeight,
-                document.documentElement.clientHeight, document.documentElement.scrollHeight,
-                document.documentElement.offsetHeight
             );
             const height = getDocumentHeight();
             document.body.style.height = `${height}px !important`;
@@ -590,9 +536,10 @@ const studocuDownloader = async (url, options = {}) => {
             scale: 1,
             omitBackground: false
         });
-        console.log(`✅ PDF generated successfully! Size: ${(pdfBuffer.length / 1024 / 1024).toFixed(2)} MB`);
         return pdfBuffer;
     } catch (error) {
         console.error("❌ Error during PDF generation:", error);
         if (error.message.includes('timeout')) {
@@ -616,14 +563,144 @@ const studocuDownloader = async (url, options = {}) => {
     }
 };
 // API Routes
 app.post('/api/download', async (req, res) => {
     const { url, filename, email, password } = req.body;
     if (!url) {
         return res.status(400).json({ error: 'URL is required.' });
     }
     if (!url.includes('studocu.com')) {
         return res.status(400).json({ error: 'Please provide a valid StuDocu URL.' });
     }
@@ -634,17 +711,14 @@ app.post('/api/download', async (req, res) => {
     }
     console.log(`🎯 Processing request for: ${normalizedUrl}`);
     try {
         const startTime = Date.now();
         const pdfBuffer = await studocuDownloader(normalizedUrl, { filename, email, password });
         const processingTime = ((Date.now() - startTime) / 1000).toFixed(2);
         res.setHeader('Content-Type', 'application/pdf');
         res.setHeader('Content-Disposition', 'attachment; filename=studocu-document.pdf');
         res.setHeader('Content-Length', pdfBuffer.length);
         res.send(pdfBuffer);
         console.log(`🎉 Request completed successfully in ${processingTime}s`);
     } catch (error) {
         console.error(`❌ Failed to process ${normalizedUrl}:`, error.message);
@@ -652,23 +726,55 @@ app.post('/api/download', async (req, res) => {
     }
 });
 app.get('/health', (req, res) => {
-    res.json({ status: 'healthy', timestamp: new Date().toISOString(), uptime: process.uptime() });
 });
 app.get('/', (req, res) => {
     res.json({
-        message: '🚀 Enhanced StuDocu Downloader API v5.3 - Advanced Bypass with Print Styles',
-        version: '5.3',
         features: [
             '🍪 Advanced cookie banner bypass',
             '🔓 Premium content unblurring (client-side only; server-side blur requires premium login)',
             '🔑 Login support for full unblurred content access',
             '🤖 Anti-bot detection evasion',
-            '📄 Full document content extraction with print styles for clean PDF'
         ],
         endpoints: {
             download: 'POST /api/download (body: {url, filename?, email?, password?})',
             health: 'GET /health'
         },
         note: 'For full unblurred content, provide premium email and password. Blurring is often server-side, so CSS bypass may not suffice without login.'
@@ -686,6 +792,6 @@ process.on('SIGINT', () => {
 });
 app.listen(port, () => {
-    console.log(`🚀 Enhanced StuDocu Downloader v5.3 running on http://localhost:${port}`);
-    console.log(`✨ Features: Advanced cookie bypass, content unblurring, login support, print styles, anti-detection`);
 });

  */
 const bypassCookiesAndRestrictions = async (page) => {
     console.log("🍪 Starting comprehensive cookie and restriction bypass...");
     // Step 1: Set cookies before page load
     const preCookies = [
         { name: 'cookieConsent', value: 'accepted', domain: '.studocu.com' },
         { name: 'marketing_consent', value: 'false', domain: '.studocu.com' },
         { name: 'functional_consent', value: 'true', domain: '.studocu.com' },
     ];
     for (const cookie of preCookies) {
         try {
             await page.setCookie(cookie);
     // Step 2: Inject CSS to hide cookie banners immediately
     await page.addStyleTag({
         content: `
+            /* Hide all possible cookie banners */
+            [id*="cookie" i]:not(img):not(input), [class*="cookie" i]:not(img):not(input), [data-testid*="cookie" i], [aria-label*="cookie" i],
+            .gdpr-banner, .gdpr-popup, .gdpr-modal, .consent-banner, .consent-popup, .consent-modal, .privacy-banner, .privacy-popup, .privacy-modal,
+            .cookie-law, .cookie-policy, .cookie-compliance, .onetrust-banner-sdk, #onetrust-consent-sdk, .cmp-banner, .cmp-popup, .cmp-modal,
+            [class*="CookieBanner"], [class*="CookieNotice"], [class*="ConsentBanner"], [class*="ConsentManager"], .cc-banner, .cc-window, .cc-compliance,
+            div[style*="position: fixed"]:has-text("cookie"), div[style*="position: fixed"]:has-text("consent"), .fixed:has-text("cookie"), .fixed:has-text("consent") {
+                display: none !important;
+                visibility: hidden !important;
+                opacity: 0 !important;
+                z-index: -9999 !important;
+                pointer-events: none !important;
+            }
+            /* Remove blur and premium overlays */
+            [class*="blur" i], [class*="premium" i], [class*="paywall" i], [class*="sample-preview-blur" i] {
+                filter: none !important;
+                backdrop-filter: none !important;
+                opacity: 1 !important;
+                visibility: visible !important;
+            }
+            /* Ensure document content is visible */
+            .document-content, .page-content, [data-page] {
+                filter: none !important;
+                opacity: 1 !important;
+                visibility: visible !important;
+                pointer-events: auto !important;
+            }
+            /* Remove fixed overlays */
+            .fixed-overlay, .sticky-overlay, .content-overlay {
+                display: none !important;
+            }
+            /* Restore scrolling */
+            html, body {
+                overflow: auto !important;
+                position: static !important;
+            }
+        `
     });
     // Step 3: Inject JavaScript to handle dynamic cookie banners
                         const text = element.textContent || '';
                         const className = element.className || '';
                         const id = element.id || '';
                         // Check if this looks like a cookie banner
                         if (
                             text.toLowerCase().includes('cookie') ||
                 });
             });
         });
         observer.observe(document.body, { childList: true, subtree: true });
         // Set up periodic cleanup
         setInterval(() => {
             const cookieElements = document.querySelectorAll(`
+                [id*="cookie" i]:not(img):not(input), [class*="cookie" i]:not(img):not(input), [data-testid*="cookie" i],
+                .gdpr-banner, .consent-banner, .privacy-banner, .onetrust-banner-sdk, #onetrust-consent-sdk,
+                .cmp-banner, .cc-banner
+            `);
             cookieElements.forEach(el => el.remove());
             // Restore body scroll
             document.body.style.overflow = 'auto';
             document.documentElement.style.overflow = 'auto';
  */
 const unblurContent = async (page) => {
     console.log("🔓 Unblurring content and bypassing premium restrictions...");
     await page.evaluate(() => {
         // Function to remove all visual restrictions
         const removeRestrictions = () => {
             const removeBlur = (element = document) => {
                 element.querySelectorAll("*").forEach(el => {
                     const style = window.getComputedStyle(el);
                     // Check for blur via filter, backdrop-filter, or class names
                     if (
                         style.filter?.includes("blur") ||
                             el.classList.remove("blur", "blurred", "premium-blur");
                         }
                     }
                     // Check parent elements for blur-inducing styles
                     const parent = el.parentElement;
                     if (parent) {
             document.querySelectorAll("div, section, aside").forEach(el => {
                 const style = window.getComputedStyle(el);
                 if (
+                    (style.backgroundColor.includes("rgba") && (style.backgroundColor.includes("0.5") || parseFloat(style.zIndex) > 1000)) ||
                     (el.className && el.className.toString().toLowerCase().includes("overlay")) ||
                     (el.className && el.className.toString().toLowerCase().includes("paywall"))
                 ) {
             // Ensure document content is visible
             const contentSelectors = [
+                '.document-content', '.page-content', '.content', '[data-page]', '[data-testid*="document"]',
+                '[data-testid*="page"]', '.page', '.document-page', 'main', 'article'
             ];
             contentSelectors.forEach(selector => {
                 document.querySelectorAll(selector).forEach(el => {
             // Remove overlay divs that might be blocking content
             const overlays = document.querySelectorAll(`
+                [class*="overlay" i], [class*="modal" i], [class*="popup" i], [class*="banner" i],
+                [style*="position: fixed"], [style*="position: absolute"][style*="z-index"]
+            `);
             overlays.forEach(overlay => {
                 const text = overlay.textContent || '';
+                if (text.includes('premium') || text.includes('unlock') || text.includes('subscribe') || text.includes('cookie') || text.includes('consent') || text.includes('login')) {
                     overlay.remove();
                 }
             });
  */
 const applyPrintStyles = async (page) => {
     console.log("🖨️ Applying print styles for clean PDF...");
     await page.evaluate(() => {
         const style = document.createElement("style");
         style.id = "print-style-extension";
         style.innerHTML = `
+            @page {
+                size: A4 portrait;
+                margin: 5mm;
+            }
+            @media print {
+                html, body {
+                    margin: 0 !important;
+                    padding: 0 !important;
+                    overflow: visible !important;
+                }
+                header, footer, nav, aside, .no-print, .ads, .sidebar, .premium-banner,
+                .ViewerToolbar, .Layout_info-bar-wrapper__He0Ho, .Sidebar_sidebar-scrollable__kqeBZ,
+                .HeaderWrapper_header-wrapper__mCmf3, .Layout_visible-content-bottom-wrapper-sticky__yaaAB,
+                .Layout_bottom-section-wrapper__yBWWk, .Layout_footer-wrapper__bheJQ,
+                .InlineBanner_inline-banner-wrapper__DAi5X, .banner-wrapper, #top-bar-wrapper,
+                .Layout_sidebar-wrapper__unavM, .Layout_is-open__9DQr4 {
+                    display: none !important;
+                }
+                body {
+                    background: white !important;
+                    color: black !important;
+                }
+                * {
+                    box-shadow: none !important;
+                    background: transparent !important;
+                }
+                .Viewer_document-wrapper__JPBWQ, .Viewer_document-wrapper__LXzoQ, .Viewer_document-wrapper__XsO4j, .page-content {
+                    display: flex !important;
+                    flex-direction: column !important;
+                    width: 100% !important;
+                    max-width: 210mm !important;
+                    margin: 0 auto !important;
+                }
+                [data-page], .page, .document-page, img {
+                    page-break-after: always !important;
+                    page-break-inside: avoid !important;
+                    page-break-before: avoid !important;
+                    width: 100% !important;
+                    max-width: 100% !important;
+                    height: auto !important;
+                }
+            }
+        `;
         document.head.appendChild(style);
     });
 };
     let browser;
     try {
         console.log("🚀 Launching browser with stealth configuration...");
         browser = await puppeteer.launch({
+            headless: true,
             args: [
                 '--no-sandbox',
                 '--disable-setuid-sandbox',
                 '--disable-web-security',
                 '--disable-features=site-per-process',
                 '--disable-blink-features=AutomationControlled',
+                '--disable-extensions'
             ],
             timeout: 300000,
         });
         const page = await browser.newPage();
         page.on('request', (req) => {
             const resourceType = req.resourceType();
             const reqUrl = req.url();
             // Block trackers, ads, and analytics
             if (
                 reqUrl.includes('doubleclick') ||
                 reqUrl.includes('mixpanel') ||
                 reqUrl.includes('onetrust') ||
                 reqUrl.includes('cookielaw') ||
+                (resourceType === 'other' && reqUrl.includes('track'))
             ) {
                 req.abort();
             } else {
         }
         console.log(`📄 Navigating to ${url}...`);
         // Navigate with retry logic
         let navigationSuccess = false;
         let attempts = 0;
         // Wait for document content with multiple selectors
         console.log("⏳ Waiting for document content to load...");
         const contentSelectors = [
+            '.document-content', '.page-content', '[data-page]', '[data-testid*="document"]',
+            'img[src*="document"]', 'img[src*="page"]', '.page', 'main img', 'article img'
         ];
         let contentFound = false;
         for (const selector of contentSelectors) {
                 console.log(`❌ Selector ${selector} not found, trying next...`);
             }
         }
         if (!contentFound) {
             console.log("⚠️ No specific content selector found, proceeding with page content...");
         }
         console.log("📜 Loading all document pages with enhanced slow scroll...");
         await page.evaluate(async () => {
             const delay = (ms) => new Promise((res) => setTimeout(res, ms));
             let scrollHeight = document.body.scrollHeight;
             while (true) {
                 let totalHeight = 0;
                     totalHeight += distance;
                     await delay(500); // Increased delay for better loading
                 }
                 await delay(2000); // Extra wait after reaching bottom
                 const newHeight = document.body.scrollHeight;
                 if (newHeight === scrollHeight) break;
                 scrollHeight = newHeight;
             }
             // Scroll to top
             window.scrollTo({ top: 0, behavior: "smooth" });
             await delay(1000);
         await page.evaluate(() => {
             const getDocumentHeight = () => Math.max(
                 document.body.scrollHeight, document.body.offsetHeight,
+                document.documentElement.clientHeight, document.documentElement.scrollHeight, document.documentElement.offsetHeight
             );
             const height = getDocumentHeight();
             document.body.style.height = `${height}px !important`;
             scale: 1,
             omitBackground: false
         });
+        console.log(`✅ PDF generated successfully! Size: ${(pdfBuffer.length / 1024 / 1024).toFixed(2)} MB`);
         return pdfBuffer;
     } catch (error) {
         console.error("❌ Error during PDF generation:", error);
         if (error.message.includes('timeout')) {
     }
 };
+/**
+ * NEW: StuDocu downloader with page-by-page progress streaming
+ */
+const studocuDownloaderStreamed = async (url, options, res) => {
+    let browser;
+    try {
+        console.log("🚀 Launching browser for streaming with stealth configuration...");
+        browser = await puppeteer.launch({
+            headless: true,
+            args: [
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-accelerated-2d-canvas',
+                '--no-first-run',
+                '--no-zygote',
+                '--disable-gpu'
+            ],
+            timeout: 300000,
+        });
+        const page = await browser.newPage();
+        await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
+        await page.setViewport({ width: 794, height: 1122 });
+        await page.evaluateOnNewDocument(() => {
+            Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+        });
+        await bypassCookiesAndRestrictions(page);
+        await page.setRequestInterception(true);
+        page.on('request', (req) => {
+            if (['image', 'stylesheet', 'font', 'other'].includes(req.resourceType()) && !req.url().includes('studocu.com')) {
+                req.abort();
+            } else {
+                req.continue();
+            }
+        });
+        if (options.email && options.password) {
+            console.log("🔑 Logging in for streaming...");
+            await page.goto('https://www.studocu.com/en-us/login', { waitUntil: 'domcontentloaded' });
+            await page.waitForSelector('#email');
+            await page.type('#email', options.email);
+            await page.type('#password', options.password);
+            await page.click('button[type="submit"]');
+            await page.waitForNavigation({ waitUntil: 'networkidle2' });
+            console.log("✅ Login successful for streaming.");
+        }
+        console.log(`📄 Navigating to ${url} for streaming...`);
+        await page.goto(url, { waitUntil: 'domcontentloaded' });
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        await unblurContent(page);
+        console.log("⏳ Waiting for document pages to load...");
+        await page.waitForSelector('[data-page]', { timeout: 30000 });
+        console.log("📜 Scrolling to load all pages for streaming...");
+        await page.evaluate(async () => {
+            await new Promise(resolve => {
+                let totalHeight = 0;
+                const distance = 100;
+                const timer = setInterval(() => {
+                    const scrollHeight = document.body.scrollHeight;
+                    window.scrollBy(0, distance);
+                    totalHeight += distance;
+                    if (totalHeight >= scrollHeight) {
+                        clearInterval(timer);
+                        resolve();
+                    }
+                }, 100);
+            });
+        });
+        await unblurContent(page);
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        const pageElements = await page.$$('[data-page]');
+        const totalPages = pageElements.length;
+        console.log(`📄 Found ${totalPages} pages to stream.`);
+        if (totalPages === 0) {
+            throw new Error("No document pages found to stream. The content might be protected or not loaded correctly.");
+        }
+        // Set headers for streaming
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Transfer-Encoding', 'chunked');
+        for (let i = 0; i < totalPages; i++) {
+            console.log(`🎨 Rendering page ${i + 1} of ${totalPages}...`);
+            const pageElement = pageElements[i];
+            const imageData = await pageElement.screenshot({ type: 'png', encoding: 'base64' });
+            const progressUpdate = {
+                pageNumber: i + 1,
+                totalPages: totalPages,
+                imageData: `data:image/png;base64,${imageData}`
+            };
+            res.write(JSON.stringify(progressUpdate) + '\n'); // Send as a new line delimited JSON
+        }
+        console.log("✅ All pages have been rendered and sent.");
+    } catch (error) {
+        console.error("❌ Error during streamed download:", error);
+        const errorResponse = {
+            error: `Failed to generate streamed PDF: ${error.message}`
+        };
+        if (!res.headersSent) {
+            res.status(500).json(errorResponse);
+        } else {
+            res.write(JSON.stringify(errorResponse) + '\n');
+        }
+    } finally {
+        if (browser) {
+            console.log("🔒 Closing browser for streaming...");
+            await browser.close();
+        }
+        if (!res.writableEnded) {
+            res.end(); // End the stream
+        }
+    }
+};
 // API Routes
+// Original endpoint for downloading the full PDF at once
 app.post('/api/download', async (req, res) => {
     const { url, filename, email, password } = req.body;
     if (!url) {
         return res.status(400).json({ error: 'URL is required.' });
     }
     if (!url.includes('studocu.com')) {
         return res.status(400).json({ error: 'Please provide a valid StuDocu URL.' });
     }
     }
     console.log(`🎯 Processing request for: ${normalizedUrl}`);
     try {
         const startTime = Date.now();
         const pdfBuffer = await studocuDownloader(normalizedUrl, { filename, email, password });
         const processingTime = ((Date.now() - startTime) / 1000).toFixed(2);
         res.setHeader('Content-Type', 'application/pdf');
         res.setHeader('Content-Disposition', 'attachment; filename=studocu-document.pdf');
         res.setHeader('Content-Length', pdfBuffer.length);
         res.send(pdfBuffer);
         console.log(`🎉 Request completed successfully in ${processingTime}s`);
     } catch (error) {
         console.error(`❌ Failed to process ${normalizedUrl}:`, error.message);
     }
 });
+// NEW: Endpoint for streaming the document page by page
+app.post('/api/download-stream', async (req, res) => {
+    const { url, email, password } = req.body;
+    if (!url) {
+        return res.status(400).json({ error: 'URL is required.' });
+    }
+    if (!url.includes('studocu.com')) {
+        return res.status(400).json({ error: 'Please provide a valid StuDocu URL.' });
+    }
+    let normalizedUrl = url.trim();
+    if (!normalizedUrl.startsWith('http')) {
+        normalizedUrl = 'https://' + normalizedUrl;
+    }
+    console.log(`🎯 Processing stream request for: ${normalizedUrl}`);
+    try {
+        await studocuDownloaderStreamed(normalizedUrl, { email, password }, res);
+        console.log(`🎉 Stream request completed for ${normalizedUrl}`);
+    } catch (error) {
+        console.error(`❌ Failed to process stream for ${normalizedUrl}:`, error.message);
+        // Error is handled within the downloader function to ensure proper response closure
+    }
+});
 app.get('/health', (req, res) => {
+    res.json({
+        status: 'healthy',
+        timestamp: new Date().toISOString(),
+        uptime: process.uptime()
+    });
 });
 app.get('/', (req, res) => {
     res.json({
+        message: '🚀 Enhanced StuDocu Downloader API v5.3 - Advanced Bypass with Print Styles and Streaming',
+        version: '5.3.1',
         features: [
             '🍪 Advanced cookie banner bypass',
             '🔓 Premium content unblurring (client-side only; server-side blur requires premium login)',
             '🔑 Login support for full unblurred content access',
             '🤖 Anti-bot detection evasion',
+            '📄 Full document content extraction with print styles for clean PDF',
+            '🔄 Real-time page rendering and streaming to the frontend'
         ],
         endpoints: {
             download: 'POST /api/download (body: {url, filename?, email?, password?})',
+            download_stream: 'POST /api/download-stream (body: {url, email?, password?})',
             health: 'GET /health'
         },
         note: 'For full unblurred content, provide premium email and password. Blurring is often server-side, so CSS bypass may not suffice without login.'
 });
 app.listen(port, () => {
+    console.log(`🚀 Enhanced StuDocu Downloader v5.3.1 running on http://localhost:${port}`);
+    console.log(`✨ Features: Advanced cookie bypass, content unblurring, login support, print styles, anti-detection, and real-time page streaming`);
 });