Use Cloudflare workers to reverse proxy GitHub.

Reverse proxying Github seems to be considered fraudulent and can result in domain banning. It is not recommended to try.
First, bind your domain to Cloudflare, then create a Worker and write the following code and add a custom domain.
// Target website for reverse proxying.
const upstream = 'github.com';

// Mobile version of the target website for reverse proxying.
const upstream_mobile = 'github.com';

// Blacklist of regions (set as needed).
const blocked_region = [''];

// Blacklist of IP addresses (set as needed).
const blocked_ip_address = ['0.0.0.0', '127.0.0.1'];

// Path replacement.
const replace_dict = {
  '$upstream': '$custom_domain', // Replace "$upstream" with "$custom_domain"
  '//github.com': '' // Remove "//github.com" from the path
};

addEventListener('fetch', event => {
  event.respondWith(fetchAndApply(event.request));
});

async function fetchAndApply(request) {
  const region = request.headers.get('cf-ipcountry').toUpperCase(); // Get the visitor's region
  const ip_address = request.headers.get('cf-connecting-ip'); // Get the visitor's IP address
  const user_agent = request.headers.get('user-agent'); // Get the visitor's User-Agent header

  let response = null;
  let url = new URL(request.url);
  let url_host = url.host;

  if (url.protocol == 'http:') { // Redirect to HTTPS if the request protocol is HTTP
	url.protocol = 'https:';
	response = Response.redirect(url.href);
	return response;
  }

  if (await device_status(user_agent)) { // Check if it's a mobile device
	var upstream_domain = upstream;
  } else {
	var upstream_domain = upstream_mobile;
  }

  url.host = upstream_domain;

  if (blocked_region.includes(region)) { // Check if the region is in the blacklist
	response = new Response('Access denied: WorkersProxy is not available in your region yet.', {
	  status: 403
	});
  } else if (blocked_ip_address.includes(ip_address)){ // Check if the IP address is in the blacklist
	response = new Response('Access denied: Your IP address is blocked by WorkersProxy.', {
	  status: 403
	});
  } else {
	let method = request.method;
	let request_headers = request.headers;
	let new_request_headers = new Headers(request_headers);

	new_request_headers.set('Host', upstream_domain); // Set the Host field of the request header to the domain of the target website
	new_request_headers.set('Referer', url.href); // Set the Referer field of the request header to the current request URL

	let original_response = await fetch(url.href, {
	  method: method,
	  headers: new_request_headers
	});

	let original_response_clone = original_response.clone();
	let original_text = null;
	let response_headers = original_response.headers;
	let new_response_headers = new Headers(response_headers);
	let status = original_response.status;

	// Modify the response header settings
	new_response_headers.set('cache-control', 'public, max-age=14400');
	new_response_headers.set('access-control-allow-origin', '*');
	new_response_headers.set('access-control-allow-credentials', true);
	new_response_headers.delete('content-security-policy');
	new_response_headers.delete('content-security-policy-report-only');
	new_response_headers.delete('clear-site-data');

	const content_type = new_response_headers.get('content-type');
	if (content_type && content_type.includes('text/html') && content_type.includes('UTF-8')) {
	  original_text = await replace_response_text(original_response_clone, upstream_domain, url_host); // Replace the text content in the response
	} else {
	  original_text = original_response_clone.body;
	}

	response = new Response(original_text, {
	  status,
	  headers: new_response_headers
	});
  }
  return response;
}

async function replace_response_text(response, upstream_domain, host_name) {
  let text = await response.text();

  for (let i in replace_dict) {
	let j = replace_dict[i];
	if (i == '$upstream') {
	  i = upstream_domain;
	} else if (i == '$custom_domain') {
	  i = host_name;
	}

	if (j == '$upstream') {
	  j = upstream_domain;
	} else if (j == '$custom_domain') {
	  j = host_name;
	}

	let re = new RegExp(i, 'g');
	text = text.replace(re, j); // Use regular expressions to replace text content
  }

  return text;
}

async function device_status(user_agent_info) {
  var agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
  var flag = true;
  for (var v = 0; v < agents.length; v++) {
	if (user_agent_info.indexOf(agents[v]) > 0) {
	  flag = false;
	  break;
	}
  }
  return flag;
}