@api-client/core 0.18.12 → 0.18.13

package/build/src/runtime/http-engine/CoreEngine.js

@@ -1,45 +1,268 @@
-import net from 'net';
-import tls from 'tls';
-import http from 'http';
-import https from 'https';
-import { HttpEngine } from './HttpEngine.js';
+import { EventEmitter } from 'events';
+import { HttpRequest } from '../../models/HttpRequest.js';
+import { SentRequest } from '../../models/SentRequest.js';
 import { Response } from '../../models/Response.js';
+import { ErrorResponse } from '../../models/ErrorResponse.js';
+import { RequestsSize } from '../../models/RequestsSize.js';
+import { HttpResponse } from '../../models/HttpResponse.js';
+import { ResponseRedirect } from '../../models/ResponseRedirect.js';
+import { RequestLog } from '../../models/RequestLog.js';
 import { SerializableError } from '../../models/SerializableError.js';
+import { ResponseAuthorization } from '../../models/ResponseAuthorization.js';
 import { Headers } from '../../lib/headers/Headers.js';
+import { getPort } from './RequestUtils.js';
+import { HttpResponseParser, RequestState } from './parsers/index.js';
+import { ConnectionManager } from './connections/index.js';
+import { AuthManager } from './auth/index.js';
+import { MessageBuilder } from './message/index.js';
+import { HttpEngineErrorFactory } from './errors/index.js';
+import { isMethodWithoutBody, HEADER_PROXY_AUTHORIZATION } from './constants.js';
+import { decompress } from './compression/index.js';
+import { checkServerIdentity } from './certificates/index.js';
+import { readUrl, getHostHeader, getRedirectLocation, isRedirectLoop } from './url/index.js';
+import { processRedirectCookies } from './cookies/index.js';
+import { computeStats } from './statistics/index.js';
+import { processResponse } from './response/index.js';
+import { getCodeMessage } from './HttpErrorCodes.js';
+import { createLogger } from '../../lib/logging/index.js';
 import * as PayloadSupport from './PayloadSupport.js';
-import { addContentLength, getPort } from './RequestUtils.js';
-import { NtlmAuth } from './ntlm/NtlmAuth.js';
+import { addContentLength } from './RequestUtils.js';
 import { PayloadSerializer } from '../../lib/transformers/PayloadSerializer.js';
-const nlBuffer = Buffer.from([13, 10]);
-const nlNlBuffer = Buffer.from([13, 10, 13, 10]);
-export var RequestState;
-(function (RequestState) {
-    RequestState[RequestState["Status"] = 0] = "Status";
-    RequestState[RequestState["Headers"] = 1] = "Headers";
-    RequestState[RequestState["Body"] = 2] = "Body";
-    RequestState[RequestState["Done"] = 3] = "Done";
-})(RequestState || (RequestState = {}));
+import { ProxyAuthenticationError } from './errors/HttpEngineErrors.js';
+export const mainPromiseSymbol = Symbol('mainPromise');
 /**
- * API Client's HTTP engine.
+ * API Client's HTTP engine with refactored parsing and connection handling.
  * An HTTP 1.1 engine working directly on the socket. It communicates with the remote machine and
  * collects stats about the request and response.
  */
