@e-mc/request 0.10.5 → 0.11.0

package/index.js

@@ -1,25 +1,25 @@
 "use strict";
-var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-const path = require("path");
-const fs = require("fs");
-const crypto = require("crypto");
-const child_process = require("child_process");
-const http = require("http");
-const https = require("https");
-const http2 = require("http2");
-const dns = require("dns");
-const net = require("net");
-const stream = require("stream");
-const zlib = require("zlib");
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+const path = require("node:path");
+const fs = require("node:fs");
+const crypto = require("node:crypto");
+const child_process = require("node:child_process");
+const http = require("node:http");
+const https = require("node:https");
+const http2 = require("node:http2");
+const dns = require("node:dns");
+const net = require("node:net");
+const stream = require("node:stream");
+const zlib = require("node:zlib");
 const qs = require("node:querystring");
 const combined = require("combined-stream");
 const pm = require("picomatch");
-const yaml = require("js-yaml");
 const which = require("which");
 const types_1 = require("@e-mc/types");
 const module_1 = require("@e-mc/module");
 const util_1 = require("@e-mc/request/util");
 const host_1 = require("@e-mc/request/http/host");
+const adapter_1 = require("@e-mc/request/http/adapter");
 const kSession = Symbol('session');
 const kHttpVersion = Symbol('httpVersion');
 const kIpVersion = Symbol('ipVersion');
@@ -35,6 +35,7 @@ const kPendingDns = Symbol('pendingDns');
 const kConnectHttp = Symbol('connectHttp');
 const kStatusOn = Symbol('statusOn');
 const kHeadersOn = Symbol('headersOn');
+const kAdapter = Symbol('adapter');
 const SUPPORTED_NODE20 = (0, types_1.supported)(20);
 const REGEXP_PEMCERT = /^-{3,}[ \t]*BEGIN[ \t].+\n-{3,}[ \t]*END[ \t][^-]+-{3,}$/s;
 const REGEXP_GLOBWITHIN = /\\\?|(?:(?<!\\)(?:\*|\[!?[^!\]]+\]|\{(?:[^,]+,)+[^}]+\}|[!?+*@]\((?:[^|]+\|)*[^)]+\)|\?.*\?|\?$))/;
@@ -75,14 +76,13 @@ const ARIA2 = {
     FILE_ALLOCATION: 'none',
     CONF_PATH: ''
 };
+let HTTP_ADAPTER = adapter_1;
 let KEEP_ALIVE = null;
 let ACCEPT_ENCODING = false;
 let READ_TIMEOUT = 0;
 let AGENT_TIMEOUT = 0;
 let LOG_HTTP = false;
 let LOG_TIMEPROCESS = true;
