@e-mc/request 0.13.6 → 0.13.8

package/README.md

@@ -1,6 +1,6 @@
 # @e-mc/request
 
-* NodeJS 18.20.5 LTS
+* NodeJS 18.20 LTS
 * ES2022
 
 ## General Usage
@@ -9,12 +9,12 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.13.6/lib/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.13.8/lib/index.d.ts)
 
 ```typescript
 import type { IModule, ModuleConstructor } from "./index";
 import type { HttpAgentSettings, HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from "./http";
-import type { ApplyOptions, Aria2Options, FormDataPart, HeadersOnCallback, HostConfig, IHttpAdapter, OpenOptions, PostOptions, ProxySettings, PutOptions, RcloneOptions, ReadExpectType, RequestInit, StatusOnCallback } from "./request";
+import type { ApplyOptions, Aria2Options, HeadersOnCallback, HostConfig, IHttpAdapter, OpenOptions, PostFileParts, PostOptions, ProxySettings, PutOptions, RcloneOptions, ReadExpectType, RequestInit, StatusOnCallback } from "./request";
 import type { DnsLookupSettings, RequestModule, RequestSettings } from "./settings";
 
 import type { ClientRequest, OutgoingHttpHeaders } from "node:http";
@@ -51,8 +51,8 @@ interface IRequest extends IModule {
     head(uri: string | URL, options?: OpenOptions): ClientRequest;
     put(uri: string | URL, data: unknown, options: PutOptions): Promise<Buffer | string | null>;
     put(uri: string | URL, data: unknown, contentType?: string, options?: PutOptions): Promise<Buffer | string | null>;
-    post(uri: string | URL, parts: FormDataPart[]): Promise<Buffer | string | null>;
-    post(uri: string | URL, form: Record<string, unknown>, parts: FormDataPart[]): Promise<Buffer | string | null>;
+    post(uri: string | URL, parts: PostFileParts): Promise<Buffer | string | null>;
+    post(uri: string | URL, form: Record<string, unknown>, parts: PostFileParts): Promise<Buffer | string | null>;
     post(uri: string | URL, data: unknown, options: PostOptions): Promise<Buffer | string | null>;
     post(uri: string | URL, data: unknown, contentType?: string, options?: PostOptions): Promise<Buffer | string | null>;
     get(uri: string | URL, format: "json" | "yaml" | "json5" | "xml" | "toml"): Promise<object | null>;
@@ -252,9 +252,9 @@ instance.get("http://hostname/path/config.yml", options).then(data => {
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.13.6/lib/http.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.6/lib/request.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.6/lib/settings.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.8/lib/http.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.8/lib/request.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.8/lib/settings.d.ts
 
 * https://www.npmjs.com/package/@types/node
 

package/http/adapter/index.js

@@ -355,7 +355,12 @@ class HttpAdapter {
                                     result = new (require(packageName = 'fast-xml-parser').XMLParser)(parser).parse(buffer);
                                     break;
                                 case 'toml':
-                                    result = require(packageName = 'toml').parse(buffer);
+                                    try {
+                                        result = require('smol-toml').parse(buffer);
+                                    }
+                                    catch {
+                                        result = require(packageName = 'toml').parse(buffer);
+                                    }
                                     break;
                                 default:
                                     result = JSON.parse(buffer);

package/http/host/altsvc/index.js

@@ -0,0 +1,92 @@
+"use strict";
+class HttpHostAltSvc {
+    host;
+    #location = {};
+    #available = [];
+    #errors = [];
+    #versionData;
+    constructor(host, versionData) {
+        this.host = host;
+        this.#versionData = versionData;
+    }
+    did(version) {
+        return this.#versionData[version].status !== -1;
+    }
+    next() {
+        const queue = this.#available.shift();
+        if (queue) {
+            const { hostname, port, version, expires } = queue;
+            const ms = expires - Date.now();
+            if (ms < 0) {
+                return this.next();
+            }
+            let timeout = null;
+            if (!isNaN(ms)) {
+                timeout = setTimeout(() => {
+                    if (!this.next()) {
+                        this.host.version = 1;
+                    }
+                }, ms);
+            }
+            this.#location = { hostname, port, version, timeout, origin: this.host.protocol + '//' + hostname + ':' + port };
+            return true;
+        }
+        return false;
+    }
+    close(error) {
+        const { hostname, port, version, timeout } = this.#location;
+        if (hostname) {
+            this.#location = {};
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            if (error) {
+                this.#errors.push({ hostname, port, version });
+                return this.next();
+            }
+        }
+        return false;
+    }
+    clear(version) {
+        if (version) {
+            if (this.#available.length === 0) {
+                this.flag(version, 0);
+            }
+            else if (!this.close(true)) {
+                this.flag(version, -1);
+            }
+        }
+        else {
+            this.close();
+            this.#available = [];
+            this.#errors = [];
+            for (const item of this.#versionData) {
+                if (item.alpn !== 0) {
+                    item.status = -1;
+                }
+            }
+        }
+    }
+    flag(version, value) {
+        this.#versionData[version - 1].status = value;
+    }
+    valid(hostname, port, version) {
+        return !this.errors.find(item => item.hostname === hostname && item.port === port && item.version === version);
+    }
+    set available(value) {
+        this.#available = value;
+    }
+    get errors() {
+        return this.#errors;
+    }
+    get hostname() {
+        return this.#location.hostname;
+    }
+    get port() {
+        return this.#location.port;
+    }
+    get origin() {
+        return this.#location.origin;
+    }
+}
+module.exports = HttpHostAltSvc;

package/http/host/index.js

@@ -1,6 +1,7 @@
 "use strict";
 const tls = require("node:tls");
 const types_1 = require("@e-mc/types");
+const altsvc_1 = require("@e-mc/request/http/host/altsvc");
 const HOST_LOCAL = new Set(['localhost']);
 const HOST_STREAM = new Map();
 const HOST_HTTP_1_1 = [];
@@ -11,6 +12,7 @@ for (const network of Object.entries(require('node:os').networkInterfaces())) {
         HOST_LOCAL.add(address);
     }
 }
+const createData = () => ({ success: 0, failed: 0, errors: 0, alpn: 1, status: -1 });
 class HttpHost {
     static normalizeOrigin(value) {
         return (value = value.trim()).replace(/\/+$/, '') + (!/:\d+$/.test(value) ? ':' + (value.startsWith('https') ? '443' : '80') : '');
@@ -61,19 +63,14 @@ class HttpHost {
     localhost;
     _tlsConnect = null;
     #version;
-    #altSvc = [];
-    #altSvcQueue = [];
-    #altSvcError = [];
     #protocol;
     #secure;
     #hostname;
     #port;
     #origin;
     #streamSize;
-    #versionData = [
-        [0, 0, 0, 1, -1],
-        [0, 0, 0, -1, -1]
-    ];
+    #versionData = [createData(), createData()];
+    #altSvc;
     constructor(url, httpVersion = 1) {
         const { protocol, hostname } = url;
         const secure = protocol === 'https:';
@@ -86,6 +83,7 @@ class HttpHost {
         this.#origin = url.origin;
         this.localhost = HOST_LOCAL.has(hostname);
         this.#streamSize = HOST_STREAM.get(address) || (this.localhost ? 65536 : 4096);
+        this.#altSvc = new altsvc_1(this, this.#versionData);
         if (protocol !== 'file:' && !HOST_HTTP_1_1.includes(address = protocol + '//' + address)) {
             if (secure) {
                 this.#version = HOST_ALPN_H2.includes(address) ? 2 : httpVersion;
@@ -98,7 +96,7 @@ class HttpHost {
         }
         this.#version = 1;
         for (const version of this.#versionData) {
-            version[4] = 0;
+            version.status = 0;
         }
     }
     async hasProtocol(version) {
@@ -107,17 +105,17 @@ class HttpHost {
             if (!data || !this.secure) {
                 return 0;
             }
-            const status = data[3];
-            switch (status) {
+            switch (data.alpn) {
                 case 0:
                 case 1:
-                    return status;
+                    return data.alpn;
                 default:
                     return this._tlsConnect ||= new Promise(resolve => {
                         const alpn = 'h' + version;
                         const socket = tls.connect(+this.port, this.hostname, { ALPNProtocols: [alpn], requestCert: true, rejectUnauthorized: false }, () => {
                             this._tlsConnect = null;
-                            resolve(data[3] = alpn === socket.alpnProtocol ? 1 : 0);
+                            data.alpn = alpn === socket.alpnProtocol ? 1 : 0;
+                            resolve(data.alpn);
                         });
                         socket
                             .setNoDelay(false)
@@ -127,7 +125,8 @@ class HttpHost {
                             if (this._tlsConnect) {
                                 this._tlsConnect = null;
                                 if (this.error(version) >= 10) {
-                                    resolve(data[3] = 0);
+                                    data.alpn = 0;
+                                    resolve(0);
                                 }
                                 else {
                                     resolve(2);
@@ -137,7 +136,8 @@ class HttpHost {
                             .on('error', () => {
                             this.failed(version);
                             this._tlsConnect = null;
-                            resolve(data[3] = 0);
+                            data.alpn = 0;
+                            resolve(0);
                         })
                             .end();
                     });
@@ -147,179 +147,132 @@ class HttpHost {
     }
     success(version, status) {
         const data = this.#versionData[version - 1];
-        return status ? data[0] : ++data[0];
+        return status ? data.success : ++data.success;
     }
     failed(version, status) {
         const data = this.#versionData[version - 1];
         if (status) {
-            return data[1];
+            return data.failed;
         }
-        this.clearAltSvc(version);
-        return ++data[1];
+        this.altSvc.clear(version);
+        return ++data.failed;
     }
     error(version, status) {
         const data = this.#versionData[version - 1];
         if (status) {
-            return data[2];
+            return data.errors;
         }
-        if (data[4] !== 2) {
-            this.closeAltSvc(true);
+        if (data.status !== 2) {
+            this.altSvc.close(true);
         }
-        return ++data[2];
+        return ++data.errors;
     }
     upgrade(version, altSvc) {
         if (altSvc && this.secure) {
             if (altSvc === 'clear') {
-                this.clearAltSvc();
+                this.altSvc.clear();
                 return;
             }
             const data = this.#versionData;
             for (let i = data.length - 1; i >= version; --i) {
                 const host = data[i];
-                if (host[4] === 0) {
+                if (host.status === 0) {
                     continue;
                 }
+                const h = i + 1;
                 const increment = (flag) => {
-                    host[4] = flag;
-                    if (this.#version < i + 1) {
-                        this.#version = i + 1;
+                    host.status = flag;
+                    if (this.#version < h) {
+                        this.#version = h;
                         return true;
                     }
                     return false;
                 };
-                const addresses = [];
-                const time = Date.now();
+                const available = [];
                 const hostname = this.#hostname;
-                const excluded = this.#altSvcError;
-                for (const match of altSvc.matchAll(new RegExp(`h${i + 1}(?:-\\d+)?="([^:]*):(\\d+)"([^,]*)`, 'g'))) {
+                for (const match of altSvc.matchAll(new RegExp(`h${h}(?:-\\d+)?="([^:]*):(\\d+)"([^,]*)`, 'g'))) {
                     const port = match[2];
                     if (!match[1] && port === this.port) {
                         increment(2);
-                        addresses.length = 0;
+                        available.length = 0;
                         break;
                     }
                     const address = match[1] || hostname;
                     const ma = +(/ma=(\d+)/.exec(match[3])?.[1] || 86400);
-                    if (!excluded.includes(`h${i + 1}:${address}:${port}`)) {
-                        addresses.push([
-                            address,
+                    if (this.altSvc.valid(address, port, h)) {
+                        available.push({
+                            hostname: address,
                             port,
-                            ma >= 2592000 ? NaN : time + Math.min(ma * 1000, 2147483647),
-                            i + 1,
-                            match[3].includes('persist=1')
-                        ]);
+                            version: h,
+                            expires: ma >= 2592000 ? NaN : Date.now() + Math.min(ma * 1000, 2147483647),
+                            persist: match[3].includes('persist=1')
+                        });
                     }
                 }
-                if (addresses.length > 0) {
-                    this.closeAltSvc();
-                    this.#altSvcQueue = addresses.sort((a, b) => {
-                        if (a[0] === hostname) {
+                if (available.length > 0) {
+                    this.altSvc.close();
+                    this.altSvc.available = available.sort((a, b) => {
+                        if (a.hostname === hostname) {
                             return -1;
                         }
-                        if (b[0] === hostname) {
+                        if (b.hostname === hostname) {
                             return 1;
                         }
-                        if (isNaN(a[2]) || a[2] > b[2]) {
+                        if (isNaN(a.expires) || a.expires > b.expires) {
                             return -1;
                         }
-                        if (isNaN(b[2]) || a[2] < b[2]) {
+                        if (isNaN(b.expires) || a.expires < b.expires) {
                             return 1;
                         }
-                        if (a[3] && !b[3]) {
-                            return -1;
-                        }
-                        if (!a[3] && b[3]) {
-                            return -1;
-                        }
                         return 0;
                     });
                     if (increment(1)) {
-                        this.nextAltSvc();
+                        this.altSvc.next();
                     }
                 }
             }
         }
     }
     didAltSvc(version) {
-        return this.#versionData[version][4] !== -1;
+        return this.#versionData[version].status !== -1;
     }
     nextAltSvc() {
-        const queue = this.#altSvcQueue.shift();
-        if (queue) {
-            const [hostname, port, expires, version] = queue;
-            const timeout = expires - Date.now();
-            if (timeout < 0) {
-                return this.nextAltSvc();
-            }
-            let timer = null;
-            if (!isNaN(timeout)) {
-                timer = setTimeout(() => {
-                    if (!this.nextAltSvc()) {
-                        this.version = 1;
-                    }
-                }, timeout);
-            }
-            this.#altSvc = [hostname, port, timer, version, this.protocol + '//' + hostname + ':' + port];
-            return true;
-        }
-        return false;
+        return this.altSvc.next();
     }
     closeAltSvc(error) {
-        const [hostname, port, timeout, version] = this.#altSvc;
-        if (hostname) {
-            this.#altSvc = [];
-            if (timeout) {
-                clearTimeout(timeout);
-            }
-            if (error) {
-                this.#altSvcError.push(`h${version}:${hostname}:${port}`);
-                return this.nextAltSvc();
-            }
-        }
-        return false;
+        return this.altSvc.close(error);
     }
     clearAltSvc(version) {
-        if (version) {
-            if (this.#altSvcQueue.length === 0) {
-                this.flagAltSvc(version, 0);
-            }
-            else if (!this.closeAltSvc(true)) {
-                this.flagAltSvc(version, -1);
-            }
-        }
-        else {
-            this.closeAltSvc();
-            this.#altSvcQueue = [];
-            this.#altSvcError = [];
-            for (const item of this.#versionData) {
-                if (item[3]) {
-                    item[4] = -1;
-                }
-            }
-        }
+        this.altSvc.clear(version);
     }
     flagAltSvc(version, value) {
-        this.#versionData[version - 1][4] = value;
+        this.altSvc.flag(version, value);
     }
     reset() {
-        this.clearAltSvc();
+        this.altSvc.clear();
         this.#versionData.forEach((item, index) => {
-            item[0] = 0;
-            item[1] = 0;
-            item[2] = 0;
+            item.success = 0;
+            item.failed = 0;
+            item.errors = 0;
             if (index > 0) {
-                item[3] = -1;
+                item.alpn = -1;
             }
         });
     }
+    v1() {
+        return this.#version === 1;
+    }
     v2() {
         return this.#version === 2;
     }
+    get altSvc() {
+        return this.#altSvc;
+    }
     set version(value) {
         switch (value) {
             case 1:
             case 2:
-                this.flagAltSvc(this.#version = value, -1);
+                this.altSvc.flag(this.#version = value, -1);
                 break;
         }
     }
@@ -333,13 +286,13 @@ class HttpHost {
         return this.#secure;
     }
     get hostname() {
-        return this.#altSvc[0] || this.#hostname;
+        return this.altSvc.hostname || this.#hostname;
     }
     get port() {
-        return this.#altSvc[1] || this.#port;
+        return this.altSvc.port || this.#port;
     }
     get origin() {
-        return this.#altSvc[4] || this.#origin;
+        return this.altSvc.origin || this.#origin;
     }
     get streamSize() {
         return this.#streamSize;

package/index.js

@@ -28,13 +28,14 @@ const REGEXP_GLOBWITHIN = /\\\?|(?:(?<!\\)(?:\*|\[!?[^!\]]+\]|\{(?:[^,]+,)+[^}]+
 const REGEXP_RCLONE = /^rclone:\?/i;
 const HTTP = {
     HOST: {},
-    HEADERS: {},
+    HEADERS: Object.create(null),
+    CACHE: new WeakMap(),
     VERSION: 1,
     PROXY: null
 };
 const TLS = {
-    TEXT: {},
-    FILE: {}
+    TEXT: Object.create(null),
+    FILE: Object.create(null)
 };
 const DNS = {
     CACHE: Object.create(null),
@@ -61,7 +62,7 @@ const ARIA2 = {
     LOWEST_SPEED_LIMIT: null,
     ALWAYS_RESUME: false,
     FILE_ALLOCATION: 'none',
-    PROXY: {},
+    PROXY: Object.create(null),
     NO_PROXY: '',
     CONF_PATH: ''
 };
@@ -115,21 +116,6 @@ let READ_TIMEOUT = 0;
 let AGENT_TIMEOUT = 0;
 let LOG_HTTP = false;
 let LOG_TIMEPROCESS = true;
-function getBaseHeaders(uri, headers) {
-    let result;
-    uri = (0, util_1.trimPath)(uri);
-    for (const pathname in headers) {
-        if (pathname === uri || uri.startsWith(pathname + '/')) {
-            (result ||= []).push([pathname, headers[pathname]]);
-        }
-    }
-    if (result) {
-        if (result.length > 1) {
-            result.sort((a, b) => b[0].length - a[0].length);
-        }
-        return result[0][1];
-    }
-}
 function setDnsCache(hostname, value, expires) {
     expires ??= DNS.EXPIRES;
     if (expires > 0 && !DNS.CACHE[hostname]) {
@@ -146,11 +132,6 @@ function setDnsCache(hostname, value, expires) {
         }
     }
 }
-function setOutgoingHeaders(output, headers) {
-    for (const href in headers) {
-        output[href] = (0, util_1.normalizeHeaders)(headers[href]);
-    }
-}
 function getProxySettings(request, agentTimeout) {
     const proxy = request.proxy;
     if (proxy && (proxy.origin || proxy.address && proxy.port)) {
@@ -175,11 +156,9 @@ function getProxySettings(request, agentTimeout) {
     return null;
 }
 function closeTorrent(pid) {
-    if (typeof pid === 'number') {
-        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 => value[0] === pid);
+    if (index !== -1) {
+        ARIA2.PID_QUEUE.splice(index, 1);
     }
 }
 function clearDnsLookup() {
@@ -199,9 +178,9 @@ function resetHttpHost(version) {
         case 2:
             for (const origin in HTTP.HOST) {
                 const host = HTTP.HOST[origin];
-                if (host.secure && host.version === 1) {
+                if (host.secure && host.v1()) {
                     const failed = host.failed(2, true);
-                    if (failed === 0 && host.failed(2, true) < 10 || failed < 3 && host.success(2, true) > 0) {
+                    if (failed === 0 && host.error(2, true) < 10 || failed < 3 && host.success(2, true) > 0) {
                         host.version = version;
                     }
                 }
@@ -296,50 +275,16 @@ function copySearchParams(url, base) {
         }
     });
 }
-function checkEncoding(request, response, statusCode, outStream, contentEncoding) {
+function checkEncoding(request, statusCode, contentEncoding) {
     switch (statusCode) {
         case 206:
             request.emit('error', (0, types_1.errorValue)("Aborted", 'Partial content'));
         case 204:
         case 205:
         case 304:
-            return;
-    }
-    if (!contentEncoding) {
-        return;
-    }
-    contentEncoding = contentEncoding.trim().toLowerCase();
-    const chunkSize = outStream?.writableHighWaterMark;
-    let pipeTo;
-    if (!contentEncoding.includes(',')) {
-        pipeTo = decompressEncoding(contentEncoding, chunkSize);
-    }
-    else {
-        for (const value of contentEncoding.split(/\s*,\s*/).reverse()) {
-            const next = decompressEncoding(value, chunkSize);
-            if (!next) {
-                return;
-            }
-            pipeTo = pipeTo ? pipeTo.pipe(next) : next;
-        }
-    }
-    if (pipeTo) {
-        if (outStream) {
-            stream.pipeline(response, pipeTo, outStream, err => {
-                if (err) {
-                    response.emit('error', err);
-                }
-            });
-        }
-        else {
-            stream.pipeline(response, pipeTo, err => {
-                if (err) {
-                    response.emit('error', err);
-                }
-            });
-        }
-        return pipeTo;
+            return false;
     }
+    return !!contentEncoding;
 }
 function sendBody(request, options) {
     const postData = options.postData;
@@ -351,26 +296,11 @@ function sendBody(request, options) {
     }
     request.end();
 }
-function decompressEncoding(value, chunkSize) {
-    switch (value) {
-        case 'gzip':
-            return zlib.createGunzip({ chunkSize });
-        case 'br':
-            return zlib.createBrotliDecompress({ chunkSize });
-        case 'deflate':
-            return zlib.createInflate({ chunkSize });
-        case 'deflate-raw':
-            return zlib.createInflateRaw({ chunkSize });
-        case 'zstd':
-            if (SUPPORTED_ZSTD) {
-                return zlib.createZstdDecompress({ chunkSize });
-            }
-            break;
-    }
-}
 function resetAria2() {
-    clearInterval(ARIA2.PID_TIMER);
-    ARIA2.PID_TIMER = null;
+    if (ARIA2.PID_TIMER) {
+        clearInterval(ARIA2.PID_TIMER);
+        ARIA2.PID_TIMER = null;
+    }
 }
 function escapeShellQuote(value) {
     value = value.replace(/(?<!\\)"/g, '\\"');
@@ -464,32 +394,7 @@ function setBinHeaders(args, headers) {
         args.push(...items.map(value => `--header="${name}: ${escapeShellQuote(value)}"`));
     }
 }
-function finalizeBinArgs(instance, name, bin, args, opts, binOpts, cmd = []) {
-    if (binOpts) {
-        for (const leading of binOpts) {
-            if (leading.startsWith('-')) {
-                const pattern = new RegExp(`^${leading}(?:=|$)`);
-                for (let i = 0; i < opts.length; ++i) {
-                    if (pattern.test(opts[i])) {
-                        opts.splice(i--, i);
-                        break;
-                    }
-                }
-            }
-        }
-        args = binOpts.concat(args);
-    }
-    if (args.length > 0) {
-        if (module_1.hasLogType(32768)) {
-            instance.formatMessage(32768, name.toUpperCase(), [bin].concat(cmd).join(' '), args.join(' '), { ...module_1.LOG_STYLE_WARN });
-        }
-        else {
-            instance.addLog(4, path.basename(bin) + ' ' + args.join(' '), name);
-        }
-    }
-    return args;
-}
-function addAria2Proxy(args, protocol, host) {
+function appendAria2Proxy(args, protocol, host) {
     const { origin, username, password } = host;
     args.push(`--${protocol}-proxy="${origin}"`);
     if (username) {
@@ -509,8 +414,7 @@ function createAgentOptions(options) {
     }
 }
 const hasResponse = (value) => value >= 200 && (value < 300 || value === 304);
-const isDirEnd = (value) => value.endsWith('/') || value.endsWith(path.sep);
-const trimCharEnd = (value) => value.substring(0, value.length - 1);
+const isDirEnd = (value) => (value = value.at(-1), value === '/' || value === path.sep);
 const configureDns = (family, options) => family === 0 ? options : { family, hints: family === 6 ? dns.V4MAPPED : 0 };
 const ignoreOpt = (opts, ...values) => !opts?.some(opt => values.some(value => opt === value || opt.startsWith(value + '=')));
 const escapeQuote = (value) => value.replace(/[\\"]/g, capture => '\\' + capture);
@@ -583,7 +487,7 @@ class Request extends module_1 {
                 try {
                     for (const uri in proxy) {
                         const host = new URL(uri);
-                        ARIA2.PROXY[trimCharEnd(host.protocol)] = { host };
+                        ARIA2.PROXY[host.protocol.slice(0, -1)] = { host };
                     }
                 }
                 catch {
@@ -686,7 +590,7 @@ class Request extends module_1 {
             if ((read_timeout = (0, util_1.fromSeconds)(read_timeout)) >= 0) {
                 READ_TIMEOUT = read_timeout;
             }
-            if ((0, types_1.isObject)(agent)) {
+            if (agent) {
                 let { keep_alive, timeout, proxy_env } = agent;
                 if ((agent_timeout = (0, util_1.fromSeconds)(timeout)) > 0) {
                     AGENT_TIMEOUT = agent_timeout;
@@ -715,8 +619,10 @@ class Request extends module_1 {
                         break;
                 }
             }
-            if ((0, types_1.isPlainObject)(headers)) {
-                setOutgoingHeaders(HTTP.HEADERS, headers);
+            for (const href in headers) {
+                if ((0, types_1.isObject)(headers[href])) {
+                    HTTP.HEADERS[href] = (0, util_1.normalizeHeaders)(headers[href]);
+                }
             }
             if ((0, types_1.isPlainObject)(certs)) {
                 [TLS.TEXT, TLS.FILE] = validateCerts(certs);
@@ -827,9 +733,9 @@ class Request extends module_1 {
     };
     #singleton = false;
     #httpVersion = null;
+    #headers = null;
     #ipVersion;
     #agentTimeout;
-    #headers = null;
     #baseUrl = null;
     #connectDns = Object.create(null);
     #pendingDns = Object.create(null);
@@ -839,7 +745,7 @@ class Request extends module_1 {
     #adapter = HTTP_ADAPTER;
     #certs = null;
     #downloading = new Set();
-    #hostInfo = {};
+    #hostInfo = Object.create(null);
     #session = [Object.create(null)];
     constructor(data) {
         super();
@@ -865,9 +771,7 @@ class Request extends module_1 {
             if (proxy) {
                 this.proxy = proxy;
             }
-            if ((0, types_1.isObject)(headers)) {
-                setOutgoingHeaders(this.#headers = {}, headers);
-            }
+            this.parseHeaders(headers);
             if ((0, types_1.isObject)(certs)) {
                 this.#certs = validateCerts(certs);
             }
@@ -975,9 +879,7 @@ class Request extends module_1 {
     init(config) {
         if (config) {
             const { headers, httpVersion, ipVersion, readTimeout } = config;
-            if ((0, types_1.isObject)(headers)) {
-                setOutgoingHeaders(this.#headers ||= {}, headers);
-            }
+            this.parseHeaders(headers);
             if (httpVersion !== undefined) {
                 this.httpVersion = httpVersion;
             }
@@ -1201,8 +1103,7 @@ class Request extends module_1 {
         }
     }
     headersOf(uri) {
-        const headers = this.#headers;
-        return headers && getBaseHeaders(uri, headers) || (this.host ? getBaseHeaders(uri, HTTP.HEADERS) : undefined);
+        return this.findHeadersByUri(uri) || (this.host ? this.findHeadersByUri(uri, HTTP.HEADERS) : undefined);
     }
     async aria2c(uri, options = {}) {
         if (!ARIA2.BIN) {
@@ -1219,15 +1120,10 @@ class Request extends module_1 {
             ({ signal, silent } = options);
             ({ pathname, headers, binOpts } = this.parseBinOpts(options, ['--daemon'], ['--input-file']));
         }
-        try {
-            if (typeof uri === 'string' && module_1.isURL(uri)) {
-                uri = new URL(uri);
-            }
-            pathname = checkBinTarget(this, "aria2", uri, pathname, 'aria2', binOpts);
-        }
-        catch (err) {
-            return Promise.reject(err);
+        if ((0, types_1.isString)(uri) && module_1.isURL(uri)) {
+            uri = new URL(uri);
         }
+        pathname = checkBinTarget(this, "aria2", uri, pathname, 'aria2', binOpts);
         silent ??= this.#singleton;
         return new Promise((resolve, reject) => {
             let protocol, origin, username, password;
@@ -1322,7 +1218,7 @@ class Request extends module_1 {
                         }
                     }
                 }
-                switch (protocol = trimCharEnd(protocol)) {
+                switch (protocol = protocol.slice(0, -1)) {
                     case 'http':
                     case 'https':
                         if (ignoreOpt(binOpts, '--http-no-cache')) {
@@ -1346,12 +1242,12 @@ class Request extends module_1 {
                 }
             }
             if (proxy) {
-                addAria2Proxy(args, protocol, proxy.host);
+                appendAria2Proxy(args, protocol, proxy.host);
             }
             else if (ARIA2.PROXY.all) {
-                addAria2Proxy(opts, 'all', ARIA2.PROXY.all.host);
+                appendAria2Proxy(opts, 'all', ARIA2.PROXY.all.host);
             }
-            args = finalizeBinArgs(this, "aria2", ARIA2.BIN, args, opts, binOpts);
+            args = this.mergeBinOpts(args, opts, binOpts, { name: "aria2", bin: ARIA2.BIN });
             opts.push(`"${escapeShellQuote(uri)}"`);
             args = args.concat(init, opts);
             const startTime = Date.now();
@@ -1492,12 +1388,7 @@ class Request extends module_1 {
             default:
                 return Promise.reject((0, types_1.errorMessage)("rclone", "Invalid command", command || uri));
         }
-        try {
-            pathname = checkBinTarget(this, "rclone", uri, pathname, command, binOpts);
-        }
-        catch (err) {
-            return Promise.reject(err);
-        }
+        pathname = checkBinTarget(this, "rclone", uri, pathname, command, binOpts);
         silent ??= this.#singleton;
         return new Promise((resolve, reject) => {
             const init = [
@@ -1640,7 +1531,7 @@ class Request extends module_1 {
             setBinHeaders(args, headers);
             const cwd = module_1.isDir(pathname) ? pathname : path.dirname(pathname);
             const cmd = [source, pathname];
-            args = finalizeBinArgs(this, "rclone", RCLONE.BIN, args, opts, binOpts, cmd).concat(init, opts);
+            args = this.mergeBinOpts(args, opts, binOpts, { name: "rclone", bin: RCLONE.BIN, cmd }).concat(init, opts);
             args.push(...cmd.map(value => (0, types_1.sanitizeCmd)(value)));
             args.unshift(command);
             const startTime = Date.now();
@@ -1866,14 +1757,20 @@ class Request extends module_1 {
                     }
                     connected = true;
                     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('-');
-                                for (const listener of listenerMap[event]) {
-                                    if (name !== 'error') {
-                                        request.removeListener(name, listener);
+                        const contentEncoding = response['content-encoding'];
+                        if (checkEncoding(request, statusCode, contentEncoding) && (emitter = this.pipeline(request, contentEncoding, outStream))) {
+                            if (typeof emitter === 'number') {
+                                this.abortHeaders(request, options, { href: url.href, statusCode: emitter, message: (0, util_1.fromStatusCode)(emitter) });
+                            }
+                            else {
+                                for (const event in listenerMap) {
+                                    const [name, type] = event.split('-');
+                                    for (const listener of listenerMap[event]) {
+                                        if (name !== 'error') {
+                                            request.removeListener(name, listener);
+                                        }
+                                        emitter[type](name === 'end' ? 'finish' : name, listener);
                                     }
-                                    emitter[type](name === 'end' ? 'finish' : name, listener);
                                 }
                             }
                         }
@@ -1942,7 +1839,7 @@ class Request extends module_1 {
                 if (proxy) {
                     keepAlive ??= proxy.keepAlive;
                     agentTimeout ??= proxy.agentTimeout;
-                    const proxyHeaders = this.#headers && getBaseHeaders(proxy.host.href, this.#headers) || getBaseHeaders(proxy.host.href, HTTP.HEADERS);
+                    const proxyHeaders = this.findHeadersByUri(proxy.host.href) || this.findHeadersByUri(proxy.host.href, HTTP.HEADERS);
                     const pkg = secure ? 'https-proxy-agent' : 'http-proxy-agent';
                     try {
                         agent = require(pkg)(proxy.host, keepAlive === true || keepAlive === false && agentTimeout !== 0 || agentTimeout > 0 ? { ...agentOptions, keepAlive: keepAlive ?? true, timeout: agentTimeout, headers: proxyHeaders } : { ...agentOptions, headers: proxyHeaders });
@@ -1993,11 +1890,17 @@ class Request extends module_1 {
                 const statusCode = response.statusCode;
                 const incoming = response.headers;
                 if (!expectContinue && 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');
-                        });
+                    const contentEncoding = incoming['content-encoding'];
+                    let source;
+                    if (checkEncoding(request, statusCode, contentEncoding) && (source = this.pipeline(response, contentEncoding, outStream))) {
+                        if (typeof source === 'number') {
+                            this.abortHeaders(request, options, { href: url.href, statusCode: source, message: (0, util_1.fromStatusCode)(source) });
+                        }
+                        else {
+                            source.once('finish', () => {
+                                request.emit('end');
+                            });
+                        }
                     }
                     else {
                         if (encoding) {
@@ -2042,7 +1945,7 @@ class Request extends module_1 {
                         if (version === 2 && incoming.upgrade?.includes('h2')) {
                             host.version = 2;
                         }
-                        else if (!host.didAltSvc(1)) {
+                        else if (!host.altSvc.did(1)) {
                             host.upgrade(1, incoming['alt-svc']);
                         }
                     }
@@ -2162,13 +2065,7 @@ class Request extends module_1 {
         else {
             options = {};
         }
-        const headers = (0, util_1.parseOutgoingHeaders)(options.headers) || {};
-        for (const attr in headers) {
-            const name = attr.toLowerCase();
-            if (name === 'content-type' || name === 'content-length') {
-                delete headers[attr];
-            }
-        }
+        const headers = (0, util_1.parseOutgoingHeaders)(options.headers, 'content-type', 'content-length') || {};
         if (!putting && (parts || contentType === "multipart/form-data" || contentType === 'form-data')) {
             let valid = false;
             if ((0, types_1.isArray)(parts)) {
@@ -2195,9 +2092,18 @@ class Request extends module_1 {
                         addValue(name, data[name]);
                     }
                 }
-                for (let { name, data: target, value, contentType: type, filename } of parts) {
-                    if (!name) {
-                        continue;
+                for (const part of parts) {
+                    let name, target, value, type, filename;
+                    if ((0, types_1.isPlainObject)(part)) {
+                        ({ name, data: target, value, contentType: type, filename } = part);
+                    }
+                    else if ((0, types_1.supported)(18, 13) && part instanceof File) {
+                        name = part.name;
+                        type = part.type;
+                        target = Buffer.from(await part.arrayBuffer());
+                    }
+                    if (!(0, types_1.isString)(name)) {
+                        throw (0, types_1.errorValue)('Name of file part was invalid', uri.toString());
                     }
                     if (target) {
                         if (typeof target === 'string') {
@@ -2317,6 +2223,59 @@ class Request extends module_1 {
         });
         this.#downloading.clear();
     }
+    pipeline(response, encoding, outStream) {
+        const chunkSize = outStream?.writableHighWaterMark;
+        let pipeTo;
+        encoding = encoding.trim().toLowerCase();
+        if (!encoding.includes(',')) {
+            pipeTo = this.fromEncoding(encoding, { chunkSize });
+        }
+        else {
+            for (const value of encoding.split(/\s*,\s*/).reverse()) {
+                const next = this.fromEncoding(value, { chunkSize });
+                if (!next) {
+                    pipeTo = undefined;
+                    break;
+                }
+                pipeTo = pipeTo ? pipeTo.pipe(next) : next;
+            }
+        }
+        if (!pipeTo) {
+            return 415;
+        }
+        if (outStream) {
+            stream.pipeline(response, pipeTo, outStream, err => {
+                if (err) {
+                    response.emit('error', err);
+                }
+            });
+        }
+        else {
+            stream.pipeline(response, pipeTo, err => {
+                if (err) {
+                    response.emit('error', err);
+                }
+            });
+        }
+        return pipeTo;
+    }
+    fromEncoding(value, options) {
+        switch (value) {
+            case 'gzip':
+                return zlib.createGunzip(options);
+            case 'br':
+                return zlib.createBrotliDecompress(options);
+            case 'deflate':
+                return zlib.createInflate(options);
+            case 'deflate-raw':
+                return zlib.createInflateRaw(options);
+            case 'zstd':
+                if (SUPPORTED_ZSTD) {
+                    return zlib.createZstdDecompress(options);
+                }
+                break;
+        }
+    }
     matchStatus(code, url, headers, request, options) {
         const status = this.#statusOn?.get(code);
         if (status) {
@@ -2395,7 +2354,7 @@ class Request extends module_1 {
         }
         if ((0, types_1.isArray)(options.binOpts)) {
             let next = false;
-            binOpts = options.binOpts.filter((opt) => !((0, types_1.isString)(opt) && /^-[a-z].*$/i.test(opt.trim()))).map((opt) => {
+            binOpts = options.binOpts.filter((opt) => !((0, types_1.isString)(opt) && /^-[a-z].*$/i.test(opt))).map((opt) => {
                 if (next) {
                     if (!module_1.asString(opt).startsWith('--')) {
                         return [];
@@ -2445,6 +2404,58 @@ class Request extends module_1 {
         }
         return { pathname, headers: (0, util_1.parseOutgoingHeaders)(options.headers), binOpts };
     }
+    mergeBinOpts(args, opts, binOpts, options) {
+        if (binOpts) {
+            for (const leading of binOpts) {
+                if (leading.charAt(0) === '-') {
+                    const pattern = new RegExp(`^${leading}(?:=|$)`);
+                    for (let i = 0; i < opts.length; ++i) {
+                        if (pattern.test(opts[i])) {
+                            opts.splice(i--, i);
+                            break;
+                        }
+                    }
+                }
+            }
+            args = binOpts.concat(args);
+        }
+        if (options && args.length > 0) {
+            const { name, bin, cmd = [] } = options;
+            if (module_1.hasLogType(32768)) {
+                this.formatMessage(32768, name.toUpperCase(), [bin].concat(cmd).join(' '), args.join(' '), { ...module_1.LOG_STYLE_WARN });
+            }
+            else {
+                this.addLog(4, path.basename(bin) + ' ' + args.join(' '), name);
+            }
+        }
+        return args;
+    }
+    parseHeaders(outgoing) {
+        if ((0, types_1.isPlainObject)(outgoing)) {
+            Object.assign(this.#headers ||= {}, outgoing);
+        }
+    }
+    findHeadersByUri(uri, outgoing = this.#headers) {
+        if (outgoing) {
+            const data = [];
+            uri = (0, util_1.trimPath)(uri);
+            for (const pathname in outgoing) {
+                if (pathname === uri || uri.startsWith(pathname + '/')) {
+                    data.push([pathname, outgoing[pathname]]);
+                }
+            }
+            if (data.length > 0) {
+                data.sort((a, b) => b[0].length - a[0].length);
+                const headers = data[0][1];
+                let result = HTTP.CACHE.get(headers);
+                if (!result) {
+                    result = (0, util_1.normalizeHeaders)(headers);
+                    HTTP.CACHE.set(headers, result);
+                }
+                return result;
+            }
+        }
+    }
     set adapter(value) {
         if (adapter_1.constructorOf(value)) {
             this.#adapter = value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/request",
-  "version": "0.13.6",
+  "version": "0.13.8",
   "description": "Request constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -19,8 +19,8 @@
   "license": "BSD-3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/module": "0.13.6",
-    "@e-mc/types": "0.13.6",
+    "@e-mc/module": "0.13.8",
+    "@e-mc/types": "0.13.8",
     "combined-stream": "^1.0.8",
     "js-yaml": "^4.1.1",
     "picomatch": "^4.0.3",

package/util.d.ts

@@ -6,15 +6,15 @@ import type { Readable, Writable } from 'node:stream';
 
 declare namespace util {
     function parseHeader<T = unknown>(headers: IncomingHttpHeaders, name: string): T | undefined;
-    function parseOutgoingHeaders(headers: OutgoingHttpHeaders | Headers | undefined): OutgoingHttpHeaders | undefined;
-    function normalizeHeaders(headers: OutgoingHttpHeaders): OutgoingHttpHeaders;
+    function parseOutgoingHeaders(headers: OutgoingHttpHeaders | Headers | undefined, ...ignore: string[]): OutgoingHttpHeaders | undefined;
+    function normalizeHeaders(headers: OutgoingHttpHeaders | Headers): OutgoingHttpHeaders;
     function getBasicAuth(auth: AuthValue): string;
     function getBasicAuth(username: unknown, password?: unknown): string;
     function hasBasicAuth(value: string): boolean;
     function checkRetryable(err: unknown): boolean;
     function isRetryable(value: number, timeout?: boolean): boolean;
-    function parseHttpProxy(value?: string): HttpProxySettings | undefined;
-    function trimPath(value: string): string;
+    function parseHttpProxy(value?: string, ignoreEnv?: boolean): HttpProxySettings | undefined;
+    function trimPath(value: string, char?: string): string;
     function asInt(value: unknown): number;
     function asFloat(value: unknown): number;
     function fromSeconds(value: unknown): number;

package/util.js

@@ -25,45 +25,63 @@ const node_util_1 = require("node:util");
 const types_1 = require("@e-mc/types");
 const module_1 = require("@e-mc/module");
 const host_1 = require("@e-mc/request/http/host");
+function setHeader(result, key, value) {
+    if (key === 'set-cookie') {
+        (result[key] ||= []).push(value);
+    }
+    else {
+        result[key] = value;
+    }
+}
 const safeInt = (value) => value >= 0 ? Math.min(value, Number.MAX_SAFE_INTEGER) : NaN;
 function parseHeader(headers, name) {
     const value = headers[name];
-    if (!value) {
-        return;
-    }
     switch (name.toLowerCase()) {
-        case 'content-disposition': {
-            let result;
-            for (const match of value.matchAll(/\bfilename(?:\*\s*=\s*UTF-8''([^\s;]+)|\s*=\s*(?:"([^"]+)"|([^\s;]+)))/gi)) {
-                if (match[1]) {
-                    return decodeURIComponent(match[1]).trim();
+        case 'content-disposition':
+            if ((0, types_1.isString)(value)) {
+                let result;
+                for (const match of value.matchAll(/\bfilename(?:\*\s*=\s*UTF-8''([^\s;]+)|\s*=\s*(?:"([^"]+)"|([^\s;]+)))/gi)) {
+                    if (match[1]) {
+                        return decodeURIComponent(match[1]).trim();
+                    }
+                    result = (match[2] || match[3]).trim();
                 }
-                result = (match[2] || match[3]).trim();
+                return result;
             }
-            return result;
-        }
+            break;
     }
 }
-function parseOutgoingHeaders(headers) {
+function parseOutgoingHeaders(headers, ...ignore) {
     if (!headers) {
         return;
     }
     if (headers instanceof Headers) {
-        const result = {};
+        const result = Object.create(null);
         headers.forEach((value, key) => {
-            if (key === 'set-cookie') {
-                (result[key] ||= []).push(value);
-            }
-            else {
-                result[key] = value;
+            if (!ignore.includes(key)) {
+                setHeader(result, key, value);
             }
         });
         return result;
     }
+    if (ignore.length > 0) {
+        const result = {};
+        for (const attr in headers) {
+            const name = attr.toLowerCase();
+            if (!ignore.includes(name)) {
+                result[name] = headers[attr];
+            }
+        }
+        return result;
+    }
     return { ...headers };
 }
 function normalizeHeaders(headers) {
     const result = Object.create(null);
+    if (headers instanceof Headers) {
+        headers.forEach((value, key) => setHeader(result, key, value));
+        return result;
+    }
     for (const name in headers) {
         let value = headers[name];
         switch (typeof value) {
@@ -182,9 +200,11 @@ function parseHttpProxy(value, ignoreEnv) {
         }
     }
 }
-function trimPath(value) {
-    const length = value.length - 1;
-    return value[length] === '/' ? value.substring(0, length) : value;
+function trimPath(value, char = '/') {
+    while (value.at(-1) === char) {
+        value = value.slice(0, -1);
+    }
+    return value;
 }
 function asInt(value) {
     switch (typeof value) {