-export class CoreEngine extends HttpEngine {
-    state = RequestState.Status;
-    rawHeaders;
-    _hostTestReg = /^\s*host\s*:/im;
-    responseInfo;
+export class CoreEngine extends EventEmitter {
+    request;
+    opts;
+    logger;
+    /**
+     * The current sent request
+     */
+    sentRequest;
+    redirects = [];
+    /**
+     * When true the request has been aborted.
+     */
+    aborted = false;
+    /**
+     * Parsed value of the request URL.
+     */
+    uri;
+    socket;
+    /**
+     * Host header can be different than registered URL because of
+     * `hosts` rules.
+     * If a rule changes host value of the URL the original URL host value
+     * is used when generating the request and not overwritten one.
+     * This way virtual hosts can be tested using hosts.
+     */
+    hostHeader;
+    hostTestReg = /^\s*host\s*:/im;
+    /**
+     * Set when the request is redirected.
+     */
+    redirecting = false;
+    /**
+     * The response headers.
+     * The object may be empty when the response is not set.
+     */
+    currentHeaders = new Headers();
+    /**
+     * The response object build during the execution.
+     */
+    currentResponse;
+    /**
+     * Keeps the raw body in a temporary buffer while processing the response.
+     */
+    _rawBody;
+    stats = {};
+    auth;
+    mainResolver;
+    mainRejecter;
+    [mainPromiseSymbol];
+    _signal;
+    // CoreEngine specific properties
+    parser;
+    connectionManager;
+    authManager;
+    messageBuilder;
     hasProxy;
     isProxyTunnel;
     isProxySsl;
+    /**
+     * @return True if following redirects is allowed.
+     */
+    get followRedirects() {
+        const { opts } = this;
+        if (typeof opts.followRedirects === 'boolean') {
+            return opts.followRedirects;
+        }
+        return true;
+    }
+    /**
+     * The request timeout.
+     */
+    get timeout() {
+        const { opts } = this;
+        if (typeof opts.timeout === 'number') {
+            return opts.timeout;
+        }
+        return 0;
+    }
+    /**
+     * The abort signal to set on this request.
+     * Aborts the request when the signal fires.
+     */
+    get signal() {
+        return this._signal;
+    }
+    set signal(value) {
+        const old = this._signal;
+        if (old === value) {
+            return;
+        }
+        this._signal = value;
+        if (old) {
+            old.removeEventListener('abort', this._abortHandler);
+        }
+        if (value) {
+            value.addEventListener('abort', this._abortHandler);
+        }
+    }
     constructor(request, opts = {}) {
-        super(request, opts);
-        this.responseInfo = {
-            chunked: false,
-        };
+        super();
+        this.request = new HttpRequest({ ...request });
+        this.opts = opts;
+        this.logger = this.setupLogger(opts);
+        this.sentRequest = new SentRequest({ ...request, startTime: Date.now() });
+        this.uri = this.readUrl(request.url);
+        this.hostHeader = this.getHostHeader(request.url);
+        // CoreEngine specific initialization
         this.hasProxy = !!this.opts.proxy;
         this.isProxyTunnel = this.hasProxy && this.request.url.startsWith('https:');
         this.isProxySsl = !!this.opts.proxy && this.opts.proxy.startsWith('https:');
+        // Initialize the HTTP response parser
+        this.parser = new HttpResponseParser(this.logger, this.createParserCallbacks());
+        // Initialize the connection manager
+        this.connectionManager = new ConnectionManager(this.logger, this.stats);
+        // Initialize the auth manager
+        const proxyCredentials = {
+            proxyUsername: this.opts.proxyUsername,
+            proxyPassword: this.opts.proxyPassword,
+            proxyAuthorization: this.opts.proxyAuthorization,
+        };
+        this.authManager = new AuthManager({
+            logger: this.logger,
+            proxyCredentials,
+        });
+        // Initialize the message builder
+        this.messageBuilder = new MessageBuilder({
+            logger: this.logger,
+            request: this.request,
+            hasProxy: this.hasProxy,
+            isProxyTunnel: this.isProxyTunnel,
+            hostHeader: this.hostHeader,
+        });
+        this._abortHandler = this._abortHandler.bind(this);
+        if (opts.signal) {
+            this.signal = opts.signal;
+        }
+    }
+    /**
+     * Creates a logger object to log debug output.
+     */
+    setupLogger(opts = {}) {
+        if (opts.logger) {
+            return opts.logger;
+        }
+        return createLogger();
+    }
+    /**
+     * Updates the `uri` property from current request URL
+     */
+    readUrl(value) {
+        return readUrl(value, { hosts: this.opts.hosts });
+    }
+    /**
+     * Get host header for the request
+     */
+    getHostHeader(url) {
+        return getHostHeader(url, { hosts: this.opts.hosts });
+    }
+    /**
+     * Aborts current request.
+     * It emits `error` event
+     */
+    abort() {
+        this.logger.debug('Aborting the request...');
+        this.aborted = true;
+        if (!this.socket) {
+            return;
+        }
+        this.socket.removeAllListeners();
+        if (this.socket.destroyed) {
+            this.socket = undefined;
+            return;
+        }
+        this.socket.pause();
+        this.socket.destroy();
+        this.socket = undefined;
+    }
+    /**
+     * Handler for the `abort` event on the `AbortSignal`.
+     */
+    _abortHandler() {
+        const e = new SerializableError('Request aborted', 3);
+        this._errorRequest(e);
+        this.abort();
+    }
+    /**
+     * Create parser callbacks to handle parsed data
+     */
+    createParserCallbacks() {
+        return {
+            onStatusParsed: (status, statusText) => {
+                this.logger.debug('onStatusParsed called', status, statusText);
+                const response = Response.fromValues(status, statusText);
+                response.loadingTime = 0;
+                this.currentResponse = response;
+            },
+            onHeadersParsed: (headers) => {
+                this.logger.debug('onHeadersParsed called');
+                this.currentHeaders = headers;
+                if (this.currentResponse) {
+                    this.currentResponse.headers = headers.toString();
+                }
+            },
+            onBodyComplete: (body) => {
+                this.logger.debug('onBodyComplete called');
+                this._rawBody = body;
+                this._reportResponse().catch((error) => {
+                    this.logger.error('Error in _reportResponse:', error);
+                    this._errorRequest({
+                        message: `Response processing failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    });
+                });
+            },
+            onError: (error) => {
+                this.logger.debug('onError called', error);
+                this._errorRequest({
+                    message: error.message || 'Unknown error occurred',
+                });
+            },
+            onAbort: () => {
+                this.logger.debug('onAbort called');
+                this.abort();
+            },
+            emit: (event, detail) => {
+                this.logger.debug('emit called', event, detail);
+                this.emit(event, detail);
+            },
+        };
     }
     /**
      * Sends the request
@@ -51,19 +274,27 @@ export class CoreEngine extends HttpEngine {
     }
     async sendRequest() {
         try {
-            if (this.hasProxy) {
-                await this.connectProxy();
-            }
-            else {
-                await this.connect();
-            }
-            if (!this.socket || this.aborted) {
+            // Use the connection manager to establish the connection
+            const socket = await this.establishConnection();
+            if (!socket || this.aborted) {
                 return;
             }
             const message = await this.prepareMessage();
             await this.writeMessage(message);
         }
         catch (cause) {
+            if (cause instanceof ProxyAuthenticationError) {
+                this.currentHeaders = new Headers(cause.response.headers);
+                const currentResponse = Response.fromValues(cause.response.statusCode || 401, cause.response.statusMessage, this.currentHeaders.toString());
+                currentResponse.loadingTime = 0;
+                this.currentResponse = currentResponse;
+                if (cause.head.length) {
+                    this._rawBody = cause.head;
+                    currentResponse.payload = PayloadSerializer.stringifyBuffer(cause.head);
+                }
+                this._publishResponse();
+                return;
+            }
             const e = cause;
             const err = new SerializableError(e.message, { cause: e });
             if (e.code || e.code === 0) {
@@ -74,46 +305,371 @@ export class CoreEngine extends HttpEngine {
                 message: err.message,
                 code: err.code,
             });
-            throw cause;
+        }
+    }
+    /**
+     * Establish connection using the connection manager
+     */
+    async establishConnection() {
+        const port = getPort(this.uri.port, this.uri.protocol);
+        const host = this.uri.hostname;
+        const protocol = this.uri.protocol;
+        const socket = await this.connectionManager.createConnection(host, port, protocol, this.opts);
+        const { timeout } = this;
+        if (timeout > 0) {
+            socket.setTimeout(timeout);
+        }
+        this.socket = socket;
+        this._addSocketListeners(socket);
+        socket.resume();
+        return socket;
+    }
+    /**
+     * Decompresses received body if `content-encoding` header is set.
+     */
+    async decompress(body) {
+        return decompress(body, {
+            aborted: this.aborted,
+            headers: this.currentHeaders,
+        });
+    }
+    /**
+     * Prepares headers list to be send to the remote machine.
+     * If `defaultHeaders` option is set then it adds `user-agent` and `accept`
+     * headers.
+     */
+    prepareHeaders(headers, withPayload = false) {
+        if (this.opts.defaultHeaders) {
+            if (!headers.has('user-agent')) {
+                if (this.opts.defaultUserAgent) {
+                    headers.set('user-agent', this.opts.defaultUserAgent);
+                }
+                else {
+                    headers.set('user-agent', 'api client');
+                }
+            }
+            if (!headers.has('accept')) {
+                if (this.opts.defaultAccept) {
+                    headers.set('accept', this.opts.defaultAccept);
+                }
+                else {
+                    headers.set('accept', '*/*');
+                }
+            }
+        }
+        if (withPayload) {
+            if (!headers.has('content-type') && this.request.payloadOptions) {
+                if (this.request.payloadOptions.mime) {
+                    headers.set('content-type', this.request.payloadOptions.mime);
+                }
+            }
         }
     }
     /**
      * Cleans the state after finished.
      */
     _cleanUp() {
-        super._cleanUp();
-        this.state = RequestState.Status;
-        this.rawHeaders = undefined;
-        this.responseInfo = {
-            chunked: false,
-        };
+        this.redirects = [];
+        this.currentHeaders = new Headers();
+        this.currentResponse = undefined;
+        this._rawBody = undefined;
+        this.redirecting = false;
+        this.stats = {};
+        this.mainRejecter = undefined;
+        this.mainResolver = undefined;
+        this._clearSocketEventListeners();
+        this.parser.reset();
     }
     /**
      * Cleans up the state for redirect.
      */
     _cleanUpRedirect() {
-        super._cleanUpRedirect();
-        this.state = RequestState.Status;
-        this.rawHeaders = undefined;
-        this.responseInfo = {
-            chunked: false,
+        this.currentHeaders = new Headers();
+        this.currentResponse = undefined;
+        this._rawBody = undefined;
+        this.stats = {};
+        this._clearSocketEventListeners();
+        this.parser.reset();
+    }
+    /**
+     * Reports response when redirected.
+     */
+    _reportRedirect(status) {
+        const { request, currentHeaders } = this;
+        if (!currentHeaders) {
+            return false;
+        }
+        const rerUrl = currentHeaders.get('location');
+        // https://github.com/jarrodek/socket-fetch/issues/13
+        const redirectOptions = this.getRedirectOptions(status, request.method, rerUrl);
+        if (!redirectOptions.redirect) {
+            return false;
+        }
+        this.redirecting = true;
+        setTimeout(() => this._redirectRequest(redirectOptions));
+        return true;
+    }
+    /**
+     * Get redirect options based on status and method
+     */
+    getRedirectOptions(status, method, location) {
+        if (!location) {
+            return { redirect: false };
+        }
+        // 301, 302, 303, 307, 308 are redirect status codes
+        if (status >= 300 && status < 400) {
+            const forceGet = status === 301 || status === 302 || status === 303;
+            return { redirect: true, location, forceGet };
+        }
+        return { redirect: false };
+    }
+    /**
+     * Creates a response and adds it to the redirects list and redirects
+     * the request to the new location.
+     */
+    async _redirectRequest(options) {
+        if (this.followRedirects === false) {
+            this._publishResponse();
+            return;
+        }
+        const location = options.location && this.getRedirectLocation(options.location, this.request.url);
+        if (!location) {
+            this._errorRequest({ code: 302 });
+            return;
+        }
+        // check if this is infinite loop
+        if (this.isRedirectLoop(location, this.redirects)) {
+            this._errorRequest({ code: 310 });
+            return;
+        }
+        const detail = {
+            location,
+            returnValue: true,
         };
+        this.emit('beforeredirect', detail);
+        if (!detail.returnValue) {
+            this._publishResponse();
+            return;
+        }
+        try {
+            const responseCookies = this.currentHeaders.get('set-cookie');
+            const response = await this._createRedirectResponse(location);
+            this.redirects.push(response);
+            this._cleanUpRedirect();
+            if (responseCookies) {
+                this._processRedirectCookies(responseCookies, location);
+            }
+            this.redirecting = false;
+            this.request.url = location;
+            this.sentRequest.url = location;
+            if (options.forceGet) {
+                this.request.method = 'GET';
+            }
+            this.uri = this.readUrl(location);
+            this.hostHeader = this.getHostHeader(location);
+            // No idea why but without setTimeout the program loses it's
+            // scope after calling the function.
+            setTimeout(() => this.send());
+        }
+        catch (e) {
+            const error = e;
+            this._errorRequest({
+                message: (error && error.message) || 'Unknown error occurred',
+            });
+        }
+    }
+    /**
+     * Get redirect location
+     */
+    getRedirectLocation(location, currentUrl) {
+        return getRedirectLocation(location, currentUrl);
+    }
+    /**
+     * Check if redirect is a loop
+     */
+    isRedirectLoop(location, redirects) {
+        return isRedirectLoop(location, redirects);
+    }
+    /**
+     * @param location The redirect location.
+     * @return Redirect response object
+     */
+    async _createRedirectResponse(location) {
+        const { currentResponse = new Response() } = this;
+        const response = HttpResponse.fromValues(currentResponse.status, currentResponse.statusText, currentResponse.headers);
+        if (currentResponse.payload) {
+            response.payload = currentResponse.payload;
+        }
+        const body = await this.decompress(this._rawBody);
+        if (body) {
+            await response.writePayload(body);
+            currentResponse.payload = response.payload;
+        }
+        const redirect = ResponseRedirect.fromValues(location, response.toJSON(), this.stats.startTime, this.stats.responseTime);
+        redirect.timings = this._computeStats(this.stats);
+        return redirect;
+    }
+    /**
+     * Creates a response object
+     */
+    async _createResponse() {
+        if (this.aborted) {
+            throw new Error(`Request aborted.`);
+        }
+        const { currentResponse } = this;
+        if (!currentResponse) {
+            throw new Error(`Tried to create a response but no response data is set.`);
+        }
+        const { status } = currentResponse;
+        if (status === undefined) {
+            throw new Error(`The response status is empty.
+It means that the successful connection wasn't made.
+Check your request parameters.`);
+        }
+        const body = await this.decompress(this._rawBody);
+        const response = Response.fromValues(status, currentResponse.statusText, currentResponse.headers);
+        response.timings = this._computeStats(this.stats);
+        response.loadingTime = response.timings.total();
+        if (body) {
+            await response.writePayload(body);
+            currentResponse.payload = response.payload;
+        }
+        if (status === 401) {
+            this.logger.silly('Setting auth on the response...');
+            response.auth = this._getAuth();
+        }
+        return response;
+    }
+    /**
+     * Finishes the response with error message.
+     */
+    _errorRequest(opts) {
+        const { currentResponse } = this;
+        this.aborted = true;
+        let message;
+        if (opts.code && !opts.message) {
+            message = getCodeMessage(opts.code);
+        }
+        else if (opts.message) {
+            message = opts.message;
+        }
+        message = message || 'Unknown error occurred';
+        const error = new SerializableError(message, opts.code);
+        const log = RequestLog.fromRequest(this.sentRequest.toJSON());
+        const response = ErrorResponse.fromError(error);
+        log.response = response;
+        if (currentResponse && currentResponse.status) {
+            response.status = currentResponse.status;
+            response.statusText = currentResponse.statusText;
+            response.headers = currentResponse.headers;
+            response.payload = currentResponse.payload;
+        }
+        this.finalizeRequest(log);
+        this._cleanUp();
+    }
+    /**
+     * Generates authorization info object from response.
+     */
+    _getAuth() {
+        this.logger.debug('Getting auth from response headers');
+        let auth = this.currentHeaders.get('www-authenticate');
+        const result = new ResponseAuthorization();
+        if (auth) {
+            this.logger.silly('Auth header found', auth);
+            auth = auth.toLowerCase();
+            if (auth.indexOf('ntlm') !== -1) {
+                this.logger.silly('Detected NTLM authorization');
+                result.method = 'ntlm';
+            }
+            else if (auth.indexOf('basic') !== -1) {
+                result.method = 'basic';
+                this.logger.silly('Detected basic authorization');
+            }
+            else if (auth.indexOf('digest') !== -1) {
+                result.method = 'digest';
+                this.logger.silly('Detected digest authorization');
+            }
+        }
+        return result;
+    }
+    /**
+     * Creates HAR 1.2 timings object from stats.
+     */
+    _computeStats(stats) {
+        return computeStats(stats);
+    }
+    /**
+     * Handles cookie exchange when redirecting the request.
+     */
+    _processRedirectCookies(responseCookies, location) {
+        this.request.headers = processRedirectCookies(responseCookies, location, this.request.url, this.request.toHeadersString());
+    }
+    /**
+     * Checks certificate identity using TLS api.
+     */
+    _checkServerIdentity(host, cert) {
+        return checkServerIdentity(host, cert);
+    }
+    /**
+     * Clears event listeners of the socket object,
+     */
+    _clearSocketEventListeners() {
+        if (!this.socket) {
+            return;
+        }
+        this.socket.removeAllListeners('error');
+        this.socket.removeAllListeners('timeout');
+        this.socket.removeAllListeners('end');
+    }
+    /**
+     * Called with the `send()` function to initialize the main promise returned by the send function.
+     * The send function returns a promise that is resolved when the request finish.
+     */
+    wrapExecution() {
+        let promise;
+        if (this[mainPromiseSymbol]) {
+            promise = this[mainPromiseSymbol];
+        }
+        else {
+            promise = new Promise((resolve, reject) => {
+                this.mainResolver = resolve;
+                this.mainRejecter = reject;
+            });
+            this[mainPromiseSymbol] = promise;
+        }
+        return promise;
+    }
+    /**
+     * Called by the request finalizer or error finalized to report the response.
+     */
+    finalizeRequest(log) {
+        const { mainRejecter, mainResolver } = this;
+        if (!mainRejecter || !mainResolver) {
+            return;
+        }
+        if (log instanceof SerializableError) {
+            mainRejecter(log);
+        }
+        else {
+            mainResolver(log.toJSON());
+        }
+        this.mainRejecter = undefined;
+        this.mainResolver = undefined;
+        this[mainPromiseSymbol] = undefined;
     }
     /**
      * Prepares an HTTP message from API Client's request object.
-     *
-     * @returns Resolved promise to an `ArrayBuffer`.
      */
     async prepareMessage() {
         let payload = this.request.payload;
-        if (['get', 'head'].includes(this.request.method.toLowerCase())) {
+        if (isMethodWithoutBody(this.request.method)) {
             payload = undefined;
         }
         const headers = new Headers(this.request.toHeadersString());
         this.prepareHeaders(headers, !!payload);
         const auth = this.hasProxy && !this.isProxyTunnel ? this._proxyAuthHeader() : undefined;
         if (auth) {
-            headers.set('proxy-authorization', auth);
+            headers.set(HEADER_PROXY_AUTHORIZATION, auth);
         }
         const buffer = PayloadSupport.payloadToBuffer(headers, payload);
         if (buffer) {
@@ -121,7 +677,9 @@ export class CoreEngine extends HttpEngine {
         }
         this._handleAuthorization(headers);
         this.sentRequest.headers = headers.toString();
-        const message = this._prepareMessage(headers, buffer);
+        // Update message builder with current host header
+        this.messageBuilder.updateHostHeader(this.hostHeader || '');
+        const message = this.messageBuilder.buildMessage(headers, buffer);
         if (this.auth) {
             // This restores altered by authorization original headers
             // so it can be safe to use when redirecting
@@ -134,15 +692,13 @@ export class CoreEngine extends HttpEngine {
     }
     /**
      * Sends a data to a socket.
-     *
-     * @param buffer HTTP message to send
      */
     writeMessage(buffer) {
         this.logger.debug(`Writing the message to the socket...`);
         let msg = buffer.toString();
         const limit = this.opts.sentMessageLimit;
         if (limit && limit > 0 && msg.length >= limit) {
-            msg = msg.substr(0, limit);
+            msg = msg.substring(0, limit);
             msg += ' ...';
         }
         this.sentRequest.httpMessage = msg;
@@ -164,241 +720,26 @@ export class CoreEngine extends HttpEngine {
             });
         });
     }
-    /**
-     * Connects to a server and sends the message.
-     *
-     * @returns Promise resolved when socket is connected.
-     */
-    async connect() {
-        const port = getPort(this.uri.port, this.uri.protocol);
-        const host = this.uri.hostname;
-        let socket;
-        if (port === 443 || this.uri.protocol === 'https:') {
-            socket = await this._connectTls(port, host);
-        }
-        else {
-            socket = await this._connect(port, host);
-        }
-        const { timeout } = this;
-        if (timeout > 0) {
-            socket.setTimeout(timeout);
-        }
-        this.socket = socket;
-        this._addSocketListeners(socket);
-        socket.resume();
-        return socket;
-    }
-    /**
-     * Connects to a server and writes a message using insecure connection.
-     *
-     * @param port A port number to connect to.
-     * @param host A host name to connect to
-     * @returns A promise resolved when the message was sent to a server
-     */
-    _connect(port, host) {
-        this.logger.debug('Opening an HTTP connection...');
-        return new Promise((resolve, reject) => {
-            this.stats.connectionTime = Date.now();
-            const isIp = net.isIP(host);
-            if (isIp) {
-                this.stats.lookupTime = Date.now();
-            }
-            const client = net.createConnection(port, host, () => {
-                this.logger.debug('HTTP connection established.');
-                this.stats.connectedTime = Date.now();
-                resolve(client);
-            });
-            client.pause();
-            if (!isIp) {
-                client.once('lookup', () => {
-                    this.stats.lookupTime = Date.now();
-                });
-            }
-            client.once('error', (err) => reject(err));
-        });
-    }
-    /**
-     * Connects to a server and writes a message using secured connection.
-     *
-     * @param port A port number to connect to.
-     * @param host A host name to connect to
-     * @returns A promise resolved when the message was sent to a server
-     */
-    _connectTls(port, host) {
-        this.logger.debug('Opening an SSL connection...');
-        const { opts } = this;
-        const options = {};
-        const isIp = net.isIP(host);
-        if (!isIp) {
-            options.servername = host;
-        }
-        if (opts.validateCertificates) {
-            options.checkServerIdentity = this._checkServerIdentity.bind(this);
-        }
-        else {
-            options.rejectUnauthorized = false;
-            options.checkServerIdentity = () => {
-                return undefined;
-            };
-            // target.requestOCSP = false;
-        }
-        const certs = this.opts.certificates;
-        if (Array.isArray(certs)) {
-            certs.forEach((cert) => this._addClientCertificate(cert, options));
-        }
-        return new Promise((resolve, reject) => {
-            const time = Date.now();
-            this.stats.connectionTime = time;
-            if (isIp) {
-                this.stats.lookupTime = time;
-            }
-            const client = tls.connect(port, host, options, () => {
-                this.logger.debug('SSL connection established.');
-                const connectTime = Date.now();
-                this.stats.connectedTime = connectTime;
-                this.stats.secureStartTime = connectTime;
-                resolve(client);
-            });
-            client.pause();
-            client.once('error', (e) => reject(e));
-            if (!isIp) {
-                client.once('lookup', () => {
-                    this.stats.lookupTime = Date.now();
-                });
-            }
-            client.once('secureConnect', () => {
-                this.stats.secureConnectedTime = Date.now();
-            });
-        });
-    }
-    /**
-     * Prepares a full HTTP message body
-     *
-     * @param httpHeaders The list ogf headers to append.
-     * @param buffer The buffer with the HTTP message
-     * @returns The Buffer of the HTTP message
-     */
-    _prepareMessage(httpHeaders, buffer) {
-        this.logger.debug('Preparing an HTTP message...');
-        const headers = [];
-        // const search = this.uri.search;
-        // let path = this.uri.pathname;
-        // if (search) {
-        //   path += search;
-        // }
-        // headers.push(`${this.arcRequest.method} ${path} HTTP/1.1`);
-        const status = this._createHttpStatus();
-        this.logger.debug(`Created message status: ${status}`);
-        headers.push(status);
-        if (this._hostRequired()) {
-            this.logger.debug(`Adding the "host" header: ${this.hostHeader}`);
-            headers.push(`Host: ${this.hostHeader}`);
-        }
-        let str = headers.join('\r\n');
-        const addHeaders = httpHeaders.toString();
-        if (addHeaders) {
-            this.logger.debug(`Adding headers to the request...`);
-            str += '\r\n';
-            str += PayloadSupport.normalizeString(addHeaders);
-        }
-        const startBuffer = Buffer.from(str, 'utf8');
-        const endBuffer = Buffer.from(new Uint8Array([13, 10, 13, 10]));
-        let body;
-        let sum = startBuffer.length + endBuffer.length;
-        if (buffer) {
-            sum += buffer.length;
-            body = Buffer.concat([startBuffer, endBuffer, buffer], sum);
-        }
-        else {
-            body = Buffer.concat([startBuffer, endBuffer], sum);
-        }
-        this.logger.debug(`The message is ready.`);
-        return body;
-    }
-    /**
-     * Creates an HTTP status line for the message.
-     * For proxy connections it, depending whether target is SSL or not, sets the path
-     * as the full URL or just the authority.
-     * @returns The generates status message.
-     */
-    _createHttpStatus() {
-        const { request, uri, hasProxy, isProxyTunnel } = this;
-        const parts = [request.method];
-        if (hasProxy && !isProxyTunnel) {
-            // if (isProxyTunnel) {
-            //   // when a tunnel then the target is over SSL so the default port is 443.
-            //   parts.push(`${uri.hostname}:${uri.port || 443}`);
-            // } else {
-            //   parts.push(arcRequest.url);
-            // }
-            parts.push(request.url);
-        }
-        else {
-            let path = uri.pathname;
-            if (uri.search) {
-                path += uri.search;
-            }
-            parts.push(path);
-        }
-        parts.push('HTTP/1.1');
-        return parts.join(' ');
-    }
-    /**
-     * Tests if current connection is required to add `host` header.
-     * It returns `false` only if `host` header has been already provided.
-     *
-     * @returns True when the `host` header should be added to the headers list.
-     */
-    _hostRequired() {
-        const headers = this.request.headers;
-        if (typeof headers !== 'string') {
-            return true;
-        }
-        return !this._hostTestReg.test(headers);
-    }
     /**
      * Alters authorization header depending on the `auth` object
-     * @param headers A headers object where to append headers when needed
      */
     _handleAuthorization(headers) {
         const { authorization } = this.opts;
-        const enabled = Array.isArray(authorization) ? authorization.filter((i) => i.enabled) : [];
-        if (!enabled.length) {
-            return;
-        }
-        const ntlm = enabled.find((i) => i.type === 'ntlm');
-        if (ntlm) {
-            this._authorizeNtlm(ntlm.config, headers);
+        this.authManager.handleRequestAuthorization(headers, authorization, this.uri.host);
+        // Sync the auth state from AuthManager to parent class for compatibility
+        const authState = this.authManager.getAuthState();
+        if (authState) {
+            this.auth = authState;
         }
     }
     /**
-     * Authorize the request with NTLM
-     * @param authData Credentials to use
-     * @param headers A headers object where to append headers if needed
+     * Generate proxy authorization header
      */
-    _authorizeNtlm(authData, headers) {
-        const init = { ...authData, url: this.request.url };
-        const auth = new NtlmAuth(init);
-        if (!this.auth) {
-            this.auth = {
-                method: 'ntlm',
-                state: 0,
-                headers: headers.toString(),
-            };
-            const msg = auth.createMessage1(this.uri.host);
-            headers.set('Authorization', `NTLM ${msg.toBase64()}`);
-            headers.set('Connection', 'keep-alive');
-        }
-        else if (this.auth && this.auth.state === 1) {
-            const msg = auth.createMessage3(this.auth.challengeHeader, this.uri.host);
-            this.auth.state = 2;
-            headers.set('Authorization', `NTLM ${msg.toBase64()}`);
-        }
+    _proxyAuthHeader() {
+        return this.authManager.generateProxyAuthHeader();
     }
     /**
      * Add event listeners to existing socket.
-     * @param socket An instance of the socket.
-     * @return The same socket. Used for chaining.
      */
     _addSocketListeners(socket) {
         let received = false;
@@ -412,9 +753,12 @@ export class CoreEngine extends HttpEngine {
             }
             data = Buffer.from(data);
             try {
-                this._processSocketMessage(data);
+                // Use the new parser instead of the old parsing methods
+                this.parser.processData(data);
+                this.logger.debug('Parser state:', this.parser.getState());
             }
             catch (e) {
+                this.logger.error('Error in _addSocketListeners:', e);
                 const err = e;
                 this._errorRequest({
                     message: err.message || 'Unknown error occurred',
@@ -423,50 +767,44 @@ export class CoreEngine extends HttpEngine {
             }
         });
         socket.once('timeout', () => {
-            this.state = RequestState.Done;
-            this._errorRequest(new Error('Connection timeout.'));
+            this.logger.debug(`Socket timeout occurred after ${this.timeout}ms.`);
+            this.parser.abort();
+            this._errorRequest(HttpEngineErrorFactory.connectionTimeout(this.timeout));
             socket.destroy();
         });
         socket.on('end', () => {
+            const endTime = Date.now();
             this.logger.debug(`Server connection ended.`);
             socket.removeAllListeners('timeout');
             socket.removeAllListeners('error');
-            const endTime = Date.now();
+            socket.removeAllListeners('data');
             this.stats.lastReceivedTime = endTime;
             this.sentRequest.endTime = endTime;
-            if (this.state !== RequestState.Done) {
+            // console.log(`Socket ended at ${endTime} in state`, this.parser.getState())
+            if (this.parser.getState() !== RequestState.Done) {
                 if (!this.currentResponse) {
-                    this.logger.error(`Connection closed without receiving any data.`);
-                    // The parser haven't found the end of message so there was no message!
-                    const e = new SerializableError('Connection closed without receiving any data', 100);
+                    const message = `Connection closed without receiving any data.`;
+                    this.logger.error(message);
+                    const e = HttpEngineErrorFactory.connectionError(message, 100);
                     this._errorRequest(e);
                 }
                 else {
-                    // There is an issue with the response. Size mismatch? Anyway,
-                    // it tries to create a response from current data.
                     this.emit('loadend');
                     this._publishResponse();
                 }
             }
         });
         socket.once('error', (err) => {
+            this.logger.error(`Socket error occurred: ${err.message}`);
             socket.removeAllListeners('timeout');
             this._errorRequest(err);
         });
         return socket;
     }
-    /**
-     * Processes response message chunk
-     * @param buffer Message buffer
-     */
-    _processResponse(buffer) {
-        this._processSocketMessage(buffer);
-        this._reportResponse();
-    }
     /**
      * Reports response after processing it.
      */
-    _reportResponse() {
+    async _reportResponse() {
         this._clearSocketEventListeners();
         const { aborted, currentResponse } = this;
         if (aborted || !currentResponse) {
@@ -476,607 +814,115 @@ export class CoreEngine extends HttpEngine {
         const endTime = Date.now();
         this.stats.lastReceivedTime = endTime;
         this.sentRequest.endTime = endTime;
-        if (status >= 300 && status < 400) {
-            if (this.followRedirects && this._reportRedirect(status)) {
-                this.closeClient();
-                return;
-            }
-        }
-        else if (status === 401 && this.auth) {
-            switch (this.auth.method) {
-                case 'ntlm':
-                    this.handleNtlmResponse();
+        const result = processResponse({
+            status,
+            currentResponse,
+            currentHeaders: this.currentHeaders,
+            followRedirects: this.followRedirects,
+            auth: this.auth,
+            aborted: this.aborted,
+        });
+        switch (result.action) {
+            case 'redirect':
+                if (this._reportRedirect(status)) {
+                    this.closeClient();
                     return;
-            }
+                }
+                break;
+            case 'auth':
+                if (result.data?.method === 'ntlm') {
+                    await this.handleNtlmResponse();
+                    return;
+                }
+                break;
+            case 'publish':
+                this.closeClient();
+                this.emit('loadend');
+                this._publishResponse();
+                break;
+            case 'abort':
+                // Already aborted, do nothing
+                break;
         }
-        this.closeClient();
-        this.emit('loadend');
-        this._publishResponse();
     }
     /**
      * Generate response object and publish it to the listeners.
      */
-    _publishResponse() {
-        this.state = RequestState.Done;
-        if (!this._rawBody) {
-            if (this.responseInfo.body) {
-                this._rawBody = this.responseInfo.body;
-            }
-            else if (this.responseInfo.chunk) {
-                this._rawBody = this.responseInfo.chunk;
-            }
+    async _publishResponse() {
+        if (this.aborted) {
+            return;
         }
-        return super._publishResponse();
-    }
-    /**
-     * @param location The redirect location.
-     * @return Redirect response object
-     */
-    async _createRedirectResponse(location) {
-        const { currentResponse = new Response() } = this;
-        this.currentResponse = currentResponse;
-        if (!this.currentResponse.payload) {
-            if (this._rawBody) {
-                this.currentResponse.payload = PayloadSerializer.stringifyBuffer(this._rawBody);
-            }
-            else if (this.responseInfo.body) {
-                this.currentResponse.payload = PayloadSerializer.stringifyBuffer(this.responseInfo.body);
-            }
-            else if (this.responseInfo.chunk) {
-                this.currentResponse.payload = PayloadSerializer.stringifyBuffer(this.responseInfo.chunk);
+        try {
+            const response = await this._createResponse();
+            const result = RequestLog.fromRequestResponse(this.sentRequest.toJSON(), response.toJSON());
+            if (this.redirects.length) {
+                result.redirects = this.redirects;
+            }
+            result.size = new RequestsSize();
+            if (this.sentRequest.httpMessage) {
+                result.size.request = Buffer.from(this.sentRequest.httpMessage).length;
+            }
+            if (response.payload) {
+                if (typeof response.payload === 'string') {
+                    result.size.response = response.payload.length;
+                }
+                else {
+                    result.size.response = response.payload.data.length;
+                }
             }
+            this.finalizeRequest(result);
         }
-        return super._createRedirectResponse(location);
+        catch (e) {
+            const error = e;
+            this.logger.error('Error in _publishResponse:', error);
+            this._errorRequest({
+                message: (error && error.message) || 'Unknown error occurred',
+            });
+        }
+        this.abort();
+        this._cleanUp();
     }
     /**
      * closes the connection, if any
      */
     closeClient() {
         if (this.socket && !this.socket.destroyed) {
+            this.logger.debug('Closing the socket connection...');
             this.socket.destroy();
         }
     }
     /**
      * Handles the response with NTLM authorization
      */
-    handleNtlmResponse() {
-        const { auth } = this;
-        if (!auth) {
-            throw new Error('No auth data.');
-        }
-        if (auth.state === 0) {
-            if (this.currentHeaders.has('www-authenticate')) {
-                auth.state = 1;
-                auth.challengeHeader = this.currentHeaders.get('www-authenticate');
-                this._cleanUpRedirect();
-                this.prepareMessage().then((message) => this.writeMessage(message));
-                return;
+    async handleNtlmResponse() {
+        this.logger.debug('Handling NTLM response...');
+        this.logger.debug('Current headers:', this.currentHeaders?.toString());
+        this.logger.debug('Auth state:', this.authManager.getAuthState());
+        const shouldRetry = this.authManager.handleNtlmResponse(this.currentHeaders);
+        this.logger.debug('Should retry NTLM:', shouldRetry);
+        if (shouldRetry) {
+            // Update the parent auth state to match AuthManager state
+            this.auth = this.authManager.getAuthState();
+            this._cleanUpRedirect();
+            try {
+                const message = await this.prepareMessage();
+                await this.writeMessage(message);
+                // Don't return here - let the socket listeners handle the response
+            }
+            catch (error) {
+                this.logger.error('Failed to retry NTLM authentication:', error);
+                this._errorRequest({
+                    message: `NTLM retry failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                });
             }
+            return;
         }
+        this.logger.debug('NTLM authentication completed');
+        // Clear both auth states
+        this.authManager.clearAuthState();
         delete this.auth;
         this.emit('loadend');
         this._publishResponse();
     }
-    /**
-     * Process received message.
-     *
-     * @param data Received message.
-     */
-    _processSocketMessage(data) {
-        if (this.aborted) {
-            return;
-        }
-        if (this.state === RequestState.Done) {
-            return;
-        }
-        let remaining = data;
-        if (this.state === RequestState.Status) {
-            remaining = this._processStatus(remaining);
-            if (!remaining) {
-                return;
-            }
-        }
-        if (this.state === RequestState.Headers) {
-            remaining = this._processHeaders(remaining);
-            if (!remaining) {
-                return;
-            }
-        }
-        if (this.state === RequestState.Body) {
-            this._processBody(remaining);
-            return;
-        }
-    }
-    /**
-     * Read status line from the response.
-     * This function will set `status` and `statusText` fields
-     * and then will set `state` to HEADERS.
-     *
-     * @param data The received data
-     */
-    _processStatus(data) {
-        if (this.aborted) {
-            return;
-        }
-        const response = Response.fromValues(0);
-        response.loadingTime = 0;
-        this.currentResponse = response;
-        if (!data) {
-            return;
-        }
-        this.logger.info('Processing status');
-        const index = data.indexOf(nlBuffer);
-        let statusLine = data.slice(0, index).toString();
-        data = data.slice(index + 2);
-        statusLine = statusLine.replace(/HTTP\/\d(\.\d)?\s/, '');
-        const delimiterPos = statusLine.indexOf(' ');
-        let status;
-        let msg = '';
-        if (delimiterPos === -1) {
-            status = statusLine;
-        }
-        else {
-            status = statusLine.substr(0, delimiterPos);
-            msg = statusLine.substr(delimiterPos + 1);
-        }
-        let typedStatus = Number(status);
-        if (Number.isNaN(typedStatus)) {
-            typedStatus = 0;
-        }
-        if (msg && msg.indexOf('\n') !== -1) {
-            msg = msg.split('\n')[0];
-        }
-        const cr = this.currentResponse;
-        cr.status = typedStatus;
-        cr.statusText = msg;
-        this.logger.info('Received status', typedStatus, msg);
-        this.state = RequestState.Headers;
-        return data;
-    }
-    /**
-     * Read headers from the received data.
-     *
-     * @param data Received data
-     * @returns Remaining data in the buffer.
-     */
-    _processHeaders(data) {
-        if (this.aborted) {
-            return;
-        }
-        if (!data) {
-            this._parseHeaders();
-            return;
-        }
-        this.logger.info('Processing headers');
-        // Looking for end of headers section
-        let index = data.indexOf(nlNlBuffer);
-        let padding = 4;
-        if (index === -1) {
-            // It can also be 2x ASCII 10
-            const _index = data.indexOf(Buffer.from([10, 10]));
-            if (_index !== -1) {
-                index = _index;
-                padding = 2;
-            }
-        }
-        // https://github.com/jarrodek/socket-fetch/issues/3
-        const enterIndex = data.indexOf(nlBuffer);
-        if (index === -1 && enterIndex !== 0) {
-            // end in next chunk
-            if (!this.rawHeaders) {
-                this.rawHeaders = data;
-            }
-            else {
-                const sum = this.rawHeaders.length + data.length;
-                this.rawHeaders = Buffer.concat([this.rawHeaders, data], sum);
-            }
-            return;
-        }
-        if (enterIndex !== 0) {
-            const headersArray = data.slice(0, index);
-            if (!this.rawHeaders) {
-                this.rawHeaders = headersArray;
-            }
-            else {
-                const sum = this.rawHeaders.length + headersArray.length;
-                this.rawHeaders = Buffer.concat([this.rawHeaders, headersArray], sum);
-            }
-        }
-        this._parseHeaders(this.rawHeaders);
-        delete this.rawHeaders;
-        this.state = RequestState.Body;
-        const start = index === -1 ? 0 : index;
-        const move = enterIndex === 0 ? 2 : padding;
-        data = data.slice(start + move);
-        return this._postHeaders(data);
-    }
-    /**
-     * Check the response headers and end the request if necessary.
-     * @param data Current response data buffer
-     */
-    _postHeaders(data) {
-        if (this.request.method === 'HEAD') {
-            this._reportResponse();
-            return;
-        }
-        if (data.length === 0) {
-            if (this.currentResponse?.status === 204) {
-                this._reportResponse();
-                return;
-            }
-            if (this.currentHeaders.has('Content-Length')) {
-                // If the server do not close the connection and clearly indicate that
-                // there are no further data to receive the app can close the connection
-                // and prepare the response.
-                const length = Number(this.currentHeaders.get('Content-Length'));
-                if (!Number.isNaN(length) && length === 0) {
-                    this._reportResponse();
-                    return;
-                }
-            }
-            // See: https://github.com/advanced-rest-client/arc-electron/issues/106
-            // The client should wait until the connection is closed instead of assuming it should end the request.
-            //  else if (!this.currentHeaders.has('Transfer-Encoding') || !this.currentHeaders.get('Transfer-Encoding')) {
-            //   // Fix for https://github.com/jarrodek/socket-fetch/issues/6
-            //   // There is no body in the response.
-            //   // this._reportResponse();
-            //   return;
-            // }
-            return;
-        }
-        return data;
-    }
-    /**
-     * This function assumes that all headers has been read and it's
-     * just before changing the status to BODY.
-     */
-    _parseHeaders(buffer) {
-        let raw = '';
-        if (buffer) {
-            raw = buffer.toString();
-        }
-        ;
-        this.currentResponse.headers = raw;
-        this.logger.info('Received headers list', raw);
-        const headers = new Headers(raw);
-        this.currentHeaders = headers;
-        if (headers.has('Content-Length')) {
-            this.responseInfo.contentLength = Number(headers.get('Content-Length'));
-        }
-        if (headers.has('Transfer-Encoding')) {
-            const tr = headers.get('Transfer-Encoding');
-            if (tr === 'chunked') {
-                this.responseInfo.chunked = true;
-            }
-        }
-        const rawHeaders = headers.toString();
-        const detail = {
-            returnValue: true,
-            value: rawHeaders,
-        };
-        this.emit('headersreceived', detail);
-        if (!detail.returnValue) {
-            this.abort();
-        }
-    }
-    /**
-     * @param data A data to process
-     */
-    _processBody(data) {
-        if (this.aborted || !data) {
-            return;
-        }
-        if (this.responseInfo.chunked) {
-            this._processBodyChunked(data);
-        }
-        else {
-            this._processBodyContentLength(data);
-        }
-    }
-    _processBodyContentLength(data) {
-        if (typeof this.responseInfo.contentLength === 'undefined') {
-            this._errorRequest(new Error(`The content-length header of the response is missing.`));
-            return;
-        }
-        if (!this.responseInfo.body) {
-            this.responseInfo.body = data;
-            if (data.length >= this.responseInfo.contentLength) {
-                this._reportResponse();
-                return;
-            }
-            return;
-        }
-        const sum = this.responseInfo.body.length + data.length;
-        this.responseInfo.body = Buffer.concat([this.responseInfo.body, data], sum);
-        if (this.responseInfo.body.length >= this.responseInfo.contentLength) {
-            this._reportResponse();
-            return;
-        }
-    }
-    /**
-     * @param data A latest data to process
-     */
-    _processBodyChunked(data) {
-        if (!data) {
-            return;
-        }
-        if (this.responseInfo.chunk) {
-            data = Buffer.concat([this.responseInfo.chunk, data], this.responseInfo.chunk.length + data.length);
-            this.responseInfo.chunk = undefined;
-        }
-        while (true) {
-            if (this.responseInfo.chunkSize === 0 && data.indexOf(nlNlBuffer) === 0) {
-                this._reportResponse();
-                return;
-            }
-            if (!this.responseInfo.chunkSize) {
-                data = this.readChunkSize(data);
-                if (!data) {
-                    return;
-                }
-                if (!this.responseInfo.chunkSize && this.responseInfo.chunkSize !== 0) {
-                    // It may happen that node's buffer cuts the data
-                    // just before the chunk size.
-                    // It should proceed it in next portion of the data.
-                    this.responseInfo.chunk = data;
-                    return;
-                }
-                if (!this.responseInfo.chunkSize) {
-                    this._reportResponse();
-                    return;
-                }
-            }
-            const size = Math.min(this.responseInfo.chunkSize, data.length);
-            const sliced = data.slice(0, size);
-            if (!this._rawBody) {
-                this._rawBody = sliced;
-            }
-            else {
-                const sum = size + this._rawBody.length;
-                this._rawBody = Buffer.concat([this._rawBody, sliced], sum);
-            }
-            this.responseInfo.chunkSize -= size;
-            if (data.length === 0) {
-                // this.logger.warn('Next chunk will start with CRLF!');
-                return;
-            }
-            data = data.slice(size + 2); // + CR
-            if (data.length === 0) {
-                // this.logger.info('No more data here. Waiting for new chunk');
-                return;
-            }
-        }
-    }
-    /**
-     * If response's Transfer-Encoding is 'chunked' read until next CR.
-     * Everything before it is a chunk size.
-     */
-    readChunkSize(array) {
-        if (this.aborted) {
-            return;
-        }
-        let index = array.indexOf(nlBuffer);
-        if (index === -1) {
-            // not found in this portion of data.
-            return array;
-        }
-        if (index === 0) {
-            // Node's buffer cuts CRLF after the end of chunk data, without last CLCR,
-            // here's to fix it.
-            // It can be either new line from the last chunk or end of
-            // the message where
-            // the rest of the array is [13, 10, 48, 13, 10, 13, 10]
-            if (array.indexOf(nlNlBuffer) === 0) {
-                this.responseInfo.chunkSize = 0;
-                return Buffer.alloc(0);
-            }
-            array = array.slice(index + 2);
-            index = array.indexOf(nlBuffer);
-        }
-        // this.logger.info('Size index: ', index);
-        const chunkSize = parseInt(array.slice(0, index).toString(), 16);
-        if (Number.isNaN(chunkSize)) {
-            this.responseInfo.chunkSize = undefined;
-            return array.slice(index + 2);
-        }
-        this.responseInfo.chunkSize = chunkSize;
-        return array.slice(index + 2);
-    }
-    /**
-     * Connects to a server through a proxy. Depending on the proxy type the returned socket
-     * is a socket created after creating a tunnel (SSL) or the proxy socket.
-     *
-     * @returns Promise resolved when socket is connected.
-     */
-    async connectProxy() {
-        let socket;
-        if (this.isProxyTunnel) {
-            socket = await this.connectTunnel(this.isProxySsl);
-        }
-        else {
-            socket = await this.proxyHttp(this.isProxySsl);
-        }
-        if (!socket) {
-            return;
-        }
-        const { timeout } = this;
-        if (timeout > 0) {
-            socket.setTimeout(timeout);
-        }
-        this.socket = socket;
-        this._addSocketListeners(socket);
-        socket.resume();
-        return socket;
-    }
-    /**
-     * Creates a tunnel to a Proxy for SSL connections.
-     * The returned socket is the one created after the tunnel is established.
-     * @param proxyIsSsl Whether the proxy is an SSL connection.
-     * @returns Promise resolved when socket is connected.
-     */
-    async connectTunnel(proxyIsSsl = false) {
-        this.logger.debug(`Creating a tunnel through the proxy...`);
-        const { proxy } = this.opts;
-        const { url } = this.request;
-        if (!proxy) {
-            throw new Error(`No proxy configuration found.`);
-        }
-        let proxyUrl = proxy;
-        if (proxyIsSsl && !proxyUrl.startsWith('https:')) {
-            proxyUrl = `https://${proxyUrl}`;
-        }
-        else if (!proxyIsSsl && !proxyUrl.startsWith('http:')) {
-            proxyUrl = `http://${proxyUrl}`;
-        }
-        const proxyUri = new URL(proxyUrl);
-        const targetUrl = new URL(url);
-        const proxyPort = proxyUri.port || (proxyIsSsl ? 443 : 80);
-        const targetPort = targetUrl.port || 443; // target is always SSL so 443.
-        const authority = `${targetUrl.hostname}:${targetPort}`;
-        const connectOptions = {
-            host: proxyUri.hostname,
-            port: proxyPort,
-            method: 'CONNECT',
-            path: authority,
-            headers: {
-                host: authority,
-            },
-        };
-        if (proxyIsSsl) {
-            connectOptions.rejectUnauthorized = false;
-            // @ts-expect-error This is correct!
-            connectOptions.requestOCSP = false;
-        }
-        const auth = this._proxyAuthHeader();
-        if (auth) {
-            this.logger.debug(`Adding proxy authorization.`);
-            connectOptions.headers['proxy-authorization'] = auth;
-        }
-        const lib = proxyIsSsl ? https : http;
-        return new Promise((resolve, reject) => {
-            this.stats.connectionTime = Date.now();
-            const connectRequest = lib.request(connectOptions);
-            connectRequest.once('socket', (socket) => {
-                socket.on('lookup', () => {
-                    this.stats.lookupTime = Date.now();
-                });
-            });
-            connectRequest.on('error', (err) => {
-                this.logger.error('Error establishing proxy tunnel:', err);
-                reject(new SerializableError(`Failed to establish proxy tunnel: ${err.message}`, err.code ? Number(err.code) : 111));
-            });
-            connectRequest.on('connect', async (res, socket, head) => {
-                const time = Date.now();
-                this.stats.connectedTime = time;
-                this.stats.secureStartTime = time;
-                if (typeof this.stats.lookupTime === 'undefined') {
-                    this.stats.lookupTime = time;
-                }
-                if (res.statusCode === 401) {
-                    this.currentHeaders = new Headers(res.headers);
-                    const currentResponse = Response.fromValues(res.statusCode, res.statusMessage, this.currentHeaders.toString());
-                    currentResponse.loadingTime = 0;
-                    this.currentResponse = currentResponse;
-                    if (head.length) {
-                        this._rawBody = head;
-                        currentResponse.payload = PayloadSerializer.stringifyBuffer(head);
-                    }
-                    connectRequest.destroy();
-                    resolve(undefined);
-                    setTimeout(() => {
-                        // const e = new NetError('The proxy requires authentication.', 127);
-                        this._publishResponse();
-                    });
-                }
-                else if (res.statusCode === 407) {
-                    await this.handleProxyAuthentication(res, socket);
-                }
-                else if (res.statusCode !== 200) {
-                    this.logger.debug(`The proxy tunnel ended with ${res.statusCode} status code. Erroring request.`);
-                    connectRequest.destroy();
-                    const errorMessage = res.statusMessage || `Proxy tunnel establishment failed with status code ${res.statusCode}`;
-                    const e = new SerializableError(errorMessage, res.statusCode);
-                    reject(e);
-                }
-                else {
-                    this.logger.debug(`Established a proxy tunnel.`);
-                    this.logger.debug(`Upgrading connection to SSL...`);
-                    const tlsSocket = tls.connect({ socket, rejectUnauthorized: false }, () => {
-                        this.logger.debug(`Connection upgraded to SSL.`);
-                        resolve(tlsSocket);
-                    });
-                    tlsSocket.once('secureConnect', () => {
-                        this.stats.secureConnectedTime = Date.now();
-                    });
-                }
-            });
-            connectRequest.end();
-        });
-    }
-    async handleProxyAuthentication(res, socket) {
-        if (res.statusCode === 407) {
-            // Proxy Authentication Required
-            this.currentHeaders = new Headers(res.headers);
-            const authHeader = this.currentHeaders.get('proxy-authenticate');
-            if (authHeader && authHeader.startsWith('Digest')) {
-                // Parse the Digest challenge and update _proxyAuthHeader to generate the correct response.
-                this._errorRequest(new SerializableError(`Unsupported proxy authentication scheme: ${authHeader}`, 127));
-                socket.destroy();
-                // this._cleanUpRedirect(); // Might need adjustments
-                // const message = await this.prepareMessage();
-                // this.writeMessage(message);
-            }
-            else if (authHeader && authHeader.startsWith('Basic')) {
-                // Basic auth is usually handled directly in _proxyAuthHeader, so this might be redundant.
-                this._cleanUpRedirect(); // Might need adjustments
-                const message = await this.prepareMessage();
-                this.writeMessage(message);
-            }
-            else {
-                // Unsupported authentication scheme
-                this._errorRequest(new SerializableError(`Unsupported proxy authentication scheme: ${authHeader}`, 127));
-                socket.destroy();
-            }
-        }
-    }
-    /**
-     * Creates connection to a proxy for an HTTP (non-SSL) transport.
-     * This is the same as calling _connect or _connectTls but the target is the proxy and not the
-     * target URL. The message sent to the proxy server is different than the one sent
-     * to the target.
-     * @param proxyIsSsl
-     * @returns Promise resolved when socket is connected.
-     */
-    async proxyHttp(proxyIsSsl = false) {
-        this.logger.debug('Proxying an HTTP request...');
-        const { proxy } = this.opts;
-        if (!proxy) {
-            throw new Error(`No proxy configuration found.`);
-        }
-        let proxyUrl = proxy;
-        if (proxyIsSsl && !proxyUrl.startsWith('https:')) {
-            proxyUrl = `https://${proxyUrl}`;
-        }
-        else if (!proxyIsSsl && !proxyUrl.startsWith('http:')) {
-            proxyUrl = `http://${proxyUrl}`;
-        }
-        const proxyUri = new URL(proxyUrl);
-        const port = Number(proxyUri.port || 443);
-        const host = proxyUri.hostname;
-        let socket;
-        try {
-            if (proxyIsSsl) {
-                socket = await this._connectTls(port, host);
-            }
-            else {
-                socket = await this._connect(port, host);
-            }
-        }
-        catch (error) {
-            const err = error;
-            throw new SerializableError(`Failed to connect to proxy: ${err.message}`, err.code ? Number(err.code) : 112);
-        }
-        return socket;
-    }
 }
 //# sourceMappingURL=CoreEngine.js.map