@e-mc/request 0.9.6 → 0.10.0

package/index.js

@@ -1,7 +1,8 @@
 "use strict";
-var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+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");
@@ -15,16 +16,17 @@ 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 host_1 = require("@e-mc/request/http/host");
+const types_1 = require("@e-mc/types");
 const util_1 = require("@e-mc/request/util");
+const host_1 = require("@e-mc/request/http/host");
 const kSession = Symbol('session');
 const kHttpVersion = Symbol('httpVersion');
 const kIpVersion = Symbol('ipVersion');
 const kAgentTimeout = Symbol('agentTimeout');
 const kHeaders = Symbol('headers');
 const kCerts = Symbol('certs');
+const kBaseURL = Symbol('baseURL');
 const kDownloading = Symbol('downloading');
 const kSingleton = Symbol('singleton');
 const kHostInfo = Symbol('hostInfo');
@@ -33,8 +35,9 @@ const kPendingDns = Symbol('pendingDns');
 const kConnectHttp = Symbol('connectHttp');
 const kStatusOn = Symbol('statusOn');
 const kHeadersOn = Symbol('headersOn');
-const PLATFORM_WIN32 = process.platform === 'win32';
-const SUPPORT_NODEJS20 = module_1.supported(20);
+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 = /\\\?|(?:(?<!\\)(?:\*|\[!?[^!\]]+\]|\{(?:[^,]+,)+[^}]+\}|[!?+*@]\((?:[^|]+\|)*[^)]+\)|\?.*\?|\?$))/;
 const HTTP = {
     HOST: {},
     HEADERS: {},
@@ -52,13 +55,14 @@ const DNS = {
     FAMILY: 0
 };
 const ARIA2 = {
-    BIN: which.sync(PLATFORM_WIN32 ? 'aria2c.exe' : 'aria2c', { nothrow: true }) || '',
+    BIN: which.sync(module_1.PLATFORM_WIN32 ? 'aria2c.exe' : 'aria2c', { nothrow: true }) || '',
     EXEC_UID: undefined,
     EXEC_GID: undefined,
     PID_TIMER: null,
     PID_QUEUE: [],
     UPDATE_STATUS: 0,
     UPDATE_BROADCAST_ONLY: false,
+    CHECK_INTEGRITY: false,
     BT_STOP_TIMEOUT: 60,
     BT_TRACKER_CONNECT_TIMEOUT: 30,
     BT_TRACKER_TIMEOUT: 60,
@@ -118,15 +122,6 @@ function setDnsCache(hostname, value, expires) {
         }
     }
 }
