Analyse the whole script thoroughly and fix any thing that might Stop it from full filling the request in any circumstances. Handle all of the edge cases that might prevent request from full filled. Send the fully working full updated code. -- // Default Configuration
const DEFAULT_CONFIG = {
  ALLOWED_DOMAINS: new Set([
    'https://api.abhibhai.com',
    'https://lnee.netlify.app',
    'https://proxe.netlify.app',
    'http://localhost:8080',
  ]),
  BLOCKED_TARGET_HOSTS: new Set(['blocked.example.com']),
  FORWARD_HEADERS: new Set([
    'accept',
    'accept-language',
    'user-agent',
    'content-type',
    'authorization',
    'cache-control',
    'pragma',
    'expires',
    'last-modified',
    'if-modified-since',
    'if-none-match',
    'range',
    'content-range',
    'accept-encoding',
    'accept-datetime',
    'cookie',
  ]),
  REMOVE_HEADERS: new Set([
    'cf-connecting-ip',
    'x-forwarded-for',
    'x-real-ip',
    'forwarded',
    'via',
    'proxy-authorization',
    'proxy-authenticate',
    'client-ip',
    'true-client-ip',
    'x-forwarded-host',
    'x-forwarded-port',
    'x-forwarded-proto',
    'x-forwarded-protocol',
    'x-forwarded-ssl',
    'x-url-scheme',
    'x-original-forwarded-for',
    'x-http-forwarded-for',
    'x-original-host',
    'x-forwarded-by',
    'x-proxy-user-ip',
    'x-cluster-client-ip',
    'x-forwarded',
    'x-real-ip',
    'forwarded-for',
    'forwarded-proto',
  ]),
  TIMEOUT: 29000, // in milliseconds (29 seconds)
  AUTH_KEY: 'your-secure-auth-key', // Replace with your actual auth key
  SECURITY_HEADERS: {
    'X-Content-Type-Options': 'nosniff',
    'Referrer-Policy': 'no-referrer',
    'Strict-Transport-Security': 'max-age=63072000; includeSubDomains; preload',
    'X-Frame-Options': 'DENY',
  },
  CUSTOM_ERROR_RESPONSES: {
    // Example:
    // 404: { error: 'Not Found' },
  },
  CACHE_CONTROL: {
    DEFAULT_MAX_AGE: 300, // 5 minutes
    CUSTOM_RULES: {
      // '/specific-path': 'public, max-age=600',
    },
  },
};

// Clone the default configuration to allow runtime modifications
let CONFIG = {
  ...DEFAULT_CONFIG,
  ALLOWED_DOMAINS: new Set([...DEFAULT_CONFIG.ALLOWED_DOMAINS]),
  BLOCKED_TARGET_HOSTS: new Set([...DEFAULT_CONFIG.BLOCKED_TARGET_HOSTS]),
  FORWARD_HEADERS: new Set([...DEFAULT_CONFIG.FORWARD_HEADERS].map(header => header.toLowerCase())),
  REMOVE_HEADERS: new Set([...DEFAULT_CONFIG.REMOVE_HEADERS].map(header => header.toLowerCase())),
};

// Custom Error Class for Proxy-Specific Errors
class ProxyError extends Error {
  constructor(message, status) {
    super(message);
    this.name = 'ProxyError';
    this.status = status;
  }
}

// Event Listener for Fetch Events
addEventListener('fetch', (event) => {
  event.respondWith(
    handleRequest(event).catch((error) => handleError(error, event.request))
  );
});

// Main Request Handler
async function handleRequest(event) {
  const request = event.request;
  const url = new URL(request.url);

  // Handle Preflight CORS Requests
  if (request.method === 'OPTIONS') {
    return handlePreflightRequest(request);
  }

  // Handle Configuration Updates
  if (request.method === 'POST' && url.pathname === '/config') {
    return handleConfigUpdate(request);
  }

  // Check for Allowed Origin
  const origin = request.headers.get('Origin');
  if (!isAllowedOrigin(origin)) {
    throw new ProxyError('Forbidden: Origin not allowed', 403);
  }

  // Forward the Request
  return forwardRequest(request, origin);
}

