(function(){ // Suppress font preload warnings and other non-critical warnings const originalWarn = console.warn; const originalError = console.error; console.warn = function(...args) { const message = args.join(' '); if ( message.includes('preloaded using link preload but not used') || message.includes('was preloaded using link preload') || message.includes('placeholder-logo.jpg') || (message.includes('MIME type') && message.includes('stylesheet')) ) { return; // Suppress these warnings } originalWarn.apply(console, args); }; console.error = function(...args) { const message = args.join(' '); if ( message.includes('_vercel/insights') || (message.includes('Refused to execute script') && message.includes('_vercel')) || (message.includes('Cannot access') && message.includes('before initialization')) ) { return; // Suppress these errors without any recovery attempts } originalError.apply(console, args); }; // Handle Vercel insights script errors gracefully const originalErrorHandler = window.onerror; window.onerror = function(msg, url, line, col, error) { if (url && url.includes('_vercel/insights')) { return true; // Suppress error } if (originalErrorHandler) { return originalErrorHandler.call(this, msg, url, line, col, error); } return false; }; window.addEventListener('error', function(e) { if (e.target && e.target.tagName === 'SCRIPT') { const src = e.target.src || ''; if (src.includes('_vercel/insights')) { e.preventDefault(); e.stopPropagation(); return false; } } }, true); // Suppress Vercel insights fetch errors if (window.fetch) { const originalFetch = window.fetch; window.fetch = function(...args) { const url = args[0]; if (typeof url === 'string' && url.includes('_vercel/insights')) { return Promise.reject(new Error('Vercel insights disabled')); } return originalFetch.apply(this, args); }; } // Improved chunk loading error handler with retry logic const chunkErrorState = { failedChunks: new Map(), // Track failed chunks: url -> {count, lastError, retries} reloadAttempted: false, reloadCount: 0, MAX_RELOADS: 1, // Only allow 1 reload to prevent loops MAX_RETRIES_PER_CHUNK: 3, // Retry each chunk 3 times before giving up RETRY_DELAYS: [1000, 2000, 3000], // Exponential backoff delays }; // Retry loading a chunk async function retryChunkLoad(chunkUrl, retryCount) { try { const response = await fetch(chunkUrl, { method: 'HEAD', // Just check if it exists cache: 'no-store', }); if (response.ok) { // Chunk exists, try to reload it by creating a new script tag return new Promise((resolve, reject) => { if (!document.head) { reject(new Error('Document head not available')); return; } const script = document.createElement('script'); script.src = chunkUrl + '?t=' + Date.now(); script.async = true; script.onload = () => { console.log('[Chunk Handler] Successfully retried chunk:', chunkUrl); chunkErrorState.failedChunks.delete(chunkUrl); resolve(true); }; script.onerror = () => { // Clean up script tag if it fails if (script.parentNode) { try { // Use modern remove() method which is safer if (script.parentNode) { script.remove(); } } catch (e) { // Ignore if already removed } } reject(new Error('Failed to load chunk')); }; document.head.appendChild(script); }); } else if (response.status === 404 || response.status === 400) { // Chunk doesn't exist (404) or server rejects request (400) - this is a real error // 400 Bad Request for chunks usually means the chunk file doesn't exist on the server return false; } else { // Other error status - might be temporary return false; } } catch (error) { console.warn('[Chunk Handler] Retry failed for chunk:', chunkUrl, error); return false; } } // Handle chunk error with smart retry logic function handleChunkError(chunkUrl, errorInfo) { // Ignore if we've already attempted a reload if (chunkErrorState.reloadAttempted) { return; } // Track this chunk's failure const chunkData = chunkErrorState.failedChunks.get(chunkUrl) || { count: 0, lastError: null, retries: 0, }; chunkData.count++; chunkData.lastError = errorInfo; chunkErrorState.failedChunks.set(chunkUrl, chunkData); // Check if this is a 404 or 400 (chunk doesn't exist or server rejects) - immediate reload needed // 400 Bad Request for chunks typically means the chunk file doesn't exist on the server const isMissingChunk = errorInfo.status === 404 || errorInfo.status === 400 || errorInfo.message?.includes('404') || errorInfo.message?.includes('400') || errorInfo.message?.includes('Bad Request') || errorInfo.error?.includes('404') || errorInfo.error?.includes('400') || errorInfo.error?.includes('Bad Request') || (errorInfo.message?.includes('ERR_ABORTED') && errorInfo.message?.includes('400')); // Check if we've retried this chunk too many times const shouldReload = isMissingChunk || chunkData.count >= chunkErrorState.MAX_RETRIES_PER_CHUNK; // Log the error appropriately if (isMissingChunk) { console.warn('[Chunk Handler] Chunk missing (status:', errorInfo.status || '400/404', '):', chunkUrl); } else { console.warn('[Chunk Handler] Chunk load error, will retry:', chunkUrl, 'error:', errorInfo); } if (!shouldReload && chunkData.retries < chunkErrorState.MAX_RETRIES_PER_CHUNK) { // Retry loading the chunk with exponential backoff chunkData.retries++; const delay = chunkErrorState.RETRY_DELAYS[chunkData.retries - 1] || 3000; console.warn('[Chunk Handler] Retrying chunk load in', delay + 'ms:', chunkUrl, '(attempt', chunkData.retries + '/' + chunkErrorState.MAX_RETRIES_PER_CHUNK + ')'); setTimeout(async () => { const success = await retryChunkLoad(chunkUrl, chunkData.retries); if (!success) { // Retry failed, check if we should reload const updatedData = chunkErrorState.failedChunks.get(chunkUrl); if (updatedData && updatedData.retries >= chunkErrorState.MAX_RETRIES_PER_CHUNK) { attemptPageReload(chunkUrl, errorInfo); } } }, delay); return; // Don't reload yet, wait for retry } // If we get here, we need to reload attemptPageReload(chunkUrl, errorInfo); } // Attempt to reload the page (only once) function attemptPageReload(chunkUrl, errorInfo) { if (chunkErrorState.reloadAttempted) { return; } chunkErrorState.reloadCount++; if (chunkErrorState.reloadCount > chunkErrorState.MAX_RELOADS) { // Max reloads reached - show error message console.error('[Chunk Handler] Max reloads reached. Chunk may be missing:', chunkUrl); showChunkError(chunkUrl); return; } chunkErrorState.reloadAttempted = true; console.warn('[Chunk Handler] Chunk load failed after retries, clearing cache and reloading...', { chunkUrl, errorInfo, reloadCount: chunkErrorState.reloadCount, }); // Clear caches if ("caches" in window) { caches.keys().then(function(names) { names.forEach(function(name) { caches.delete(name).catch(function() {}); }); }); } // Unregister service workers if ("serviceWorker" in navigator) { navigator.serviceWorker.getRegistrations().then(function(registrations) { registrations.forEach(function(reg) { reg.unregister().catch(function() {}); }); }); } // Reload after a short delay to allow cache clearing setTimeout(function() { const currentUrl = window.location.href.split('#')[0]; const separator = currentUrl.includes('?') ? '&' : '?'; window.location.href = currentUrl + separator + '_chunk_reload=' + Date.now(); }, 500); } // Show error message when chunk can't be loaded function showChunkError(chunkUrl) { // Remove any existing error message safely const existing = document.getElementById('chunk-error-message'); if (existing && existing.parentNode) { try { // Use modern remove() method which is safer if (existing.parentNode) { existing.remove(); } } catch (e) { // Element might already be removed, ignore } } if (!document.body) { return; // Can't show error if body doesn't exist } const div = document.createElement("div"); div.id = 'chunk-error-message'; div.style.cssText = "position:fixed;top:0;left:0;right:0;background:#dc2626;color:#fff;padding:1rem;text-align:center;z-index:99999;font-family:sans-serif;"; div.innerHTML = "Loading Error: Please clear your browser cache (Ctrl+Shift+Delete) and refresh the page. "; document.body.appendChild(div); } // Handle script tag errors window.addEventListener("error", function(e) { const target = e.target; if (target && target.tagName === "SCRIPT") { const src = target.src || target.getAttribute("src") || ""; if (src && (src.includes("_next/static") || src.includes("chunks"))) { // Extract status code from error message (e.g., "400 (Bad Request)" or "ERR_ABORTED 400") let status = target.status; if (!status && e.message) { // Use string methods to avoid regex escaping issues in script tag const message = String(e.message || ''); // Check for 404 first (more specific) if (message.includes('404')) { status = 404; } // Then check for 400 or Bad Request else if (message.includes('400') || message.includes('Bad Request')) { status = 400; } // Check for ERR_ABORTED with status code else if (message.includes('ERR_ABORTED')) { // Extract 3-digit status code after ERR_ABORTED using string methods const abortIndex = message.indexOf('ERR_ABORTED'); if (abortIndex !== -1) { const afterAbort = message.substring(abortIndex + 'ERR_ABORTED'.length).trim(); // Find first 3-digit number in the string after ERR_ABORTED let numStr = ''; for (let i = 0; i < afterAbort.length && numStr.length < 3; i++) { const char = afterAbort[i]; if (char >= '0' && char <= '9') { numStr += char; } else if (numStr.length > 0) { break; // Stop if we hit non-digit after starting a number } } if (numStr.length === 3) { const parsedStatus = parseInt(numStr, 10); if (!isNaN(parsedStatus) && parsedStatus >= 100 && parsedStatus <= 599) { status = parsedStatus; } } } } } // Also check for Bad Request in message const isBadRequest = e.message?.includes('Bad Request') || e.message?.includes('400') || src.includes('400'); handleChunkError(src, { type: "script_error", status: status || (isBadRequest ? 400 : null), message: e.message, error: e.message, }); // Don't prevent default - let the error propagate naturally return false; } } // Check for chunk-related error messages if (e.message && ( e.message.includes("Loading chunk") || e.message.includes("ChunkLoadError") )) { // Try to extract chunk URL from error message using string methods const message = String(e.message || ''); const httpIndex = message.indexOf('http://'); const httpsIndex = message.indexOf('https://'); const startIndex = httpsIndex !== -1 ? httpsIndex : (httpIndex !== -1 ? httpIndex : -1); let chunkUrl = null; if (startIndex !== -1) { // Extract URL until we hit whitespace or end of string let urlEnd = startIndex; while (urlEnd < message.length) { const char = message[urlEnd]; const charCode = char.charCodeAt(0); // Check for space (32), newline (10), tab (9), carriage return (13) if (charCode === 32 || charCode === 10 || charCode === 9 || charCode === 13) { break; } urlEnd++; } chunkUrl = message.substring(startIndex, urlEnd); } if (chunkUrl) { handleChunkError(chunkUrl, { type: "error_event", message: e.message, }); } return false; } }, true); // Handle promise rejections (Next.js chunk loading errors) window.addEventListener("unhandledrejection", function(e) { const reason = e.reason; if (reason) { const message = reason.message || reason.toString() || ""; const name = reason.name || ""; if ( message.includes("Loading chunk") || message.includes("ChunkLoadError") || name === "ChunkLoadError" ) { // Try to extract chunk URL using string methods const msgStr = String(message || ''); const httpIndex = msgStr.indexOf('http://'); const httpsIndex = msgStr.indexOf('https://'); const startIndex = httpsIndex !== -1 ? httpsIndex : (httpIndex !== -1 ? httpIndex : -1); let chunkUrl = null; if (startIndex !== -1) { // Extract URL until we hit whitespace or end of string let urlEnd = startIndex; while (urlEnd < msgStr.length) { const char = msgStr[urlEnd]; const charCode = char.charCodeAt(0); // Check for space (32), newline (10), tab (9), carriage return (13) if (charCode === 32 || charCode === 10 || charCode === 9 || charCode === 13) { break; } urlEnd++; } chunkUrl = msgStr.substring(startIndex, urlEnd); } if (chunkUrl) { handleChunkError(chunkUrl, { type: "promise_rejection", message: message, name: name, }); } e.preventDefault(); } } }); // Intercept fetch requests for chunks if (window.fetch) { const originalFetch = window.fetch; window.fetch = function(...args) { const url = args[0]; if (typeof url === "string" && (url.includes("_next/static") || url.includes("chunks"))) { return originalFetch.apply(this, args) .then(function(response) { // Check response status even for successful fetches if (!response.ok && (response.status === 400 || response.status === 404)) { handleChunkError(url, { type: "fetch_error", error: "HTTP " + response.status, status: response.status, message: "Failed to load chunk: " + response.status, }); } return response; }) .catch(function(error) { // Check if it's a chunk loading error const isChunkError = error.message && ( error.message.includes("400") || error.message.includes("404") || error.message.includes("Bad Request") || error.message.includes("ERR_ABORTED") ); if (isChunkError) { // Try to get status from error message // Use simple string checks instead of regex to avoid escaping issues const status = error.message.includes("400") || error.message.includes("ERR_ABORTED 400") ? 400 : error.message.includes("404") || error.message.includes("ERR_ABORTED 404") ? 404 : null; handleChunkError(url, { type: "fetch_error", error: error.message, status: status, message: error.message, }); } throw error; }); } return originalFetch.apply(this, args); }; } })();