-let LOG_STDOUT = true;
-let LOG_TIMEFORMAT = 'readable';
 let LIB_ZSTD = null;
 try {
     require('zstd-codec/lib/zstd-stream').run(codec => {
@@ -92,8 +92,8 @@ try {
 catch {
 }
 function getBaseHeaders(uri, headers) {
-    uri = (0, util_1.trimPath)(uri);
     let result;
+    uri = (0, util_1.trimPath)(uri);
     for (const pathname in headers) {
         if (pathname === uri || uri.startsWith(pathname + '/')) {
             (result ||= []).push([pathname, headers[pathname]]);
@@ -331,8 +331,8 @@ function decompressEncoding(value, chunkSize) {
             break;
     }
 }
-function abortHeaders(href, request, options, statusCode = '') {
-    const reason = (0, types_1.errorMessage)(statusCode, "Aborted by client", href);
+function abortHeaders(href, request, options, statusCode = '', message) {
+    const reason = (0, types_1.errorMessage)(statusCode, message || "Aborted by client", href);
     const outAbort = options.outAbort;
     if (outAbort) {
         outAbort.abort(reason);
@@ -346,7 +346,7 @@ function resetAria2() {
 }
 function escapeShellQuote(value) {
     value = value.replaceAll('"', '\\"');
-    return module_1.PLATFORM_WIN32 ? value : value.replace(/[ $`]/g, capture => (capture !== ' ' ? '\\' : '') + '\\' + capture);
+    return module_1.PLATFORM_WIN32 ? value : value.replace(/[ $`;]/g, capture => (capture !== ' ' ? '\\' : '') + '\\' + capture);
 }
 function failedDns(err, pending) {
     for (const cb of pending) {
@@ -375,523 +375,10 @@ function successDns(instance, value, pending, connected) {
     }
     pending.length = 0;
 }
+const isFunction = (value) => typeof value === 'function';
 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);
-class Fetch {
-    static isUnsupported(value) {
-        return value === 421 || value === 505;
-    }
-    static isDowngrade(err) {
-        return err instanceof Error && (err.code === 'ERR_HTTP2_ERROR' || this.isUnsupported(Math.abs(err.errno)));
-    }
-    static wasAborted(err) {
-        return err instanceof Error && err.message.startsWith("Aborted");
-    }
-    static isConnectionTimeout(err) {
-        switch (err instanceof Error && err.code) {
-            case 'ETIMEDOUT':
-            case 'ECONNRESET':
-                return true;
-            default:
-                return false;
-        }
-    }
-    constructor(instance, uri, opts) {
-        this.instance = instance;
-        this.opts = opts;
-        this.retries = 0;
-        this.redirects = 0;
-        this.closed = false;
-        this.aborted = false;
-        this.timeout = null;
-        this.outStream = null;
-        this.status = opts.silent === false || !opts.silent && !instance[kSingleton];
-        this.log = this.status && LOG_HTTP && LOG_TIMEPROCESS;
-        this.startTime = this.log ? process.hrtime() : 0;
-        this.setConfig(uri);
-    }
-    async start() {
-        return new Promise((resolve, reject) => {
-            this.resolve = resolve;
-            this.reject = reject;
-            this.init();
-        });
-    }
-    init() {
-        this.aborted = false;
-        this.setWriteStream();
-        const config = this.config;
-        const client = this.instance.open(this.uri, config);
-        this.client = client;
-        if (config.httpVersion === 2) {
-            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 (Fetch.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) {
-                    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 (Fetch.wasAborted(err)) {
-                    this.errorResponse(err);
-                }
-                else {
-                    switch (!Fetch.isDowngrade(err) && await config.host.hasProtocol(2)) {
-                        case 1:
-                            this.errorResponse(err);
-                            break;
-                        case 2:
-                            this.retryDownload(false, err);
-                            break;
-                        default:
-                            this.retryDownload(true, err);
-                            break;
-                    }
-                }
-            });
-        }
-        else {
-            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) {
-                    this.errorResponse(err);
-                }
-            });
-        }
-        client.on('timeout', () => {
-            if (this.aborted) {
-                return;
-            }
-            if (++this.retries <= this.retryLimit) {
-                this.abortResponse();
-                this.retryTimeout();
-            }
-            else {
-                this.terminate(this.formatStatus(408));
-            }
-        });
-    }
-    setConfig(uri) {
-        this.uri = uri;
-        this.config = this.instance.opts(uri, this.opts);
-    }
-    setWriteStream() {
-        const pipeTo = this.pipeTo;
-        if (typeof pipeTo === 'string') {
-            try {
-                this.outStream = fs.createWriteStream(pipeTo, { emitClose: false, highWaterMark: this.config.host.streamSize });
-                this.config.outStream = this.outStream;
-            }
-            catch (err) {
-                this.terminate(err);
-            }
-        }
-        else {
-            this.config.outStream = pipeTo;
-        }
-    }
-    abortResponse() {
-        if (this.closed) {
-            return;
-        }
-        if (this.timeout) {
-            clearTimeout(this.timeout);
-        }
-        this.aborted = true;
-        this.client.destroy();
-        this.cleanup();
-    }
-    retryDownload(downgrade, message) {
-        if (this.aborted) {
-            return;
-        }
-        this.abortResponse();
-        if (downgrade) {
-            const host = this.config.host;
-            host.failed(2);
-            if (host.version > 1) {
-                if (this.status) {
-                    this.instance.formatMessage(1024, 'HTTP2', ["Unsupported protocol", host.origin], message, { failed: true });
-                }
-                host.version = 1;
-            }
-        }
-        this.opts.httpVersion = 1;
-        this.init();
-    }
-    acceptResponse(headers) {
-        const { instance, config, client, opts, pipeTo } = this;
-        const parent = this.instance.host;
-        const progressId = config.progressId;
-        if ('outHeaders' in opts) {
-            opts.outHeaders = headers;
-        }
-        if ('outFilename' in opts) {
-            opts.outFilename = (0, util_1.parseHeader)(headers, 'content-disposition');
-        }
-        const pipeline = pipeTo ? !(0, types_1.isString)(pipeTo) : false;
-        const enabled = config.connected?.call(client, headers) !== false && !pipeline;
-        const maxBufferSize = config.maxBufferSize ? (0, types_1.alignSize)(config.maxBufferSize) : 0;
-        const contentLength = parent && progressId !== undefined ? parseInt(headers['content-length'] || '0') : 0;
-        let log = this.log, buffer = null, dataLength = 0, mibsTime, delayTime;
-        if (log || contentLength > 0 || instance.readTimeout > 0) {
-            client.once('readable', () => {
-                if (instance.readTimeout > 0) {
-                    this.timeout = setTimeout(() => {
-                        this.terminate((0, types_1.errorValue)("Timeout was exceeded", this.uri.toString()));
-                    }, instance.readTimeout);
-                }
-                if (log) {
-                    switch (instance.settings?.time_format || LOG_TIMEFORMAT) {
-                        case 'readable':
-                            delayTime = process.hrtime(this.startTime);
-                            break;
-                        case 'relative':
-                            delayTime = Date.now() - instance.startTime;
-                            break;
-                        case 'none':
-                            if (opts.silent !== false) {
-                                log = false;
-                            }
-                            break;
-                    }
-                }
-                mibsTime = process.hrtime();
-                if (contentLength > 0) {
-                    parent.updateProgress("request", progressId, 0, 0, mibsTime);
-                }
-            });
-        }
-        if (enabled) {
-            const encoding = opts.encoding;
-            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 (contentLength > 0) {
-                    dataLength += Buffer.byteLength(chunk, encoding);
-                    parent.updateProgress("request", progressId, dataLength, contentLength);
-                }
-                if (maxBufferSize > 0) {
-                    if (contentLength === 0) {
-                        dataLength += Buffer.byteLength(chunk, encoding);
-                    }
-                    if (dataLength > maxBufferSize) {
-                        this.terminate((0, types_1.errorValue)("Size limit was exceeded", this.uri.toString()));
-                    }
-                }
-            });
-        }
-        client.once('end', () => {
-            if (this.closed || this.aborted) {
-                return;
-            }
-            this.close();
-            const encoding = opts.encoding;
-            let result, messageUnit, titleBgColor;
-            if (buffer) {
-                if (Array.isArray(buffer)) {
-                    buffer = Buffer.concat(buffer);
-                    if (encoding) {
-                        buffer = buffer.toString(encoding);
-                    }
-                }
-                dataLength = Buffer.byteLength(buffer, encoding);
-                if (mibsTime) {
-                    messageUnit = (0, util_1.getTransferRate)(dataLength, (0, types_1.convertTime)(process.hrtime(mibsTime), false) * 1000);
-                }
-                if (contentLength > 0) {
-                    parent.updateProgress("request", progressId, dataLength, dataLength);
-                }
-                if (typeof buffer === 'string') {
-                    if (buffer.startsWith('\uFEFF') && encoding !== 'utf16le' && encoding !== 'utf-16le') {
-                        buffer = buffer.substring(1);
-                    }
-                    if (config.outFormat) {
-                        const { out: format, parser } = config.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.status && !(packageName && instance.checkPackage(err, packageName))) {
-                                instance.writeFail(["Unable to parse URI response", format], err, 1024);
-                            }
-                            result = null;
-                        }
-                    }
-                }
-                if (result === undefined) {
-                    result = buffer;
-                }
-            }
-            else {
-                if (contentLength > 0) {
-                    parent.updateProgress("request", progressId, 0, contentLength);
-                }
-                if (enabled && instance.readExpect === 'always') {
-                    this.terminate("No data received");
-                    return;
-                }
-                result = encoding && !pipeline ? '' : null;
-                titleBgColor = 'bgBlue';
-            }
-            if (log) {
-                instance.writeTimeProcess('HTTP' + config.httpVersion, config.statusMessage || this.uri.toString(), this.startTime, { type: 1024, queue: !!parent, titleBgColor, messageUnit, messageUnitMinWidth: 9, delayTime, bypassLog: LOG_STDOUT });
-            }
-            this.resolve(result);
-        });
-        config.host.success(this.httpVersion);
-    }
-    redirectResponse(statusCode, location) {
-        if (location) {
-            if (this.config.follow_redirect === false || this.config.followRedirect === false) {
-                this.terminate(this.formatStatus(statusCode, "Follow redirect was disabled"));
-            }
-            else if (++this.redirects <= this.redirectLimit) {
-                this.abortResponse();
-                this.setConfig(Request.fromURL(this.config.url, location));
-                this.init();
-            }
-            else {
-                this.terminate(this.formatStatus(statusCode, "Exceeded redirect limit"));
-            }
-        }
-        else {
-            this.terminate(this.formatStatus(statusCode, "Missing redirect location"));
-        }
-    }
-    errorResponse(err) {
-        if (Fetch.wasAborted(err)) {
-            this.terminate(err);
-        }
-        else if ((0, util_1.checkRetryable)(err) && ++this.retries <= this.retryLimit) {
-            this.abortResponse();
-            if (Fetch.isConnectionTimeout(err)) {
-                this.retryTimeout();
-            }
-            else {
-                setTimeout(() => {
-                    this.init();
-                }, this.retryWait);
-            }
-        }
-        else {
-            this.config.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(Request.fromStatusCode(statusCode)));
-        if ((0, util_1.isRetryable)(statusCode, true)) {
-            process.nextTick(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.timeout) {
-            clearTimeout(this.timeout);
-        }
-        if (!this.closed) {
-            this.cleanup();
-            this.close();
-            this.reject(typeof err === 'string' ? new Error(err) : err);
-        }
-    }
-    sendWarning(message) {
-        if (this.status) {
-            const { host, url } = this.config;
-            this.instance.formatMessage(1024, 'HTTP' + this.httpVersion, [message, host.origin], url.toString(), { ...module_1.LOG_STYLE_WARN });
-        }
-    }
-    formatStatus(value, hint) {
-        return value + ': ' + (hint || Request.fromStatusCode(value)) + ` (${this.uri.toString()})`;
-    }
-    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})`;
-    }
-    close() {
-        if (this.timeout) {
-            clearTimeout(this.timeout);
-        }
-        this.closed = true;
-        if (this.aborted && !this.client.aborted && !this.client.destroyed) {
-            this.opts.outAbort?.abort();
-        }
-    }
-    cleanup() {
-        const outAbort = this.opts.outAbort;
-        if (outAbort) {
-            this.downloading.delete(outAbort);
-        }
-        if ((0, types_1.isString)(this.pipeTo) && this.outStream) {
-            (0, util_1.cleanupStream)(this.outStream, this.pipeTo);
-        }
-    }
-    get destroyed() {
-        return this.client.destroyed || this.httpVersion === 2 && this.client.aborted;
-    }
-    get downloading() {
-        return this.instance[kDownloading];
-    }
-    get httpVersion() {
-        return this.config.httpVersion;
-    }
-    get outAbort() {
-        return this.config.outAbort;
-    }
-    get pipeTo() {
-        return this.opts.pipeTo;
-    }
-    get retryLimit() {
-        return this.settings.retryLimit;
-    }
-    get retryWait() {
-        return this.settings.retryWait;
-    }
-    get retryAfter() {
-        return this.settings.retryAfter;
-    }
-    get redirectLimit() {
-        return this.settings.redirectLimit;
-    }
-    get settings() {
-        return this.instance['_config'];
-    }
-}
 class Request extends module_1 {
     static async purgeMemory(percent = 1, limit = 0, parent) {
         if (percent >= 1) {
@@ -985,9 +472,8 @@ class Request extends module_1 {
                 READ_TIMEOUT = read_timeout;
             }
             if ((0, types_1.isObject)(agent)) {
-                let keep_alive;
-                ({ keep_alive, timeout: agent_timeout } = agent);
-                if ((agent_timeout = (0, util_1.fromSeconds)(agent_timeout)) > 0) {
+                let { keep_alive, timeout } = agent;
+                if ((agent_timeout = (0, util_1.fromSeconds)(timeout)) > 0) {
                     AGENT_TIMEOUT = agent_timeout;
                 }
                 else {
@@ -1020,19 +506,13 @@ class Request extends module_1 {
                 [TLS.TEXT, TLS.FILE] = validateCerts(certs);
             }
             HTTP.PROXY = getProxySettings(request, agent_timeout);
-            const time_format = request.settings?.time_format;
-            switch (time_format) {
-                case 'readable':
-                case 'relative':
-                case 'none':
-                    LOG_TIMEFORMAT = time_format;
-                    break;
-            }
             host_1.defineHostConfig(request);
+            if ('defineHostConfig' in HTTP_ADAPTER) {
+                HTTP_ADAPTER.defineHostConfig(request);
+            }
         }
         LOG_HTTP = this.hasLogType(1024);
         LOG_TIMEPROCESS = this.hasLogType(256);
-        LOG_STDOUT = module_1.hasLogType(32768);
         return true;
     }
     static readCACert(value, cache) {
@@ -1048,153 +528,10 @@ class Request extends module_1 {
         return typeof value === 'string' && (value = value.trim()).length > 0 && REGEXP_PEMCERT.test(value);
     }
     static fromURL(url, value) {
-        if (this.isURL(value)) {
-            return value;
-        }
-        const auth = host_1.formatBasicAuth(url);
-        return url.protocol + '//' + (auth && (auth + '@')) + url.hostname + (url.port ? ':' + url.port : '') + (value.startsWith('/') ? '' : '/') + value;
+        return (0, util_1.fromURL)(url, value);
     }
     static fromStatusCode(value) {
-        value = +value;
-        if (value < 200) {
-            switch (value) {
-                case 100:
-                    return 'Continue';
-                case 101:
-                    return 'Switching Protocol';
-                case 102:
-                    return 'Processing';
-                case 103:
-                    return 'Early Hints';
-            }
-        }
-        else if (value < 300) {
-            switch (value) {
-                case 200:
-                    return 'OK';
-                case 201:
-                    return 'Created';
-                case 202:
-                    return 'Accepted';
-                case 203:
-                    return 'Non-Authoritative Information';
-                case 204:
-                    return 'No Content';
-                case 205:
-                    return 'Reset Content';
-                case 206:
-                    return 'Partial Content';
-            }
-        }
-        else if (value < 400) {
-            switch (value) {
-                case 300:
-                    return 'Multiple Choice';
-                case 301:
-                    return 'Moved Permanently';
-                case 302:
-                    return 'Found';
-                case 303:
-                    return 'See Other';
-                case 304:
-                    return 'Not Modified';
-                case 305:
-                    return 'Use Proxy';
-                case 307:
-                    return 'Temporary Redirect';
-                case 308:
-                    return 'Permanent Redirect';
-            }
-        }
-        else if (value < 500) {
-            switch (value) {
-                case 400:
-                    return 'Bad Request';
-                case 401:
-                    return 'Upgrade Required';
-                case 402:
-                    return 'Payment Required';
-                case 403:
-                    return 'Forbidden';
-                case 404:
-                    return 'Not Found';
-                case 405:
-                    return 'Method Not Allowed';
-                case 406:
-                    return 'Not Acceptable';
-                case 407:
-                    return 'Proxy Authentication Required';
-                case 408:
-                    return 'Request Timeout';
-                case 409:
-                    return 'Conflict';
-                case 410:
-                    return 'Gone';
-                case 411:
-                    return 'Length Required';
-                case 412:
-                    return 'Precondition Failed';
-                case 413:
-                    return 'Payload Too Large';
-                case 414:
-                    return 'URI Too Long';
-                case 415:
-                    return 'Unsupported Media Type';
-                case 416:
-                    return 'Range Not Satisfiable';
-                case 417:
-                    return 'Expectation Failed';
-                case 421:
-                    return 'Misdirected Request';
-                case 422:
-                    return 'Unprocessable Entity';
-                case 423:
-                    return 'Locked';
-                case 424:
-                    return 'Failed Dependency';
-                case 425:
-                    return 'Too Early';
-                case 426:
-                    return 'Upgrade Required';
-                case 428:
-                    return 'Precondition Required';
-                case 429:
-                    return 'Too Many Requests';
-                case 431:
-                    return 'Request Header Fields Too Large';
-                case 451:
-                    return 'Unavailable For Legal Reasons';
-            }
-        }
-        else {
-            switch (value) {
-                case 500:
-                    return 'Internal Server Error';
-                case 501:
-                    return 'Not Implemented';
-                case 502:
-                    return 'Bad Gateway';
-                case 503:
-                    return 'Service Unavailable';
-                case 504:
-                    return 'Gateway Timeout';
-                case 505:
-                    return 'HTTP Version Not Supported';
-                case 506:
-                    return 'Variant Also Negotiates';
-                case 507:
-                    return 'Insufficient Storage';
-                case 508:
-                    return 'Loop Detected';
-                case 509:
-                    return 'Bandwidth Limit Exceeded';
-                case 510:
-                    return 'Not Extended';
-                case 511:
-                    return 'Network Authentication Required';
-            }
-        }
-        return "Unknown";
+        return (0, util_1.fromStatusCode)(value);
     }
     static defineHttpAgent(options) {
         const { keepAlive, timeout = 0 } = options;
@@ -1243,6 +580,11 @@ class Request extends module_1 {
             }
         }
     }
+    static defineHttpAdapter(module) {
+        if (isFunction(module) && module.prototype instanceof adapter_1) {
+            HTTP_ADAPTER = module;
+        }
+    }
     static getAria2Path() {
         return ARIA2.BIN;
     }
@@ -1271,9 +613,10 @@ class Request extends module_1 {
         this[_h] = [{}, {}];
         this[_j] = null;
         this[_k] = null;
-        this[_l] = new Set();
-        this[_m] = {};
-        this[_o] = [Object.create(null)];
+        this[_l] = HTTP_ADAPTER;
+        this[_m] = new Set();
+        this[_o] = {};
+        this[_p] = [Object.create(null)];
         if ((0, types_1.isPlainObject)(data)) {
             const { headers, read_timeout, agent, use, connect, certs } = data;
             const timeout = (0, util_1.fromSeconds)(data.timeout);
@@ -1355,7 +698,7 @@ class Request extends module_1 {
                         count = Math.max(count, value);
                     }
                 });
-                if (LOG_STDOUT) {
+                if (module_1.hasLogType(32768)) {
                     output.sort((a, b) => {
                         if (a[2] === b[2]) {
                             return a[1] < b[1] ? -1 : 1;
@@ -1556,7 +899,24 @@ class Request extends module_1 {
             if (!include && !exclude && !localhost) {
                 return proxy;
             }
-            if ((0, types_1.isArray)(include) && !include.some(value => REGEXP_GLOBWITHIN.test(value) ? pm.isMatch(uri, value) : uri.startsWith(value)) || (0, types_1.isArray)(exclude) && exclude.some(value => REGEXP_GLOBWITHIN.test(value) ? pm.isMatch(uri, value) : uri.startsWith(value))) {
+            if (exclude) {
+                let valid = true;
+                for (const value of exclude) {
+                    if (value.startsWith('!')) {
+                        if (REGEXP_GLOBWITHIN.test(value.substring(1))) {
+                            valid = true;
+                            break;
+                        }
+                    }
+                    else if (valid && (REGEXP_GLOBWITHIN.test(value) ? pm.isMatch(uri, value) : uri.startsWith(value))) {
+                        valid = false;
+                    }
+                }
+                if (!valid) {
+                    return;
+                }
+            }
+            if ((0, types_1.isArray)(include) && !include.some(value => REGEXP_GLOBWITHIN.test(value) ? pm.isMatch(uri, value) : uri.startsWith(value))) {
                 return;
             }
             return proxy;
@@ -1848,7 +1208,7 @@ class Request extends module_1 {
             opts.push(`"${escapeShellQuote(uri)}"`);
             args = args.concat(init, opts);
             const startTime = Date.now();
-            let out = '', message = '', aborted;
+            let out = '', message = '', aborted = false;
             const errorResponse = (pid, err) => {
                 aborted = true;
                 closeTorrent(pid);
@@ -1983,7 +1343,7 @@ class Request extends module_1 {
         return { ...options, host, url };
     }
     open(uri, options) {
-        let { host, url, httpVersion, method = 'GET', search, encoding, format, headers: outgoing, postData, keepAlive, agentTimeout, socketPath, timeout = this._config.connectTimeout, outStream } = options, headers = (0, util_1.parseOutgoingHeaders)(outgoing), getting = false, posting = false;
+        let { host, url, httpVersion, method = 'GET', search, encoding, format, headers: outgoing, socketPath, expectContinue = false, timeout = this._config.connectTimeout, outStream } = options, headers = (0, util_1.parseOutgoingHeaders)(outgoing), getting = false, posting = false;
         switch (method = method.toUpperCase()) {
             case 'GET':
             case 'DELETE':
@@ -2066,10 +1426,29 @@ class Request extends module_1 {
         const pathname = url.pathname + (socketPath ? '' : url.search);
         const proxy = this.proxyOf(uri, host.localhost);
         const version = this.httpVersion;
-        let request, ca, cert, key, ciphers, minVersion, baseHeaders = this.headersOf(uri);
+        const baseHeaders = this.headersOf(uri);
+        let request, ca, cert, key, ciphers, minVersion;
         if (getting && this.acceptEncoding && !host.localhost && !baseHeaders?.['accept-encoding']) {
             (headers ||= {})['accept-encoding'] ||= 'gzip, deflate, br' + (LIB_ZSTD ? ', zstd' : '');
         }
+        if (posting && options.postData) {
+            if (expectContinue) {
+                (headers ||= {}).expect = '100-continue';
+            }
+            else {
+                let expect;
+                if (headers && 'expect' in headers) {
+                    expect = headers.expect;
+                }
+                else if (baseHeaders) {
+                    expect = baseHeaders.expect;
+                }
+                expectContinue = expect === '100-continue';
+            }
+        }
+        else {
+            expectContinue = false;
+        }
         if (secure) {
             const certs = this[kCerts]?.[0][origin] || this.host && TLS.TEXT[origin];
             if (certs) {
@@ -2082,10 +1461,14 @@ class Request extends module_1 {
                 const listenerMap = {};
                 const onEvent = request.on.bind(request);
                 const onceEvent = request.once.bind(request);
-                let connected, emitter;
+                let connected = false, emitter;
                 request.on('response', response => {
-                    connected = true;
                     const statusCode = response[':status'];
+                    if (expectContinue) {
+                        abortHeaders.call(this, url.href, request, options, statusCode, "Did not receive continue acknowledgment");
+                        return;
+                    }
+                    connected = true;
                     if (this.matchStatus(statusCode, url, response, request, options) && statusCode >= 200 && statusCode < 300) {
                         if (emitter = checkEncoding(request, request, statusCode, outStream, response['content-encoding'])) {
                             for (const event in listenerMap) {
@@ -2114,8 +1497,8 @@ class Request extends module_1 {
                             this[kConnectHttp][1][origin] = (this[kConnectHttp][1][origin] || 0) + 1;
                         }
                     }
-                    request.setTimeout(this._config.timeout);
                     this.matchHeaders(url, response, request, options);
+                    request.setTimeout(this._config.timeout);
                 });
                 request.on = function (event, listener) {
                     switch (event) {
@@ -2159,16 +1542,14 @@ class Request extends module_1 {
         else {
             let agent;
             if (!socketPath) {
+                let { keepAlive, agentTimeout } = options;
                 if (proxy) {
                     const pkg = secure ? 'https-proxy-agent' : 'http-proxy-agent';
                     try {
                         keepAlive ??= proxy.keepAlive;
                         agentTimeout ??= proxy.agentTimeout;
                         const proxyHeaders = this[kHeaders] && getBaseHeaders(proxy.host.href, this[kHeaders]) || getBaseHeaders(proxy.host.href, HTTP.HEADERS);
-                        agent = require(pkg)(proxy.host, typeof keepAlive === 'boolean' || agentTimeout > 0 || proxyHeaders ? { keepAlive: keepAlive ?? true, timeout: agentTimeout, headers: proxyHeaders } : undefined);
-                        if (proxyHeaders) {
-                            baseHeaders = { ...baseHeaders, ...proxyHeaders };
-                        }
+                        agent = require(pkg)(proxy.host, (typeof keepAlive === 'boolean' || agentTimeout > 0) && agentTimeout !== 0 ? { keepAlive: keepAlive ?? true, timeout: agentTimeout, headers: proxyHeaders } : { headers: proxyHeaders });
                     }
                     catch (err) {
                         this.checkPackage(err, pkg, "Unknown");
@@ -2208,10 +1589,12 @@ 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 (!expectContinue && this.matchStatus(statusCode, url, incoming, request, options) && (getting || posting) && statusCode >= 200 && statusCode < 300) {
                     let source = checkEncoding(request, response, statusCode, outStream, incoming['content-encoding']);
                     if (source) {
-                        source.once('finish', () => request.emit('end'));
+                        source.once('finish', () => {
+                            request.emit('end');
+                        });
                     }
                     else {
                         if (encoding) {
@@ -2228,7 +1611,9 @@ class Request extends module_1 {
                             });
                         }
                         else {
-                            response.once('end', () => request.emit('end'));
+                            response.once('end', () => {
+                                request.emit('end');
+                            });
                         }
                         source = response;
                     }
@@ -2273,9 +1658,15 @@ class Request extends module_1 {
                         .once('end', () => {
                         request.emit('end');
                     });
+                    if (expectContinue) {
+                        abortHeaders.call(this, url.href, request, options, statusCode, "Did not receive continue acknowledgment");
+                        return;
+                    }
                 }
                 if (this._config.timeout) {
-                    response.setTimeout(this._config.timeout, () => request.emit('timeout'));
+                    response.setTimeout(this._config.timeout, () => {
+                        request.emit('timeout');
+                    });
                 }
                 this.matchHeaders(url, incoming, request, options);
             });
@@ -2295,15 +1686,32 @@ class Request extends module_1 {
                 ac.abort(new Error("Aborted by process"));
             }, { once: true });
         }
-        if (posting) {
-            if ((0, types_1.isString)(postData) || Buffer.isBuffer(postData)) {
-                request.write(postData);
-            }
-            else if (postData instanceof stream.Stream) {
-                postData.pipe(request);
+        const sendBody = () => {
+            if (posting) {
+                const postData = options.postData;
+                if ((0, types_1.isString)(postData) || Buffer.isBuffer(postData)) {
+                    request.write(postData);
+                }
+                else if (postData instanceof stream.Stream) {
+                    postData.pipe(request);
+                }
             }
+        };
+        if (expectContinue) {
+            const pending = setTimeout(() => {
+                request.end();
+            }, options.expectTimeout || 5 * 1000);
+            request.on('continue', () => {
+                clearTimeout(pending);
+                expectContinue = false;
+                sendBody();
+                request.end();
+            });
+        }
+        else {
+            sendBody();
+            request.end();
         }
-        request.end();
         return request;
     }
     head(uri, options) {
@@ -2344,14 +1752,13 @@ class Request extends module_1 {
         }
         let dataEncoding;
         if ((0, types_1.isPlainObject)(options)) {
-            let formData;
-            ({ formData, dataEncoding } = options);
-            if (!putting && formData) {
-                (parts ||= []).push(...Array.isArray(formData) ? formData : [formData]);
+            if (!putting && options.formData) {
+                (parts ||= []).push(...Array.isArray(options.formData) ? options.formData : [options.formData]);
             }
             else {
                 contentType ||= options.contentType;
             }
+            dataEncoding = options.dataEncoding;
         }
         else {
             options = {};
@@ -2364,7 +1771,7 @@ class Request extends module_1 {
             }
         }
         if (!putting && (parts || contentType === "multipart/form-data" || contentType === 'form-data')) {
-            let valid;
+            let valid = false;
             if ((0, types_1.isArray)(parts)) {
                 const write = combined.create();
                 const boundary = crypto.randomUUID().replaceAll('-', '');
@@ -2446,7 +1853,7 @@ class Request extends module_1 {
         }
         else {
             if (contentType && !contentType.includes('/')) {
-                contentType = 'application/' + contentType.trim();
+                contentType = 'application/' + contentType;
             }
             if (!(0, types_1.isPlainObject)(data)) {
                 data = module_1.asString(data);
@@ -2468,14 +1875,35 @@ class Request extends module_1 {
         headers['content-type'] = contentType || "text/plain";
         return this.get(uri, options);
     }
-    async get(uri, options = {}) {
-        const opts = (typeof options === 'string' ? { format: options, encoding: 'utf-8' } : options);
+    async get(uri, options) {
+        const opts = (typeof options === 'string' ? { format: options, encoding: 'utf-8' } : options || {});
         if (this.readExpect === 'string') {
             opts.encoding = (0, types_1.getEncoding)(opts.encoding);
         }
-        return new Fetch(this, uri, opts).start();
+        const singleton = this[kSingleton];
+        const verbose = !opts.silent && !singleton || opts.silent === false;
+        const log = verbose && LOG_HTTP && LOG_TIMEPROCESS;
+        const state = Object.freeze({
+            verbose,
+            log,
+            singleton,
+            config: this._config
+        });
+        return new this[kAdapter](this, state, uri, opts).start();
     }
-    reset() {
+    reset(adapter) {
+        if (adapter) {
+            if (adapter.timeout) {
+                clearTimeout(adapter.timeout);
+                adapter.timeout = null;
+            }
+            const ac = adapter.abortController;
+            if (ac) {
+                this[kDownloading].delete(ac);
+                adapter.abortController = null;
+            }
+            return;
+        }
         this[kPendingDns] = Object.create(null);
         this[kDownloading].clear();
     }
@@ -2545,6 +1973,11 @@ class Request extends module_1 {
         }
         return true;
     }
+    set adapter(value) {
+        if (isFunction(value) && value.prototype instanceof adapter_1) {
+            this[kAdapter] = value;
+        }
+    }
     set agentTimeout(value) {
         if (value > 0) {
             this[kAgentTimeout] = value;
@@ -2585,5 +2018,5 @@ class Request extends module_1 {
         return this.module.settings ||= {};
     }
 }
-_a = kSingleton, _b = kHttpVersion, _c = kHeaders, _d = kCerts, _e = kBaseURL, _f = kConnectDns, _g = kPendingDns, _h = kConnectHttp, _j = kStatusOn, _k = kHeadersOn, _l = kDownloading, _m = kHostInfo, _o = kSession;
+_a = kSingleton, _b = kHttpVersion, _c = kHeaders, _d = kCerts, _e = kBaseURL, _f = kConnectDns, _g = kPendingDns, _h = kConnectHttp, _j = kStatusOn, _k = kHeadersOn, _l = kAdapter, _m = kDownloading, _o = kHostInfo, _p = kSession;
 module.exports = Request;