Нужно переписать программу на JS (jQuery или что то такое, чтобы клиент-сайд был)

using System;
using System.Net.Http;
using System.Collections.Generic;
using System.Threading;
using System.IO;
using System.Reflection;
using System.Net;
using System.Threading.Tasks;

namespace UrlChecker
{
    class Program
    {
        public static List <String> RequestResult = new List<string>();
        public static bool WlistCheckComplited = false;
        public static HttpClient client = new HttpClient(new GlobalRedirectHandler(new HttpClientHandler()));

        public class Option
        {
            public bool IsWhiteList;
            public String Descripinon;
            public List<String> UrlList = new List<string>();
            public bool ListIsChecked = false;
        }

        public static List<Option> OptionsList = new List<Option>();
        public static bool OtionsIsGeted = false;
        public static int WListAccesseble = 0;
        public static int WListNotAccesseble = 0;
        public static int BListAccesseble = 0;
        public static int BListNotAccesseble = 0;

        static void Main(string[] args)
        {

            LogClear();
            LogAdd("Тестирование начинается!");

            client.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.109 Safari/537.36");
            client.Timeout = System.TimeSpan.FromSeconds(10);

            //SystemInformation.UserName;
            LogAdd("***********************************************************");
            LogAdd ("Компьютер\\пользователь: " + Environment.MachineName + "\\" + Environment.UserName);
            LogAdd("***********************************************************");

            TryToGetParametrs("http://chto-to-tam.ru/UrlChecker/regestry.txt");

            while (OtionsIsGeted == false)
            {
                Thread.Sleep(10);
            };

            for(int i = 0; OptionsList.Count - 1 >= i; i++)
            {
                LogAdd("Обработка списка " + OptionsList[i].Descripinon);
                foreach (string url in OptionsList[i].UrlList)
                {
                    TryToGetUrlWithCheck(url);
                    Thread.Sleep(100);
                }
                OptionsList[i].ListIsChecked = true;
                Thread.Sleep(10000);
            }

            //TryToGetUrlWithCheck("http://росметодкабинет.рф/Новости/");
            //TryToGetUrlWithCheck("http://росметодкабинет.рф");

            //Console.WriteLine("Доступно сайтов из белых списков: " + WListAccesseble.ToString());
            //Console.WriteLine("Недосупно сайтов из белых списков: " + WListNotAccesseble.ToString());
            //Console.WriteLine("Доступно сайтов из черных списков: " + BListAccesseble.ToString());
            //Console.WriteLine("Недоступно сайтов из черных списков: " + BListNotAccesseble.ToString());

            //Console.WriteLine("Работа завершена. Нажмите любую клавишу...");
            LogAdd("***********************************************************");
            LogAdd("Доступно сайтов из белых списков: " + WListAccesseble.ToString());
            LogAdd("Недосупно сайтов из белых списков: " + WListNotAccesseble.ToString());
            LogAdd("Доступно сайтов из черных списков: " + BListAccesseble.ToString());
            LogAdd("Недоступно сайтов из черных списков: " + BListNotAccesseble.ToString());
            LogAdd("***********************************************************");
            LogAdd("Работа завершена. Нажмите любую клавишу...");
            Console.ReadKey();
        }

        static async void TryToGetParametrs(String Url)
        {
            try
            {
                //HttpResponseMessage response = await client.GetAsync(Url);
                //response.EnsureSuccessStatusCode();
                string responseBody = await client.GetStringAsync(Url); //await response.Content.ReadAsStringAsync();

                string[] ParametrsRaw = responseBody.Split('\n');



                foreach (string param in ParametrsRaw)
                {
                    string[] p = param.Split('|');
                    Option opt = new Option();
                    opt.IsWhiteList = (p[0] == "white_list" ?  true : false);
                    opt.Descripinon = p[1];
                    responseBody = await client.GetStringAsync(p[2]);
                    foreach(string Str in responseBody.Split('\n'))
                    {
                        if (Str != "") opt.UrlList.Add(Str);
                    }
                    OptionsList.Add(opt);
                }

                LogAdd("Получен список параметров!");
                OtionsIsGeted = true;
            }
            catch (HttpRequestException e)
            {
                LogAdd("Ошибка получения параметров");
            }

        }

