@chainlink/external-adapter-framework 1.7.6 → 2.0.0

package/generator-adapter/node_modules/got/dist/source/core/index.js

@@ -1,1125 +0,0 @@
-import process from 'node:process';
-import { Buffer } from 'node:buffer';
-import { Duplex } from 'node:stream';
-import { URL, URLSearchParams } from 'node:url';
-import http, { ServerResponse } from 'node:http';
-import timer from '@szmarczak/http-timer';
-import CacheableRequest, { CacheError as CacheableCacheError, } from 'cacheable-request';
-import decompressResponse from 'decompress-response';
-import is from '@sindresorhus/is';
-import getStream from 'get-stream';
-import { FormDataEncoder, isFormData as isFormDataLike } from 'form-data-encoder';
-import getBodySize from './utils/get-body-size.js';
-import isFormData from './utils/is-form-data.js';
-import proxyEvents from './utils/proxy-events.js';
-import timedOut, { TimeoutError as TimedOutTimeoutError } from './timed-out.js';
-import urlToOptions from './utils/url-to-options.js';
-import WeakableMap from './utils/weakable-map.js';
-import calculateRetryDelay from './calculate-retry-delay.js';
-import Options from './options.js';
-import { isResponseOk } from './response.js';
-import isClientRequest from './utils/is-client-request.js';
-import isUnixSocketURL from './utils/is-unix-socket-url.js';
-import { RequestError, ReadError, MaxRedirectsError, HTTPError, TimeoutError, UploadError, CacheError, AbortError, } from './errors.js';
-const { buffer: getBuffer } = getStream;
-const supportsBrotli = is.string(process.versions.brotli);
-const methodsWithoutBody = new Set(['GET', 'HEAD']);
-const cacheableStore = new WeakableMap();
-const redirectCodes = new Set([300, 301, 302, 303, 304, 307, 308]);
-const proxiedRequestEvents = [
-    'socket',
-    'connect',
-    'continue',
-    'information',
-    'upgrade',
-];
-const noop = () => { };
-export default class Request extends Duplex {
-    constructor(url, options, defaults) {
-        super({
-            // Don't destroy immediately, as the error may be emitted on unsuccessful retry
-            autoDestroy: false,
-            // It needs to be zero because we're just proxying the data to another stream
-            highWaterMark: 0,
-        });
-        // @ts-expect-error - Ignoring for now.
-        Object.defineProperty(this, 'constructor', {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_noPipe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // @ts-expect-error https://github.com/microsoft/TypeScript/issues/9568
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "response", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "requestUrl", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "redirectUrls", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "retryCount", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_stopRetry", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_downloadedSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_uploadedSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_stopReading", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_pipedServerResponses", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_request", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_responseSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_bodySize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_unproxyEvents", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_isFromCache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_cannotHaveBody", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_triggerRead", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_cancelTimeouts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_removeListeners", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_nativeResponse", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_flushed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_aborted", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // We need this because `this._request` if `undefined` when using cache
-        Object.defineProperty(this, "_requestInitialized", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this._downloadedSize = 0;
-        this._uploadedSize = 0;
-        this._stopReading = false;
-        this._pipedServerResponses = new Set();
-        this._cannotHaveBody = false;
-        this._unproxyEvents = noop;
-        this._triggerRead = false;
-        this._cancelTimeouts = noop;
-        this._removeListeners = noop;
-        this._jobs = [];
-        this._flushed = false;
-        this._requestInitialized = false;
-        this._aborted = false;
-        this.redirectUrls = [];
-        this.retryCount = 0;
-        this._stopRetry = noop;
-        this.on('pipe', (source) => {
-            if (source?.headers) {
-                Object.assign(this.options.headers, source.headers);
-            }
-        });
-        this.on('newListener', event => {
-            if (event === 'retry' && this.listenerCount('retry') > 0) {
-                throw new Error('A retry listener has been attached already.');
-            }
-        });
-        try {
-            this.options = new Options(url, options, defaults);
-            if (!this.options.url) {
-                if (this.options.prefixUrl === '') {
-                    throw new TypeError('Missing `url` property');
-                }
-                this.options.url = '';
-            }
-            this.requestUrl = this.options.url;
-        }
-        catch (error) {
-            const { options } = error;
-            if (options) {
-                this.options = options;
-            }
-            this.flush = async () => {
-                this.flush = async () => { };
-                this.destroy(error);
-            };
-            return;
-        }
-        // Important! If you replace `body` in a handler with another stream, make sure it's readable first.
-        // The below is run only once.
-        const { body } = this.options;
-        if (is.nodeStream(body)) {
-            body.once('error', error => {
-                if (this._flushed) {
-                    this._beforeError(new UploadError(error, this));
-                }
-                else {
-                    this.flush = async () => {
-                        this.flush = async () => { };
-                        this._beforeError(new UploadError(error, this));
-                    };
-                }
-            });
-        }
-        if (this.options.signal) {
-            const abort = () => {
-                this.destroy(new AbortError(this));
-            };
-            if (this.options.signal.aborted) {
-                abort();
-            }
-            else {
-                this.options.signal.addEventListener('abort', abort);
-                this._removeListeners = () => {
-                    this.options.signal.removeEventListener('abort', abort);
-                };
-            }
-        }
-    }
-    async flush() {
-        if (this._flushed) {
-            return;
-        }
-        this._flushed = true;
-        try {
-            await this._finalizeBody();
-            if (this.destroyed) {
-                return;
-            }
-            await this._makeRequest();
-            if (this.destroyed) {
-                this._request?.destroy();
-                return;
-            }
-            // Queued writes etc.
-            for (const job of this._jobs) {
-                job();
-            }
-            // Prevent memory leak
-            this._jobs.length = 0;
-            this._requestInitialized = true;
-        }
-        catch (error) {
-            this._beforeError(error);
-        }
-    }
-    _beforeError(error) {
-        if (this._stopReading) {
-            return;
-        }
-        const { response, options } = this;
-        const attemptCount = this.retryCount + (error.name === 'RetryError' ? 0 : 1);
-        this._stopReading = true;
-        if (!(error instanceof RequestError)) {
-            error = new RequestError(error.message, error, this);
-        }
-        const typedError = error;
-        void (async () => {
-            // Node.js parser is really weird.
-            // It emits post-request Parse Errors on the same instance as previous request. WTF.
-            // Therefore we need to check if it has been destroyed as well.
-            //
-            // Furthermore, Node.js 16 `response.destroy()` doesn't immediately destroy the socket,
-            // but makes the response unreadable. So we additionally need to check `response.readable`.
-            if (response?.readable && !response.rawBody && !this._request?.socket?.destroyed) {
-                // @types/node has incorrect typings. `setEncoding` accepts `null` as well.
-                response.setEncoding(this.readableEncoding);
-                const success = await this._setRawBody(response);
-                if (success) {
-                    response.body = response.rawBody.toString();
-                }
-            }
-            if (this.listenerCount('retry') !== 0) {
-                let backoff;
-                try {
-                    let retryAfter;
-                    if (response && 'retry-after' in response.headers) {
-                        retryAfter = Number(response.headers['retry-after']);
-                        if (Number.isNaN(retryAfter)) {
-                            retryAfter = Date.parse(response.headers['retry-after']) - Date.now();
-                            if (retryAfter <= 0) {
-                                retryAfter = 1;
-                            }
-                        }
-                        else {
-                            retryAfter *= 1000;
-                        }
-                    }
-                    const retryOptions = options.retry;
-                    backoff = await retryOptions.calculateDelay({
-                        attemptCount,
-                        retryOptions,
-                        error: typedError,
-                        retryAfter,
-                        computedValue: calculateRetryDelay({
-                            attemptCount,
-                            retryOptions,
-                            error: typedError,
-                            retryAfter,
-                            computedValue: retryOptions.maxRetryAfter ?? options.timeout.request ?? Number.POSITIVE_INFINITY,
-                        }),
-                    });
-                }
-                catch (error_) {
-                    void this._error(new RequestError(error_.message, error_, this));
-                    return;
-                }
-                if (backoff) {
-                    await new Promise(resolve => {
-                        const timeout = setTimeout(resolve, backoff);
-                        this._stopRetry = () => {
-                            clearTimeout(timeout);
-                            resolve();
-                        };
-                    });
-                    // Something forced us to abort the retry
-                    if (this.destroyed) {
-                        return;
-                    }
-                    try {
-                        for (const hook of this.options.hooks.beforeRetry) {
-                            // eslint-disable-next-line no-await-in-loop
-                            await hook(typedError, this.retryCount + 1);
-                        }
-                    }
-                    catch (error_) {
-                        void this._error(new RequestError(error_.message, error, this));
-                        return;
-                    }
-                    // Something forced us to abort the retry
-                    if (this.destroyed) {
-                        return;
-                    }
-                    this.destroy();
-                    this.emit('retry', this.retryCount + 1, error, (updatedOptions) => {
-                        const request = new Request(options.url, updatedOptions, options);
-                        request.retryCount = this.retryCount + 1;
-                        process.nextTick(() => {
-                            void request.flush();
-                        });
-                        return request;
-                    });
-                    return;
-                }
-            }
-            void this._error(typedError);
-        })();
-    }
-    _read() {
-        this._triggerRead = true;
-        const { response } = this;
-        if (response && !this._stopReading) {
-            // We cannot put this in the `if` above
-            // because `.read()` also triggers the `end` event
-            if (response.readableLength) {
-                this._triggerRead = false;
-            }
-            let data;
-            while ((data = response.read()) !== null) {
-                this._downloadedSize += data.length; // eslint-disable-line @typescript-eslint/restrict-plus-operands
-                const progress = this.downloadProgress;
-                if (progress.percent < 1) {
-                    this.emit('downloadProgress', progress);
-                }
-                this.push(data);
-            }
-        }
-    }
-    _write(chunk, encoding, callback) {
-        const write = () => {
-            this._writeRequest(chunk, encoding, callback);
-        };
-        if (this._requestInitialized) {
-            write();
-        }
-        else {
-            this._jobs.push(write);
-        }
-    }
-    _final(callback) {
-        const endRequest = () => {
-            // We need to check if `this._request` is present,
-            // because it isn't when we use cache.
-            if (!this._request || this._request.destroyed) {
-                callback();
-                return;
-            }
-            this._request.end((error) => {
-                // The request has been destroyed before `_final` finished.
-                // See https://github.com/nodejs/node/issues/39356
-                if (this._request._writableState?.errored) {
-                    return;
-                }
-                if (!error) {
-                    this._bodySize = this._uploadedSize;
-                    this.emit('uploadProgress', this.uploadProgress);
-                    this._request.emit('upload-complete');
-                }
-                callback(error);
-            });
-        };
-        if (this._requestInitialized) {
-            endRequest();
-        }
-        else {
-            this._jobs.push(endRequest);
-        }
-    }
-    _destroy(error, callback) {
-        this._stopReading = true;
-        this.flush = async () => { };
-        // Prevent further retries
-        this._stopRetry();
-        this._cancelTimeouts();
-        this._removeListeners();
-        if (this.options) {
-            const { body } = this.options;
-            if (is.nodeStream(body)) {
-                body.destroy();
-            }
-        }
-        if (this._request) {
-            this._request.destroy();
-        }
-        if (error !== null && !is.undefined(error) && !(error instanceof RequestError)) {
-            error = new RequestError(error.message, error, this);
-        }
-        callback(error);
-    }
-    pipe(destination, options) {
-        if (destination instanceof ServerResponse) {
-            this._pipedServerResponses.add(destination);
-        }
-        return super.pipe(destination, options);
-    }
-    unpipe(destination) {
-        if (destination instanceof ServerResponse) {
-            this._pipedServerResponses.delete(destination);
-        }
-        super.unpipe(destination);
-        return this;
-    }
-    async _finalizeBody() {
-        const { options } = this;
-        const { headers } = options;
-        const isForm = !is.undefined(options.form);
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        const isJSON = !is.undefined(options.json);
-        const isBody = !is.undefined(options.body);
-        const cannotHaveBody = methodsWithoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
-        this._cannotHaveBody = cannotHaveBody;
-        if (isForm || isJSON || isBody) {
-            if (cannotHaveBody) {
-                throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
-            }
-            // Serialize body
-            const noContentType = !is.string(headers['content-type']);
-            if (isBody) {
-                // Body is spec-compliant FormData
-                if (isFormDataLike(options.body)) {
-                    const encoder = new FormDataEncoder(options.body);
-                    if (noContentType) {
-                        headers['content-type'] = encoder.headers['Content-Type'];
-                    }
-                    if ('Content-Length' in encoder.headers) {
-                        headers['content-length'] = encoder.headers['Content-Length'];
-                    }
-                    options.body = encoder.encode();
-                }
-                // Special case for https://github.com/form-data/form-data
-                if (isFormData(options.body) && noContentType) {
-                    headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
-                }
-            }
-            else if (isForm) {
-                if (noContentType) {
-                    headers['content-type'] = 'application/x-www-form-urlencoded';
-                }
-                const { form } = options;
-                options.form = undefined;
-                options.body = (new URLSearchParams(form)).toString();
-            }
-            else {
-                if (noContentType) {
-                    headers['content-type'] = 'application/json';
-                }
-                const { json } = options;
-                options.json = undefined;
-                options.body = options.stringifyJson(json);
-            }
-            const uploadBodySize = await getBodySize(options.body, options.headers);
-            // See https://tools.ietf.org/html/rfc7230#section-3.3.2
-            // A user agent SHOULD send a Content-Length in a request message when
-            // no Transfer-Encoding is sent and the request method defines a meaning
-            // for an enclosed payload body.  For example, a Content-Length header
-            // field is normally sent in a POST request even when the value is 0
-            // (indicating an empty payload body).  A user agent SHOULD NOT send a
-            // Content-Length header field when the request message does not contain
-            // a payload body and the method semantics do not anticipate such a
-            // body.
-            if (is.undefined(headers['content-length']) && is.undefined(headers['transfer-encoding']) && !cannotHaveBody && !is.undefined(uploadBodySize)) {
-                headers['content-length'] = String(uploadBodySize);
-            }
-        }
-        if (options.responseType === 'json' && !('accept' in options.headers)) {
-            options.headers.accept = 'application/json';
-        }
-        this._bodySize = Number(headers['content-length']) || undefined;
-    }
-    async _onResponseBase(response) {
-        // This will be called e.g. when using cache so we need to check if this request has been aborted.
-        if (this.isAborted) {
-            return;
-        }
-        const { options } = this;
-        const { url } = options;
-        this._nativeResponse = response;
-        if (options.decompress) {
-            response = decompressResponse(response);
-        }
-        const statusCode = response.statusCode;
-        const typedResponse = response;
-        typedResponse.statusMessage = typedResponse.statusMessage ?? http.STATUS_CODES[statusCode];
-        typedResponse.url = options.url.toString();
-        typedResponse.requestUrl = this.requestUrl;
-        typedResponse.redirectUrls = this.redirectUrls;
-        typedResponse.request = this;
-        typedResponse.isFromCache = this._nativeResponse.fromCache ?? false;
-        typedResponse.ip = this.ip;
-        typedResponse.retryCount = this.retryCount;
-        typedResponse.ok = isResponseOk(typedResponse);
-        this._isFromCache = typedResponse.isFromCache;
-        this._responseSize = Number(response.headers['content-length']) || undefined;
-        this.response = typedResponse;
-        response.once('end', () => {
-            this._responseSize = this._downloadedSize;
-            this.emit('downloadProgress', this.downloadProgress);
-        });
-        response.once('error', (error) => {
-            this._aborted = true;
-            // Force clean-up, because some packages don't do this.
-            // TODO: Fix decompress-response
-            response.destroy();
-            this._beforeError(new ReadError(error, this));
-        });
-        response.once('aborted', () => {
-            this._aborted = true;
-            this._beforeError(new ReadError({
-                name: 'Error',
-                message: 'The server aborted pending request',
-                code: 'ECONNRESET',
-            }, this));
-        });
-        this.emit('downloadProgress', this.downloadProgress);
-        const rawCookies = response.headers['set-cookie'];
-        if (is.object(options.cookieJar) && rawCookies) {
-            let promises = rawCookies.map(async (rawCookie) => options.cookieJar.setCookie(rawCookie, url.toString()));
-            if (options.ignoreInvalidCookies) {
-                promises = promises.map(async (promise) => {
-                    try {
-                        await promise;
-                    }
-                    catch { }
-                });
-            }
-            try {
-                await Promise.all(promises);
-            }
-            catch (error) {
-                this._beforeError(error);
-                return;
-            }
-        }
-        // The above is running a promise, therefore we need to check if this request has been aborted yet again.
-        if (this.isAborted) {
-            return;
-        }
-        if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
-            // We're being redirected, we don't care about the response.
-            // It'd be best to abort the request, but we can't because
-            // we would have to sacrifice the TCP connection. We don't want that.
-            response.resume();
-            this._cancelTimeouts();
-            this._unproxyEvents();
-            if (this.redirectUrls.length >= options.maxRedirects) {
-                this._beforeError(new MaxRedirectsError(this));
-                return;
-            }
-            this._request = undefined;
-            const updatedOptions = new Options(undefined, undefined, this.options);
-            const serverRequestedGet = statusCode === 303 && updatedOptions.method !== 'GET' && updatedOptions.method !== 'HEAD';
-            const canRewrite = statusCode !== 307 && statusCode !== 308;
-            const userRequestedGet = updatedOptions.methodRewriting && canRewrite;
-            if (serverRequestedGet || userRequestedGet) {
-                updatedOptions.method = 'GET';
-                updatedOptions.body = undefined;
-                updatedOptions.json = undefined;
-                updatedOptions.form = undefined;
-                delete updatedOptions.headers['content-length'];
-            }
-            try {
-                // We need this in order to support UTF-8
-                const redirectBuffer = Buffer.from(response.headers.location, 'binary').toString();
-                const redirectUrl = new URL(redirectBuffer, url);
-                if (!isUnixSocketURL(url) && isUnixSocketURL(redirectUrl)) {
-                    this._beforeError(new RequestError('Cannot redirect to UNIX socket', {}, this));
-                    return;
-                }
-                // Redirecting to a different site, clear sensitive data.
-                if (redirectUrl.hostname !== url.hostname || redirectUrl.port !== url.port) {
-                    if ('host' in updatedOptions.headers) {
-                        delete updatedOptions.headers.host;
-                    }
-                    if ('cookie' in updatedOptions.headers) {
-                        delete updatedOptions.headers.cookie;
-                    }
-                    if ('authorization' in updatedOptions.headers) {
-                        delete updatedOptions.headers.authorization;
-                    }
-                    if (updatedOptions.username || updatedOptions.password) {
-                        updatedOptions.username = '';
-                        updatedOptions.password = '';
-                    }
-                }
-                else {
-                    redirectUrl.username = updatedOptions.username;
-                    redirectUrl.password = updatedOptions.password;
-                }
-                this.redirectUrls.push(redirectUrl);
-                updatedOptions.prefixUrl = '';
-                updatedOptions.url = redirectUrl;
-                for (const hook of updatedOptions.hooks.beforeRedirect) {
-                    // eslint-disable-next-line no-await-in-loop
-                    await hook(updatedOptions, typedResponse);
-                }
-                this.emit('redirect', updatedOptions, typedResponse);
-                this.options = updatedOptions;
-                await this._makeRequest();
-            }
-            catch (error) {
-                this._beforeError(error);
-                return;
-            }
-            return;
-        }
-        // `HTTPError`s always have `error.response.body` defined.
-        // Therefore we cannot retry if `options.throwHttpErrors` is false.
-        // On the last retry, if `options.throwHttpErrors` is false, we would need to return the body,
-        // but that wouldn't be possible since the body would be already read in `error.response.body`.
-        if (options.isStream && options.throwHttpErrors && !isResponseOk(typedResponse)) {
-            this._beforeError(new HTTPError(typedResponse));
-            return;
-        }
-        response.on('readable', () => {
-            if (this._triggerRead) {
-                this._read();
-            }
-        });
-        this.on('resume', () => {
-            response.resume();
-        });
-        this.on('pause', () => {
-            response.pause();
-        });
-        response.once('end', () => {
-            this.push(null);
-        });
-        if (this._noPipe) {
-            const success = await this._setRawBody();
-            if (success) {
-                this.emit('response', response);
-            }
-            return;
-        }
-        this.emit('response', response);
-        for (const destination of this._pipedServerResponses) {
-            if (destination.headersSent) {
-                continue;
-            }
-            // eslint-disable-next-line guard-for-in
-            for (const key in response.headers) {
-                const isAllowed = options.decompress ? key !== 'content-encoding' : true;
-                const value = response.headers[key];
-                if (isAllowed) {
-                    destination.setHeader(key, value);
-                }
-            }
-            destination.statusCode = statusCode;
-        }
-    }
-    async _setRawBody(from = this) {
-        if (from.readableEnded) {
-            return false;
-        }
-        try {
-            // Errors are emitted via the `error` event
-            const rawBody = await getBuffer(from);
-            // On retry Request is destroyed with no error, therefore the above will successfully resolve.
-            // So in order to check if this was really successfull, we need to check if it has been properly ended.
-            if (!this.isAborted) {
-                this.response.rawBody = rawBody;
-                return true;
-            }
-        }
-        catch { }
-        return false;
-    }
-    async _onResponse(response) {
-        try {
-            await this._onResponseBase(response);
-        }
-        catch (error) {
-            /* istanbul ignore next: better safe than sorry */
-            this._beforeError(error);
-        }
-    }
-    _onRequest(request) {
-        const { options } = this;
-        const { timeout, url } = options;
-        timer(request);
-        if (this.options.http2) {
-            // Unset stream timeout, as the `timeout` option was used only for connection timeout.
-            request.setTimeout(0);
-        }
-        this._cancelTimeouts = timedOut(request, timeout, url);
-        const responseEventName = options.cache ? 'cacheableResponse' : 'response';
-        request.once(responseEventName, (response) => {
-            void this._onResponse(response);
-        });
-        request.once('error', (error) => {
-            this._aborted = true;
-            // Force clean-up, because some packages (e.g. nock) don't do this.
-            request.destroy();
-            error = error instanceof TimedOutTimeoutError ? new TimeoutError(error, this.timings, this) : new RequestError(error.message, error, this);
-            this._beforeError(error);
-        });
-        this._unproxyEvents = proxyEvents(request, this, proxiedRequestEvents);
-        this._request = request;
-        this.emit('uploadProgress', this.uploadProgress);
-        this._sendBody();
-        this.emit('request', request);
-    }
-    async _asyncWrite(chunk) {
-        return new Promise((resolve, reject) => {
-            super.write(chunk, error => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            });
-        });
-    }
-    _sendBody() {
-        // Send body
-        const { body } = this.options;
-        const currentRequest = this.redirectUrls.length === 0 ? this : this._request ?? this;
-        if (is.nodeStream(body)) {
-            body.pipe(currentRequest);
-        }
-        else if (is.generator(body) || is.asyncGenerator(body)) {
-            (async () => {
-                try {
-                    for await (const chunk of body) {
-                        await this._asyncWrite(chunk);
-                    }
-                    super.end();
-                }
-                catch (error) {
-                    this._beforeError(error);
-                }
-            })();
-        }
-        else if (!is.undefined(body)) {
-            this._writeRequest(body, undefined, () => { });
-            currentRequest.end();
-        }
-        else if (this._cannotHaveBody || this._noPipe) {
-            currentRequest.end();
-        }
-    }
-    _prepareCache(cache) {
-        if (!cacheableStore.has(cache)) {
-            const cacheableRequest = new CacheableRequest(((requestOptions, handler) => {
-                const result = requestOptions._request(requestOptions, handler);
-                // TODO: remove this when `cacheable-request` supports async request functions.
-                if (is.promise(result)) {
-                    // We only need to implement the error handler in order to support HTTP2 caching.
-                    // The result will be a promise anyway.
-                    // @ts-expect-error ignore
-                    // eslint-disable-next-line @typescript-eslint/promise-function-async
-                    result.once = (event, handler) => {
-                        if (event === 'error') {
-                            (async () => {
-                                try {
-                                    await result;
-                                }
-                                catch (error) {
-                                    handler(error);
-                                }
-                            })();
-                        }
-                        else if (event === 'abort') {
-                            // The empty catch is needed here in case when
-                            // it rejects before it's `await`ed in `_makeRequest`.
-                            (async () => {
-                                try {
-                                    const request = (await result);
-                                    request.once('abort', handler);
-                                }
-                                catch { }
-                            })();
-                        }
-                        else {
-                            /* istanbul ignore next: safety check */
-                            throw new Error(`Unknown HTTP2 promise event: ${event}`);
-                        }
-                        return result;
-                    };
-                }
-                return result;
-            }), cache);
-            cacheableStore.set(cache, cacheableRequest.request());
-        }
-    }
-    async _createCacheableRequest(url, options) {
-        return new Promise((resolve, reject) => {
-            // TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
-            Object.assign(options, urlToOptions(url));
-            let request;
-            // TODO: Fix `cacheable-response`. This is ugly.
-            const cacheRequest = cacheableStore.get(options.cache)(options, async (response) => {
-                response._readableState.autoDestroy = false;
-                if (request) {
-                    const fix = () => {
-                        if (response.req) {
-                            response.complete = response.req.res.complete;
-                        }
-                    };
-                    response.prependOnceListener('end', fix);
-                    fix();
-                    (await request).emit('cacheableResponse', response);
-                }
-                resolve(response);
-            });
-            cacheRequest.once('error', reject);
-            cacheRequest.once('request', async (requestOrPromise) => {
-                request = requestOrPromise;
-                resolve(request);
-            });
-        });
-    }
-    async _makeRequest() {
-        const { options } = this;
-        const { headers, username, password } = options;
-        const cookieJar = options.cookieJar;
-        for (const key in headers) {
-            if (is.undefined(headers[key])) {
-                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-                delete headers[key];
-            }
-            else if (is.null_(headers[key])) {
-                throw new TypeError(`Use \`undefined\` instead of \`null\` to delete the \`${key}\` header`);
-            }
-        }
-        if (options.decompress && is.undefined(headers['accept-encoding'])) {
-            headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate';
-        }
-        if (username || password) {
-            const credentials = Buffer.from(`${username}:${password}`).toString('base64');
-            headers.authorization = `Basic ${credentials}`;
-        }
-        // Set cookies
-        if (cookieJar) {
-            const cookieString = await cookieJar.getCookieString(options.url.toString());
-            if (is.nonEmptyString(cookieString)) {
-                headers.cookie = cookieString;
-            }
-        }
-        // Reset `prefixUrl`
-        options.prefixUrl = '';
-        let request;
-        for (const hook of options.hooks.beforeRequest) {
-            // eslint-disable-next-line no-await-in-loop
-            const result = await hook(options);
-            if (!is.undefined(result)) {
-                // @ts-expect-error Skip the type mismatch to support abstract responses
-                request = () => result;
-                break;
-            }
-        }
-        if (!request) {
-            request = options.getRequestFunction();
-        }
-        const url = options.url;
-        this._requestOptions = options.createNativeRequestOptions();
-        if (options.cache) {
-            this._requestOptions._request = request;
-            this._requestOptions.cache = options.cache;
-            this._requestOptions.body = options.body;
-            this._prepareCache(options.cache);
-        }
-        // Cache support
-        const fn = options.cache ? this._createCacheableRequest : request;
-        try {
-            // We can't do `await fn(...)`,
-            // because stream `error` event can be emitted before `Promise.resolve()`.
-            let requestOrResponse = fn(url, this._requestOptions);
-            if (is.promise(requestOrResponse)) {
-                requestOrResponse = await requestOrResponse;
-            }
-            // Fallback
-            if (is.undefined(requestOrResponse)) {
-                requestOrResponse = options.getFallbackRequestFunction()(url, this._requestOptions);
-                if (is.promise(requestOrResponse)) {
-                    requestOrResponse = await requestOrResponse;
-                }
-            }
-            if (isClientRequest(requestOrResponse)) {
-                this._onRequest(requestOrResponse);
-            }
-            else if (this.writable) {
-                this.once('finish', () => {
-                    void this._onResponse(requestOrResponse);
-                });
-                this._sendBody();
-            }
-            else {
-                void this._onResponse(requestOrResponse);
-            }
-        }
-        catch (error) {
-            if (error instanceof CacheableCacheError) {
-                throw new CacheError(error, this);
-            }
-            throw error;
-        }
-    }
-    async _error(error) {
-        try {
-            if (error instanceof HTTPError && !this.options.throwHttpErrors) {
-                // This branch can be reached only when using the Promise API
-                // Skip calling the hooks on purpose.
-                // See https://github.com/sindresorhus/got/issues/2103
-            }
-            else {
-                for (const hook of this.options.hooks.beforeError) {
-                    // eslint-disable-next-line no-await-in-loop
-                    error = await hook(error);
-                }
-            }
-        }
-        catch (error_) {
-            error = new RequestError(error_.message, error_, this);
-        }
-        this.destroy(error);
-    }
-    _writeRequest(chunk, encoding, callback) {
-        if (!this._request || this._request.destroyed) {
-            // Probably the `ClientRequest` instance will throw
-            return;
-        }
-        this._request.write(chunk, encoding, (error) => {
-            // The `!destroyed` check is required to prevent `uploadProgress` being emitted after the stream was destroyed
-            if (!error && !this._request.destroyed) {
-                this._uploadedSize += Buffer.byteLength(chunk, encoding);
-                const progress = this.uploadProgress;
-                if (progress.percent < 1) {
-                    this.emit('uploadProgress', progress);
-                }
-            }
-            callback(error);
-        });
-    }
-    /**
-    The remote IP address.
-    */
-    get ip() {
-        return this.socket?.remoteAddress;
-    }
-    /**
-    Indicates whether the request has been aborted or not.
-    */
-    get isAborted() {
-        return this._aborted;
-    }
-    get socket() {
-        return this._request?.socket ?? undefined;
-    }
-    /**
-    Progress event for downloading (receiving a response).
-    */
-    get downloadProgress() {
-        let percent;
-        if (this._responseSize) {
-            percent = this._downloadedSize / this._responseSize;
-        }
-        else if (this._responseSize === this._downloadedSize) {
-            percent = 1;
-        }
-        else {
-            percent = 0;
-        }
-        return {
-            percent,
-            transferred: this._downloadedSize,
-            total: this._responseSize,
-        };
-    }
-    /**
-    Progress event for uploading (sending a request).
-    */
-    get uploadProgress() {
-        let percent;
-        if (this._bodySize) {
-            percent = this._uploadedSize / this._bodySize;
-        }
-        else if (this._bodySize === this._uploadedSize) {
-            percent = 1;
-        }
-        else {
-            percent = 0;
-        }
-        return {
-            percent,
-            transferred: this._uploadedSize,
-            total: this._bodySize,
-        };
-    }
-    /**
-    The object contains the following properties:
-
-    - `start` - Time when the request started.
-    - `socket` - Time when a socket was assigned to the request.
-    - `lookup` - Time when the DNS lookup finished.
-    - `connect` - Time when the socket successfully connected.
-    - `secureConnect` - Time when the socket securely connected.
-    - `upload` - Time when the request finished uploading.
-    - `response` - Time when the request fired `response` event.
-    - `end` - Time when the response fired `end` event.
-    - `error` - Time when the request fired `error` event.
-    - `abort` - Time when the request fired `abort` event.
-    - `phases`
-        - `wait` - `timings.socket - timings.start`
-        - `dns` - `timings.lookup - timings.socket`
-        - `tcp` - `timings.connect - timings.lookup`
-        - `tls` - `timings.secureConnect - timings.connect`
-        - `request` - `timings.upload - (timings.secureConnect || timings.connect)`
-        - `firstByte` - `timings.response - timings.upload`
-        - `download` - `timings.end - timings.response`
-        - `total` - `(timings.end || timings.error || timings.abort) - timings.start`
-
-    If something has not been measured yet, it will be `undefined`.
-
-    __Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
-    */
-    get timings() {
-        return this._request?.timings;
-    }
-    /**
-    Whether the response was retrieved from the cache.
-    */
-    get isFromCache() {
-        return this._isFromCache;
-    }
-    get reusedSocket() {
-        return this._request?.reusedSocket;
-    }
-}