Fix this and any other errors, issues, problems you might find and send the fully working full codes in one html file. --- <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Monochrome Light Novel Collection</title>
    <link rel="preconnect" href="https://fonts.googleapis.com">
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/dexie@3.2.2/dist/dexie.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/intersection-observer@0.12.2/intersection-observer.min.js"></script>
    
    <style>
        :root {
            --primary-color: #000000;
            --secondary-color: #333333;
            --background-color: #ffffff;
            --card-background: #f0f0f0;
            --text-primary: #000000;
            --text-secondary: #666666;
            --shadow-sm: 0 1px 3px rgba(0,0,0,0.12);
            --shadow-md: 0 4px 6px rgba(0,0,0,0.1);
            --shadow-lg: 0 10px 15px rgba(0,0,0,0.1);
            --radius-sm: 0.375rem;
            --radius-md: 0.5rem;
            --radius-lg: 1rem;
        }

        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }

        body {
            font-family: 'Inter', system-ui, -apple-system, sans-serif;
            background-color: var(--background-color);
            color: var(--text-primary);
            line-height: 1.5;
        }

        .header {
            background: linear-gradient(135deg, var(--primary-color), var(--secondary-color));
            color: white;
            padding: 1.5rem;
            position: sticky;
            top: 0;
            z-index: 50;
            box-shadow: var(--shadow-md);
        }

        .header__content {
            max-width: 1280px;
            margin: 0 auto;
            display: flex;
            justify-content: space-between;
            align-items: center;
        }

        .header__title {
            font-size: 1.875rem;
            font-weight: 700;
        }

        .main {
            max-width: 1280px;
            margin: 2rem auto;
            padding: 0 1rem;
        }

        .grid {
            display: grid;
            grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
            gap: 2rem;
            padding: 1rem;
        }

        .card {
            background: var(--card-background);
            border-radius: var(--radius-md);
            overflow: hidden;
            box-shadow: var(--shadow-sm);
            transition: transform 0.2s ease, box-shadow 0.2s ease;
            cursor: pointer;
            position: relative;
        }

        .card:hover {
            transform: translateY(-4px);
            box-shadow: var(--shadow-lg);
        }

        .card__image-container {
            position: relative;
            padding-top: 142%; /* 1:1.42 aspect ratio */
            background: #e0e0e0;
            overflow: hidden;
        }

        .card__image {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            object-fit: cover;
            transition: opacity 0.3s ease, filter 0.3s ease;
            filter: grayscale(100%);
        }

        .card__image.lazy {
            opacity: 0;
        }

        .card__image.loaded {
            opacity: 1;
        }

        .card:hover .card__image {
            filter: grayscale(0%);
        }

        .card__content {
            padding: 1rem;
        }

        .card__title {
            font-size: 1rem;
            font-weight: 600;
            color: var(--text-primary);
            overflow: hidden;
            text-overflow: ellipsis;
            display: -webkit-box;
            -webkit-line-clamp: 2;
            -webkit-box-orient: vertical;
        }

        .loader {
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100px;
            color: var(--text-secondary);
        }

        .loader__spinner {
            width: 40px;
            height: 40px;
            border: 3px solid #f3f3f3;
            border-top: 3px solid var(--primary-color);
            border-radius: 50%;
            animation: spin 1s linear infinite;
        }

        .error-message {
            text-align: center;
            color: #ff0000;
            padding: 1rem;
            background: #ffe6e6;
            border-radius: var(--radius-sm);
            margin: 1rem 0;
        }

        .search-container {
            margin-bottom: 2rem;
            display: flex;
            justify-content: center;
        }

        .search-input {
            width: 100%;
            max-width: 500px;
            padding: 0.75rem 1rem;
            font-size: 1rem;
            border: 2px solid var(--secondary-color);
            border-radius: var(--radius-md);
            outline: none;
            transition: border-color 0.2s ease;
        }

        .search-input:focus {
            border-color: var(--primary-color);
        }

        .modal {
            display: none;
            position: fixed;
            z-index: 100;
            left: 0;
            top: 0;
            width: 100%;
            height: 100%;
            overflow: auto;
            background-color: rgba(0,0,0,0.8);
        }

        .modal-content {
            background-color: var(--background-color);
            margin: 10% auto;
            padding: 20px;
            border: 1px solid var(--secondary-color);
            width: 80%;
            max-width: 600px;
            border-radius: var(--radius-lg);
            box-shadow: var(--shadow-lg);
        }

        .close {
            color: var(--text-secondary);
            float: right;
            font-size: 28px;
            font-weight: bold;
            cursor: pointer;
        }

        .close:hover,
        .close:focus {
            color: var(--text-primary);
            text-decoration: none;
            cursor: pointer;
        }

        @keyframes spin {
            0% { transform: rotate(0deg); }
            100% { transform: rotate(360deg); }
        }

        @media (max-width: 768px) {
            .header__title {
                font-size: 1.5rem;
            }

            .grid {
                grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
                gap: 1rem;
            }

            .card__title {
                font-size: 0.875rem;
            }
        }

        @media (max-width: 480px) {
            .grid {
                grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
                gap: 0.75rem;
            }
        }
    </style>