        static async void TryToGetUrlWithCheck(String Url)
        {
            HttpResponseMessage response = new HttpResponseMessage();
            ServicePointManager.SecurityProtocol = SecurityProtocolType.SystemDefault | SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
            ServicePointManager.ServerCertificateValidationCallback = (z, x, c, v) => true;
            try { 
                response = await client.GetAsync(Url);
                //if ((int)response.StatusCode == 200 || (int)response.StatusCode == 201)
                //    LogAdd(Url + " - Ok!");
                //else
                //    response.EnsureSuccessStatusCode();
                switch ((int)response.StatusCode)
                {
                    case 200:
                    case 201:
                        //        if(RequestResult[0].Contains(response.RequestMessage.RequestUri.ToString()))
                        for (int i = 0; OptionsList.Count - 1 >= i; i++)
                        {
                            if (OptionsList[i].IsWhiteList == true)
                            {
                                if (OptionsList[i].UrlList.Contains(Url))
                                {
                                    LogAdd("Ok! - " + Url);
                                    WListAccesseble++;
                                }
                                else
                                {
                                    LogAdd("Error! URL не включен в белые списки (" + response.RequestMessage.RequestUri.ToString() + ")");
                                    BListAccesseble++;
                                }
                            }
                            else continue;
                        }                 
                        break;
                    default:
                        for (int i = 0; OptionsList.Count - 1 >= i; i++)
                        {
                            if (OptionsList[i].IsWhiteList == true)
                            {
                                if (OptionsList[i].UrlList.Contains(Url))
                                {
                                    LogAdd("Error! Url из белого списка " + OptionsList[i].Descripinon + " недосупен (" + Url + ")");
                                    WListNotAccesseble++;
                                }
                                else
                                {
                                    LogAdd("Ok! URL не включен в белый список и недосупен (" + Url + ")");
                                    BListNotAccesseble++;
                                }
                            }
                            else continue;
                        }
                        break;
                }
            }
            catch (HttpRequestException e)
            {
                LogAdd("Error! - " + e.Message + " " + Url);
            }
        }

        public static void LogAdd(string Msg)
        {
            try
            {
                string path = @"" + Environment.CurrentDirectory + "\\" + Environment.MachineName /*Assembly.GetExecutingAssembly().Location*/ + "-" + DateTime.Now.ToString("yyyy-MM-dd") + ".txt";
                StreamWriter sw = File.AppendText(path);
                sw.WriteLine(DateTime.Now.ToString() + " " + Msg);
                sw.Close();
                Console.WriteLine(DateTime.Now.ToString() + " " + Msg);
            }
            catch (Exception ex)
            {
            }
        }

        public static void LogClear()
        {
            try
            {
                string path = @"" + Environment.CurrentDirectory + "\\" + Environment.MachineName /*Assembly.GetExecutingAssembly().Location*/ + "-" + DateTime.Now.ToString("yyyy-MM-dd") + ".txt";
                File.Delete(path);
            }
            catch (Exception ex)
            {
            }
        }
    }

    public class GlobalRedirectHandler : DelegatingHandler
    {

        public GlobalRedirectHandler(HttpMessageHandler innerHandler)
        {
            InnerHandler = innerHandler;
        }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var tcs = new TaskCompletionSource<HttpResponseMessage>();

            base.SendAsync(request, cancellationToken).ContinueWith(t =>
                    {
                        HttpResponseMessage response;
                        try
                        {
                            response = t.Result;
                        }
                        catch (Exception e)
                        {
                            response = new HttpResponseMessage(HttpStatusCode.ServiceUnavailable);
                            response.ReasonPhrase = e.Message;
                        }
                        if (response.StatusCode == HttpStatusCode.MovedPermanently
                            || response.StatusCode == HttpStatusCode.Moved
                            || response.StatusCode == HttpStatusCode.Redirect
                            || response.StatusCode == HttpStatusCode.Found
                            || response.StatusCode == HttpStatusCode.SeeOther
                            || response.StatusCode == HttpStatusCode.RedirectKeepVerb
                            || response.StatusCode == HttpStatusCode.TemporaryRedirect

                            || (int)response.StatusCode == 308)
                        {

                            var newRequest = CopyRequest(response.RequestMessage);

                            if (response.StatusCode == HttpStatusCode.Redirect
                                || response.StatusCode == HttpStatusCode.Found
                                || response.StatusCode == HttpStatusCode.SeeOther)
                            {
                                newRequest.Content = null;
                                newRequest.Method = HttpMethod.Get;

                            }
                            base.SendAsync(newRequest, cancellationToken).ContinueWith(t2 => tcs.SetResult(t2.Result));
                        }
                        else
                        {
                            tcs.SetResult(response);
                        }
                    }
                );

            return tcs.Task;
        }

        private static HttpRequestMessage CopyRequest(HttpRequestMessage oldRequest)
        {
            var newrequest = new HttpRequestMessage(oldRequest.Method, oldRequest.RequestUri);

            foreach (var header in oldRequest.Headers)
            {
                newrequest.Headers.TryAddWithoutValidation(header.Key, header.Value);
            }
            foreach (var property in oldRequest.Properties)
            {
                newrequest.Properties.Add(property);
            }
            if (oldRequest.Content != null)
                newrequest.Content = new StreamContent(oldRequest.Content.ReadAsStreamAsync().Result);
            return newrequest;
        }
    }
}