-function isConnectionTimeout(err) {
-    switch (err instanceof Error && err.code) {
-        case 'ETIMEDOUT':
-        case 'ECONNRESET':
-            return true;
-        default:
-            return false;
-    }
-}
 function setOutgoingHeaders(output, headers) {
     for (const href in headers) {
         output[href] = (0, util_1.normalizeHeaders)(headers[href]);
@@ -156,14 +151,18 @@ function getProxySettings(request, agentTimeout) {
     return null;
 }
 function closeTorrent(pid) {
-    const index = ARIA2.PID_QUEUE.findIndex(value => pid === value[0]);
-    if (index !== -1) {
-        ARIA2.PID_QUEUE.splice(index, 1);
+    if (typeof pid === 'number') {
+        const index = ARIA2.PID_QUEUE.findIndex(value => pid === value[0]);
+        if (index !== -1) {
+            ARIA2.PID_QUEUE.splice(index, 1);
+        }
     }
 }
 function clearDnsLookup() {
     DNS.CACHE = Object.create(null);
-    DNS.TIMEOUT.forEach(value => clearTimeout(value));
+    for (const value of DNS.TIMEOUT) {
+        clearTimeout(value);
+    }
     DNS.TIMEOUT.length = 0;
 }
 function resetHttpHost(version) {
@@ -194,15 +193,8 @@ function resetHttpHost(version) {
 function validateCerts(certs) {
     const text = {};
     const file = {};
-    const checkFile = (values) => {
-        for (let pathname of values) {
-            if (module_1.isPath(pathname = path.resolve(pathname))) {
-                return pathname;
-            }
-        }
-    };
     for (let origin in certs) {
-        let { ca, cert, key, passphrase, version: minVersion } = certs[origin], file_ca, file_cert, file_key, keyObject;
+        let { ca, cert, key, passphrase, ciphers, version: minVersion } = certs[origin], file_ca, file_cert, file_key, keyObject;
         try {
             origin = new URL(origin).origin;
         }
@@ -241,16 +233,16 @@ function validateCerts(certs) {
                 }
                 file_key = checkFile(key);
                 key = key.map(value => Request.readTLSKey(value)).filter(value => value);
-                if (key.length) {
+                if (key.length > 0) {
                     if (!Array.isArray(passphrase)) {
                         passphrase = passphrase ? [passphrase] : [];
                     }
-                    keyObject = key.length > 1 || passphrase.length ? key.map((pem, index) => ({ pem, passphrase: passphrase[index] })) : key[0];
+                    keyObject = key.length > 1 || passphrase.length > 0 ? key.map((pem, index) => ({ pem, passphrase: passphrase[index] })) : key[0];
                 }
             }
         }
         if (ca || cert) {
-            text[origin] = { ca, cert, key: keyObject, version: minVersion };
+            text[origin] = { ca, cert, key: keyObject, ciphers, version: minVersion };
         }
         if (file_ca || file_cert) {
             file[origin] = { ca: file_ca, cert: file_cert, key: file_key };
@@ -258,32 +250,42 @@ function validateCerts(certs) {
     }
     return [text, file];
 }
-function abortHeaders(href, request, options) {
-    const reason = (0, types_1.errorValue)("Aborted by client", href);
-    const outAbort = options.outAbort;
-    if (outAbort) {
-        outAbort.abort(reason);
-        this[kDownloading].delete(outAbort);
+function checkFile(values) {
+    for (let pathname of values) {
+        if (module_1.isPath(pathname = path.resolve(pathname))) {
+            return pathname;
+        }
     }
-    request.destroy(reason);
 }
-function checkEncoding(request, response, statusCode, outStream, contentEncoding = '') {
+function parseSize(value, zero) {
+    if (zero && (value === '0' || value === 0)) {
+        return 0;
+    }
+    if ((0, types_1.isString)(value) && /^\d+[KM]$/.test(value = value.trim().toUpperCase())) {
+        return value;
+    }
+}
+function copySearchParams(url, base) {
+    base.searchParams.forEach((value, key) => {
+        if (!url.searchParams.has(key)) {
+            url.searchParams.append(key, value);
+        }
+    });
+}
+function checkEncoding(request, response, statusCode, outStream, contentEncoding) {
     switch (statusCode) {
         case 206:
             request.emit('error', (0, types_1.errorValue)("Aborted", 'Partial content'));
         case 204:
             return;
-        default:
-            contentEncoding = contentEncoding.trim();
-            if (!contentEncoding) {
-                return;
-            }
-            contentEncoding = contentEncoding.toLowerCase();
-            break;
     }
+    if (!contentEncoding) {
+        return;
+    }
+    contentEncoding = contentEncoding.trim().toLowerCase();
     const chunkSize = outStream?.writableHighWaterMark;
     let pipeTo;
-    if (contentEncoding.indexOf(',') === -1) {
+    if (!contentEncoding.includes(',')) {
         pipeTo = decompressEncoding(contentEncoding, chunkSize);
     }
     else {
@@ -297,10 +299,18 @@ function checkEncoding(request, response, statusCode, outStream, contentEncoding
     }
     if (pipeTo) {
         if (outStream) {
-            stream.pipeline(response, pipeTo, outStream, err => err && response.emit('error', err));
+            stream.pipeline(response, pipeTo, outStream, err => {
+                if (err) {
+                    response.emit('error', err);
+                }
+            });
         }
         else {
-            stream.pipeline(response, pipeTo, err => err && response.emit('error', err));
+            stream.pipeline(response, pipeTo, err => {
+                if (err) {
+                    response.emit('error', err);
+                }
+            });
         }
         return pipeTo;
     }
@@ -322,10 +332,577 @@ function decompressEncoding(value, chunkSize) {
             break;
     }
 }
+function abortHeaders(href, request, options) {
+    const reason = (0, types_1.errorValue)("Aborted by client", href);
+    const outAbort = options.outAbort;
+    if (outAbort) {
+        outAbort.abort(reason);
+        this[kDownloading].delete(outAbort);
+    }
+    request.destroy(reason);
+}
+function resetAria2() {
+    clearInterval(ARIA2.PID_TIMER);
+    ARIA2.PID_TIMER = null;
+}
+function escapeShellQuote(value) {
+    value = value.replaceAll('"', '\\"');
+    return module_1.PLATFORM_WIN32 ? value : value.replace(/[ $`]/g, capture => (capture !== ' ' ? '\\' : '') + '\\' + capture);
+}
+function failedDns(err, pending) {
+    for (const cb of pending) {
+        if (SUPPORTED_NODE20) {
+            cb(err, []);
+        }
+        else {
+            cb(err, '', 0);
+        }
+    }
+    pending.length = 0;
+}
+function successDns(instance, value, pending, connected) {
+    instance[kConnectDns][value] = connected;
+    setDnsCache(value, connected, null);
+    if (SUPPORTED_NODE20) {
+        for (const cb of pending) {
+            cb(null, connected);
+        }
+    }
+    else {
+        const { address, family } = connected[0];
+        for (const cb of pending) {
+            cb(null, address, family);
+        }
+    }
+    pending.length = 0;
+}
+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.promise = [resolve, reject];
+            this.init();
+        });
+    }
+    init() {
+        if (this.retries > 0) {
+            this.cleanup();
+            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.rejectError(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.rejectError((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.abortResponse();
+                    this.rejectError(this.formatStatus(statusCode));
+                }
+            })
+                .on('abort', () => {
+                this.aborted = true;
+                this.rejectError((0, types_1.createAbortError)());
+            })
+                .on('error', err => {
+                if (!this.aborted) {
+                    this.errorResponse(err);
+                }
+            });
+        }
+        client.on('timeout', () => {
+            if (this.aborted) {
+                return;
+            }
+            this.abortResponse();
+            if (++this.retries <= this.retryLimit) {
+                this.retryTimeout();
+            }
+            else {
+                this.rejectError(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.rejectError(err);
+            }
+        }
+        else {
+            this.config.outStream = pipeTo;
+        }
+    }
+    abortResponse() {
+        if (this.closed) {
+            return;
+        }
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+        }
+        this.aborted = true;
+        if (this.outAbort) {
+            if (!this.client.aborted) {
+                this.outAbort.abort();
+            }
+            this.downloading.delete(this.outAbort);
+        }
+        this.client.destroy();
+    }
+    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.abortResponse();
+                        this.rejectError((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.abortResponse();
+                        this.rejectError((0, types_1.errorValue)("Size limit was exceeded", this.uri.toString()));
+                    }
+                }
+            });
+        }
+        client.once('end', () => {
+            if (this.closed || this.aborted) {
+                return;
+            }
+            if (this.timeout) {
+                clearTimeout(this.timeout);
+            }
+            if (this.outAbort) {
+                this.downloading.delete(this.outAbort);
+            }
+            this.closed = true;
+            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.rejectError("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.promise[0](result);
+        });
+        config.host.success(this.httpVersion);
+    }
+    redirectResponse(statusCode, location) {
+        this.abortResponse();
+        if (location) {
+            if (this.config.follow_redirect === false) {
+                this.rejectError(this.formatStatus(statusCode, "Follow redirect was disabled"));
+            }
+            else if (++this.redirects <= this.redirectLimit) {
+                this.setConfig(Request.fromURL(this.config.url, location));
+                this.init();
+            }
+            else {
+                this.rejectError(this.formatStatus(statusCode, "Exceeded redirect limit"));
+            }
+        }
+        else {
+            this.rejectError(this.formatStatus(statusCode, "Missing redirect location"));
+        }
+    }
+    errorResponse(err) {
+        this.abortResponse();
+        if (Fetch.wasAborted(err)) {
+            this.rejectError(err);
+        }
+        else if ((0, util_1.checkRetryable)(err) && ++this.retries <= this.retryLimit) {
+            if (Fetch.isConnectionTimeout(err)) {
+                this.retryTimeout();
+            }
+            else {
+                setTimeout(() => {
+                    this.init();
+                }, this.retryWait);
+            }
+        }
+        else {
+            this.config.host.error(this.httpVersion);
+            this.rejectError(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.rejectError(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();
+    }
+    rejectError(err) {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+        }
+        if (!this.closed) {
+            this.closed = true;
+            this.cleanup();
+            this.promise[1](typeof err === 'string' ? new Error(err) : err);
+        }
+        if (this.outAbort) {
+            this.downloading.delete(this.outAbort);
+        }
+    }
+    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})`;
+    }
+    cleanup() {
+        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) {
-            resetHttpHost();
+            resetHttpHost(0);
             clearDnsLookup();
         }
         else if (percent === 0) {
@@ -341,16 +918,8 @@ class Request extends module_1 {
             return false;
         }
         const { request, download } = settings;
-        if (download && (0, types_1.isPlainObject)(download.aria2)) {
-            let { bin, exec, update_status, max_concurrent_downloads, max_connection_per_server, bt_stop_timeout, bt_tracker_connect_timeout, bt_tracker_timeout, min_split_size, disk_cache, lowest_speed_limit, always_resume, file_allocation, conf_path } = download.aria2;
-            const parseSize = (value, zero) => {
-                if (zero && (value === '0' || value === 0)) {
-                    return 0;
-                }
-                if ((0, types_1.isString)(value) && /^\d+[KM]$/.test(value = value.trim().toUpperCase())) {
-                    return value;
-                }
-            };
+        if (download?.aria2) {
+            let { bin, exec, update_status, max_concurrent_downloads, max_connection_per_server, check_integrity, bt_stop_timeout, bt_tracker_connect_timeout, bt_tracker_timeout, min_split_size, disk_cache, lowest_speed_limit, always_resume, file_allocation, conf_path } = download.aria2;
             if (bin === false) {
                 ARIA2.BIN = '';
             }
@@ -375,6 +944,9 @@ class Request extends module_1 {
             if ((max_concurrent_downloads = (0, util_1.asInt)(max_concurrent_downloads)) > 0) {
                 ARIA2.MAX_CONCURRENT_DOWNLOADS = max_concurrent_downloads;
             }
+            if (typeof check_integrity === 'boolean') {
+                ARIA2.CHECK_INTEGRITY = check_integrity;
+            }
             if ((max_connection_per_server = (0, util_1.asInt)(max_connection_per_server)) > 0) {
                 ARIA2.MAX_CONNECTION_PER_SERVER = max_connection_per_server;
             }
@@ -387,7 +959,7 @@ class Request extends module_1 {
             if ((bt_tracker_timeout = (0, util_1.asInt)(bt_tracker_timeout)) > 0) {
                 ARIA2.BT_TRACKER_TIMEOUT = bt_tracker_timeout;
             }
-            if (min_split_size = parseSize(min_split_size)) {
+            if (min_split_size = parseSize(min_split_size, false)) {
                 ARIA2.MIN_SPLIT_SIZE = min_split_size;
             }
             if ((disk_cache = parseSize(disk_cache, true)) !== undefined) {
@@ -414,7 +986,7 @@ class Request extends module_1 {
                 ARIA2.CONF_PATH = conf_path;
             }
         }
-        if ((0, types_1.isPlainObject)(request)) {
+        if (request) {
             let { read_timeout, agent, use, headers, certs } = request, agent_timeout;
             if ((read_timeout = (0, util_1.fromSeconds)(read_timeout)) >= 0) {
                 READ_TIMEOUT = read_timeout;
@@ -436,7 +1008,7 @@ class Request extends module_1 {
                 }
                 this.defineHttpAgent({ keepAlive: keep_alive, timeout: agent_timeout });
             }
-            if ((0, types_1.isObject)(use)) {
+            if (use) {
                 let { http_version, accept_encoding } = use;
                 if (typeof accept_encoding === 'boolean') {
                     ACCEPT_ENCODING = accept_encoding;
@@ -448,10 +1020,10 @@ class Request extends module_1 {
                         break;
                 }
             }
-            if ((0, types_1.isObject)(headers)) {
+            if ((0, types_1.isPlainObject)(headers)) {
                 setOutgoingHeaders(HTTP.HEADERS, headers);
             }
-            if ((0, types_1.isObject)(certs)) {
+            if ((0, types_1.isPlainObject)(certs)) {
                 [TLS.TEXT, TLS.FILE] = validateCerts(certs);
             }
             HTTP.PROXY = getProxySettings(request, agent_timeout);
@@ -463,6 +1035,7 @@ class Request extends module_1 {
                     LOG_TIMEFORMAT = time_format;
                     break;
             }
+            host_1.defineHostConfig(request);
         }
         LOG_HTTP = this.hasLogType(1024);
         LOG_TIMEPROCESS = this.hasLogType(256);
@@ -470,7 +1043,7 @@ class Request extends module_1 {
         return true;
     }
     static readCACert(value, cache) {
-        return (0, types_1.isString)(value) ? (this.isCert(value) ? value : this.readText(value, cache)).trim() : '';
+        return (this.isCert(value) ? value : this.readText(value, cache)).trim();
     }
     static readTLSCert(value, cache) {
         return this.readCACert(value, cache);
@@ -479,7 +1052,7 @@ class Request extends module_1 {
         return this.readCACert(value, cache);
     }
     static isCert(value) {
-        return (0, types_1.isString)(value) && (value = value.trim()) ? value.includes('\n') && value.startsWith('---') && value.endsWith('---') : false;
+        return typeof value === 'string' && (value = value.trim()).length > 0 && REGEXP_PEMCERT.test(value);
     }
     static fromURL(url, value) {
         if (this.isURL(value)) {
@@ -489,7 +1062,8 @@ class Request extends module_1 {
         return url.protocol + '//' + (auth && (auth + '@')) + url.hostname + (url.port ? ':' + url.port : '') + (value.startsWith('/') ? '' : '/') + value;
     }
     static fromStatusCode(value) {
-        if ((value = +value) < 200) {
+        value = +value;
+        if (value < 200) {
             switch (value) {
                 case 100:
                     return 'Continue';
@@ -698,14 +1272,15 @@ class Request extends module_1 {
         this[_b] = null;
         this[_c] = null;
         this[_d] = null;
-        this[_e] = Object.create(null);
+        this[_e] = null;
         this[_f] = Object.create(null);
-        this[_g] = [{}, {}];
-        this[_h] = null;
+        this[_g] = Object.create(null);
+        this[_h] = [{}, {}];
         this[_j] = null;
-        this[_k] = new Set();
-        this[_l] = {};
-        this[_m] = [Object.create(null)];
+        this[_k] = null;
+        this[_l] = new Set();
+        this[_m] = {};
+        this[_o] = [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);
@@ -764,11 +1339,11 @@ class Request extends module_1 {
             log.length = 0;
         }
         else {
-            if (log.length && !this.host?.aborted) {
+            if (log.length > 0 && !this.host?.aborted) {
                 const output = [];
                 let count = 0;
                 this[kConnectHttp].forEach((protocol, index) => {
-                    var _o;
+                    var _p;
                     const title = 'HTTP' + (index + 1);
                     for (const origin in protocol) {
                         const value = protocol[origin];
@@ -778,7 +1353,7 @@ class Request extends module_1 {
                             if (item[1] === title && Array.isArray(item[2]) && item[2][0].startsWith(origin)) {
                                 item[1] = '';
                                 item[2][0] = item[2][0].substring(origin.length);
-                                (_o = item[4]).titleBgColor && (_o.titleBgColor = undefined);
+                                (_p = item[4]).titleBgColor && (_p.titleBgColor = undefined);
                                 item[4].titleJustify = 'right';
                                 args.push(item);
                                 log.splice(i--, 1);
@@ -796,8 +1371,7 @@ class Request extends module_1 {
                         return b[2] - a[2];
                     });
                     const width = count.toString().length;
-                    output.forEach(item => {
-                        const [title, origin, downloads, messages] = item;
+                    for (const [title, origin, downloads, messages] of output) {
                         const options = { ...title === 'HTTP1' ? module_1.LOG_STYLE_NOTICE : module_1.LOG_STYLE_INFO };
                         if (messages.length === 1) {
                             const message = messages[0];
@@ -808,12 +1382,12 @@ class Request extends module_1 {
                         }
                         else {
                             this.formatMessage(1024, title, [origin, 'downloads: ' + downloads.toString().padStart(width)], '', options);
-                            messages.forEach(args => {
+                            for (const args of messages) {
                                 args[4].titleIndent = true;
                                 this.formatMessage(...args);
-                            });
+                            }
                         }
-                    });
+                    }
                 }
             }
             super.flushLog();
@@ -829,7 +1403,9 @@ class Request extends module_1 {
         }
     }
     abort(reason) {
-        this[kDownloading].forEach(item => item.abort(reason));
+        for (const item of this[kDownloading]) {
+            item.abort(reason);
+        }
         this.close();
         if (!this[kSingleton]) {
             super.abort(reason);
@@ -929,11 +1505,11 @@ class Request extends module_1 {
         setDnsCache(hostname, this[kConnectDns][hostname] = [{ address, family }], timeout);
     }
     lookupDns(hostname) {
-        var _o;
+        var _p;
         const resolved = this[kConnectDns][hostname] || DNS.CACHE[hostname];
         if (resolved) {
             return (...args) => {
-                if (SUPPORT_NODEJS20) {
+                if (SUPPORTED_NODE20) {
                     args[2](null, resolved);
                 }
                 else {
@@ -941,36 +1517,20 @@ class Request extends module_1 {
                 }
             };
         }
-        const pending = (_o = this[kPendingDns])[hostname] || (_o[hostname] = []);
+        const pending = (_p = this[kPendingDns])[hostname] || (_p[hostname] = []);
         return (value, options, callback) => {
             if (pending.push(callback) === 1) {
-                const configure = (family) => family === 0 ? options : { family, hints: family === 6 ? dns.V4MAPPED : 0 };
-                const success = (connected) => {
-                    setDnsCache(value, this[kConnectDns][value] = connected);
-                    if (SUPPORT_NODEJS20) {
-                        pending.forEach(cb => cb(null, connected));
-                    }
-                    else {
-                        const { address, family } = connected[0];
-                        pending.forEach(cb => cb(null, address, family));
-                    }
-                    pending.length = 0;
-                };
-                const failed = (err) => {
-                    pending.forEach(cb => SUPPORT_NODEJS20 ? cb(err, []) : cb(err, '', 0));
-                    pending.length = 0;
-                };
                 let ipVersion = this.ipVersion;
-                dns.lookup(value, configure(ipVersion), (err, address, family) => {
+                dns.lookup(value, configureDns(ipVersion, options), (err, address, family) => {
                     if (!err) {
-                        success(typeof address === 'string' ? [{ address, family }] : address);
+                        successDns(this, value, pending, typeof address === 'string' ? [{ address, family }] : address);
                         return;
                     }
                     switch (err.code) {
                         case 'ENOTFOUND':
                         case 'EBADNAME':
                         case 'ENODATA':
-                            failed(err);
+                            failedDns(err, pending);
                             return;
                         case 'ETIMEOUT':
                         case 'ECONNREFUSED':
@@ -980,18 +1540,18 @@ class Request extends module_1 {
                             break;
                         default:
                             if (ipVersion === 0) {
-                                failed(err);
+                                failedDns(err, pending);
                                 return;
                             }
                             ipVersion = ipVersion === 4 ? 6 : 4;
                             break;
                     }
-                    dns.lookup(value, configure(ipVersion), (err, address, family) => {
+                    dns.lookup(value, configureDns(ipVersion, options), (err, address, family) => {
                         if (!err) {
-                            success(typeof address === 'string' ? [{ address, family }] : address);
+                            successDns(this, value, pending, typeof address === 'string' ? [{ address, family }] : address);
                         }
                         else {
-                            failed(err);
+                            failedDns(err, pending);
                         }
                     });
                 });
@@ -1005,12 +1565,10 @@ class Request extends module_1 {
             if (!include && !exclude && !localhost) {
                 return proxy;
             }
-            if ((0, types_1.isArray)(include)) {
-                return include.some(value => uri.startsWith(value)) ? proxy : undefined;
-            }
-            if (Array.isArray(exclude) && !exclude.some(value => uri.startsWith(value))) {
-                return proxy;
+            if ((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))) {
+                return undefined;
             }
+            return proxy;
         }
     }
     statusOn(code, globUrl = '*', callback) {
@@ -1054,12 +1612,7 @@ class Request extends module_1 {
             return Promise.reject((0, types_1.errorMessage)("aria2", "Binary not found"));
         }
         if (typeof uri === 'string' && module_1.isURL(uri)) {
-            try {
-                uri = new URL(uri);
-            }
-            catch (err) {
-                return Promise.reject(err);
-            }
+            uri = new URL(uri);
         }
         let pathname, headers, binOpts, silent;
         if (options) {
@@ -1070,7 +1623,7 @@ class Request extends module_1 {
                 ({ pathname, headers, binOpts, silent } = options);
                 if ((0, types_1.isArray)(binOpts)) {
                     let next = false;
-                    binOpts = binOpts.filter(opt => !((0, types_1.isString)(opt) && /^-[a-z][\S\s]*$/i.test(opt.trim()))).map((opt) => {
+                    binOpts = binOpts.filter(opt => !((0, types_1.isString)(opt) && /^-[a-z].*$/i.test(opt.trim()))).map((opt) => {
                         if (next) {
                             if (!module_1.asString(opt).startsWith('--')) {
                                 return [];
@@ -1108,7 +1661,7 @@ class Request extends module_1 {
                                 return [opt.toString()];
                             default:
                                 if ((0, types_1.isArray)(opt)) {
-                                    return opt.filter(item => (0, types_1.isString)(item)).map((item) => module_1.sanitizeArgs(item));
+                                    return opt.filter(item => (0, types_1.isString)(item)).map(item => module_1.sanitizeArgs(item));
                                 }
                                 break;
                         }
@@ -1135,12 +1688,8 @@ class Request extends module_1 {
             if (uri instanceof URL) {
                 ({ protocol, origin, username, password, href: uri } = uri);
             }
-            const escapeQuote = (value) => {
-                value = value.replace(/"/g, '\\"');
-                return PLATFORM_WIN32 ? value : value.replace(/[ $`]/g, capture => (capture !== ' ' ? '\\' : '') + '\\' + capture);
-            };
             const init = [
-                `--dir="${escapeQuote(pathname)}"`,
+                `--dir="${escapeShellQuote(pathname)}"`,
                 '--download-result=full',
                 '--follow-torrent=mem',
                 '--follow-metalink=mem',
@@ -1188,13 +1737,15 @@ class Request extends module_1 {
                 '--file-allocation=' + ARIA2.FILE_ALLOCATION,
                 '--max-tries=' + (retryLimit + 1)
             ];
-            const ignoreOpt = (...values) => !binOpts?.some(item => values.includes(item));
             if (ARIA2.MAX_CONCURRENT_DOWNLOADS) {
                 opts.push('--max-concurrent-downloads=' + ARIA2.MAX_CONCURRENT_DOWNLOADS);
             }
             if (ARIA2.MAX_CONNECTION_PER_SERVER) {
                 opts.push('--max-connection-per-server=' + ARIA2.MAX_CONNECTION_PER_SERVER);
             }
+            if (ARIA2.CHECK_INTEGRITY) {
+                opts.push('--check-integrity=true');
+            }
             if (ARIA2.MIN_SPLIT_SIZE) {
                 opts.push('--min-split-size=' + ARIA2.MIN_SPLIT_SIZE);
             }
@@ -1205,7 +1756,7 @@ class Request extends module_1 {
                 opts.push('--lowest-speed-limit=' + ARIA2.LOWEST_SPEED_LIMIT);
             }
             if (ARIA2.CONF_PATH) {
-                opts.push(`--conf-path="${escapeQuote(ARIA2.CONF_PATH)}"`);
+                opts.push(`--conf-path="${escapeShellQuote(ARIA2.CONF_PATH)}"`);
             }
             if (!ARIA2.ALWAYS_RESUME) {
                 opts.push('--always-resume=false', '--keep-unfinished-download-result=false');
@@ -1223,7 +1774,7 @@ class Request extends module_1 {
                 if (this.agentTimeout === 0) {
                     opts.push('--enable-http-keep-alive=false');
                 }
-                const baseHeaders = ignoreOpt('--header') && this.headersOf(uri);
+                const baseHeaders = ignoreOpt(binOpts, '--header') && this.headersOf(uri);
                 if (headers || baseHeaders) {
                     if (baseHeaders) {
                         headers = headers ? { ...baseHeaders, ...headers } : baseHeaders;
@@ -1233,47 +1784,50 @@ class Request extends module_1 {
                         if (!Array.isArray(items)) {
                             items = [items.toString()];
                         }
-                        args.push(...items.map(value => `--header="${name}: ${escapeQuote(value)}"`));
+                        args.push(...items.map(value => `--header="${name}: ${escapeShellQuote(value)}"`));
                     }
                 }
                 if (origin) {
                     const secure = this[kCerts]?.[1][origin] || this.host && TLS.FILE[origin];
                     if (secure) {
-                        if (secure.ca && ignoreOpt('--ca-certificate')) {
-                            args.push(`--ca-certificate="${escapeQuote(secure.ca)}"`);
+                        if (secure.ca && ignoreOpt(binOpts, '--ca-certificate')) {
+                            args.push(`--ca-certificate="${escapeShellQuote(secure.ca)}"`);
                         }
-                        if (secure.cert && ignoreOpt('--certificate', '--private-key')) {
-                            args.push(`--certificate="${escapeQuote(secure.cert)}"`);
+                        if (secure.cert && ignoreOpt(binOpts, '--certificate', '--private-key')) {
+                            args.push(`--certificate="${escapeShellQuote(secure.cert)}"`);
                             if (secure.key) {
-                                args.push(`--private-key="${escapeQuote(secure.key)}"`);
+                                args.push(`--private-key="${escapeShellQuote(secure.key)}"`);
                             }
                         }
                     }
                 }
                 switch (protocol = protocol.substring(0, protocol.length - 1)) {
-                    case 'ftp':
                     case 'http':
-                    case 'https': {
+                    case 'https':
+                        if (ignoreOpt(binOpts, '--http-no-cache')) {
+                            args.push('--http-no-cache=true');
+                        }
+                    case 'ftp': {
                         const prefix = protocol === 'https' ? 'http' : protocol;
-                        if (ignoreOpt(`--${prefix}-user`, `--${prefix}-passwd`)) {
+                        if (ignoreOpt(binOpts, `--${prefix}-user`, `--${prefix}-passwd`)) {
                             if (username) {
-                                args.push(`--${prefix}-user="${escapeQuote(decodeURIComponent(username))}"`);
+                                args.push(`--${prefix}-user="${escapeShellQuote(decodeURIComponent(username))}"`);
                             }
                             if (password) {
-                                args.push(`--${prefix}-passwd="${escapeQuote(decodeURIComponent(password))}"`);
+                                args.push(`--${prefix}-passwd="${escapeShellQuote(decodeURIComponent(password))}"`);
                             }
                         }
                         const proxy = this.proxyOf(uri);
-                        if (proxy && ignoreOpt(`--${protocol}-proxy-user`, `--${protocol}-proxy-passwd`)) {
+                        if (proxy && ignoreOpt(binOpts, `--${protocol}-proxy-user`, `--${protocol}-proxy-passwd`)) {
                             ({ origin, username, password } = proxy.host);
-                            if (ignoreOpt(`--${protocol}-proxy`)) {
+                            if (ignoreOpt(binOpts, `--${protocol}-proxy`)) {
                                 args.push(`--${protocol}-proxy="${origin}"`);
                             }
                             if (username) {
-                                args.push(`--${protocol}-proxy-user="${escapeQuote(decodeURIComponent(username))}"`);
+                                args.push(`--${protocol}-proxy-user="${escapeShellQuote(decodeURIComponent(username))}"`);
                             }
                             if (password) {
-                                args.push(`--${protocol}-proxy-passwd="${escapeQuote(decodeURIComponent(password))}"`);
+                                args.push(`--${protocol}-proxy-passwd="${escapeShellQuote(decodeURIComponent(password))}"`);
                             }
                         }
                         break;
@@ -1291,7 +1845,7 @@ class Request extends module_1 {
                 }
                 args = binOpts.concat(args);
             }
-            if (args.length) {
+            if (args.length > 0) {
                 if (module_1.hasLogType(32768)) {
                     this.formatMessage(32768, 'ARIA2', ARIA2.BIN, args.join(' '), { ...module_1.LOG_STYLE_WARN });
                 }
@@ -1299,7 +1853,7 @@ class Request extends module_1 {
                     this.addLog(types_1.STATUS_TYPE.INFO, path.basename(ARIA2.BIN) + ' ' + args.join(' '), "aria2");
                 }
             }
-            opts.push(`"${escapeQuote(uri)}"`);
+            opts.push(`"${escapeShellQuote(uri)}"`);
             args = args.concat(init, opts);
             const startTime = Date.now();
             let out = '', message = '', aborted;
@@ -1340,29 +1894,31 @@ class Request extends module_1 {
                                     break;
                                 }
                             case 'ERR':
-                                fs.unlink(file, err => err && !silent && !this[kSingleton] && this.writeFail(["Unable to delete file", path.basename(file)], err, { type: 32, fatal: false }));
+                                fs.unlink(file, err => {
+                                    if (err && !silent && !this[kSingleton]) {
+                                        this.writeFail(["Unable to delete file", path.basename(file)], err, { type: 32, fatal: false });
+                                    }
+                                });
                                 break;
                         }
                     }
                 }
-                if (result.length && !silent && LOG_HTTP && LOG_TIMEPROCESS) {
+                if (result.length > 0 && !silent && LOG_HTTP && LOG_TIMEPROCESS) {
                     this.writeTimeProcess("aria2", uri, startTime, { type: 1024, queue: true, messageUnit, messageUnitMinWidth: 9, bypassLog: true });
                 }
-                this.addLog(result.length ? types_1.STATUS_TYPE.INFO : types_1.STATUS_TYPE.ERROR, out, currentTime, currentTime - startTime, "aria2", uri);
+                this.addLog(result.length > 0 ? types_1.STATUS_TYPE.INFO : types_1.STATUS_TYPE.ERROR, out, currentTime, currentTime - startTime, "aria2", uri);
                 resolve(result);
             })
-                .on('error', err => errorResponse(pid, err));
+                .on('error', err => {
+                errorResponse(pid, err);
+            });
             stdout.setEncoding('utf-8').on('data', (value) => out += value);
             stderr.setEncoding('utf-8').on('data', (value) => message += value);
             if (pid !== undefined && module_1.isFile(uri, 'torrent')) {
                 if (!ARIA2.PID_TIMER) {
-                    const clearTimer = () => {
-                        clearInterval(ARIA2.PID_TIMER);
-                        ARIA2.PID_TIMER = null;
-                    };
                     ARIA2.PID_TIMER = setInterval(() => {
                         if (ARIA2.PID_QUEUE.length === 0) {
-                            clearTimer();
+                            resetAria2();
                             return;
                         }
                         for (const item of ARIA2.PID_QUEUE) {
@@ -1376,7 +1932,7 @@ class Request extends module_1 {
                         if (ARIA2.UPDATE_STATUS && !silent) {
                             const item = ARIA2.PID_QUEUE.shift();
                             if (!item) {
-                                clearTimer();
+                                resetAria2();
                                 return;
                             }
                             if ((!ARIA2.UPDATE_BROADCAST_ONLY || item[2]) && this.host?.logState !== 0) {
@@ -1388,7 +1944,7 @@ class Request extends module_1 {
                                     const current = (0, types_1.getLogCurrent)();
                                     progressBar = current?.type === 128 && current.title === "aria2";
                                 }
-                                this.formatMessage(128, "aria2", ['Downloading...', (0, types_1.formatTime)(startTime, true)], (PLATFORM_WIN32 ? 'taskkill /f /pid' : 'kill') + ` ${item[0]} -> ` + item[1], { ...module_1.LOG_STYLE_INFO, progressBar, broadcastId: item[2] });
+                                this.formatMessage(128, "aria2", ['Downloading...', (0, types_1.formatTime)(startTime, true)], (module_1.PLATFORM_WIN32 ? 'taskkill /f /pid' : 'kill') + ` ${item[0]} -> ` + item[1], { ...module_1.LOG_STYLE_INFO, progressBar, broadcastId: item[2] });
                             }
                             ARIA2.PID_QUEUE.push(item);
                         }
@@ -1407,21 +1963,30 @@ class Request extends module_1 {
         return this.get(uri, options);
     }
     opts(url, options) {
-        var _o, _p, _q, _r;
-        if (typeof url === 'string') {
+        var _p, _q, _r, _s;
+        const base = this[kBaseURL];
+        if (base) {
+            if (typeof url === 'string') {
+                url = new URL(url, base[0]);
+            }
+            if (!options?.base) {
+                copySearchParams(url, base[0]);
+            }
+        }
+        else if (typeof url === 'string') {
             url = new URL(url);
         }
         let host;
         if (this.host) {
-            host = (_o = HTTP.HOST)[_p = url.origin] || (_o[_p] = new host_1(url, HTTP.VERSION));
+            host = (_p = HTTP.HOST)[_q = url.origin] || (_p[_q] = new host_1(url, HTTP.VERSION));
         }
         else {
-            host = (_q = this[kHostInfo])[_r = url.origin] || (_q[_r] = new host_1(url, this.httpVersion || 1));
+            host = (_r = this[kHostInfo])[_s = url.origin] || (_r[_s] = new host_1(url, this.httpVersion || 1));
         }
         return { ...options, host, url };
     }
     open(uri, options) {
-        var _o, _p;
+        var _p, _q;
         let { host, url, httpVersion, method = 'GET', search, encoding, format, headers, postData, keepAlive, agentTimeout, socketPath, timeout = this._config.connectTimeout, outStream } = options;
         const getting = method === 'GET';
         const posting = method === 'POST';
@@ -1460,15 +2025,33 @@ class Request extends module_1 {
             url = uri;
             uri = url.toString();
         }
+        const base = this[kBaseURL];
         if (!host) {
-            ({ host, url } = this.opts(url || uri));
+            ({ host, url } = this.opts(url || uri, { base: options.base }));
             options.host = host;
             options.url = url;
         }
         else if (!url) {
-            url = new URL(uri);
+            if (base) {
+                url = new URL(uri, base[0]);
+                if (!options.base) {
+                    copySearchParams(url, base[0]);
+                }
+            }
+            else {
+                url = new URL(uri);
+            }
             options.url = url;
         }
+        if (options.base) {
+            this[kBaseURL] = [url, httpVersion, headers];
+        }
+        else if (base) {
+            httpVersion ?? (httpVersion = base[1]);
+            if (base[2]) {
+                headers = { ...base[2], ...headers };
+            }
+        }
         if (search) {
             for (const param in search) {
                 url.searchParams.append(param, search[param]);
@@ -1479,18 +2062,18 @@ class Request extends module_1 {
         const pathname = url.pathname + (socketPath ? '' : url.search);
         const proxy = this.proxyOf(uri, localhost);
         const version = this.httpVersion;
-        let request, ca, cert, key, minVersion, baseHeaders = this.headersOf(uri);
+        let request, ca, cert, key, ciphers, minVersion, baseHeaders = this.headersOf(uri);
         if (getting && this.acceptEncoding && !localhost && !baseHeaders?.['accept-encoding']) {
-            (_o = (headers || (headers = {})))['accept-encoding'] || (_o['accept-encoding'] = 'gzip, deflate, br' + (LIB_ZSTD ? ', zstd' : ''));
+            (_p = (headers || (headers = {})))['accept-encoding'] || (_p['accept-encoding'] = 'gzip, deflate, br' + (LIB_ZSTD ? ', zstd' : ''));
         }
         if (secure) {
             const certs = this[kCerts]?.[0][origin] || this.host && TLS.TEXT[origin];
             if (certs) {
-                ({ ca, cert, key, version: minVersion } = certs);
+                ({ ca, cert, key, ciphers, version: minVersion } = certs);
             }
         }
         if (!proxy && httpVersion !== 1 && ((httpVersion || host.version) === 2 && version !== 1 || secure && version === 2 && host.failed(2, true) === 0)) {
-            request = ((_p = this[kSession][0])[origin] || (_p[origin] = http2.connect(origin, { lookup: this.lookupDns(hostname), ca, cert, key, minVersion, settings: localhost ? { maxFrameSize: 16777215, enablePush: false } : { enablePush: false } }))).request({ ...baseHeaders, ...host_1.getBasicAuth(url), ...headers, ':path': pathname, ':method': method });
+            request = ((_q = this[kSession][0])[origin] || (_q[origin] = http2.connect(origin, { lookup: this.lookupDns(hostname), ca, cert, key, ciphers, minVersion, settings: localhost ? { maxFrameSize: 16777215, enablePush: false } : { enablePush: false } }))).request({ ...baseHeaders, ...host_1.getBasicAuth(url), ...headers, ':path': pathname, ':method': method });
             if (getting) {
                 const listenerMap = {};
                 const onEvent = request.on.bind(request);
@@ -1500,21 +2083,24 @@ class Request extends module_1 {
                     connected = true;
                     const statusCode = response[':status'];
                     if (this.matchStatus(statusCode, url, response, request, options) && statusCode >= 200 && statusCode < 300) {
-                        emitter = checkEncoding(request, request, statusCode, outStream, response['content-encoding']);
-                        if (emitter) {
+                        if (emitter = checkEncoding(request, request, statusCode, outStream, response['content-encoding'])) {
                             for (const event in listenerMap) {
-                                listenerMap[event].forEach(listener => {
-                                    const [name, type] = event.split('-');
+                                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);
-                                });
+                                }
                             }
                         }
                         else {
                             if (outStream) {
-                                stream.pipeline(request, outStream, err => err && request.emit('error', err));
+                                stream.pipeline(request, outStream, err => {
+                                    if (err) {
+                                        request.emit('error', err);
+                                    }
+                                });
                             }
                             if (encoding) {
                                 request.setEncoding((0, types_1.getEncoding)(encoding));
@@ -1528,7 +2114,7 @@ class Request extends module_1 {
                     this.matchHeaders(url, response, request, options);
                 });
                 request.on = function (event, listener) {
-                    var _o;
+                    var _p;
                     switch (event) {
                         case 'data':
                         case 'error':
@@ -1538,7 +2124,7 @@ class Request extends module_1 {
                                 break;
                             }
                             if (!connected) {
-                                (listenerMap[_o = event + '-on'] || (listenerMap[_o] = [])).push(listener);
+                                (listenerMap[_p = event + '-on'] || (listenerMap[_p] = [])).push(listener);
                             }
                         default:
                             onEvent(event, listener);
@@ -1547,7 +2133,7 @@ class Request extends module_1 {
                     return this;
                 };
                 request.once = function (event, listener) {
-                    var _o;
+                    var _p;
                     switch (event) {
                         case 'data':
                         case 'error':
@@ -1557,7 +2143,7 @@ class Request extends module_1 {
                                 break;
                             }
                             if (!connected) {
-                                (listenerMap[_o = event + '-once'] || (listenerMap[_o] = [])).push(listener);
+                                (listenerMap[_p = event + '-once'] || (listenerMap[_p] = [])).push(listener);
                             }
                         default:
                             onceEvent(event, listener);
@@ -1575,9 +2161,9 @@ class Request extends module_1 {
                     const pkg = secure ? 'https-proxy-agent' : 'http-proxy-agent';
                     try {
                         const { protocol, hostname: proxyname, port, username, password, href } = proxy.host;
-                        keepAlive ?? (keepAlive = proxy.keepAlive || false);
+                        keepAlive ?? (keepAlive = proxy.keepAlive);
                         agentTimeout ?? (agentTimeout = proxy.agentTimeout);
-                        agent = require(pkg)(keepAlive || agentTimeout > 0 ? { protocol, hostname: proxyname, port, username, password, keepAlive, timeout: agentTimeout } : href);
+                        agent = require(pkg)(keepAlive !== null || agentTimeout > 0 ? { protocol, hostname: proxyname, port, username, password, keepAlive: keepAlive ?? true, timeout: agentTimeout } : href);
                         const proxyHeaders = this[kHeaders] && getBaseHeaders(href, this[kHeaders]) || getBaseHeaders(href, HTTP.HEADERS);
                         if (proxyHeaders) {
                             baseHeaders = { ...baseHeaders, ...proxyHeaders };
@@ -1594,10 +2180,9 @@ class Request extends module_1 {
                     agent = new (secure ? https.Agent : http.Agent)({ keepAlive: true, timeout: agentTimeout });
                 }
                 else if (agentTimeout !== 0) {
-                    keepAlive = this.keepAlive || false;
                     agentTimeout ?? (agentTimeout = this.agentTimeout);
-                    if (keepAlive || agentTimeout > 0) {
-                        agent = new (secure ? https.Agent : http.Agent)({ keepAlive, timeout: agentTimeout });
+                    if (this.keepAlive !== null || agentTimeout > 0) {
+                        agent = new (secure ? https.Agent : http.Agent)({ keepAlive: this.keepAlive ?? true, timeout: agentTimeout });
                     }
                 }
             }
@@ -1614,6 +2199,7 @@ class Request extends module_1 {
                 ca,
                 cert,
                 key,
+                ciphers,
                 minVersion,
                 headers,
                 lookup: this.lookupDns(hostname),
@@ -1646,12 +2232,22 @@ class Request extends module_1 {
                         source = response;
                     }
                     response
-                        .on('close', () => request.emit('close'))
-                        .on('error', err => request.emit('error', err))
-                        .once('readable', () => request.emit('readable'));
-                    source.on('data', chunk => request.emit('data', chunk));
+                        .on('close', () => {
+                        request.emit('close');
+                    })
+                        .on('error', err => {
+                        request.emit('error', err);
+                    })
+                        .once('readable', () => {
+                        request.emit('readable');
+                    });
+                    source.on('data', chunk => {
+                        request.emit('data', chunk);
+                    });
                     if (response !== source) {
-                        source.on('error', err => request.emit('error', err));
+                        source.on('error', err => {
+                            request.emit('error', err);
+                        });
                     }
                     if (!posting) {
                         if (version === 2 && incoming.upgrade?.includes('h2')) {
@@ -1667,9 +2263,15 @@ class Request extends module_1 {
                 }
                 else {
                     response
-                        .on('close', () => request.emit('close'))
-                        .on('error', err => request.emit('error', err))
-                        .once('end', () => request.emit('end'));
+                        .on('close', () => {
+                        request.emit('close');
+                    })
+                        .on('error', err => {
+                        request.emit('error', err);
+                    })
+                        .once('end', () => {
+                        request.emit('end');
+                    });
                 }
                 if (this._config.timeout) {
                     response.setTimeout(this._config.timeout, () => request.emit('timeout'));
@@ -1685,7 +2287,9 @@ class Request extends module_1 {
             const ac = new AbortController();
             this[kDownloading].add(options.outAbort = ac);
             stream.addAbortSignal(ac.signal, request);
-            this.signal.addEventListener('abort', () => ac.abort(new Error("Aborted by process")), { once: true });
+            this.signal.addEventListener('abort', () => {
+                ac.abort(new Error("Aborted by process"));
+            }, { once: true });
         }
         if (posting) {
             if ((0, types_1.isString)(postData) || Buffer.isBuffer(postData)) {
@@ -1745,7 +2349,7 @@ class Request extends module_1 {
             let valid;
             if ((0, types_1.isArray)(parts)) {
                 const write = combined.create();
-                const boundary = (0, types_1.generateUUID)().replace(/-/g, '');
+                const boundary = crypto.randomUUID().replaceAll('-', '');
                 contentType = "multipart/form-data" + `; boundary="${boundary}"`;
                 let contentLength = 0;
                 const createPart = (name, filename, type) => {
@@ -1762,7 +2366,6 @@ class Request extends module_1 {
                         contentLength += Buffer.byteLength(disposition);
                     }
                 };
-                const escapeQuote = (value) => value.replace(/[\\"]/g, capture => '\\' + capture);
                 if ((0, types_1.isPlainObject)(data)) {
                     for (const name in data) {
                         addValue(name, data[name]);
@@ -1773,46 +2376,41 @@ class Request extends module_1 {
                         continue;
                     }
                     if (target) {
-                        try {
-                            if (typeof target === 'string') {
-                                filename || (filename = path.basename(target));
-                                type || (type = module_1.lookupMime(filename));
-                                target = fs.readFileSync(target);
+                        if (typeof target === 'string') {
+                            filename || (filename = path.basename(target));
+                            type || (type = module_1.lookupMime(filename));
+                            target = fs.readFileSync(target);
+                        }
+                        else if (target instanceof stream.Readable) {
+                            const chunks = [];
+                            for await (const chunk of target) {
+                                chunks.push(chunk);
                             }
-                            else if (target instanceof stream.Readable) {
-                                const chunks = [];
-                                for await (const chunk of target) {
-                                    chunks.push(chunk);
-                                }
-                                target = Buffer.concat(chunks);
+                            target = Buffer.concat(chunks);
+                        }
+                        if (!Buffer.isBuffer(target)) {
+                            throw (0, types_1.errorMessage)('File', "Unknown", "multipart/form-data");
+                        }
+                        if (!type || !filename) {
+                            const result = await module_1.resolveMime(target);
+                            let ext;
+                            if (result) {
+                                type || (type = result.mime);
+                                ext = result.ext;
                             }
-                            if (!Buffer.isBuffer(target)) {
-                                throw (0, types_1.errorMessage)('File', "Unknown", "multipart/form-data");
+                            else if (type) {
+                                ext = module_1.lookupMime(type, true);
                             }
-                            if (!type || !filename) {
-                                const result = await module_1.resolveMime(target);
-                                let ext;
-                                if (result) {
-                                    type || (type = result.mime);
-                                    ext = result.ext;
-                                }
-                                else if (type) {
-                                    ext = module_1.lookupMime(type, true);
-                                }
-                                if (ext && !filename) {
-                                    filename = (0, types_1.generateUUID)() + '.' + ext;
-                                }
+                            if (ext && !filename) {
+                                filename = crypto.randomUUID() + '.' + ext;
                             }
-                            const disposition = createPart(name, filename, type || "application/octet-stream");
-                            write.append(disposition);
-                            write.append(target);
-                            write.append("\r\n");
-                            contentLength += Buffer.byteLength(disposition) + target.length + 2;
-                            valid = true;
-                        }
-                        catch (err) {
-                            return Promise.reject(err);
                         }
+                        const disposition = createPart(name, filename, type || "application/octet-stream");
+                        write.append(disposition);
+                        write.append(target);
+                        write.append("\r\n");
+                        contentLength += Buffer.byteLength(disposition) + target.length + 2;
+                        valid = true;
                     }
                     else {
                         addValue(name, value);
@@ -1855,437 +2453,7 @@ class Request extends module_1 {
         if (this.readExpect === 'string') {
             opts.encoding = (0, types_1.getEncoding)(opts.encoding);
         }
-        return new Promise((resolve, reject) => {
-            const pipeTo = opts.pipeTo;
-            const status = opts.silent === false || !opts.silent && !this[kSingleton];
-            let log = status && LOG_HTTP && LOG_TIMEPROCESS, retries = 0, redirects = 0, closed, timeout, outStream;
-            const startTime = log ? process.hrtime() : 0;
-            const throwError = (err, outAbort) => {
-                if (timeout) {
-                    clearTimeout(timeout);
-                }
-                if (!closed) {
-                    closed = true;
-                    if (outStream && (0, types_1.isString)(pipeTo)) {
-                        (0, util_1.cleanupStream)(outStream, pipeTo);
-                    }
-                    reject(typeof err === 'string' ? new Error(err) : err);
-                }
-                if (outAbort) {
-                    this[kDownloading].delete(outAbort);
-                }
-            };
-            const formatStatus = (value, hint) => value + ': ' + (hint || Request.fromStatusCode(value)) + ` (${uri.toString()})`;
-            (function downloadUri(href, httpVersion) {
-                let outAbort;
-                try {
-                    const request = this.opts(href, opts);
-                    if (outStream && (0, types_1.isString)(pipeTo)) {
-                        (0, util_1.cleanupStream)(outStream, pipeTo);
-                    }
-                    if (pipeTo) {
-                        if (typeof pipeTo === 'string') {
-                            outStream = fs.createWriteStream(pipeTo, { emitClose: false, highWaterMark: request.host.localhost ? 65536 : 4096 });
-                            request.outStream = outStream;
-                        }
-                        else {
-                            request.outStream = pipeTo;
-                        }
-                    }
-                    if (httpVersion) {
-                        request.httpVersion = httpVersion;
-                    }
-                    const client = this.open(href, request);
-                    const { host, url, encoding, progressId, outFormat } = request;
-                    let buffer, aborted;
-                    ({ httpVersion, outAbort } = request);
-                    const isAborted = () => client.destroyed || httpVersion === 2 && client.aborted;
-                    const isRetry = (value) => (0, util_1.isRetryable)(value) && ++retries <= this._config.retryLimit;
-                    const isUnsupported = (value) => value === 421 || value === 505;
-                    const isDowngrade = (err) => err instanceof Error && (err.code === 'ERR_HTTP2_ERROR' || isUnsupported(Math.abs(err.errno)));
-                    const wasAborted = (err) => err instanceof Error && err.message.startsWith("Aborted");
-                    const sendWarning = (message) => status && LOG_HTTP && this.formatMessage(1024, 'HTTP' + httpVersion, [message, host.origin], url.toString(), { ...module_1.LOG_STYLE_WARN });
-                    const formatRetry = (message) => message + ` (${retries} / ${this._config.retryLimit})`;
-                    const formatNgFlags = (value, statusCode, location) => location ? `Using HTTP 1.1 for URL redirect (${location})` : formatStatus(statusCode, value ? 'NGHTTP2 Error ' + value : '');
-                    const abortResponse = () => {
-                        if (closed) {
-                            return;
-                        }
-                        if (timeout) {
-                            clearTimeout(timeout);
-                        }
-                        buffer = null;
-                        aborted = true;
-                        if (outAbort) {
-                            if (!client.aborted) {
-                                outAbort.abort();
-                            }
-                            this[kDownloading].delete(outAbort);
-                        }
-                        client.destroy();
-                    };
-                    const retryTimeout = () => {
-                        sendWarning(formatRetry('Connection timeout'));
-                        downloadUri.call(this, href);
-                    };
-                    const acceptResponse = (headers) => {
-                        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 = request.connected?.call(client, headers) !== false && !pipeline;
-                        const maxBufferSize = request.maxBufferSize ? (0, types_1.alignSize)(request.maxBufferSize) : 0;
-                        const { host: parent, readTimeout } = this;
-                        const contentLength = parent && progressId !== undefined ? parseInt(headers['content-length'] || '0') : 0;
-                        let dataLength = 0, mibsTime, delayTime;
-                        if (log || readTimeout > 0 || contentLength > 0) {
-                            client.once('readable', () => {
-                                if (readTimeout > 0) {
-                                    timeout = setTimeout(() => {
-                                        abortResponse();
-                                        throwError((0, types_1.errorValue)("Timeout was exceeded", href.toString()));
-                                    }, readTimeout);
-                                }
-                                if (log) {
-                                    switch (this.settings.time_format || LOG_TIMEFORMAT) {
-                                        case 'readable':
-                                            delayTime = process.hrtime(startTime);
-                                            break;
-                                        case 'relative':
-                                            delayTime = Date.now() - this.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) {
-                            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) {
-                                        abortResponse();
-                                        throwError((0, types_1.errorValue)("Size limit was exceeded", href.toString()));
-                                    }
-                                }
-                            });
-                        }
-                        client.once('end', () => {
-                            if (closed || aborted) {
-                                return;
-                            }
-                            if (timeout) {
-                                clearTimeout(timeout);
-                            }
-                            if (outAbort) {
-                                this[kDownloading].delete(outAbort);
-                            }
-                            closed = true;
-                            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 (outFormat) {
-                                        const { out: format, parser } = 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 (status && !(packageName && this.checkPackage(err, packageName))) {
-                                                this.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 && this.readExpect === 'always') {
-                                    throwError('No data received');
-                                    return;
-                                }
-                                result = encoding && !pipeline ? '' : null;
-                                titleBgColor = 'bgBlue';
-                            }
-                            if (log) {
-                                this.writeTimeProcess('HTTP' + httpVersion, request.statusMessage || url.toString(), startTime, { type: 1024, queue: !!this.host, titleBgColor, messageUnit, messageUnitMinWidth: 9, delayTime, bypassLog: LOG_STDOUT });
-                            }
-                            resolve(result);
-                        });
-                        host.success(httpVersion);
-                    };
-                    const redirectResponse = (statusCode, location) => {
-                        abortResponse();
-                        if (location) {
-                            if (request.follow_redirect === false) {
-                                throwError(formatStatus(statusCode, 'Follow redirect was disabled'));
-                            }
-                            else if (++redirects <= this._config.redirectLimit) {
-                                downloadUri.call(this, Request.fromURL(url, location));
-                            }
-                            else {
-                                throwError(formatStatus(statusCode, 'Exceeded redirect limit'));
-                            }
-                        }
-                        else {
-                            throwError(formatStatus(statusCode, 'Missing redirect location'));
-                        }
-                    };
-                    const errorResponse = (err) => {
-                        abortResponse();
-                        if (wasAborted(err)) {
-                            throwError(err);
-                        }
-                        else if ((0, util_1.checkRetryable)(err) && ++retries <= this._config.retryLimit) {
-                            if (isConnectionTimeout(err)) {
-                                retryTimeout();
-                            }
-                            else {
-                                setTimeout(() => downloadUri.call(this, href), this._config.retryWait);
-                            }
-                        }
-                        else {
-                            host.error(httpVersion);
-                            throwError(err);
-                        }
-                    };
-                    const retryResponse = (statusCode, retryAfter) => {
-                        abortResponse();
-                        if (retryAfter && this._config.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._config.retryAfter) {
-                                    sendWarning(`Retry After (${retryAfter})`);
-                                    setTimeout(() => downloadUri.call(this, href), offset);
-                                }
-                                else {
-                                    throwError(formatStatus(statusCode));
-                                }
-                                return;
-                            }
-                        }
-                        sendWarning(formatRetry(Request.fromStatusCode(statusCode)));
-                        if ((0, util_1.isRetryable)(statusCode, true)) {
-                            process.nextTick(downloadUri.bind(this), href);
-                        }
-                        else {
-                            setTimeout(() => downloadUri.call(this, href), this._config.retryWait);
-                        }
-                    };
-                    if (httpVersion === 2) {
-                        const retryDownload = (downgrade, message) => {
-                            if (aborted) {
-                                return;
-                            }
-                            abortResponse();
-                            if (downgrade) {
-                                host.failed(2);
-                                if (host.version > 1) {
-                                    if (status && LOG_HTTP) {
-                                        this.formatMessage(1024, 'HTTP2', ['Unsupported protocol', host.origin], message, { failed: true });
-                                    }
-                                    host.version = 1;
-                                }
-                            }
-                            downloadUri.call(this, href, 1);
-                        };
-                        client
-                            .on('response', (headers, flags) => {
-                            if (isAborted()) {
-                                return;
-                            }
-                            const statusCode = headers[':status'];
-                            if (statusCode < 300) {
-                                acceptResponse(headers);
-                            }
-                            else if (statusCode < 400) {
-                                redirectResponse(statusCode, headers.location);
-                            }
-                            else if (statusCode === 401 ||
-                                statusCode === 402 ||
-                                statusCode === 403 ||
-                                statusCode === 404 ||
-                                statusCode === 407 ||
-                                statusCode === 410) {
-                                throwError(formatStatus(statusCode), outAbort);
-                            }
-                            else if (isRetry(statusCode)) {
-                                retryResponse(statusCode, headers['retry-after']);
-                            }
-                            else if (isUnsupported(statusCode)) {
-                                retryDownload(true, 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:
-                                        retryDownload(true, formatNgFlags(flags, statusCode, headers.location));
-                                        break;
-                                    default:
-                                        retryDownload(false, formatStatus(statusCode));
-                                        break;
-                                }
-                            }
-                        })
-                            .on('unknownProtocol', () => {
-                            if (!aborted) {
-                                retryDownload(true, 'Unknown protocol (HTTP/2)');
-                            }
-                        })
-                            .on('aborted', () => {
-                            aborted = true;
-                            throwError((0, types_1.createAbortError)(), outAbort);
-                        })
-                            .on('error', async (err) => {
-                            if (aborted) {
-                                return;
-                            }
-                            if (wasAborted(err)) {
-                                errorResponse(err);
-                            }
-                            else {
-                                switch (!isDowngrade(err) && await host.hasProtocol(2)) {
-                                    case 1:
-                                        errorResponse(err);
-                                        break;
-                                    case 2:
-                                        retryDownload(false, err);
-                                        break;
-                                    default:
-                                        retryDownload(true, err);
-                                        break;
-                                }
-                            }
-                        });
-                    }
-                    else {
-                        client
-                            .on('response', res => {
-                            if (isAborted()) {
-                                return;
-                            }
-                            const statusCode = res.statusCode;
-                            if (statusCode < 300) {
-                                acceptResponse(res.headers);
-                            }
-                            else if (statusCode < 400) {
-                                redirectResponse(statusCode, res.headers.location);
-                            }
-                            else if (isRetry(statusCode)) {
-                                retryResponse(statusCode, res.headers['retry-after']);
-                            }
-                            else {
-                                abortResponse();
-                                throwError(formatStatus(statusCode));
-                            }
-                        })
-                            .on('abort', () => {
-                            aborted = true;
-                            throwError((0, types_1.createAbortError)(), outAbort);
-                        })
-                            .on('error', err => {
-                            if (!aborted) {
-                                errorResponse(err);
-                            }
-                        });
-                    }
-                    client.on('timeout', () => {
-                        if (aborted) {
-                            return;
-                        }
-                        abortResponse();
-                        if (++retries <= this._config.retryLimit) {
-                            retryTimeout();
-                        }
-                        else {
-                            throwError(formatStatus(408));
-                        }
-                    });
-                }
-                catch (err) {
-                    throwError(err, outAbort);
-                }
-            }).bind(this)(uri);
-        });
+        return new Fetch(this, uri, opts).start();
     }
     reset() {
         this[kPendingDns] = Object.create(null);
@@ -2394,10 +2562,9 @@ class Request extends module_1 {
         return this[kIpVersion];
     }
     get settings() {
-        var _o;
-        return (_o = this.module).settings || (_o.settings = {});
+        var _p;
+        return (_p = this.module).settings || (_p.settings = {});
     }
 }
-_a = kSingleton, _b = kHttpVersion, _c = kHeaders, _d = kCerts, _e = kConnectDns, _f = kPendingDns, _g = kConnectHttp, _h = kStatusOn, _j = kHeadersOn, _k = kDownloading, _l = kHostInfo, _m = kSession;
-
+_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;
 module.exports = Request;