Make it more concise which do it's job perfectly and that is to work as a proxy service in cloudflare worker's environment to bypass all of the CORS policy restrictions for all of the requests and responses correctly without any issue and let all types of requests and responses pass through the proxy without getting any CORS error for the allowed domains. Send the fully working full codes. -- // Default Configuration
const DEFAULT_CONFIG = {
  ALLOWED_ORIGINS: new Set([
    'https://api.abhibhai.com',
    'https://lnee.netlify.app',
    'https://proxe.netlify.app',
    'http://localhost:8080',
  ]),
  ALLOWED_TARGET_DOMAINS: new Set(['*']),
  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_ORIGINS: new Set([...DEFAULT_CONFIG.ALLOWED_ORIGINS].map(origin => new URL(origin).origin.toLowerCase())),
  ALLOWED_TARGET_DOMAINS: new Set([...DEFAULT_CONFIG.ALLOWED_TARGET_DOMAINS].map(domain => domain.toLowerCase())),
  BLOCKED_TARGET_HOSTS: new Set([...DEFAULT_CONFIG.BLOCKED_TARGET_HOSTS].map(host => host.toLowerCase())),
  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 (origin && !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) {
  try {
    const parsedOrigin = new URL(origin);
    const normalizedOrigin = parsedOrigin.origin.toLowerCase();
    return CONFIG.ALLOWED_ORIGINS.has(normalizedOrigin) || CONFIG.ALLOWED_ORIGINS.has('*');
  } catch (e) {
    return false;
  }
}

// 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);
  }

  const targetHost = parsedTargetUrl.host.toLowerCase();

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

  if (!CONFIG.ALLOWED_TARGET_DOMAINS.has('*') && CONFIG.ALLOWED_TARGET_DOMAINS.size > 0 && !CONFIG.ALLOWED_TARGET_DOMAINS.has(parsedTargetUrl.hostname.toLowerCase())) {
    throw new ProxyError('Forbidden: Target domain is not allowed', 403);
  }

  // Prepare Headers for the Forwarded Request
  const forwardedHeaders = filterRequestHeaders(request.headers);
  forwardedHeaders.set('Host', parsedTargetUrl.host);

  // Handle Timeout with AbortController
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), CONFIG.TIMEOUT);

  let body = undefined;
  if (!['GET', 'HEAD'].includes(request.method)) {
    try {
      const clonedRequest = request.clone();
      body = await clonedRequest.arrayBuffer();
    } catch (err) {
      clearTimeout(timeoutId);
      throw new ProxyError('Failed to read request body', 400);
    }
  }

  const init = {
    method: request.method,
    headers: forwardedHeaders,
    redirect: 'follow',
    signal: controller.signal,
    body: body,
  };

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

  // 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 (origin && 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(', '));
    }
  }

  headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');

  if (request.headers.get('Origin') && isAllowedOrigin(request.headers.get('Origin'))) {
    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 if Origin is present
  if (request.headers.get('Origin')) {
    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);

  // 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) {
  console.error('Error:', error);
  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 if Origin is present
  if (request.headers.get('Origin')) {
    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.clone().json();
    validateConfig(updatedConfig);
    updateConfig(updatedConfig);
    const responseBody = { message: 'Configuration updated successfully' };

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

    if (request.headers.get('Origin')) {
      for (const [key, value] of corsHeaders.entries()) {
        headers.set(key, value);
      }
    }

    return new Response(JSON.stringify(responseBody), {
      status: 200,
      headers,
    });
  } catch (error) {
    console.error('Configuration Update Error:', 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 if Origin is present
        ...(request.headers.get('Origin') ? Object.fromEntries(generateCorsHeaders(request).entries()) : {}),
      },
    });
  }
}

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

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

  // ALLOWED_TARGET_DOMAINS Validation
  if ('ALLOWED_TARGET_DOMAINS' in newConfig) {
    if (!Array.isArray(newConfig.ALLOWED_TARGET_DOMAINS)) {
      throw new ProxyError('Invalid ALLOWED_TARGET_DOMAINS format', 400);
    }
    newConfig.ALLOWED_TARGET_DOMAINS.forEach(domain => {
      if (domain !== '*' && (typeof domain !== 'string' || domain.trim() === '')) {
        throw new ProxyError(`Invalid domain in ALLOWED_TARGET_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_ORIGINS', 'ALLOWED_TARGET_DOMAINS'].includes(key)) {
          if (key === 'ALLOWED_ORIGINS') {
            CONFIG[key] = new Set(value.map(v => v.toLowerCase()));
          } else if (key === 'ALLOWED_TARGET_DOMAINS') {
            CONFIG[key] = new Set(value.map(v => v.toLowerCase()));
          } else {
            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_ORIGINS' in newConfig) {
    CONFIG.ALLOWED_ORIGINS = new Set([...CONFIG.ALLOWED_ORIGINS].map(origin => {
      if (origin === '*') return '*';
      try {
        return new URL(origin).origin.toLowerCase();
      } catch {
        // This case should be handled in validation
        return origin.toLowerCase();
      }
    }));
  }
  if ('ALLOWED_TARGET_DOMAINS' in newConfig) {
    CONFIG.ALLOWED_TARGET_DOMAINS = new Set([...CONFIG.ALLOWED_TARGET_DOMAINS].map(domain => domain.toLowerCase()));
  }
}

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