NodeJS: how to route HTTPS requests through an HTTP proxy without any external dependencies (optimized version)

(async () => {
    const urls = new Array(50).fill('https://api.ipify.org/?format=json');

    for (const [i, url] of urls.entries()) {
        console.log(`${i + 1}/${urls.length}`);
        try {
            const res = await getURL(url);
            console.log(res.body);
        } catch (e) {
            console.log(e)
        }
    }
})();

var http = require("http");
var https = require('https');

class HttpsWithProxyClient {
    constructor(proxyConf) {
        this.proxyConf = proxyConf;
        this.proxyAgent = null;
        this.lastRequestHostname = null;
    }

    // Async private method, used only internally by HttpsWithProxyClient
    // Handle the connection with the HTTP proxy
    // In case the connection is successful, it returns a new http.Agent with keepAlive activated
    async _connectToProxy(url) {
        return new Promise((resolve, reject) => {
            const headers = {
                'Proxy-Authorization': 'Basic ' + Buffer.from(this.proxyConf.proxy_username + ':' + this.proxyConf.proxy_password).toString('base64')
            }

            const urlParsed = new URL(url);
            http.request({ // establishing a tunnel
                host: this.proxyConf.proxy_host,
                port: this.proxyConf.proxy_port,
                method: 'CONNECT',
                path: `${urlParsed.hostname}:443`,
                headers
            }).on('connect', (res, socket) => {
                if (res.statusCode === 200) {
                    resolve(new https.Agent({ socket: socket, keepAlive: true }));
                } else {
                    reject('Could not connect to proxy!')
                }

            }).on('error', (err) => {
                reject(err.message);
            }).on('timeout', (err) => {
                reject(err.message);
            }).end();
        });
    }

    // Public asynchronous method used to make an HTTPs get request on a given URL through an HTTP proxy
    async getURL(url, headers) {
        return new Promise(async (resolve, reject) => {
            const urlParsed = new URL(url);
            headers = headers || {};
            
            // If there's no current valid connection established with the proxy
            // or if the host linked to the URL requested is different from the previous request
            // -> recreate a connection with the proxy
            if (!this.proxyAgent || this.lastRequestHostname !== urlParsed.hostname) {
                try {
                    this.proxyAgent = await this._connectToProxy(url);
                    this.lastRequestHostname = urlParsed.hostname;
                } catch (e) {
                    return reject(e);
                }
                
            }

            const req = https.get({
                host: urlParsed.hostname,
                path: urlParsed.pathname,
                agent: this.proxyAgent,
                headers: headers,
            }, (response) => {
                const chunks = [];
                response.on('data', (chunk) => {
                    chunks.push(chunk);
                });
                response.on('end', () => {
                    resolve({
                        body:Buffer.concat(chunks).toString(),
                        headers: response.headers,
                        status: response.statusCode
                    })
                });

                response.on("error", (err) => {
                    reject(err);
                })

                response.setTimeout(25000, () => {
                    reject('timeout')
                })
            });

            req.on('error', (err) => {
                this.proxyAgent = null;
                reject(err.message);
            })
        })
    }
}