@e-mc/request 0.10.14 → 0.10.16

package/README.md

@@ -9,7 +9,7 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.10.14/lib/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.10.16/lib/index.d.ts)
 
 ```typescript
 import type { IModule, ModuleConstructor } from "./index";
@@ -205,9 +205,9 @@ instance.get("http://hostname/path/config.yml", options).then(data => {
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.10.14/lib/http.d.ts
-- https://www.unpkg.com/@e-mc/types@0.10.14/lib/request.d.ts
-- https://www.unpkg.com/@e-mc/types@0.10.14/lib/settings.d.ts
+- https://www.unpkg.com/@e-mc/types@0.10.16/lib/http.d.ts
+- https://www.unpkg.com/@e-mc/types@0.10.16/lib/request.d.ts
+- https://www.unpkg.com/@e-mc/types@0.10.16/lib/settings.d.ts
 
 * https://www.npmjs.com/package/@types/node
 

package/index.js

@@ -276,6 +276,8 @@ function checkEncoding(request, response, statusCode, outStream, contentEncoding
         case 206:
             request.emit('error', (0, types_1.errorValue)("Aborted", 'Partial content'));
         case 204:
+        case 205:
+        case 304:
             return;
     }
     if (!contentEncoding) {
@@ -375,6 +377,7 @@ function successDns(instance, value, pending, connected) {
     }
     pending.length = 0;
 }
+const hasResponse = (value) => value >= 200 && (value < 300 || value === 304);
 const configureDns = (family, options) => family === 0 ? options : { family, hints: family === 6 ? dns.V4MAPPED : 0 };
 const ignoreOpt = (opts, ...values) => !opts?.some(item => values.includes(item));
 const escapeQuote = (value) => value.replace(/[\\"]/g, capture => '\\' + capture);
@@ -431,13 +434,21 @@ class Fetch {
                     return;
                 }
                 const statusCode = headers[':status'];
-                if (statusCode < 300) {
-                    this.acceptResponse(headers);
+                if (statusCode === 204 || statusCode === 304) {
+                    this.acceptResponse(headers, true);
                 }
-                else if (statusCode < 400) {
+                else if (statusCode < 300) {
+                    this.acceptResponse(headers, false);
+                }
+                else if (statusCode === 301 ||
+                    statusCode === 302 ||
+                    statusCode === 303 ||
+                    statusCode === 307 ||
+                    statusCode === 308) {
                     this.redirectResponse(statusCode, headers.location);
                 }
-                else if (statusCode === 401 ||
+                else if (statusCode === 305 ||
+                    statusCode === 401 ||
                     statusCode === 402 ||
                     statusCode === 403 ||
                     statusCode === 404 ||
@@ -502,10 +513,17 @@ class Fetch {
                     return;
                 }
                 const statusCode = res.statusCode;
-                if (statusCode < 300) {
-                    this.acceptResponse(res.headers);
+                if (statusCode === 204 || statusCode === 304) {
+                    this.acceptResponse(res.headers, true);
+                }
+                else if (statusCode < 300) {
+                    this.acceptResponse(res.headers, false);
                 }
-                else if (statusCode < 400) {
+                else if (statusCode === 301 ||
+                    statusCode === 302 ||
+                    statusCode === 303 ||
+                    statusCode === 307 ||
+                    statusCode === 308) {
                     this.redirectResponse(statusCode, res.headers.location);
                 }
                 else if (this.isRetry(statusCode)) {
@@ -586,7 +604,7 @@ class Fetch {
         this.opts.httpVersion = 1;
         this.init();
     }
-    acceptResponse(headers) {
+    acceptResponse(headers, empty = false) {
         const { instance, config, client, opts, pipeTo } = this;
         const parent = this.instance.host;
         const progressId = config.progressId;
@@ -629,7 +647,7 @@ class Fetch {
                 }
             });
         }
-        if (enabled) {
+        if (enabled && !empty) {
             const encoding = opts.encoding;
             client.on('data', (chunk) => {
                 if (buffer) {
@@ -726,7 +744,7 @@ class Fetch {
                 if (contentLength > 0) {
                     parent.updateProgress("request", progressId, 0, contentLength);
                 }
-                if (enabled && instance.readExpect === 'always') {
+                if (enabled && instance.readExpect === 'always' && !empty) {
                     this.terminate("No data received");
                     return;
                 }
@@ -1237,7 +1255,7 @@ class Request extends module_1 {
                 break;
         }
         if (expires !== undefined) {
-            if (typeof expires === 'string') {
+            if ((0, types_1.isString)(expires)) {
                 expires = (0, types_1.parseExpires)(expires);
             }
             if (expires >= 0) {
@@ -1468,8 +1486,12 @@ class Request extends module_1 {
                     }
                     break;
                 case 'readExpect':
-                    if ((0, types_1.isString)(value)) {
-                        this[name] = value;
+                    switch (value) {
+                        case 'string':
+                        case 'always':
+                        case 'none':
+                            this[name] = value;
+                            break;
                     }
                     break;
             }
@@ -2098,7 +2120,7 @@ class Request extends module_1 {
                 request.on('response', response => {
                     connected = true;
                     const statusCode = response[':status'];
-                    if (this.matchStatus(statusCode, url, response, request, options) && statusCode >= 200 && statusCode < 300) {
+                    if (this.matchStatus(statusCode, url, response, request, options) && hasResponse(statusCode)) {
                         if (emitter = checkEncoding(request, request, statusCode, outStream, response['content-encoding'])) {
                             for (const event in listenerMap) {
                                 const [name, type] = event.split('-');
@@ -2220,7 +2242,7 @@ class Request extends module_1 {
             }, response => {
                 const statusCode = response.statusCode;
                 const incoming = response.headers;
-                if (this.matchStatus(statusCode, url, incoming, request, options) && (getting || posting) && statusCode >= 200 && statusCode < 300) {
+                if (this.matchStatus(statusCode, url, incoming, request, options) && (getting || posting) && hasResponse(statusCode)) {
                     let source = checkEncoding(request, response, statusCode, outStream, incoming['content-encoding']);
                     if (source) {
                         source.once('finish', () => request.emit('end'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/request",
-  "version": "0.10.14",
+  "version": "0.10.16",
   "description": "Request constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,11 +20,11 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/module": "0.10.14",
-    "@e-mc/types": "0.10.14",
+    "@e-mc/module": "0.10.16",
+    "@e-mc/types": "0.10.16",
     "combined-stream": "^1.0.8",
-    "js-yaml": "^4.1.0",
-    "picomatch": "^4.0.2",
+    "js-yaml": "^4.1.1",
+    "picomatch": "^4.0.3",
     "which": "^2.0.2"
   }
 }

package/http/adapter/index.js

@@ -1,575 +0,0 @@
-"use strict";
-const fs = require("node:fs");
-const http2 = require("node:http2");
-const yaml = require("js-yaml");
-const types_1 = require("@e-mc/types");
-const module_1 = require("@e-mc/module");
-const util_1 = require("@e-mc/request/util");
-const kHttpAdapter = Symbol.for('request:http:adapter:constructor');
-let LOG_TIMEFORMAT = 'readable';
-const isConstructor = (value) => typeof value === 'function' && !!value.prototype?.constructor.name;
-class HttpAdapter {
-    instance;
-    state;
-    uri;
-    static [kHttpAdapter] = true;
-    static constructorOf(value) {
-        return isConstructor(value) && value[kHttpAdapter] === true;
-    }
-    static isUnsupported(value) {
-        return value === 421 || value === 505;
-    }
-    static isDowngrade(err) {
-        return (0, types_1.isErrorCode)(err, 'ERR_HTTP2_ERROR') || err instanceof Error && this.isUnsupported(Math.abs(err.errno));
-    }
-    static wasAborted(err) {
-        return err instanceof Error && err.message.startsWith("Aborted");
-    }
-    static isConnectionError(err) {
-        switch (err instanceof Error && err.code) {
-            case 'ETIMEDOUT':
-            case 'ECONNRESET':
-                return true;
-            default:
-                return false;
-        }
-    }
-    static defineHostConfig({ settings }) {
-        const time_format = settings?.time_format;
-        switch (time_format) {
-            case 'readable':
-            case 'relative':
-            case 'none':
-                LOG_TIMEFORMAT = time_format;
-                break;
-        }
-    }
-    contentLength = 0;
-    retries = 0;
-    redirects = 0;
-    closed = false;
-    aborted = false;
-    timeout = null;
-    dataTime = null;
-    delayTime = undefined;
-    opts;
-    client;
-    resolve;
-    reject;
-    startTime;
-    #outStream = null;
-    #options;
-    constructor(instance, state, uri, options) {
-        this.instance = instance;
-        this.state = state;
-        this.uri = uri;
-        this.#options = options;
-        this.startTime = state.log ? process.hrtime.bigint() : BigInt(0);
-        this.setOpts();
-    }
-    async start() {
-        return new Promise((resolve, reject) => {
-            this.resolve = resolve;
-            this.reject = reject;
-            this.init();
-        });
-    }
-    init() {
-        this.aborted = false;
-        this.setWriteStream();
-        this.client = this.instance.open(this.uri, this.opts);
-        if (this.opts.httpVersion === 2) {
-            this.client
-                .on('response', (headers, flags) => {
-                if (this.destroyed) {
-                    return;
-                }
-                const statusCode = headers[':status'];
-                if (statusCode < 300) {
-                    this.acceptResponse(headers);
-                }
-                else if (statusCode < 400) {
-                    this.redirectResponse(statusCode, headers.location);
-                }
-                else if (statusCode === 401 ||
-                    statusCode === 402 ||
-                    statusCode === 403 ||
-                    statusCode === 404 ||
-                    statusCode === 407 ||
-                    statusCode === 410) {
-                    this.terminate(this.formatStatus(statusCode));
-                }
-                else if (this.isRetry(statusCode)) {
-                    this.retryResponse(statusCode, headers['retry-after']);
-                }
-                else if (HttpAdapter.isUnsupported(statusCode)) {
-                    this.retryDownload(true, this.#formatNgFlags(http2.constants.NGHTTP2_PROTOCOL_ERROR, statusCode));
-                }
-                else {
-                    switch (flags) {
-                        case http2.constants.NGHTTP2_PROTOCOL_ERROR:
-                        case http2.constants.NGHTTP2_INADEQUATE_SECURITY:
-                        case http2.constants.NGHTTP2_HTTP_1_1_REQUIRED:
-                            this.retryDownload(true, this.#formatNgFlags(flags, statusCode, headers.location));
-                            break;
-                        default:
-                            this.retryDownload(false, this.formatStatus(statusCode));
-                            break;
-                    }
-                }
-            })
-                .on('unknownProtocol', () => {
-                if (this.aborted) {
-                    return;
-                }
-                this.retryDownload(true, 'Unknown protocol (HTTP/2)');
-            })
-                .on('aborted', () => {
-                this.aborted = true;
-                this.terminate((0, types_1.createAbortError)());
-            })
-                .on('error', async (err) => {
-                if (this.aborted) {
-                    return;
-                }
-                if (HttpAdapter.wasAborted(err)) {
-                    this.errorResponse(err);
-                }
-                else {
-                    switch (!HttpAdapter.isDowngrade(err) && await this.host.hasProtocol(2)) {
-                        case 1:
-                            this.errorResponse(err);
-                            break;
-                        case 2:
-                            this.retryDownload(false, err);
-                            break;
-                        default:
-                            this.retryDownload(true, err);
-                            break;
-                    }
-                }
-            });
-        }
-        else {
-            this.client
-                .on('response', res => {
-                if (this.destroyed) {
-                    return;
-                }
-                const statusCode = res.statusCode;
-                if (statusCode < 300) {
-                    this.acceptResponse(res.headers);
-                }
-                else if (statusCode < 400) {
-                    this.redirectResponse(statusCode, res.headers.location);
-                }
-                else if (this.isRetry(statusCode)) {
-                    this.retryResponse(statusCode, res.headers['retry-after']);
-                }
-                else {
-                    this.terminate(this.formatStatus(statusCode));
-                }
-            })
-                .on('abort', () => {
-                this.aborted = true;
-                this.terminate((0, types_1.createAbortError)());
-            })
-                .on('error', err => {
-                if (this.aborted) {
-                    return;
-                }
-                this.errorResponse(err);
-            });
-        }
-        this.client.on('timeout', () => {
-            if (this.aborted) {
-                return;
-            }
-            if (++this.retries <= this.retryLimit) {
-                this.abortResponse();
-                this.retryTimeout();
-            }
-            else {
-                this.terminate(this.formatStatus(408));
-            }
-        });
-    }
-    setOpts(uri) {
-        if (uri) {
-            this.uri = uri;
-        }
-        this.opts = this.instance.opts(this.uri, this.#options);
-    }
-    setWriteStream() {
-        const pipeTo = this.pipeTo;
-        if (typeof pipeTo === 'string') {
-            try {
-                this.outStream = fs.createWriteStream(pipeTo, { emitClose: false, highWaterMark: this.host.streamSize });
-            }
-            catch (err) {
-                this.terminate(err);
-            }
-        }
-        else if (pipeTo) {
-            this.outStream = pipeTo;
-        }
-    }
-    retryDownload(downgrade, message) {
-        if (this.aborted) {
-            return;
-        }
-        this.abortResponse();
-        if (downgrade) {
-            const host = this.host;
-            host.failed(2);
-            if (host.version > 1) {
-                if (this.state.verbose) {
-                    this.instance.formatMessage(1024, 'HTTP2', ["Unsupported protocol", host.origin], message, { failed: true });
-                }
-                host.version = 1;
-            }
-        }
-        this.opts.httpVersion = 1;
-        this.init();
-    }
-    acceptResponse(headers) {
-        const opts = this.opts;
-        if ('outHeaders' in opts) {
-            opts.outHeaders = headers;
-        }
-        if ('outFilename' in opts) {
-            opts.outFilename = (0, util_1.parseHeader)(headers, 'content-disposition');
-        }
-        const pipeline = this.pipeTo ? !(0, types_1.isString)(this.pipeTo) : false;
-        const enabled = opts.connected?.call(this.client, headers) !== false && !pipeline;
-        const maxBufferSize = opts.maxBufferSize ? (0, types_1.alignSize)(opts.maxBufferSize) : 0;
-        this.contentLength = parseInt(headers['content-length'] || '0');
-        const updating = opts.progressId !== undefined && !!this.instance.host && this.contentLength > 0;
-        const readTimeout = this.instance.readTimeout;
-        let log = this.state.log, buffer = null, dataLength = 0;
-        this.client.once('readable', () => {
-            if (readTimeout > 0) {
-                this.timeout = setTimeout(() => {
-                    this.terminate((0, types_1.errorValue)("Timeout was exceeded", this.uri.toString()));
-                }, readTimeout);
-            }
-            if (log) {
-                switch (this.instance.settings?.time_format || LOG_TIMEFORMAT) {
-                    case 'readable':
-                        this.delayTime = process.hrtime.bigint() - this.startTime;
-                        break;
-                    case 'relative':
-                        this.delayTime = Date.now() - this.instance.startTime;
-                        break;
-                    case 'none':
-                        if (!this.silent) {
-                            log = false;
-                        }
-                        break;
-                }
-            }
-            this.dataTime = process.hrtime.bigint();
-            if (updating) {
-                this.updateProgress(0, 0);
-            }
-        });
-        if (enabled) {
-            const encoding = opts.encoding;
-            this.client.on('data', (chunk) => {
-                if (buffer) {
-                    if (typeof buffer === 'string') {
-                        buffer += typeof chunk === 'string' ? chunk : chunk.toString(encoding);
-                    }
-                    else if (Array.isArray(buffer)) {
-                        buffer.push(typeof chunk === 'string' ? Buffer.from(chunk, encoding) : chunk);
-                    }
-                    else {
-                        buffer = Buffer.concat([buffer, typeof chunk === 'string' ? Buffer.from(chunk, encoding) : chunk]);
-                    }
-                }
-                else {
-                    buffer = typeof chunk === 'string' ? chunk : [chunk];
-                }
-                if (updating) {
-                    dataLength += Buffer.byteLength(chunk, encoding);
-                    this.updateProgress(dataLength, this.contentLength);
-                }
-                if (maxBufferSize > 0) {
-                    if (!updating) {
-                        dataLength += Buffer.byteLength(chunk, encoding);
-                    }
-                    if (dataLength > maxBufferSize) {
-                        this.terminate((0, types_1.errorValue)("Size limit was exceeded", this.uri.toString()));
-                    }
-                }
-            });
-        }
-        if (opts.trailers) {
-            this.client.once('trailers', (trailers) => {
-                opts.trailers.call(this.client, trailers);
-            });
-        }
-        this.client.once('end', () => {
-            if (this.closed || this.aborted) {
-                return;
-            }
-            this.close();
-            const encoding = opts.encoding;
-            let result;
-            if (buffer) {
-                if (Array.isArray(buffer)) {
-                    buffer = Buffer.concat(buffer);
-                    if (encoding) {
-                        buffer = buffer.toString(encoding);
-                    }
-                }
-                dataLength = Buffer.byteLength(buffer, encoding);
-                if (updating) {
-                    this.updateProgress(dataLength, dataLength);
-                }
-                if (typeof buffer === 'string') {
-                    if (buffer.startsWith('\uFEFF') && encoding !== 'utf16le' && encoding !== 'utf-16le') {
-                        buffer = buffer.substring(1);
-                    }
-                    if (opts.outFormat) {
-                        const { out: format, parser } = opts.outFormat;
-                        let packageName;
-                        try {
-                            switch (format) {
-                                case 'yaml':
-                                    result = yaml.load(buffer, parser);
-                                    break;
-                                case 'json5':
-                                    result = require(packageName = 'json5').parse(buffer);
-                                    break;
-                                case 'xml':
-                                    result = new (require(packageName = 'fast-xml-parser').XMLParser)(parser).parse(buffer);
-                                    break;
-                                case 'toml':
-                                    result = require(packageName = 'toml').parse(buffer);
-                                    break;
-                                default:
-                                    result = JSON.parse(buffer);
-                                    break;
-                            }
-                            if (!(0, types_1.isObject)(result)) {
-                                result = null;
-                            }
-                        }
-                        catch (err) {
-                            if (this.state.verbose && !(packageName && this.instance.checkPackage(err, packageName))) {
-                                this.instance.writeFail(["Unable to parse URI response", format], err, 1024);
-                            }
-                            result = null;
-                        }
-                    }
-                }
-                if (result === undefined) {
-                    result = buffer;
-                }
-            }
-            else {
-                if (updating) {
-                    this.updateProgress(0, this.contentLength);
-                }
-                if (enabled && this.instance.readExpect === 'always') {
-                    this.terminate("No data received");
-                    return;
-                }
-                dataLength = this.contentLength || (typeof this.pipeTo === 'string' ? (0, util_1.getSize)(this.pipeTo) : 0);
-                result = encoding && !pipeline ? '' : null;
-            }
-            this.endResponse(result, dataLength, log);
-        });
-        this.host.success(this.httpVersion);
-    }
-    updateProgress(dataLength, contentLength) {
-        const { host, moduleName } = this.instance;
-        host.updateProgress(moduleName, this.opts.progressId, dataLength, contentLength, this.dataTime);
-    }
-    endResponse(result, dataLength = 0, logging = this.state.log) {
-        if (logging) {
-            this.instance.writeTimeProcess('HTTP' + this.httpVersion, this.opts.statusMessage || this.uri.toString(), this.startTime, {
-                type: 1024,
-                queue: !!this.instance.host,
-                titleBgColor: !result ? 'bgBlue' : undefined,
-                messageUnit: this.formatMibs(dataLength),
-                messageUnitMinWidth: 9,
-                delayTime: this.delayTime,
-                bypassLog: module_1.hasLogType(32768)
-            });
-        }
-        this.resolve(result);
-    }
-    redirectResponse(statusCode, location) {
-        if (location) {
-            if (this.opts.followRedirect === false) {
-                this.terminate(this.formatStatus(statusCode, "Follow redirect was disabled"));
-            }
-            else if (++this.redirects <= this.redirectLimit) {
-                this.abortResponse();
-                this.setOpts((0, util_1.fromURL)(this.opts.url, location));
-                this.init();
-            }
-            else {
-                this.terminate(this.formatStatus(statusCode, "Exceeded redirect limit"));
-            }
-        }
-        else {
-            this.terminate(this.formatStatus(statusCode, "Missing redirect location"));
-        }
-    }
-    abortResponse() {
-        if (this.closed) {
-            return;
-        }
-        this.aborted = true;
-        this.client.destroy();
-        this.instance.reset(this);
-        this.cleanup();
-    }
-    errorResponse(err) {
-        if (HttpAdapter.wasAborted(err)) {
-            this.terminate(err);
-        }
-        else if ((0, util_1.checkRetryable)(err) && ++this.retries <= this.retryLimit) {
-            this.abortResponse();
-            if (HttpAdapter.isConnectionError(err)) {
-                this.retryTimeout();
-            }
-            else {
-                setTimeout(() => {
-                    this.init();
-                }, this.retryWait);
-            }
-        }
-        else {
-            this.host.error(this.httpVersion);
-            this.terminate(err);
-        }
-    }
-    retryResponse(statusCode, retryAfter) {
-        this.abortResponse();
-        if (retryAfter && this.retryAfter > 0) {
-            let offset = +retryAfter || new Date(retryAfter);
-            if (offset instanceof Date) {
-                offset = Math.max(0, offset.getTime() - Date.now());
-            }
-            else {
-                offset *= 1000;
-            }
-            if (offset > 0) {
-                if (offset <= this.retryAfter) {
-                    this.sendWarning(`Retry After (${retryAfter})`);
-                    setTimeout(() => {
-                        this.init();
-                    }, offset);
-                }
-                else {
-                    this.terminate(this.formatStatus(statusCode));
-                }
-                return;
-            }
-        }
-        this.sendWarning(this.#formatRetry((0, util_1.fromStatusCode)(statusCode)));
-        if ((0, util_1.isRetryable)(statusCode, true)) {
-            setImmediate(this.init.bind(this));
-        }
-        else {
-            setTimeout(() => {
-                this.init();
-            }, this.retryWait);
-        }
-    }
-    isRetry(value) {
-        return (0, util_1.isRetryable)(value) && ++this.retries <= this.retryLimit;
-    }
-    retryTimeout() {
-        this.sendWarning(this.#formatRetry("HTTP connection timeout"));
-        this.init();
-    }
-    terminate(err) {
-        if (this.closed) {
-            return;
-        }
-        this.cleanup();
-        this.close();
-        this.reject(typeof err === 'string' ? new Error(err) : err);
-    }
-    sendWarning(message) {
-        if (this.state.verbose) {
-            const { host, url } = this.opts;
-            this.instance.formatMessage(1024, 'HTTP' + this.httpVersion, [message, host.origin], url.toString(), { ...module_1.LOG_STYLE_WARN });
-        }
-    }
-    formatStatus(value, hint) {
-        return value + ': ' + (hint || (0, util_1.fromStatusCode)(value)) + ` (${this.uri.toString()})`;
-    }
-    formatMibs(dataLength) {
-        if (dataLength > 0 && this.dataTime) {
-            return (0, util_1.getTransferRate)(dataLength, Math.max(1, (0, types_1.convertTime)(process.hrtime.bigint() - this.dataTime, false) * 1000));
-        }
-    }
-    close() {
-        this.closed = true;
-        this.instance.reset(this);
-        if (this.aborted && !this.client.aborted) {
-            this.abortController?.abort();
-        }
-    }
-    cleanup() {
-        if ((0, types_1.isString)(this.pipeTo) && this.outStream) {
-            (0, util_1.cleanupStream)(this.outStream, this.pipeTo);
-            this.outStream = null;
-        }
-    }
-    #formatNgFlags(value, statusCode, location) {
-        return location ? `Using HTTP 1.1 for URL redirect (${location})` : this.formatStatus(statusCode, value ? 'NGHTTP2 Error ' + value : '');
-    }
-    #formatRetry(message) {
-        return `${message} (${this.retries} / ${this.retryLimit})`;
-    }
-    set abortController(value) {
-        this.opts.outAbort = value;
-    }
-    get abortController() {
-        return this.opts.outAbort || null;
-    }
-    set outStream(value) {
-        this.#outStream = value;
-        if (value) {
-            this.opts.outStream = value;
-        }
-    }
-    get outStream() {
-        return this.#outStream;
-    }
-    get destroyed() {
-        return this.client.destroyed || this.httpVersion === 2 && this.client.aborted;
-    }
-    get host() {
-        return this.opts.host;
-    }
-    get httpVersion() {
-        return this.opts.httpVersion;
-    }
-    get pipeTo() {
-        return this.opts.pipeTo;
-    }
-    get silent() {
-        return this.opts.silent === false;
-    }
-    get retryLimit() {
-        return this.state.config.retryLimit;
-    }
-    get retryWait() {
-        return this.state.config.retryWait;
-    }
-    get retryAfter() {
-        return this.state.config.retryAfter;
-    }
-    get redirectLimit() {
-        return this.state.config.redirectLimit;
-    }
-}
-module.exports = HttpAdapter;