// Check if the Origin is Allowed
function isAllowedOrigin(origin) {
  return origin && (CONFIG.ALLOWED_DOMAINS.has(origin) || CONFIG.ALLOWED_DOMAINS.has('*'));
}

// Forward the Incoming Request to the Target URL
async function forwardRequest(request, origin) {
  const url = new URL(request.url);
  const targetUrl =
    request.headers.get('x-target-url') || url.searchParams.get('target');

  if (!targetUrl) {
    throw new ProxyError('Bad Request: Missing target URL', 400);
  }

  let parsedTargetUrl;
  try {
    parsedTargetUrl = new URL(targetUrl);
  } catch (err) {
    throw new ProxyError('Invalid URL format', 400);
  }

  if (CONFIG.BLOCKED_TARGET_HOSTS.has(parsedTargetUrl.host.toLowerCase())) {
    throw new ProxyError('Forbidden: Target host is not allowed', 403);
  }

  // Prepare Headers for the Forwarded Request
  const forwardedHeaders = filterRequestHeaders(request.headers);
  const init = {
    method: request.method,
    headers: forwardedHeaders,
    redirect: 'follow',
    signal: AbortSignal.timeout(CONFIG.TIMEOUT),
  };

  // Clone the request if the body needs to be read
  if (!['GET', 'HEAD'].includes(request.method)) {
    init.body = await request.clone().arrayBuffer();
  }

  // Perform the Fetch to the Target URL
  let response;
  try {
    response = await fetch(parsedTargetUrl.toString(), init);
  } catch (err) {
    if (err.name === 'AbortError') {
      throw new ProxyError('Request Timed Out', 504);
    } else {
      throw new ProxyError('Error Fetching Target URL', 502);
    }
  }

  // Process and Return the Response with CORS and Security Headers
  return createCorsResponse(response, request);
}

// Filter and Forward Only Allowed Headers
function filterRequestHeaders(headers) {
  const forwardedHeaders = new Headers();
  for (const [key, value] of headers.entries()) {
    const lowerKey = key.toLowerCase();
    if (CONFIG.FORWARD_HEADERS.has(lowerKey) && !CONFIG.REMOVE_HEADERS.has(lowerKey)) {
      forwardedHeaders.set(key, value);
    }
  }
  return forwardedHeaders;
}

// Generate CORS Headers
function generateCorsHeaders(request) {
  const origin = request.headers.get('Origin') || '';
  const headers = new Headers();

  if (isAllowedOrigin(origin)) {
    headers.set('Access-Control-Allow-Origin', origin);
    headers.set('Access-Control-Allow-Credentials', 'true');

    // Echo back the requested headers
    const requestHeaders = request.headers.get('Access-Control-Request-Headers');
    if (requestHeaders) {
      headers.set('Access-Control-Allow-Headers', requestHeaders);
    } else {
      // Define default allowed headers if none are requested
      headers.set('Access-Control-Allow-Headers', Array.from(CONFIG.FORWARD_HEADERS).join(', '));
    }
  } else {
    headers.set('Access-Control-Allow-Origin', 'null');
  }

  headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
  headers.set('Access-Control-Expose-Headers', Array.from(CONFIG.FORWARD_HEADERS).join(', '));
  headers.set('Access-Control-Max-Age', '86400'); // 1 day
  headers.append('Vary', 'Origin');

  return headers;
}

// Handle Preflight CORS Requests
function handlePreflightRequest(request) {
  const corsHeaders = generateCorsHeaders(request);

  return new Response(null, {
    status: 204,
    headers: corsHeaders,
  });
}