</head>
<body>
    <header class="header">
        <div class="header__content">
            <h1 class="header__title">Monochrome Light Novel Collection</h1>
        </div>
    </header>

    <main class="main">
        <div class="search-container">
            <input type="text" id="search-input" class="search-input" placeholder="Search light novels...">
        </div>
        <div id="content" class="grid">
            <div class="loader">
                <div class="loader__spinner"></div>
            </div>
        </div>
    </main>

    <div id="modal" class="modal">
        <div class="modal-content">
            <span class="close">&times;</span>
            <h2 id="modal-title"></h2>
            <p id="modal-description"></p>
            <a id="modal-link" target="_blank" rel="noopener noreferrer">Read PDF</a>
        </div>
    </div>

    <script>
        (() => {
            // Database configuration
            const db = new Dexie('MonochromeNovelsDB');
            db.version(1).stores({
                novels: '++id, name, coverUrl, pdfUrl, timestamp'
            });

            // Constants
            const RETRY_ATTEMPTS = 2;
            const RETRY_DELAY = 1000;
            const PROXY_URL = 'https://api.allorigins.win/get?url=';
            const TARGET_URL = 'https://jnovels.com/top-light-novels-to-read/';

            // Cache for in-memory storage
            const imageLoadingPromises = new Map();

            // Utility functions
            const delay = ms => new Promise(resolve => setTimeout(resolve, ms));

            const retryOperation = async (operation, attempts = RETRY_ATTEMPTS) => {
                for (let i = 0; i < attempts; i++) {
                    try {
                        return await operation();
                    } catch (error) {
                        if (i === attempts - 1) throw error;
                        await delay(RETRY_DELAY);
                    }
                }
            };

            // Data fetching and processing
            const fetchHTML = async url => {
                const response = await fetch(PROXY_URL + encodeURIComponent(url));
                if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
                const data = await response.json();
                return data.contents;
            };

            const parseHTML = html => {
                const parser = new DOMParser();
                const doc = parser.parseFromString(html, 'text/html');
                const novels = [];

                doc.querySelectorAll('span[style="color: #ff6600;"]').forEach(span => {
                    try {
                        const name = span.textContent.trim();
                        const link = span.closest('a');
                        const pdfUrl = link?.href;
                        const img = link?.closest('h3')?.nextElementSibling?.querySelector('img');
                        const coverUrl = img?.src;
                        const description = img?.closest('p')?.nextElementSibling?.textContent.trim();

                        if (name && pdfUrl && coverUrl) {
                            novels.push({ name, coverUrl, pdfUrl, description, timestamp: Date.now() });
                        }
                    } catch (error) {
                        console.error('Error parsing novel:', error);
                    }
                });

                return novels;
            };

            // Image loading with IntersectionObserver
            const setupImageObserver = () => {
                const imageObserver = new IntersectionObserver((entries, observer) => {
                    entries.forEach(entry => {
                        if (entry.isIntersecting) {
                            const img = entry.target;
                            loadImage(img).then(() => observer.unobserve(img));
                        }
                    });
                }, {
                    rootMargin: '50px 0px',
                    threshold: 0.1
                });

                return imageObserver;
            };

            const loadImage = async img => {
                const src = img.dataset.src;
                if (!src) return;

                if (!imageLoadingPromises.has(src)) {
                    const promise = retryOperation(async () => {
                        return new Promise((resolve, reject) => {
                            const tempImage = new Image();
                            tempImage.onload = () => {
                                img.src = src;
                                img.classList.remove('lazy');
                                img.classList.add('loaded');
                                resolve();
                            };
                            tempImage.onerror = reject;
                            tempImage.src = src;
                        });
                    }).finally(() => imageLoadingPromises.delete(src));

                    imageLoadingPromises.set(src, promise);
                }

                return imageLoadingPromises.get(src);
            };

            // UI Components
            const createNovelCard = novel => {
                const card = document.createElement('div');
                card.className = 'card';
                card.innerHTML = `
                    <div class="card__image-container">
                        <img 
                            class="card__image lazy" 
                            data-src="${novel.coverUrl}" 
                            alt="${novel.name}"
                        >
                    </div>
                    <div class="card__content">
                        <h2 class="card__title">${novel.name}</h2>
                    </div>
                `;
                
                card.addEventListener('click', () => {
                    showModal(novel);
                });

                return card;
            };

            const showError = message => {
                const content = document.getElementById('content');
                content.innerHTML = `
                    <div class="error-message">
                        ${message}
                    </div>
                `;
            };

            // Modal functionality
            const modal = document.getElementById('modal');
            const modalTitle = document.getElementById('modal-title');
            const modalDescription = document.getElementById('modal-description');
            const modalLink = document.getElementById('modal-link');
            const closeBtn = document.getElementsByClassName('close')[0];

            const showModal = novel => {
                modalTitle.textContent = novel.name;
                modalDescription.textContent = novel.description || 'No description available.';
                modalLink.href = novel.pdfUrl;
                modal.style.display = 'block';
            };

            closeBtn.onclick = () => {
                modal.style.display = 'none';
            };

            window.onclick = event => {
                if (event.target === modal) {
                    modal.style.display = 'none';
                }
            };

            // Search functionality
            const searchInput = document.getElementById('search-input');
            let allNovels = [];

            const filterNovels = (novels, searchTerm) => {
                const lowercaseTerm = searchTerm.toLowerCase();
                return novels.filter(novel => 
                    novel.name.toLowerCase().includes(lowercaseTerm) ||
                    (novel.description && novel.description.toLowerCase().includes(lowercaseTerm))
                );
            };

            const updateDisplay = (novels) => {
                const content = document.getElementById('content');
                content.innerHTML = '';
                const fragment = document.createDocumentFragment();
                
                novels.forEach(novel => fragment.appendChild(createNovelCard(novel)));
                content.appendChild(fragment);

                // Setup lazy loading for new cards
                document.querySelectorAll('.card__image.lazy').forEach(img => {
                    imageObserver.observe(img);
                });
            };

            searchInput.addEventListener('input', () => {
                const filteredNovels = filterNovels(allNovels, searchInput.value);
                updateDisplay(filteredNovels);
            });

            // Main application logic
            const initializeApp = async () => {
                const content = document.getElementById('content');
                const imageObserver = setupImageObserver();

                try {
                    // Check IndexedDB first
                    allNovels = await db.novels.toArray();

                    if (allNovels.length === 0) {
                        const html = await retryOperation(() => fetchHTML(TARGET_URL));
                        allNovels = parseHTML(html);
                        await db.novels.bulkAdd(allNovels);
                    }

                    // Clear loader and display novels
                    updateDisplay(allNovels);
                } catch (error) {
                    console.error('Application error:', error);
                    showError('Failed to load novels. Please try refreshing the page.');
                }
            };

            // Cleanup on page unload
            window.addEventListener('beforeunload', async () => {
                await db.novels.clear();
                imageLoadingPromises.clear();
            });

            // Initialize the application
            initializeApp();
        })();
    </script>
</body>
</html>