@e-mc/request 0.5.2 → 0.6.0

package/http/host/index.js

@@ -107,7 +107,7 @@ class HttpHost {
                         });
                         socket
                             .setNoDelay(false)
-                            .setTimeout(5000 /* HOST.TIMEOUT */)
+                            .setTimeout(10000 /* HOST.TIMEOUT */)
                             .on('timeout', () => {
                             if (this._tlsConnect) {
                                 if (this.error(version) >= 10 /* HOST.MAX_ERROR */) {
@@ -173,10 +173,11 @@ class HttpHost {
                     }
                     return false;
                 };
-                const pattern = new RegExp(`h${i + 1}="([^:]*):(\\d+)"([^,]*)`, 'g');
+                const pattern = new RegExp(`h${i + 1}(?:-\\d+)?="([^:]*):(\\d+)"([^,]*)`, 'g');
                 const addresses = [];
                 const time = Date.now();
                 const hostname = this[kHostname];
+                const excluded = this[kAltSvcError];
                 let match;
                 while (match = pattern.exec(altSvc)) {
                     const port = match[2];
@@ -187,7 +188,7 @@ class HttpHost {
                     }
                     const address = match[1] || hostname;
                     const ma = +(/ma=(\d+)/.exec(match[3])?.[1] || 86400);
-                    if (!this[kAltSvcError].includes(`h${i + 1}:${address}:${port}`)) {
+                    if (!excluded.includes(`h${i + 1}:${address}:${port}`)) {
                         addresses.push([
                             address,
                             port,
@@ -278,11 +279,7 @@ class HttpHost {
             this.closeAltSvc();
             this[kAltSvcQueue] = [];
             this[kAltSvcError] = [];
-            this[kVersionData].forEach(item => {
-                if (item[3 /* HOST_VERSION.ALPN */] !== 0) {
-                    item[4 /* HOST_VERSION.ALT_SVC */] = -1;
-                }
-            });
+            this[kVersionData].forEach(item => item[3 /* HOST_VERSION.ALPN */] && (item[4 /* HOST_VERSION.ALT_SVC */] = -1));
         }
     }
     flagAltSvc(version, value) {

package/index.js

@@ -53,6 +53,8 @@ const DNS = {
 };
 const ARIA2 = {
     BIN: which.sync(PLATFORM_WIN32 ? 'aria2c.exe' : 'aria2c', { nothrow: true }) || '',
+    EXEC_UID: undefined,
+    EXEC_GID: undefined,
     PID_TIMER: null,
     PID_QUEUE: [],
     UPDATE_STATUS: 0,
@@ -76,6 +78,14 @@ let AGENT_TIMEOUT = 0;
 let LOG_HTTP = false;
 let LOG_TIMEPROCESS = true;
 let LOG_TIMEFORMAT = 'readable';
+let LIB_ZSTD = null;
+try {
+    require('zstd-codec/lib/zstd-stream').run(codec => {
+        LIB_ZSTD = codec;
+    });
+}
+catch {
+}
 function getBaseHeaders(uri, headers) {
     uri = (0, util_1.trimPath)(uri);
     let result;
@@ -122,7 +132,7 @@ function setOutgoingHeaders(output, headers) {
 }
 function getProxySettings(request, agentTimeout) {
     const proxy = request.proxy;
-    if ((0, types_1.isObject)(proxy) && proxy.address && proxy.port) {
+    if (proxy?.address && proxy.port) {
         const port = (0, util_1.asInt)(proxy.port);
         const address = (!module_1.default.isURL(proxy.address) ? port === 80 ? 'http://' : 'https://' : '') + proxy.address;
         try {
@@ -144,11 +154,9 @@ function getProxySettings(request, agentTimeout) {
     return null;
 }
 function closeTorrent(pid) {
-    if (pid !== undefined) {
-        const index = ARIA2.PID_QUEUE.findIndex(value => pid === value[0]);
-        if (index !== -1) {
-            ARIA2.PID_QUEUE.splice(index, 1);
-        }
+    const index = ARIA2.PID_QUEUE.findIndex(value => pid === value[0]);
+    if (index !== -1) {
+        ARIA2.PID_QUEUE.splice(index, 1);
     }
 }
 function clearDnsLookup() {
@@ -266,7 +274,7 @@ class Request extends module_1.default {
         if (!this.enabled("process.password" /* KEY_NAME.PROCESS_PASSWORD */) || super.loadSettings({ process: settings.process }, password)) {
             const { request, download } = settings;
             if (download && (0, types_1.isPlainObject)(download.aria2)) {
-                let { bin, update_status, max_concurrent_downloads, max_connection_per_server, bt_stop_timeout, bt_tracker_connect_timeout, bt_tracker_timeout, min_split_size, disk_cache, lowest_speed_limit, always_resume, file_allocation, conf_path } = download.aria2;
+                let { bin, exec, update_status, max_concurrent_downloads, max_connection_per_server, bt_stop_timeout, bt_tracker_connect_timeout, bt_tracker_timeout, min_split_size, disk_cache, lowest_speed_limit, always_resume, file_allocation, conf_path } = download.aria2;
                 const parseSize = (value, zero) => {
                     if (zero && (value === '0' || value === 0)) {
                         return 0;
@@ -281,6 +289,11 @@ class Request extends module_1.default {
                 else if (bin && this.isPath(bin = path.resolve(bin), true)) {
                     ARIA2.BIN = bin;
                 }
+                if ((0, types_1.isPlainObject)(exec)) {
+                    let { uid, gid } = exec;
+                    ARIA2.EXEC_UID = (uid = (0, util_1.asInt)(uid)) >= 0 ? uid : undefined;
+                    ARIA2.EXEC_GID = (gid = (0, util_1.asInt)(gid)) >= 0 ? gid : undefined;
+                }
                 if ((0, types_1.isPlainObject)(update_status)) {
                     const { interval, broadcast_only } = update_status;
                     if (typeof broadcast_only === 'boolean') {
@@ -409,124 +422,141 @@ class Request extends module_1.default {
         return url.protocol + '//' + (auth && (auth + '@')) + url.hostname + (url.port ? ':' + url.port : '') + (value[0] !== '/' ? '/' : '') + value;
     }
     static fromStatusCode(value) {
-        switch (+value) {
-            case 100 /* HTTP_STATUS.CONTINUE */:
-                return 'Continue';
-            case 101 /* HTTP_STATUS.SWITCHING_PROTOCOL */:
-                return 'Switching Protocol';
-            case 102 /* HTTP_STATUS.PROCESSING */:
-                return 'Processing';
-            case 103 /* HTTP_STATUS.EARLY_HINTS */:
-                return 'Early Hints';
-            case 200 /* HTTP_STATUS.OK */:
-                return 'OK';
-            case 201 /* HTTP_STATUS.CREATED */:
-                return 'Created';
-            case 202 /* HTTP_STATUS.ACCEPTED */:
-                return 'Accepted';
-            case 203 /* HTTP_STATUS.NON_AUTHORITATIVE_INFORMATION */:
-                return 'Non-Authoritative Information';
-            case 204 /* HTTP_STATUS.NO_CONTENT */:
-                return 'No Content';
-            case 205 /* HTTP_STATUS.RESET_CONTENT */:
-                return 'Reset Content';
-            case 206 /* HTTP_STATUS.PARTIAL_CONTENT */:
-                return 'Partial Content';
-            case 300 /* HTTP_STATUS.MULTIPLE_CHOICES */:
-                return 'Multiple Choice';
-            case 301 /* HTTP_STATUS.MOVED_PERMANENTLY */:
-                return 'Moved Permanently';
-            case 302 /* HTTP_STATUS.FOUND */:
-                return 'Found';
-            case 303 /* HTTP_STATUS.SEE_OTHER */:
-                return 'See Other';
-            case 304 /* HTTP_STATUS.NOT_MODIFIED */:
-                return 'Not Modified';
-            case 305 /* HTTP_STATUS.USE_PROXY */:
-                return 'Use Proxy';
-            case 307 /* HTTP_STATUS.TEMPORARY_REDIRECT */:
-                return 'Temporary Redirect';
-            case 308 /* HTTP_STATUS.PERMANENT_REDIRECT */:
-                return 'Permanent Redirect';
-            case 400 /* HTTP_STATUS.BAD_REQUEST */:
-                return 'Bad Request';
-            case 401 /* HTTP_STATUS.UNAUTHORIZED */:
-                return 'Upgrade Required';
-            case 402 /* HTTP_STATUS.PAYMENT_REQUIRED */:
-                return 'Payment Required';
-            case 403 /* HTTP_STATUS.FORBIDDEN */:
-                return 'Forbidden';
-            case 404 /* HTTP_STATUS.NOT_FOUND */:
-                return 'Not Found';
-            case 405 /* HTTP_STATUS.METHOD_NOT_ALLOWED */:
-                return 'Method Not Allowed';
-            case 406 /* HTTP_STATUS.NOT_ACCEPTABLE */:
-                return 'Not Acceptable';
-            case 407 /* HTTP_STATUS.PROXY_AUTHENTICATION_REQUIRED */:
-                return 'Proxy Authentication Required';
-            case 408 /* HTTP_STATUS.REQUEST_TIMEOUT */:
-                return 'Request Timeout';
-            case 409 /* HTTP_STATUS.CONFLICT */:
-                return 'Conflict';
-            case 410 /* HTTP_STATUS.GONE */:
-                return 'Gone';
-            case 411 /* HTTP_STATUS.LENGTH_REQUIRED */:
-                return 'Length Required';
-            case 412 /* HTTP_STATUS.PRECONDITION_FAILED */:
-                return 'Precondition Failed';
-            case 413 /* HTTP_STATUS.PAYLOAD_TOO_LARGE */:
-                return 'Payload Too Large';
-            case 414 /* HTTP_STATUS.REQUEST_URI_TOO_LONG */:
-                return 'URI Too Long';
-            case 415 /* HTTP_STATUS.UNSUPPORTED_MEDIA_TYPE */:
-                return 'Unsupported Media Type';
-            case 416 /* HTTP_STATUS.RANGE_NOT_SATISFIABLE */:
-                return 'Range Not Satisfiable';
-            case 417 /* HTTP_STATUS.EXPECTATION_FAILED */:
-                return 'Expectation Failed';
-            case 421 /* HTTP_STATUS.MISDIRECTED_REQUEST */:
-                return 'Misdirected Request';
-            case 422 /* HTTP_STATUS.UNPROCESSABLE_ENTITY */:
-                return 'Unprocessable Entity';
-            case 423 /* HTTP_STATUS.LOCKED */:
-                return 'Locked';
-            case 424 /* HTTP_STATUS.FAILED_DEPENDENCY */:
-                return 'Failed Dependency';
-            case 426 /* HTTP_STATUS.UPGRADE_REQUIRED */:
-                return 'Upgrade Required';
-            case 428 /* HTTP_STATUS.PRECONDITION_REQUIRED */:
-                return 'Precondition Required';
-            case 429 /* HTTP_STATUS.TOO_MANY_REQUESTS */:
-                return 'Too Many Requests';
-            case 431 /* HTTP_STATUS.REQUEST_HEADER_FIELDS_TOO_LARGE */:
-                return 'Request Header Fields Too Large';
-            case 451 /* HTTP_STATUS.UNAVAILABLE_FOR_LEGAL_REASONS */:
-                return 'Unavailable For Legal Reasons';
-            case 500 /* HTTP_STATUS.INTERNAL_SERVER_ERROR */:
-                return 'Internal Server Error';
-            case 501 /* HTTP_STATUS.NOT_IMPLEMENTED */:
-                return 'Not Implemented';
-            case 502 /* HTTP_STATUS.BAD_GATEWAY */:
-                return 'Bad Gateway';
-            case 503 /* HTTP_STATUS.SERVICE_UNAVAILABLE */:
-                return 'Service Unavailable';
-            case 504 /* HTTP_STATUS.GATEWAY_TIMEOUT */:
-                return 'Gateway Timeout';
-            case 505 /* HTTP_STATUS.HTTP_VERSION_NOT_SUPPORTED */:
-                return 'HTTP Version Not Supported';
-            case 506 /* HTTP_STATUS.VARIANT_ALSO_NEGOTIATES */:
-                return 'Variant Also Negotiates';
-            case 507 /* HTTP_STATUS.INSUFFICIENT_STORAGE */:
-                return 'Insufficient Storage';
-            case 508 /* HTTP_STATUS.LOOP_DETECTED */:
-                return 'Loop Detected';
-            case 510 /* HTTP_STATUS.NOT_EXTENDED */:
-                return 'Not Extended';
-            case 511 /* HTTP_STATUS.NETWORK_AUTHENTICATION_REQUIRED */:
-                return 'Network Authentication Required';
-            default:
-                return "Unknown" /* ERR_MESSAGE.UNKNOWN */;
+        if ((value = +value) < 200) {
+            switch (value) {
+                case 100 /* HTTP_STATUS.CONTINUE */:
+                    return 'Continue';
+                case 101 /* HTTP_STATUS.SWITCHING_PROTOCOL */:
+                    return 'Switching Protocol';
+                case 102 /* HTTP_STATUS.PROCESSING */:
+                    return 'Processing';
+                case 103 /* HTTP_STATUS.EARLY_HINTS */:
+                    return 'Early Hints';
+            }
+        }
+        else if (value < 300) {
+            switch (value) {
+                case 200 /* HTTP_STATUS.OK */:
+                    return 'OK';
+                case 201 /* HTTP_STATUS.CREATED */:
+                    return 'Created';
+                case 202 /* HTTP_STATUS.ACCEPTED */:
+                    return 'Accepted';
+                case 203 /* HTTP_STATUS.NON_AUTHORITATIVE_INFORMATION */:
+                    return 'Non-Authoritative Information';
+                case 204 /* HTTP_STATUS.NO_CONTENT */:
+                    return 'No Content';
+                case 205 /* HTTP_STATUS.RESET_CONTENT */:
+                    return 'Reset Content';
+                case 206 /* HTTP_STATUS.PARTIAL_CONTENT */:
+                    return 'Partial Content';
+            }
+        }
+        else if (value < 400) {
+            switch (value) {
+                case 300 /* HTTP_STATUS.MULTIPLE_CHOICES */:
+                    return 'Multiple Choice';
+                case 301 /* HTTP_STATUS.MOVED_PERMANENTLY */:
+                    return 'Moved Permanently';
+                case 302 /* HTTP_STATUS.FOUND */:
+                    return 'Found';
+                case 303 /* HTTP_STATUS.SEE_OTHER */:
+                    return 'See Other';
+                case 304 /* HTTP_STATUS.NOT_MODIFIED */:
+                    return 'Not Modified';
+                case 305 /* HTTP_STATUS.USE_PROXY */:
+                    return 'Use Proxy';
+                case 307 /* HTTP_STATUS.TEMPORARY_REDIRECT */:
+                    return 'Temporary Redirect';
+                case 308 /* HTTP_STATUS.PERMANENT_REDIRECT */:
+                    return 'Permanent Redirect';
+            }
+        }
+        else if (value < 500) {
+            switch (value) {
+                case 400 /* HTTP_STATUS.BAD_REQUEST */:
+                    return 'Bad Request';
+                case 401 /* HTTP_STATUS.UNAUTHORIZED */:
+                    return 'Upgrade Required';
+                case 402 /* HTTP_STATUS.PAYMENT_REQUIRED */:
+                    return 'Payment Required';
+                case 403 /* HTTP_STATUS.FORBIDDEN */:
+                    return 'Forbidden';
+                case 404 /* HTTP_STATUS.NOT_FOUND */:
+                    return 'Not Found';
+                case 405 /* HTTP_STATUS.METHOD_NOT_ALLOWED */:
+                    return 'Method Not Allowed';
+                case 406 /* HTTP_STATUS.NOT_ACCEPTABLE */:
+                    return 'Not Acceptable';
+                case 407 /* HTTP_STATUS.PROXY_AUTHENTICATION_REQUIRED */:
+                    return 'Proxy Authentication Required';
+                case 408 /* HTTP_STATUS.REQUEST_TIMEOUT */:
+                    return 'Request Timeout';
+                case 409 /* HTTP_STATUS.CONFLICT */:
+                    return 'Conflict';
+                case 410 /* HTTP_STATUS.GONE */:
+                    return 'Gone';
+                case 411 /* HTTP_STATUS.LENGTH_REQUIRED */:
+                    return 'Length Required';
+                case 412 /* HTTP_STATUS.PRECONDITION_FAILED */:
+                    return 'Precondition Failed';
+                case 413 /* HTTP_STATUS.PAYLOAD_TOO_LARGE */:
+                    return 'Payload Too Large';
+                case 414 /* HTTP_STATUS.REQUEST_URI_TOO_LONG */:
+                    return 'URI Too Long';
+                case 415 /* HTTP_STATUS.UNSUPPORTED_MEDIA_TYPE */:
+                    return 'Unsupported Media Type';
+                case 416 /* HTTP_STATUS.RANGE_NOT_SATISFIABLE */:
+                    return 'Range Not Satisfiable';
+                case 417 /* HTTP_STATUS.EXPECTATION_FAILED */:
+                    return 'Expectation Failed';
+                case 421 /* HTTP_STATUS.MISDIRECTED_REQUEST */:
+                    return 'Misdirected Request';
+                case 422 /* HTTP_STATUS.UNPROCESSABLE_ENTITY */:
+                    return 'Unprocessable Entity';
+                case 423 /* HTTP_STATUS.LOCKED */:
+                    return 'Locked';
+                case 424 /* HTTP_STATUS.FAILED_DEPENDENCY */:
+                    return 'Failed Dependency';
+                case 426 /* HTTP_STATUS.UPGRADE_REQUIRED */:
+                    return 'Upgrade Required';
+                case 428 /* HTTP_STATUS.PRECONDITION_REQUIRED */:
+                    return 'Precondition Required';
+                case 429 /* HTTP_STATUS.TOO_MANY_REQUESTS */:
+                    return 'Too Many Requests';
+                case 431 /* HTTP_STATUS.REQUEST_HEADER_FIELDS_TOO_LARGE */:
+                    return 'Request Header Fields Too Large';
+                case 451 /* HTTP_STATUS.UNAVAILABLE_FOR_LEGAL_REASONS */:
+                    return 'Unavailable For Legal Reasons';
+            }
         }
+        else {
+            switch (value) {
+                case 500 /* HTTP_STATUS.INTERNAL_SERVER_ERROR */:
+                    return 'Internal Server Error';
+                case 501 /* HTTP_STATUS.NOT_IMPLEMENTED */:
+                    return 'Not Implemented';
+                case 502 /* HTTP_STATUS.BAD_GATEWAY */:
+                    return 'Bad Gateway';
+                case 503 /* HTTP_STATUS.SERVICE_UNAVAILABLE */:
+                    return 'Service Unavailable';
+                case 504 /* HTTP_STATUS.GATEWAY_TIMEOUT */:
+                    return 'Gateway Timeout';
+                case 505 /* HTTP_STATUS.HTTP_VERSION_NOT_SUPPORTED */:
+                    return 'HTTP Version Not Supported';
+                case 506 /* HTTP_STATUS.VARIANT_ALSO_NEGOTIATES */:
+                    return 'Variant Also Negotiates';
+                case 507 /* HTTP_STATUS.INSUFFICIENT_STORAGE */:
+                    return 'Insufficient Storage';
+                case 508 /* HTTP_STATUS.LOOP_DETECTED */:
+                    return 'Loop Detected';
+                case 510 /* HTTP_STATUS.NOT_EXTENDED */:
+                    return 'Not Extended';
+                case 511 /* HTTP_STATUS.NETWORK_AUTHENTICATION_REQUIRED */:
+                    return 'Network Authentication Required';
+            }
+        }
+        return "Unknown" /* ERR_MESSAGE.UNKNOWN */;
     }
     static defineHttpAgent(options) {
         const { keepAlive, timeout = 0 } = options;
@@ -609,11 +639,8 @@ class Request extends module_1.default {
             this.readTimeout = (value = (0, util_1.fromSeconds)(read_timeout)) >= 0 ? value : READ_TIMEOUT;
             this.keepAlive = typeof (value = agent?.keep_alive) === 'boolean' ? value : KEEP_ALIVE;
             this.acceptEncoding = typeof (value = use?.accept_encoding) === 'boolean' ? value : ACCEPT_ENCODING;
-            switch (value = (0, util_1.asInt)(use?.http_version)) {
-                case 1:
-                case 2:
-                    this[kHttpVersion] = value;
-                    break;
+            if ((value = (0, util_1.asInt)(use?.http_version)) === 1 || value === 2) {
+                this[kHttpVersion] = value;
             }
             this[kIpVersion] = (value = (0, util_1.asInt)(data.dns?.family)) && (value === 4 || value === 6) ? value : 0;
             if ((value = (0, util_1.fromSeconds)(agent?.timeout)) >= 0) {
@@ -796,28 +823,26 @@ class Request extends module_1.default {
         return this;
     }
     addDns(hostname, address, family) {
-        if (!this[kConnectDns][hostname]) {
-            switch (family) {
-                case 'IPv4':
+        switch (family) {
+            case 'IPv4':
+                family = 4;
+                break;
+            case 'IPv6':
+                family = 6;
+                break;
+            default:
+                if (net.isIPv4(address)) {
                     family = 4;
-                    break;
-                case 'IPv6':
+                }
+                else if (net.isIPv6(address)) {
                     family = 6;
-                    break;
-                default:
-                    if (net.isIPv4(address)) {
-                        family = 4;
-                    }
-                    else if (net.isIPv6(address)) {
-                        family = 6;
-                    }
-                    else {
-                        return;
-                    }
-                    break;
-            }
-            setDnsCache(hostname, this[kConnectDns][hostname] = [{ address, family }]);
+                }
+                else {
+                    return;
+                }
+                break;
         }
+        setDnsCache(hostname, this[kConnectDns][hostname] = [{ address, family }]);
     }
     lookupDns(hostname) {
         var _l;
@@ -887,17 +912,18 @@ class Request extends module_1.default {
     }
     proxyOf(uri, localhost) {
         const proxy = this.proxy || this.host && HTTP.PROXY;
-        if (proxy) {
-            const { include, exclude } = proxy;
-            if (!include && !exclude && !localhost) {
-                return proxy;
-            }
-            if ((0, types_1.isArray)(include)) {
-                return include.some(value => uri.startsWith(value)) ? proxy : undefined;
-            }
-            if (Array.isArray(exclude) && !exclude.some(value => uri.startsWith(value))) {
-                return proxy;
-            }
+        if (!proxy) {
+            return;
+        }
+        const { include, exclude } = proxy;
+        if (!include && !exclude && !localhost) {
+            return proxy;
+        }
+        if ((0, types_1.isArray)(include)) {
+            return include.some(value => uri.startsWith(value)) ? proxy : undefined;
+        }
+        if (Array.isArray(exclude) && !exclude.some(value => uri.startsWith(value))) {
+            return proxy;
         }
     }
     headersOf(uri) {
@@ -1158,7 +1184,7 @@ class Request extends module_1.default {
                 closeTorrent(pid);
                 reject(err);
             };
-            const { pid, stdout, stderr } = child_process.spawn(module_1.default.sanitizeCmd(ARIA2.BIN), args, { cwd: pathname, shell: true, signal: this.signal })
+            const { pid, stdout, stderr } = child_process.spawn(module_1.default.sanitizeCmd(ARIA2.BIN), args, { cwd: pathname, shell: true, signal: this.signal, uid: ARIA2.EXEC_UID, gid: ARIA2.EXEC_GID })
                 .on('exit', code => {
                 closeTorrent(pid);
                 if (aborted) {
@@ -1291,23 +1317,23 @@ class Request extends module_1.default {
             headers || (headers = {});
             switch (format = format.trim().toLowerCase()) {
                 case 'yaml':
-                    headers['accept'] = 'application/yaml, application/x-yaml, text/yaml, text/x-yaml';
+                    headers.accept = 'application/yaml, application/x-yaml, text/yaml, text/x-yaml';
                     break;
                 case 'json5':
-                    headers['accept'] = 'application/json5, application/json, text/javascript';
+                    headers.accept = 'application/json5, application/json, text/javascript';
                     break;
                 case 'xml':
-                    headers['accept'] = 'application/xml, text/xml';
+                    headers.accept = 'application/xml, text/xml';
                     break;
                 case 'toml':
-                    headers['accept'] = 'application/toml';
+                    headers.accept = 'application/toml';
                     break;
                 default:
-                    headers['accept'] = 'application/json, text/javascript';
+                    headers.accept = 'application/json, text/javascript';
                     format = 'json';
                     break;
             }
-            headers['accept'] += ', text/plain';
+            headers.accept += ', text/plain';
             options.encoding = (0, types_1.getEncoding)(encoding);
             options.outFormat = { out: format, parser };
         }
@@ -1346,6 +1372,11 @@ class Request extends module_1.default {
                 case 'deflate-raw':
                     pipeTo = zlib.createInflateRaw({ chunkSize });
                     break;
+                case 'zstd':
+                    if (LIB_ZSTD) {
+                        pipeTo = new LIB_ZSTD.ZstdDecompressTransform({ writableHighWaterMark: chunkSize });
+                    }
+                    break;
             }
             if (pipeTo) {
                 if (outStream) {
@@ -1357,21 +1388,22 @@ class Request extends module_1.default {
                 return pipeTo;
             }
         };
-        const { hostname, origin } = host;
+        const { hostname, origin, secure, localhost } = host;
         const pathname = url.pathname + (socketPath ? '' : url.search);
-        const proxy = this.proxyOf(uri, host.localhost);
+        const proxy = this.proxyOf(uri, localhost);
+        const version = this.httpVersion;
         let request, ca, cert, key, minVersion, baseHeaders = this.headersOf(uri);
-        if (getting && this.acceptEncoding && !host.localhost && !baseHeaders?.['accept-encoding']) {
-            (_l = (headers || (headers = {})))['accept-encoding'] || (_l['accept-encoding'] = 'gzip, deflate, br');
+        if (getting && this.acceptEncoding && !localhost && !baseHeaders?.['accept-encoding']) {
+            (_l = (headers || (headers = {})))['accept-encoding'] || (_l['accept-encoding'] = 'gzip, deflate, br' + (LIB_ZSTD ? ', zstd' : ''));
         }
-        if (host.secure) {
-            const secure = this[kCerts]?.[0][origin] || (this.host ? TLS.TEXT[origin] : null);
-            if (secure) {
-                ({ ca, cert, key, version: minVersion } = secure);
+        if (secure) {
+            const certs = this[kCerts]?.[0][origin] || (this.host ? TLS.TEXT[origin] : null);
+            if (certs) {
+                ({ ca, cert, key, version: minVersion } = certs);
             }
         }
-        if (!proxy && httpVersion !== 1 && ((httpVersion || host.version) === 2 && this.httpVersion !== 1 || host.secure && this.httpVersion === 2 && host.failed(2, true) === 0)) {
-            request = ((_m = this[kSession][0])[origin] || (_m[origin] = http2.connect(origin, { lookup: this.lookupDns(hostname), ca, cert, key, minVersion }))).request({ ...baseHeaders, ...host_1.default.getBasicAuth(url), ...headers, ':path': pathname, ':method': method });
+        if (!proxy && httpVersion !== 1 && ((httpVersion || host.version) === 2 && version !== 1 || secure && version === 2 && host.failed(2, true) === 0)) {
+            request = ((_m = this[kSession][0])[origin] || (_m[origin] = http2.connect(origin, { lookup: this.lookupDns(hostname), ca, cert, key, minVersion, settings: localhost ? { initialWindowSize: 4294967295 /* CONSTANTS.INITIAL_WINDOW_SIZE */, maxFrameSize: 16777215 /* CONSTANTS.MAX_FRAME_SIZE */, enablePush: false } : { enablePush: false } }))).request({ ...baseHeaders, ...host_1.default.getBasicAuth(url), ...headers, ':path': pathname, ':method': method });
             if (getting) {
                 const listenerMap = {};
                 const onEvent = request.on.bind(request);
@@ -1451,7 +1483,7 @@ class Request extends module_1.default {
             let agent;
             if (!socketPath) {
                 if (proxy) {
-                    const pkg = host.secure ? 'https-proxy-agent' : 'http-proxy-agent';
+                    const pkg = secure ? 'https-proxy-agent' : 'http-proxy-agent';
                     try {
                         const { protocol, hostname: proxyname, port, username, password, href } = proxy.host;
                         keepAlive ?? (keepAlive = proxy.keepAlive || false);
@@ -1467,16 +1499,16 @@ class Request extends module_1.default {
                     }
                 }
                 else if (keepAlive === false) {
-                    agent = new (host.secure ? https.Agent : http.Agent)({ keepAlive: false });
+                    agent = new (secure ? https.Agent : http.Agent)({ keepAlive: false });
                 }
                 else if (keepAlive === true || agentTimeout > 0) {
-                    agent = new (host.secure ? https.Agent : http.Agent)({ keepAlive: true, timeout: agentTimeout });
+                    agent = new (secure ? https.Agent : http.Agent)({ keepAlive: true, timeout: agentTimeout });
                 }
                 else if (agentTimeout !== 0) {
                     keepAlive = this.keepAlive || false;
                     agentTimeout ?? (agentTimeout = this.agentTimeout);
                     if (keepAlive || agentTimeout > 0) {
-                        agent = new (host.secure ? https.Agent : http.Agent)({ keepAlive, timeout: agentTimeout });
+                        agent = new (secure ? https.Agent : http.Agent)({ keepAlive, timeout: agentTimeout });
                     }
                 }
             }
@@ -1484,7 +1516,7 @@ class Request extends module_1.default {
             if (baseHeaders || basicAuth) {
                 headers = { ...baseHeaders, ...basicAuth, ...headers };
             }
-            request = (host.secure ? https : http).request(socketPath ? { socketPath, path: pathname } : {
+            request = (secure ? https : http).request(socketPath ? { socketPath, path: pathname } : {
                 protocol: host.protocol,
                 hostname,
                 port: host.port,
@@ -1500,7 +1532,8 @@ class Request extends module_1.default {
             }, response => {
                 const statusCode = response.statusCode;
                 if ((getting || posting) && statusCode >= 200 /* HTTP_STATUS.OK */ && statusCode < 300 /* HTTP_STATUS.MULTIPLE_CHOICES */) {
-                    let source = checkEncoding(response, statusCode, response.headers['content-encoding']);
+                    const incoming = response.headers;
+                    let source = checkEncoding(response, statusCode, incoming['content-encoding']);
                     if (source) {
                         source.once('finish', () => request.emit('end'));
                     }
@@ -1531,8 +1564,13 @@ class Request extends module_1.default {
                     if (response !== source) {
                         source.on('error', err => request.emit('error', err));
                     }
-                    if (!posting && !host.didAltSvc(1)) {
-                        host.upgrade(1, response.headers['alt-svc']);
+                    if (!posting) {
+                        if (version === 2 && incoming.upgrade?.includes('h2')) {
+                            host.version = 2;
+                        }
+                        else if (!host.didAltSvc(1)) {
+                            host.upgrade(1, incoming['alt-svc']);
+                        }
                     }
                     if (LOG_HTTP) {
                         this[kConnectHttp][0][origin] = (this[kConnectHttp][0][origin] || 0) + 1;
@@ -1608,11 +1646,9 @@ class Request extends module_1.default {
         }
         const headers = options.headers || (options.headers = {});
         for (const attr in headers) {
-            switch (attr.toLowerCase()) {
-                case 'content-type':
-                case 'content-length':
-                    delete headers[attr];
-                    break;
+            const name = attr.toLowerCase();
+            if (name === 'content-type' || name === 'content-length') {
+                delete headers[attr];
             }
         }
         if (parts || contentType === "multipart/form-data" /* MIME.MULTIPART */ || contentType === 'form-data') {
@@ -1643,53 +1679,54 @@ class Request extends module_1.default {
                     }
                 }
                 for (let { name, data: target, value, contentType: type, filename } of parts) {
-                    if ((0, types_1.isString)(name)) {
-                        if (target) {
-                            try {
-                                if (typeof target === 'string') {
-                                    filename || (filename = path.basename(target));
-                                    type || (type = module_1.default.lookupMime(filename));
-                                    target = fs.readFileSync(target);
+                    if (!(0, types_1.isString)(name)) {
+                        continue;
+                    }
+                    if (target) {
+                        try {
+                            if (typeof target === 'string') {
+                                filename || (filename = path.basename(target));
+                                type || (type = module_1.default.lookupMime(filename));
+                                target = fs.readFileSync(target);
+                            }
+                            else if (target instanceof stream.Readable) {
+                                const chunks = [];
+                                for await (const chunk of target) {
+                                    chunks.push(chunk);
                                 }
-                                else if (target instanceof stream.Readable) {
-                                    const chunks = [];
-                                    for await (const chunk of target) {
-                                        chunks.push(chunk);
-                                    }
-                                    target = Buffer.concat(chunks);
+                                target = Buffer.concat(chunks);
+                            }
+                            if (!Buffer.isBuffer(target)) {
+                                throw (0, types_1.errorMessage)('File', "Unknown" /* ERR_MESSAGE.UNKNOWN */, "multipart/form-data" /* MIME.MULTIPART */);
+                            }
+                            if (!type || !filename) {
+                                const result = await module_1.default.resolveMime(target);
+                                let ext;
+                                if (result) {
+                                    type || (type = result.mime);
+                                    ext = result.ext;
                                 }
-                                if (!Buffer.isBuffer(target)) {
-                                    throw (0, types_1.errorMessage)('File', "Unknown" /* ERR_MESSAGE.UNKNOWN */, "multipart/form-data" /* MIME.MULTIPART */);
+                                else if (type) {
+                                    ext = module_1.default.lookupMime(type, true);
                                 }
-                                if (!type || !filename) {
-                                    const result = await module_1.default.resolveMime(target);
-                                    let ext;
-                                    if (result) {
-                                        type || (type = result.mime);
-                                        ext = result.ext;
-                                    }
-                                    else if (type) {
-                                        ext = module_1.default.lookupMime(type, true);
-                                    }
-                                    if (ext && !filename) {
-                                        filename = (0, types_1.generateUUID)() + '.' + ext;
-                                    }
+                                if (ext && !filename) {
+                                    filename = (0, types_1.generateUUID)() + '.' + ext;
                                 }
-                                const disposition = createPart(name, filename, type || "application/octet-stream" /* MIME.OCTET_STREAM */);
-                                write.append(disposition);
-                                write.append(target);
-                                write.append("\r\n" /* FORM_DATA.CRLF */);
-                                contentLength += Buffer.byteLength(disposition) + target.length + 2 /* FORM_DATA.CRLF_LENGTH */;
-                                valid = true;
-                            }
-                            catch (err) {
-                                return Promise.reject(err);
                             }
+                            const disposition = createPart(name, filename, type || "application/octet-stream" /* MIME.OCTET_STREAM */);
+                            write.append(disposition);
+                            write.append(target);
+                            write.append("\r\n" /* FORM_DATA.CRLF */);
+                            contentLength += Buffer.byteLength(disposition) + target.length + 2 /* FORM_DATA.CRLF_LENGTH */;
+                            valid = true;
                         }
-                        else {
-                            addValue(name, value);
+                        catch (err) {
+                            return Promise.reject(err);
                         }
                     }
+                    else {
+                        addValue(name, value);
+                    }
                 }
                 if (valid) {
                     write.append("--" /* FORM_DATA.BOUNDARY_HASH */ + boundary + "--" /* FORM_DATA.BOUNDARY_HASH */ + "\r\n" /* FORM_DATA.CRLF */);
@@ -1705,17 +1742,15 @@ class Request extends module_1.default {
             if (contentType && !contentType.includes('/')) {
                 contentType = 'application/' + contentType.trim();
             }
-            if ((0, types_1.isPlainObject)(data)) {
-                if (contentType === "application/x-www-form-urlencoded" /* MIME.URLENCODED */) {
-                    data = qs.stringify(data);
-                }
-                else {
-                    data = JSON.stringify(data);
-                    contentType || (contentType = "application/json" /* MIME.JSON */);
-                }
+            if (!(0, types_1.isPlainObject)(data)) {
+                data = module_1.default.asString(data);
+            }
+            else if (contentType === "application/x-www-form-urlencoded" /* MIME.URLENCODED */) {
+                data = qs.stringify(data);
             }
             else {
-                data = module_1.default.asString(data);
+                data = JSON.stringify(data);
+                contentType || (contentType = "application/json" /* MIME.JSON */);
             }
             headers['content-length'] = Buffer.byteLength(data, (0, types_1.getEncoding)(dataEncoding)).toString();
         }
@@ -1811,14 +1846,15 @@ class Request extends module_1.default {
                         const buffering = request.connected?.call(client, headers);
                         const pipeline = pipeTo ? !(0, types_1.isString)(pipeTo) : false;
                         const enabled = buffering !== false && !pipeline;
+                        const readTimeout = this.readTimeout;
                         let mibsTime, delayTime;
-                        if (log || this.readTimeout > 0) {
+                        if (log || readTimeout > 0) {
                             client.once('readable', () => {
-                                if (this.readTimeout > 0) {
+                                if (readTimeout > 0) {
                                     timeout = setTimeout(() => {
                                         abortResponse();
                                         throwError((0, types_1.errorValue)("Timeout was exceeded" /* ERR_MESSAGE.TIMEOUT */, href.toString()));
-                                    }, this.readTimeout);
+                                    }, readTimeout);
                                 }
                                 if (log) {
                                     if (buffering === false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/request",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Request constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,8 +20,8 @@
   "license": "BSD 3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/module": "0.5.2",
-    "@e-mc/types": "0.5.2",
+    "@e-mc/module": "0.6.0",
+    "@e-mc/types": "0.6.0",
     "combined-stream": "^1.0.8",
     "js-yaml": "^4.1.0",
     "which": "^2.0.2"