// Create CORS-Compliant Response with Security Headers
async function createCorsResponse(response, request) {
  const corsHeaders = generateCorsHeaders(request);
  const responseHeaders = new Headers(response.headers);

  // Remove Disallowed Headers
  for (const header of CONFIG.REMOVE_HEADERS) {
    responseHeaders.delete(header);
  }

  // Apply CORS Headers
  for (const [key, value] of corsHeaders.entries()) {
    responseHeaders.set(key, value);
  }

  // Apply Security Headers
  for (const [key, value] of Object.entries(CONFIG.SECURITY_HEADERS)) {
    responseHeaders.set(key, value);
  }

  // Handle Cache Control
  applyCacheControl(responseHeaders, response.url);

  // Clone the response if streaming is needed
  if (response.body && response.body.locked) {
    // For cases where the body is locked and can't be used directly
    const clonedBody = await response.clone().arrayBuffer();
    return new Response(clonedBody, {
      status: response.status,
      statusText: response.statusText,
      headers: responseHeaders,
    });
  }

  // Return the Modified Response
  return new Response(response.body, {
    status: response.status,
    statusText: response.statusText,
    headers: responseHeaders,
  });
}

// Apply Cache Control Headers
function applyCacheControl(headers, url) {
  const parsedUrl = new URL(url);
  const pathname = parsedUrl.pathname;
  const customRule = CONFIG.CACHE_CONTROL.CUSTOM_RULES[pathname];

  if (customRule) {
    headers.set('Cache-Control', customRule);
  } else {
    headers.set(
      'Cache-Control',
      `public, max-age=${CONFIG.CACHE_CONTROL.DEFAULT_MAX_AGE}`
    );
  }
}

// Handle Errors and Generate Appropriate Responses
async function handleError(error, request) {
  const status = error instanceof ProxyError ? error.status : 500;
  const message = error.message || 'Internal Server Error';

  const corsHeaders = generateCorsHeaders(request);
  const headers = new Headers({
    'Content-Type': 'application/json',
    ...CONFIG.SECURITY_HEADERS,
  });

  // Apply CORS Headers
  for (const [key, value] of corsHeaders.entries()) {
    headers.set(key, value);
  }

  // Check for Custom Error Response
  const customErrorResponse = CONFIG.CUSTOM_ERROR_RESPONSES[status];
  if (customErrorResponse) {
    return new Response(JSON.stringify(customErrorResponse), {
      status,
      headers,
    });
  }

  // Default Error Response
  return new Response(JSON.stringify({ error: message }), { status, headers });
}

// Handle Configuration Updates via POST /config
async function handleConfigUpdate(request) {
  const authHeader = request.headers.get('Authorization');
  if (!isAuthorized(authHeader)) {
    throw new ProxyError('Unauthorized', 401);
  }

  try {
    const updatedConfig = await request.json();
    validateConfig(updatedConfig);
    updateConfig(updatedConfig);
    const responseBody = { message: 'Configuration updated successfully' };

    // Generate CORS Headers for the Response
    const corsHeaders = generateCorsHeaders(request);
    const headers = new Headers({
      'Content-Type': 'application/json',
      ...CONFIG.SECURITY_HEADERS,
    });

    // Apply CORS Headers
    for (const [key, value] of corsHeaders.entries()) {
      headers.set(key, value);
    }

    return new Response(JSON.stringify(responseBody), {
      status: 200,
      headers,
    });
  } catch (error) {
    if (error instanceof ProxyError) {
      return handleError(error, request);
    }
    return new Response(JSON.stringify({ error: 'Invalid configuration data' }), {
      status: 400,
      headers: {
        'Content-Type': 'application/json',
        ...CONFIG.SECURITY_HEADERS,
        // Include CORS Headers
        ...generateCorsHeaders(request),
      },
    });
  }
}

// Authorization Check for Configuration Updates
function isAuthorized(authHeader) {
  return authHeader && authHeader === `Bearer ${CONFIG.AUTH_KEY}`;
}

// Validate the Incoming Configuration
function validateConfig(newConfig) {
  // ALLOWED_DOMAINS Validation
  if ('ALLOWED_DOMAINS' in newConfig) {
    if (!Array.isArray(newConfig.ALLOWED_DOMAINS)) {
      throw new ProxyError('Invalid ALLOWED_DOMAINS format', 400);
    }
    newConfig.ALLOWED_DOMAINS.forEach((domain) => {
      try {
        new URL(domain);
      } catch {
        throw new ProxyError(`Invalid URL in ALLOWED_DOMAINS: ${domain}`, 400);
      }
    });
  }

  // BLOCKED_TARGET_HOSTS Validation
  if ('BLOCKED_TARGET_HOSTS' in newConfig) {
    if (!Array.isArray(newConfig.BLOCKED_TARGET_HOSTS)) {
      throw new ProxyError('Invalid BLOCKED_TARGET_HOSTS format', 400);
    }
    newConfig.BLOCKED_TARGET_HOSTS.forEach((host) => {
      if (typeof host !== 'string' || host.trim() === '') {
        throw new ProxyError(`Invalid host in BLOCKED_TARGET_HOSTS: ${host}`, 400);
      }
    });
  }

  // FORWARD_HEADERS Validation
  if ('FORWARD_HEADERS' in newConfig) {
    if (!Array.isArray(newConfig.FORWARD_HEADERS)) {
      throw new ProxyError('Invalid FORWARD_HEADERS format', 400);
    }
    newConfig.FORWARD_HEADERS.forEach((header) => {
      if (typeof header !== 'string' || header.trim() === '') {
        throw new ProxyError(`Invalid header in FORWARD_HEADERS: ${header}`, 400);
      }
    });
  }

  // REMOVE_HEADERS Validation
  if ('REMOVE_HEADERS' in newConfig) {
    if (!Array.isArray(newConfig.REMOVE_HEADERS)) {
      throw new ProxyError('Invalid REMOVE_HEADERS format', 400);
    }
    newConfig.REMOVE_HEADERS.forEach((header) => {
      if (typeof header !== 'string' || header.trim() === '') {
        throw new ProxyError(`Invalid header in REMOVE_HEADERS: ${header}`, 400);
      }
    });
  }

  // SECURITY_HEADERS Validation
  if ('SECURITY_HEADERS' in newConfig) {
    if (
      typeof newConfig.SECURITY_HEADERS !== 'object' ||
      Array.isArray(newConfig.SECURITY_HEADERS) ||
      newConfig.SECURITY_HEADERS === null
    ) {
      throw new ProxyError('Invalid SECURITY_HEADERS format', 400);
    }
    Object.entries(newConfig.SECURITY_HEADERS).forEach(([key, value]) => {
      if (typeof key !== 'string' || typeof value !== 'string') {
        throw new ProxyError(
          `Invalid key-value pair in SECURITY_HEADERS: ${key}: ${value}`,
          400
        );
      }
    });
  }

  // CACHE_CONTROL Validation
  if ('CACHE_CONTROL' in newConfig) {
    if (
      typeof newConfig.CACHE_CONTROL !== 'object' ||
      Array.isArray(newConfig.CACHE_CONTROL) ||
      newConfig.CACHE_CONTROL === null
    ) {
      throw new ProxyError('Invalid CACHE_CONTROL format', 400);
    }

    if (
      'DEFAULT_MAX_AGE' in newConfig.CACHE_CONTROL &&
      (typeof newConfig.CACHE_CONTROL.DEFAULT_MAX_AGE !== 'number' ||
        newConfig.CACHE_CONTROL.DEFAULT_MAX_AGE < 0)
    ) {
      throw new ProxyError('Invalid DEFAULT_MAX_AGE in CACHE_CONTROL', 400);
    }

    if (
      'CUSTOM_RULES' in newConfig.CACHE_CONTROL &&
      typeof newConfig.CACHE_CONTROL.CUSTOM_RULES !== 'object'
    ) {
      throw new ProxyError('Invalid CUSTOM_RULES in CACHE_CONTROL', 400);
    }
  }

  // CUSTOM_ERROR_RESPONSES Validation
  if ('CUSTOM_ERROR_RESPONSES' in newConfig) {
    if (
      typeof newConfig.CUSTOM_ERROR_RESPONSES !== 'object' ||
      Array.isArray(newConfig.CUSTOM_ERROR_RESPONSES) ||
      newConfig.CUSTOM_ERROR_RESPONSES === null
    ) {
      throw new ProxyError('Invalid CUSTOM_ERROR_RESPONSES format', 400);
    }
    Object.entries(newConfig.CUSTOM_ERROR_RESPONSES).forEach(([status, body]) => {
      const statusCode = parseInt(status, 10);
      if (isNaN(statusCode) || statusCode < 100 || statusCode > 599) {
        throw new ProxyError(`Invalid status code in CUSTOM_ERROR_RESPONSES: ${status}`, 400);
      }
      if (typeof body !== 'object' || body === null) {
        throw new ProxyError(
          `Invalid response body for status ${status} in CUSTOM_ERROR_RESPONSES`,
          400
        );
      }
    });
  }

  // AUTH_KEY Validation
  if ('AUTH_KEY' in newConfig) {
    if (typeof newConfig.AUTH_KEY !== 'string' || newConfig.AUTH_KEY.trim() === '') {
      throw new ProxyError('Invalid AUTH_KEY format', 400);
    }
  }

  // TIMEOUT Validation
  if ('TIMEOUT' in newConfig) {
    if (
      typeof newConfig.TIMEOUT !== 'number' ||
      newConfig.TIMEOUT <= 0 ||
      !Number.isFinite(newConfig.TIMEOUT)
    ) {
      throw new ProxyError('Invalid TIMEOUT value', 400);
    }
  }

  // Additional validations can be added here as needed
}

// Update the Configuration with New Values
function updateConfig(newConfig) {
  for (const [key, value] of Object.entries(newConfig)) {
    if (key in CONFIG) {
      if (Array.isArray(value) && CONFIG[key] instanceof Set) {
        if (['FORWARD_HEADERS', 'REMOVE_HEADERS', 'BLOCKED_TARGET_HOSTS', 'ALLOWED_DOMAINS'].includes(key)) {
          CONFIG[key] = new Set(value.map((v) => v.toLowerCase()));
        } else {
          CONFIG[key] = new Set(value);
        }
      } else if (
        typeof value === 'object' &&
        value !== null &&
        !Array.isArray(value) &&
        !(CONFIG[key] instanceof Set)
      ) {
        CONFIG[key] = { ...CONFIG[key], ...value };
      } else {
        CONFIG[key] = value;
      }
    }
  }

  // Ensure TIMEOUT doesn't exceed Cloudflare's limits (30 seconds)
  if ('TIMEOUT' in newConfig) {
    CONFIG.TIMEOUT = Math.min(CONFIG.TIMEOUT, 30000);
  }

  // Normalize headers to lowercase for consistency
  if ('FORWARD_HEADERS' in newConfig) {
    CONFIG.FORWARD_HEADERS = new Set([...CONFIG.FORWARD_HEADERS].map(header => header.toLowerCase()));
  }
  if ('REMOVE_HEADERS' in newConfig) {
    CONFIG.REMOVE_HEADERS = new Set([...CONFIG.REMOVE_HEADERS].map(header => header.toLowerCase()));
  }
  if ('ALLOWED_DOMAINS' in newConfig) {
    CONFIG.ALLOWED_DOMAINS = new Set([...CONFIG.ALLOWED_DOMAINS].map(domain => domain.toLowerCase()));
  }
}

// Optional: Helper Function to Reset Configuration to Default
function resetConfig() {
  CONFIG = {
    ...DEFAULT_CONFIG,
    ALLOWED_DOMAINS: new Set([...DEFAULT_CONFIG.ALLOWED_DOMAINS]),
    BLOCKED_TARGET_HOSTS: new Set([...DEFAULT_CONFIG.BLOCKED_TARGET_HOSTS]),
    FORWARD_HEADERS: new Set([...DEFAULT_CONFIG.FORWARD_HEADERS].map(header => header.toLowerCase())),
    REMOVE_HEADERS: new Set([...DEFAULT_CONFIG.REMOVE_HEADERS].map(header => header.toLowerCase())),
  };
}