@e-mc/request 0.0.1

package/index.js

@@ -0,0 +1,2191 @@
+"use strict";
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const child_process = require("child_process");
+const http = require("http");
+const https = require("https");
+const http2 = require("http2");
+const dns = require("dns");
+const net = require("net");
+const stream = require("stream");
+const zlib = require("zlib");
+const qs = require("querystring");
+const combined = require("combined-stream");
+const yaml = require("js-yaml");
+const which = require("which");
+const lib_v4_1 = require("../module/lib-v4");
+const types_1 = require("../types");
+const module_1 = require("../module");
+const host_1 = require("./http/host");
+const util_1 = require("./util");
+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 kDownloading = Symbol('downloading');
+const kSingleton = Symbol('singleton');
+const kHostInfo = Symbol('hostInfo');
+const kConnectDns = Symbol('connectDns');
+const kPendingDns = Symbol('pendingDns');
+const kConnectHttp = Symbol('connectHttp');
+const PLATFORM_WIN32 = process.platform === 'win32';
+const SUPPORT_ABORTSIGNAL = module_1.default.supported(15, 4);
+const HTTP = {
+    HOST: {},
+    HEADERS: {},
+    VERSION: 1,
+    PROXY: null
+};
+const TLS = {
+    TEXT: {},
+    FILE: {}
+};
+const DNS = {
+    CACHE: Object.create(null),
+    TIMEOUT: [],
+    EXPIRES: 0,
+    FAMILY: 0
+};
+const ARIA2 = {
+    BIN: which.sync(PLATFORM_WIN32 ? 'aria2c.exe' : 'aria2c', { nothrow: true }) || '',
+    PID_TIMER: null,
+    PID_QUEUE: [],
+    UPDATE_STATUS: 0,
+    UPDATE_BROADCAST_ONLY: false,
+    BT_STOP_TIMEOUT: 60,
+    BT_TRACKER_CONNECT_TIMEOUT: 30,
+    BT_TRACKER_TIMEOUT: 60,
+    MAX_CONCURRENT_DOWNLOADS: 0,
+    MAX_CONNECTION_PER_SERVER: 0,
+    MIN_SPLIT_SIZE: '',
+    DISK_CACHE: null,
+    LOWEST_SPEED_LIMIT: null,
+    ALWAYS_RESUME: false,
+    FILE_ALLOCATION: 'none',
+    CONF_PATH: ''
+};
+let KEEP_ALIVE = null;
+let ACCEPT_ENCODING = false;
+let READ_TIMEOUT = 0;
+let AGENT_TIMEOUT = 0;
+let LOG_HTTP = false;
+let LOG_TIMEPROCESS = true;
+let LOG_TIMEFORMAT = 'readable';
+function getBaseHeaders(uri, headers) {
+    uri = (0, util_1.trimPath)(uri);
+    let result;
+    for (const pathname in headers) {
+        if (pathname === uri || uri.startsWith(pathname + '/')) {
+            (result || (result = [])).push([pathname, headers[pathname]]);
+        }
+    }
+    if (result) {
+        if (result.length > 1) {
+            result.sort((a, b) => b[0].length - a[0].length);
+        }
+        return result[0][1];
+    }
+}
+function setDnsCache(hostname, value) {
+    if (DNS.EXPIRES > 0 && !DNS.CACHE[hostname]) {
+        DNS.CACHE[hostname] = value;
+        if (DNS.EXPIRES !== Infinity) {
+            const timeout = setTimeout(() => {
+                const index = DNS.TIMEOUT.findIndex(item => item === timeout);
+                if (index !== -1) {
+                    DNS.TIMEOUT.splice(index, 1);
+                }
+                DNS.CACHE[hostname] = undefined;
+            }, DNS.EXPIRES);
+            DNS.TIMEOUT.push(timeout);
+        }
+    }
+}
+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]);
+    }
+}
+function getProxySettings(request, agentTimeout) {
+    const proxy = request.proxy;
+    if ((0, types_1.isObject)(proxy) && proxy.address && proxy.port) {
+        const port = (0, util_1.asInt)(proxy.port);
+        const address = (!module_1.default.isURL(proxy.address) ? port === 80 ? 'http://' : 'https://' : '') + proxy.address;
+        try {
+            let host = new URL(address + ':' + port), include, exclude;
+            if ((0, types_1.isString)(proxy.username)) {
+                host = new URL(host.protocol + '//' + (0, util_1.getBasicAuth)(proxy.username, proxy.password) + host.host);
+            }
+            if ((0, types_1.isArray)(proxy.include)) {
+                include = proxy.include;
+            }
+            else if ((0, types_1.isArray)(proxy.exclude)) {
+                exclude = proxy.exclude;
+            }
+            return { host, include, exclude, keepAlive: proxy.keep_alive, agentTimeout };
+        }
+        catch {
+        }
+    }
+    return null;
+}
+function closeTorrent(pid) {
+    if (pid !== undefined) {
+        const index = ARIA2.PID_QUEUE.findIndex(value => pid === value[0]);
+        if (index !== -1) {
+            ARIA2.PID_QUEUE.splice(index, 1);
+        }
+    }
+}
+function clearDnsLookup() {
+    DNS.CACHE = Object.create(null);
+    DNS.TIMEOUT.forEach(value => clearTimeout(value));
+    DNS.TIMEOUT.length = 0;
+}
+function resetHttpHost(version) {
+    switch (version) {
+        case 1:
+            for (const origin in HTTP.HOST) {
+                HTTP.HOST[origin].version = 1;
+            }
+            break;
+        case 2:
+            for (const origin in HTTP.HOST) {
+                const host = HTTP.HOST[origin];
+                if (host.secure && host.version === 1) {
+                    const failed = host.failed(2, true);
+                    if (failed === 0 && host.failed(2, true) < 10 /* HOST.MAX_ERROR */ || failed < 3 /* HOST.MAX_FAILED */ && host.success(2, true) > 0) {
+                        host.version = version;
+                    }
+                }
+            }
+            break;
+        default:
+            for (const origin in HTTP.HOST) {
+                HTTP.HOST[origin].reset();
+            }
+            break;
+    }
+}
+function validateCerts(certs) {
+    const text = {};
+    const file = {};
+    const checkFile = (values) => {
+        for (let pathname of values) {
+            if (module_1.default.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;
+        try {
+            origin = new URL(origin).origin;
+        }
+        catch {
+            continue;
+        }
+        if (ca) {
+            if (!Array.isArray(ca)) {
+                ca = [ca];
+            }
+            file_ca = checkFile(ca);
+            ca = ca.map(value => Request.readCACert(value)).filter(value => value);
+            if (ca.length === 1) {
+                ca = ca[0];
+            }
+            else if (ca.length === 0) {
+                ca = undefined;
+            }
+        }
+        if (cert) {
+            if (!Array.isArray(cert)) {
+                cert = [cert];
+            }
+            file_cert = checkFile(cert);
+            cert = cert.map(value => Request.readTLSCert(value)).filter(value => value);
+            if (cert.length === 1) {
+                cert = cert[0];
+            }
+            else if (cert.length === 0) {
+                cert = undefined;
+                key = undefined;
+            }
+            if (key) {
+                if (!Array.isArray(key)) {
+                    key = [key];
+                }
+                file_key = checkFile(key);
+                key = key.map(value => Request.readTLSKey(value)).filter(value => value);
+                if (key.length) {
+                    if (!Array.isArray(passphrase)) {
+                        passphrase = passphrase ? [passphrase] : [];
+                    }
+                    keyObject = key.length > 1 || passphrase.length ? key.map((pem, index) => ({ pem, passphrase: passphrase[index] })) : key[0];
+                }
+            }
+        }
+        if (ca || cert) {
+            text[origin] = { ca, cert, key: keyObject, version: minVersion };
+        }
+        if (file_ca || file_cert) {
+            file[origin] = { ca: file_ca, cert: file_cert, key: file_key };
+        }
+    }
+    return [text, file];
+}
+class Request extends module_1.default {
+    static purgeMemory(percent = 1, limit = 0, parent) {
+        if (percent >= 1) {
+            resetHttpHost();
+            clearDnsLookup();
+        }
+        else if (percent === 0) {
+            clearDnsLookup();
+        }
+        else {
+            resetHttpHost(2);
+        }
+        return parent ? super.purgeMemory(percent, limit) : Promise.resolve(0);
+    }
+    static loadSettings(settings, password) {
+        if (!this.enabled("process.password" /* KEY_NAME.PROCESS_PASSWORD */) || super.loadSettings({ process: settings.process }, password)) {
+            const { request, download } = settings;
+            if (download && (0, types_1.isPlainObject)(download.aria2)) {
+                let { bin, update_status, max_concurrent_downloads, max_connection_per_server, bt_stop_timeout, bt_tracker_connect_timeout, bt_tracker_timeout, min_split_size, disk_cache, lowest_speed_limit, always_resume, file_allocation, conf_path } = download.aria2;
+                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 (bin === false) {
+                    ARIA2.BIN = '';
+                }
+                else if (bin && this.isPath(bin = path.resolve(bin), true)) {
+                    ARIA2.BIN = bin;
+                }
+                if ((0, types_1.isPlainObject)(update_status)) {
+                    const { interval, broadcast_only } = update_status;
+                    if (typeof broadcast_only === 'boolean') {
+                        ARIA2.UPDATE_BROADCAST_ONLY = broadcast_only;
+                    }
+                    update_status = interval;
+                }
+                if ((update_status = (0, util_1.asInt)(update_status)) >= 0) {
+                    ARIA2.UPDATE_STATUS = update_status;
+                }
+                if ((max_concurrent_downloads = (0, util_1.asInt)(max_concurrent_downloads)) > 0) {
+                    ARIA2.MAX_CONCURRENT_DOWNLOADS = max_concurrent_downloads;
+                }
+                if ((max_connection_per_server = (0, util_1.asInt)(max_connection_per_server)) > 0) {
+                    ARIA2.MAX_CONNECTION_PER_SERVER = max_connection_per_server;
+                }
+                if ((bt_stop_timeout = (0, util_1.asInt)(bt_stop_timeout)) >= 0) {
+                    ARIA2.BT_STOP_TIMEOUT = bt_stop_timeout;
+                }
+                if ((bt_tracker_connect_timeout = (0, util_1.asInt)(bt_tracker_connect_timeout)) > 0) {
+                    ARIA2.BT_TRACKER_CONNECT_TIMEOUT = bt_tracker_connect_timeout;
+                }
+                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)) {
+                    ARIA2.MIN_SPLIT_SIZE = min_split_size;
+                }
+                if ((disk_cache = parseSize(disk_cache, true)) !== undefined) {
+                    ARIA2.DISK_CACHE = disk_cache;
+                }
+                if ((lowest_speed_limit = parseSize(lowest_speed_limit, true)) !== undefined) {
+                    ARIA2.LOWEST_SPEED_LIMIT = lowest_speed_limit;
+                }
+                if (always_resume) {
+                    ARIA2.ALWAYS_RESUME = always_resume;
+                }
+                if ((0, types_1.isString)(file_allocation)) {
+                    const value = file_allocation.toLowerCase();
+                    switch (value) {
+                        case 'none':
+                        case 'prealloc':
+                        case 'trunc':
+                        case 'falloc':
+                            ARIA2.FILE_ALLOCATION = value;
+                            break;
+                    }
+                }
+                if (conf_path && this.isPath(conf_path = path.resolve(conf_path))) {
+                    ARIA2.CONF_PATH = conf_path;
+                }
+            }
+            if ((0, types_1.isPlainObject)(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;
+                }
+                if ((0, types_1.isObject)(agent)) {
+                    let keep_alive;
+                    ({ keep_alive, timeout: agent_timeout } = agent);
+                    if ((agent_timeout = (0, util_1.fromSeconds)(agent_timeout)) > 0) {
+                        AGENT_TIMEOUT = agent_timeout;
+                    }
+                    else {
+                        agent_timeout = undefined;
+                    }
+                    if (typeof keep_alive === 'boolean') {
+                        KEEP_ALIVE = keep_alive;
+                    }
+                    else {
+                        keep_alive = undefined;
+                    }
+                    this.defineHttpAgent({ keepAlive: keep_alive, timeout: agent_timeout });
+                }
+                if ((0, types_1.isObject)(use)) {
+                    let { http_version, accept_encoding } = use;
+                    if (typeof accept_encoding === 'boolean') {
+                        ACCEPT_ENCODING = accept_encoding;
+                    }
+                    switch (http_version = (0, util_1.asInt)(http_version)) {
+                        case 1:
+                        case 2:
+                            HTTP.VERSION = http_version;
+                            break;
+                    }
+                }
+                if ((0, types_1.isObject)(headers)) {
+                    setOutgoingHeaders(HTTP.HEADERS, headers);
+                }
+                if ((0, types_1.isObject)(certs)) {
+                    [TLS.TEXT, TLS.FILE] = validateCerts(certs);
+                }
+                HTTP.PROXY = getProxySettings(request, agent_timeout);
+                const time_format = request.settings?.time_format;
+                switch (time_format) {
+                    case 'readable':
+                    case 'relative':
+                    case 'none':
+                        LOG_TIMEFORMAT = time_format;
+                        break;
+                }
+                LOG_HTTP = this.hasLogType(1024 /* LOG_TYPE.HTTP */);
+                LOG_TIMEPROCESS = this.hasLogType(256 /* LOG_TYPE.TIME_PROCESS */);
+            }
+            return true;
+        }
+        return false;
+    }
+    static readCACert(value, cache) {
+        return (0, types_1.isString)(value) ? (this.isCert(value) ? value : this.readText(value, cache)).trim() : '';
+    }
+    static readTLSCert(value, cache) {
+        return this.readCACert(value, cache);
+    }
+    static readTLSKey(value, cache) {
+        return this.readCACert(value, cache);
+    }
+    static isCert(value) {
+        return (0, types_1.isString)(value) && (value = value.trim()) ? value.indexOf('\n') !== -1 && value.startsWith('---') && value.endsWith('---') : false;
+    }
+    static fromURL(url, value) {
+        if (this.isURL(value)) {
+            return value;
+        }
+        const auth = host_1.default.formatBasicAuth(url);
+        return url.protocol + '//' + (auth && (auth + '@')) + url.hostname + (url.port ? ':' + url.port : '') + (value[0] !== '/' ? '/' : '') + value;
+    }
+    static fromStatusCode(value) {
+        switch (+value) {
+            case 100 /* HTTP_STATUS.CONTINUE */:
+                return 'Continue';
+            case 101 /* HTTP_STATUS.SWITCHING_PROTOCOL */:
+                return 'Switching Protocol';
+            case 102 /* HTTP_STATUS.PROCESSING */:
+                return 'Processing';
+            case 103 /* HTTP_STATUS.EARLY_HINTS */:
+                return 'Early Hints';
+            case 200 /* HTTP_STATUS.OK */:
+                return 'OK';
+            case 201 /* HTTP_STATUS.CREATED */:
+                return 'Created';
+            case 202 /* HTTP_STATUS.ACCEPTED */:
+                return 'Accepted';
+            case 203 /* HTTP_STATUS.NON_AUTHORITATIVE_INFORMATION */:
+                return 'Non-Authoritative Information';
+            case 204 /* HTTP_STATUS.NO_CONTENT */:
+                return 'No Content';
+            case 205 /* HTTP_STATUS.RESET_CONTENT */:
+                return 'Reset Content';
+            case 206 /* HTTP_STATUS.PARTIAL_CONTENT */:
+                return 'Partial Content';
+            case 300 /* HTTP_STATUS.MULTIPLE_CHOICES */:
+                return 'Multiple Choice';
+            case 301 /* HTTP_STATUS.MOVED_PERMANENTLY */:
+                return 'Moved Permanently';
+            case 302 /* HTTP_STATUS.FOUND */:
+                return 'Found';
+            case 303 /* HTTP_STATUS.SEE_OTHER */:
+                return 'See Other';
+            case 304 /* HTTP_STATUS.NOT_MODIFIED */:
+                return 'Not Modified';
+            case 305 /* HTTP_STATUS.USE_PROXY */:
+                return 'Use Proxy';
+            case 307 /* HTTP_STATUS.TEMPORARY_REDIRECT */:
+                return 'Temporary Redirect';
+            case 308 /* HTTP_STATUS.PERMANENT_REDIRECT */:
+                return 'Permanent Redirect';
+            case 400 /* HTTP_STATUS.BAD_REQUEST */:
+                return 'Bad Request';
+            case 401 /* HTTP_STATUS.UNAUTHORIZED */:
+                return 'Upgrade Required';
+            case 402 /* HTTP_STATUS.PAYMENT_REQUIRED */:
+                return 'Payment Required';
+            case 403 /* HTTP_STATUS.FORBIDDEN */:
+                return 'Forbidden';
+            case 404 /* HTTP_STATUS.NOT_FOUND */:
+                return 'Not Found';
+            case 405 /* HTTP_STATUS.METHOD_NOT_ALLOWED */:
+                return 'Method Not Allowed';
+            case 406 /* HTTP_STATUS.NOT_ACCEPTABLE */:
+                return 'Not Acceptable';
+            case 407 /* HTTP_STATUS.PROXY_AUTHENTICATION_REQUIRED */:
+                return 'Proxy Authentication Required';
+            case 408 /* HTTP_STATUS.REQUEST_TIMEOUT */:
+                return 'Request Timeout';
+            case 409 /* HTTP_STATUS.CONFLICT */:
+                return 'Conflict';
+            case 410 /* HTTP_STATUS.GONE */:
+                return 'Gone';
+            case 411 /* HTTP_STATUS.LENGTH_REQUIRED */:
+                return 'Length Required';
+            case 412 /* HTTP_STATUS.PRECONDITION_FAILED */:
+                return 'Precondition Failed';
+            case 413 /* HTTP_STATUS.PAYLOAD_TOO_LARGE */:
+                return 'Payload Too Large';
+            case 414 /* HTTP_STATUS.REQUEST_URI_TOO_LONG */:
+                return 'URI Too Long';
+            case 415 /* HTTP_STATUS.UNSUPPORTED_MEDIA_TYPE */:
+                return 'Unsupported Media Type';
+            case 416 /* HTTP_STATUS.RANGE_NOT_SATISFIABLE */:
+                return 'Range Not Satisfiable';
+            case 417 /* HTTP_STATUS.EXPECTATION_FAILED */:
+                return 'Expectation Failed';
+            case 421 /* HTTP_STATUS.MISDIRECTED_REQUEST */:
+                return 'Misdirected Request';
+            case 422 /* HTTP_STATUS.UNPROCESSABLE_ENTITY */:
+                return 'Unprocessable Entity';
+            case 423 /* HTTP_STATUS.LOCKED */:
+                return 'Locked';
+            case 424 /* HTTP_STATUS.FAILED_DEPENDENCY */:
+                return 'Failed Dependency';
+            case 426 /* HTTP_STATUS.UPGRADE_REQUIRED */:
+                return 'Upgrade Required';
+            case 428 /* HTTP_STATUS.PRECONDITION_REQUIRED */:
+                return 'Precondition Required';
+            case 429 /* HTTP_STATUS.TOO_MANY_REQUESTS */:
+                return 'Too Many Requests';
+            case 431 /* HTTP_STATUS.REQUEST_HEADER_FIELDS_TOO_LARGE */:
+                return 'Request Header Fields Too Large';
+            case 451 /* HTTP_STATUS.UNAVAILABLE_FOR_LEGAL_REASONS */:
+                return 'Unavailable For Legal Reasons';
+            case 500 /* HTTP_STATUS.INTERNAL_SERVER_ERROR */:
+                return 'Internal Server Error';
+            case 501 /* HTTP_STATUS.NOT_IMPLEMENTED */:
+                return 'Not Implemented';
+            case 502 /* HTTP_STATUS.BAD_GATEWAY */:
+                return 'Bad Gateway';
+            case 503 /* HTTP_STATUS.SERVICE_UNAVAILABLE */:
+                return 'Service Unavailable';
+            case 504 /* HTTP_STATUS.GATEWAY_TIMEOUT */:
+                return 'Gateway Timeout';
+            case 505 /* HTTP_STATUS.HTTP_VERSION_NOT_SUPPORTED */:
+                return 'HTTP Version Not Supported';
+            case 506 /* HTTP_STATUS.VARIANT_ALSO_NEGOTIATES */:
+                return 'Variant Also Negotiates';
+            case 507 /* HTTP_STATUS.INSUFFICIENT_STORAGE */:
+                return 'Insufficient Storage';
+            case 508 /* HTTP_STATUS.LOOP_DETECTED */:
+                return 'Loop Detected';
+            case 510 /* HTTP_STATUS.NOT_EXTENDED */:
+                return 'Not Extended';
+            case 511 /* HTTP_STATUS.NETWORK_AUTHENTICATION_REQUIRED */:
+                return 'Network Authentication Required';
+            default:
+                return "Unknown" /* ERR_MESSAGE.UNKNOWN */;
+        }
+    }
+    static defineHttpAgent(options) {
+        const { keepAlive, timeout = 0 } = options;
+        if (options.http instanceof http.Agent) {
+            http.globalAgent = options.http;
+        }
+        else if (timeout > 0) {
+            http.globalAgent = new http.Agent({ keepAlive, timeout });
+        }
+        else if (typeof keepAlive === 'boolean') {
+            http.globalAgent = new http.Agent({ keepAlive });
+        }
+        if (options.https instanceof https.Agent) {
+            https.globalAgent = options.https;
+        }
+        else if (timeout > 0) {
+            https.globalAgent = new https.Agent({ keepAlive, timeout });
+        }
+        else if (typeof keepAlive === 'boolean') {
+            https.globalAgent = new https.Agent({ keepAlive });
+        }
+    }
+    static defineDnsLookup({ family, expires, resolve }, reset) {
+        if (reset) {
+            clearDnsLookup();
+        }
+        switch (family = (0, util_1.asInt)(family)) {
+            case 0:
+            case 4:
+            case 6:
+                DNS.FAMILY = family;
+                break;
+        }
+        if (expires !== undefined) {
+            if (typeof expires === 'string') {
+                expires = (0, types_1.parseExpires)(expires);
+            }
+            if (expires >= 0) {
+                DNS.EXPIRES = expires !== Infinity ? Math.min(expires, this.MAX_TIMEOUT) : Infinity;
+            }
+        }
+        for (const hostname in resolve) {
+            let { address, family: ipv } = resolve[hostname];
+            if (address && (ipv = ipv && ((ipv = +ipv) === 4 || ipv === 6) ? ipv : net.isIPv6(address) ? 6 : net.isIPv4(address) ? 4 : 0)) {
+                DNS.CACHE[hostname] = [address, ipv];
+            }
+        }
+    }
+    static getAria2Path() {
+        return ARIA2.BIN;
+    }
+    constructor(data) {
+        super();
+        this.startTime = Date.now();
+        this.readExpect = 'none';
+        this.proxy = null;
+        this._moduleName = "request" /* VALUES.MODULE */;
+        this._config = {
+            timeout: 60000 /* TIME.m */,
+            connectTimeout: 20 * 1000 /* TIME.S */,
+            redirectLimit: 10,
+            retryWait: 1000 /* TIME.S */,
+            retryAfter: 30 * 1000 /* TIME.S */,
+            retryLimit: 5
+        };
+        this[_a] = false;
+        this[_b] = null;
+        this[_c] = null;
+        this[_d] = null;
+        this[_e] = Object.create(null);
+        this[_f] = Object.create(null);
+        this[_g] = [{}, {}];
+        this[_h] = new Set();
+        this[_j] = {};
+        this[_k] = [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);
+            let value;
+            this.readTimeout = (value = (0, util_1.fromSeconds)(read_timeout)) >= 0 ? value : READ_TIMEOUT;
+            this.keepAlive = typeof (value = agent?.keep_alive) === 'boolean' ? value : KEEP_ALIVE;
+            this.acceptEncoding = typeof (value = use?.accept_encoding) === 'boolean' ? value : ACCEPT_ENCODING;
+            switch (value = (0, util_1.asInt)(use?.http_version)) {
+                case 1:
+                case 2:
+                    this[kHttpVersion] = value;
+                    break;
+            }
+            this[kIpVersion] = (value = (0, util_1.asInt)(data.dns?.family)) && (value === 4 || value === 6) ? value : 0;
+            if ((value = (0, util_1.fromSeconds)(agent?.timeout)) >= 0) {
+                this[kAgentTimeout] = value;
+            }
+            else {
+                this[kAgentTimeout] = AGENT_TIMEOUT;
+                value = undefined;
+            }
+            const proxy = getProxySettings(data, value);
+            if (proxy) {
+                this.proxy = proxy;
+            }
+            if ((0, types_1.isObject)(headers)) {
+                setOutgoingHeaders(this[kHeaders] = {}, headers);
+            }
+            if ((0, types_1.isObject)(certs)) {
+                this[kCerts] = validateCerts(certs);
+            }
+            if ((0, types_1.isObject)(connect)) {
+                this.apply({ client: {
+                        timeout,
+                        connectTimeout: (0, util_1.fromSeconds)(connect.timeout),
+                        redirectLimit: (0, util_1.asInt)(connect.redirect_limit),
+                        retryWait: (0, util_1.fromSeconds)(connect.retry_wait),
+                        retryAfter: (0, util_1.fromSeconds)(connect.retry_after),
+                        retryLimit: (0, util_1.asInt)(connect.retry_limit)
+                    } });
+            }
+            else if (timeout >= 0) {
+                this.apply({ client: { timeout } });
+            }
+        }
+        else {
+            data = {};
+            this.readTimeout = READ_TIMEOUT;
+            this.keepAlive = KEEP_ALIVE;
+            this.acceptEncoding = ACCEPT_ENCODING;
+            this[kAgentTimeout] = AGENT_TIMEOUT;
+            this[kIpVersion] = DNS.FAMILY;
+        }
+        this.module = data;
+    }
+    flushLog() {
+        if (this[kSingleton]) {
+            this._logQueued.length = 0;
+            if (LOG_HTTP) {
+                this[kConnectHttp] = [{}, {}];
+            }
+            return;
+        }
+        if (LOG_HTTP) {
+            const log = this._logQueued;
+            const output = [];
+            let count = 0;
+            this[kConnectHttp].forEach((protocol, index) => {
+                const title = 'HTTP' + (index + 1);
+                for (const origin in protocol) {
+                    const value = protocol[origin];
+                    const args = [];
+                    for (let i = 0; i < log.length; ++i) {
+                        const item = log[i];
+                        if (Array.isArray(item[2]) && item[2][0].startsWith(origin)) {
+                            item[1] = '';
+                            item[2][0] = item[2][0].substring(origin.length);
+                            item[4].titleBgColor = undefined;
+                            item[4].titleJustify = 'right';
+                            args.push(item);
+                            log.splice(i--, 1);
+                        }
+                    }
+                    output.push([title, origin, value, args]);
+                    count = Math.max(count, value);
+                }
+            });
+            if (!this.host?.aborted) {
+                output.sort((a, b) => b[2] - a[2]);
+                const width = count.toString().length;
+                output.forEach(item => {
+                    const [title, origin, downloads, messages] = item;
+                    const options = { ...title === 'HTTP1' ? module_1.default.LOG_STYLE_NOTICE : module_1.default.LOG_STYLE_INFO };
+                    if (messages.length === 1) {
+                        const message = messages[0];
+                        message[1] = title;
+                        message[2] = [origin + message[2][0], message[2][1]];
+                        message[4] = Object.assign(message[4], options);
+                        module_1.default.formatMessage(...message);
+                    }
+                    else {
+                        this.formatMessage(1024 /* LOG_TYPE.HTTP */, title, [origin, 'downloads: ' + downloads.toString().padStart(width)], '', options);
+                        messages.forEach(args => {
+                            args[4].titleIndent = true;
+                            module_1.default.formatMessage(...args);
+                        });
+                    }
+                });
+            }
+            this[kConnectHttp] = [{}, {}];
+        }
+        super.flushLog();
+    }
+    detach(singleton) {
+        if (typeof singleton === 'boolean') {
+            this[kSingleton] = singleton;
+        }
+        if (singleton !== false) {
+            super.detach();
+        }
+    }
+    abort() {
+        this[kDownloading].forEach(item => item.abort());
+        this.close();
+        if (!this[kSingleton]) {
+            super.abort();
+        }
+    }
+    init(config) {
+        if (config) {
+            const { headers, httpVersion, ipVersion, requestTimeout } = config;
+            if ((0, types_1.isObject)(headers)) {
+                setOutgoingHeaders(this[kHeaders] || (this[kHeaders] = {}), headers);
+            }
+            if (httpVersion !== undefined) {
+                this.httpVersion = httpVersion;
+            }
+            if (ipVersion !== undefined) {
+                this.ipVersion = ipVersion;
+            }
+            if (requestTimeout !== undefined) {
+                this.readTimeout = (0, util_1.fromSeconds)(requestTimeout);
+            }
+        }
+        return this;
+    }
+    apply(options) {
+        for (const name in options) {
+            const value = options[name];
+            switch (name) {
+                case 'client': {
+                    const { timeout, connectTimeout, redirectLimit, retryWait, retryAfter, retryLimit } = value;
+                    if (timeout >= 0) {
+                        this._config.timeout = timeout;
+                    }
+                    if (connectTimeout >= 0) {
+                        this._config.connectTimeout = connectTimeout;
+                    }
+                    if (redirectLimit >= 0) {
+                        this._config.redirectLimit = redirectLimit;
+                    }
+                    if (retryWait >= 0) {
+                        this._config.retryWait = Math.min(retryWait, 600 * 1000 /* TIME.S */);
+                    }
+                    if (retryAfter >= 0) {
+                        this._config.retryAfter = Math.min(retryAfter, module_1.default.MAX_TIMEOUT);
+                    }
+                    if (retryLimit >= 0) {
+                        this._config.retryLimit = retryLimit;
+                    }
+                    break;
+                }
+                case 'httpVersion':
+                case 'ipVersion':
+                    if (typeof value === 'number') {
+                        this[name] = value;
+                    }
+                    break;
+                case 'acceptEncoding':
+                case 'keepAlive':
+                    if (typeof value === 'boolean') {
+                        this[name] = value;
+                    }
+                    break;
+                case 'readExpect':
+                    if ((0, types_1.isString)(value)) {
+                        this[name] = value;
+                    }
+                    break;
+            }
+        }
+        return this;
+    }
+    addDns(hostname, address, family) {
+        if (!this[kConnectDns][hostname]) {
+            switch (family) {
+                case 'IPv4':
+                    family = 4;
+                    break;
+                case 'IPv6':
+                    family = 6;
+                    break;
+                default:
+                    if (net.isIPv4(address)) {
+                        family = 4;
+                    }
+                    else if (net.isIPv6(address)) {
+                        family = 6;
+                    }
+                    else {
+                        return;
+                    }
+                    break;
+            }
+            setDnsCache(hostname, this[kConnectDns][hostname] = [address, family]);
+        }
+    }
+    lookupDns(hostname) {
+        var _l;
+        const resolved = this[kConnectDns][hostname] || DNS.CACHE[hostname];
+        if (resolved) {
+            return (...args) => args[2](null, ...resolved);
+        }
+        const pending = (_l = this[kPendingDns])[hostname] || (_l[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);
+                    pending.forEach(cb => cb(null, ...connected));
+                    pending.length = 0;
+                };
+                const failed = (err) => {
+                    pending.forEach(cb => cb(err, '', 0));
+                    pending.length = 0;
+                };
+                let ipVersion = this.ipVersion;
+                dns.lookup(value, configure(ipVersion), (err, address, family) => {
+                    if (!err) {
+                        success([address, family]);
+                    }
+                    else {
+                        switch (err.code) {
+                            case 'ENOTFOUND':
+                            case 'EBADNAME':
+                            case 'ENODATA':
+                                failed(err);
+                                return;
+                            case 'ETIMEOUT':
+                            case 'ECONNREFUSED':
+                            case 'ESERVFAIL':
+                            case 'EFILE':
+                                ipVersion = 0;
+                                break;
+                            default:
+                                if (ipVersion === 0) {
+                                    failed(err);
+                                    return;
+                                }
+                                ipVersion = ipVersion === 4 ? 6 : 4;
+                                break;
+                        }
+                        dns.lookup(value, configure(ipVersion), (err, address, family) => {
+                            if (!err) {
+                                success([address, family]);
+                            }
+                            else {
+                                failed(err);
+                            }
+                        });
+                    }
+                });
+            }
+        };
+    }
+    proxyOf(uri, localhost) {
+        const proxy = this.proxy || this.host && HTTP.PROXY;
+        if (proxy) {
+            const { include, exclude } = proxy;
+            if (!include && !exclude && !localhost) {
+                return proxy;
+            }
+            if ((0, types_1.isArray)(include)) {
+                return include.some(value => uri.startsWith(value)) ? proxy : undefined;
+            }
+            if (Array.isArray(exclude) && !exclude.some(value => uri.startsWith(value))) {
+                return proxy;
+            }
+        }
+    }
+    headersOf(uri) {
+        const headers = this[kHeaders];
+        return headers && getBaseHeaders(uri, headers) || (this.host ? getBaseHeaders(uri, HTTP.HEADERS) : undefined);
+    }
+    aria2c(uri, options) {
+        if (!ARIA2.BIN) {
+            return Promise.reject((0, types_1.errorMessage)("aria2" /* VALUES.ARIA2 */, "Binary not found" /* ERR_MESSAGE.NOTFOUND_BINARY */));
+        }
+        if (typeof uri === 'string' && module_1.default.isURL(uri)) {
+            try {
+                uri = new URL(uri);
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        }
+        let pathname, headers, binOpts, silent;
+        if (options) {
+            if (typeof options === 'string') {
+                pathname = options;
+            }
+            else {
+                ({ 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) => {
+                        if (next) {
+                            if (!module_1.default.asString(opt).startsWith('--')) {
+                                return [];
+                            }
+                            next = false;
+                        }
+                        switch (typeof opt) {
+                            case 'string': {
+                                const value = opt.trim();
+                                if (value.startsWith('--')) {
+                                    const match = /^(--[a-z]+[a-z0-9-]*)(=)?\s*(.*)$/.exec(value);
+                                    if (match) {
+                                        switch (match[1]) {
+                                            case '--daemon':
+                                            case '--version':
+                                            case '--help':
+                                                break;
+                                            case '--input-file':
+                                                if (!match[2]) {
+                                                    next = true;
+                                                }
+                                                break;
+                                            default:
+                                                return match[3] ? [match[1], module_1.default.sanitizeArgs(match[3])] : [match[1]];
+                                        }
+                                    }
+                                }
+                                else if (value) {
+                                    return [module_1.default.sanitizeArgs(value)];
+                                }
+                                break;
+                            }
+                            case 'number':
+                            case 'boolean':
+                                return [opt.toString()];
+                            default:
+                                if ((0, types_1.isArray)(opt)) {
+                                    return opt.filter(item => (0, types_1.isString)(item)).map((item) => module_1.default.sanitizeArgs(item));
+                                }
+                                break;
+                        }
+                        return [];
+                    }).flat();
+                }
+            }
+        }
+        if (!(0, types_1.isString)(pathname)) {
+            if (this.host) {
+                return Promise.reject((0, types_1.errorMessage)("aria2" /* VALUES.ARIA2 */, "Invalid parameters" /* ERR_MESSAGE.PARAMETERS */, 'pathname'));
+            }
+            pathname = process.cwd();
+        }
+        if ((this.host || this.hasOwnPermission()) && !this.canWrite(pathname = path.resolve(pathname.trim()))) {
+            return Promise.reject((0, types_1.errorMessage)("aria2" /* VALUES.ARIA2 */, "Unsupported access" /* ERR_MESSAGE.UNSUPPORTED_ACCESS */, pathname));
+        }
+        if (!module_1.default.createDir(pathname)) {
+            return Promise.reject((0, types_1.errorMessage)("aria2" /* VALUES.ARIA2 */, "Path is not a directory" /* ERR_MESSAGE.NOT_DIRECTORY */, pathname));
+        }
+        silent ?? (silent = this[kSingleton]);
+        return new Promise((resolve, reject) => {
+            let protocol, origin, username, password;
+            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)}"`,
+                '--download-result=full',
+                '--follow-torrent=mem',
+                '--follow-metalink=mem',
+                '--seed-time=0',
+                '--max-overall-upload-limit=1K',
+                '--bt-max-peers=1',
+                '--allow-overwrite=true',
+                '--dry-run=false',
+                '--enable-color=false',
+                '--daemon=false',
+                '--stderr=false',
+                '--log=""'
+            ];
+            let args = [];
+            if ((0, types_1.isArray)(binOpts)) {
+                for (let i = 0; i < binOpts.length; ++i) {
+                    const leading = binOpts[i] + '=';
+                    for (const arg of init) {
+                        if (arg.startsWith(leading)) {
+                            const items = [];
+                            for (let k = i + 1; k < binOpts.length; ++k) {
+                                const next = binOpts[k];
+                                if (next.startsWith('--')) {
+                                    break;
+                                }
+                                items.push(next);
+                            }
+                            const l = items.length + 1;
+                            binOpts.splice(i, l);
+                            i += l;
+                            break;
+                        }
+                    }
+                }
+            }
+            else {
+                binOpts = undefined;
+            }
+            const { connectTimeout, timeout, retryWait, retryLimit } = this._config;
+            const opts = [
+                '--log-level=warn',
+                '--bt-stop-timeout=' + ARIA2.BT_STOP_TIMEOUT,
+                '--bt-tracker-connect-timeout=' + ARIA2.BT_TRACKER_CONNECT_TIMEOUT,
+                '--bt-tracker-timeout=' + ARIA2.BT_TRACKER_TIMEOUT,
+                '--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.MIN_SPLIT_SIZE) {
+                opts.push('--min-split-size=' + ARIA2.MIN_SPLIT_SIZE);
+            }
+            if (ARIA2.DISK_CACHE !== null) {
+                opts.push('--disk-cache=' + ARIA2.DISK_CACHE);
+            }
+            if (ARIA2.LOWEST_SPEED_LIMIT !== null) {
+                opts.push('--lowest-speed-limit=' + ARIA2.LOWEST_SPEED_LIMIT);
+            }
+            if (ARIA2.CONF_PATH) {
+                opts.push(`--conf-path="${escapeQuote(ARIA2.CONF_PATH)}"`);
+            }
+            if (!ARIA2.ALWAYS_RESUME) {
+                opts.push('--always-resume=false', '--keep-unfinished-download-result=false');
+            }
+            if (connectTimeout > 0) {
+                opts.push('--connect-timeout=' + Math.min(Math.ceil(connectTimeout / 1000), 600));
+            }
+            if (timeout > 0) {
+                opts.push('--timeout=' + Math.min(Math.ceil(timeout / 1000), 600));
+            }
+            if (retryWait > 0) {
+                opts.push('--retry-wait=' + Math.min(Math.ceil(retryWait / 1000), 600));
+            }
+            if (protocol) {
+                if (this.agentTimeout === 0) {
+                    opts.push('--enable-http-keep-alive=false');
+                }
+                const baseHeaders = ignoreOpt('--header') && this.headersOf(uri);
+                if (headers || baseHeaders) {
+                    if (baseHeaders) {
+                        headers = headers ? { ...baseHeaders, ...headers } : baseHeaders;
+                    }
+                    for (const name in headers) {
+                        let items = headers[name];
+                        if (!Array.isArray(items)) {
+                            items = [items.toString()];
+                        }
+                        args.push(...items.map(value => `--header="${name}: ${escapeQuote(value)}"`));
+                    }
+                }
+                if (origin) {
+                    const secure = this[kCerts]?.[1][origin] || (this.host ? TLS.FILE[origin] : null);
+                    if (secure) {
+                        if (secure.ca && ignoreOpt('--ca-certificate')) {
+                            args.push(`--ca-certificate="${escapeQuote(secure.ca)}"`);
+                        }
+                        if (secure.cert && ignoreOpt('--certificate', '--private-key')) {
+                            args.push(`--certificate="${escapeQuote(secure.cert)}"`);
+                            if (secure.key) {
+                                args.push(`--private-key="${escapeQuote(secure.key)}"`);
+                            }
+                        }
+                    }
+                }
+                switch (protocol = protocol.substring(0, protocol.length - 1)) {
+                    case 'ftp':
+                    case 'http':
+                    case 'https': {
+                        const prefix = protocol === 'https' ? 'http' : protocol;
+                        if (ignoreOpt(`--${prefix}-user`, `--${prefix}-passwd`)) {
+                            if (username) {
+                                args.push(`--${prefix}-user="${escapeQuote(decodeURIComponent(username))}"`);
+                            }
+                            if (password) {
+                                args.push(`--${prefix}-passwd="${escapeQuote(decodeURIComponent(password))}"`);
+                            }
+                        }
+                        const proxy = this.proxyOf(uri);
+                        if (proxy && ignoreOpt(`--${protocol}-proxy-user`, `--${protocol}-proxy-passwd`)) {
+                            ({ origin, username, password } = proxy.host);
+                            if (ignoreOpt(`--${protocol}-proxy`)) {
+                                args.push(`--${protocol}-proxy="${origin}"`);
+                            }
+                            if (username) {
+                                args.push(`--${protocol}-proxy-user="${escapeQuote(decodeURIComponent(username))}"`);
+                            }
+                            if (password) {
+                                args.push(`--${protocol}-proxy-passwd="${escapeQuote(decodeURIComponent(password))}"`);
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+            if (binOpts) {
+                for (const leading of binOpts) {
+                    for (let i = 0; i < opts.length; ++i) {
+                        if (opts[i].startsWith(leading)) {
+                            opts.splice(i--, i);
+                            break;
+                        }
+                    }
+                }
+                args = binOpts.concat(args);
+            }
+            if (args.length && module_1.default.hasLogType(32768 /* LOG_TYPE.STDOUT */)) {
+                this.formatMessage(32768 /* LOG_TYPE.STDOUT */, 'ARIA2', ARIA2.BIN, args.join(' '), { ...module_1.default.LOG_STYLE_WARN });
+            }
+            opts.push(`"${escapeQuote(uri)}"`);
+            args = args.concat(init, opts);
+            const startTime = Date.now();
+            let out = '', message = '', aborted;
+            const errorResponse = (pid, err) => {
+                aborted = true;
+                closeTorrent(pid);
+                reject(err);
+            };
+            const { pid, stdout, stderr } = child_process.spawn(module_1.default.sanitizeCmd(ARIA2.BIN), args, { cwd: pathname, shell: true, signal: this.signal })
+                .on('exit', code => {
+                closeTorrent(pid);
+                if (aborted) {
+                    return;
+                }
+                if (this.aborted) {
+                    errorResponse(pid, (0, types_1.createAbortError)());
+                    return;
+                }
+                if (!code) {
+                    const currentTime = Date.now();
+                    const pattern = /\|(OK|ERR|INPR)\s*\|\s*([^|]+)\|\s*(\d+)\|([^\n]+)/g;
+                    const result = [];
+                    let messageUnit, match;
+                    while (match = pattern.exec(out)) {
+                        if (match[4].startsWith('[MEMORY]')) {
+                            continue;
+                        }
+                        const file = path.normalize(match[4].trim());
+                        switch (match[1]) {
+                            case 'OK':
+                                if (match[3] === '100') {
+                                    result.push(file);
+                                }
+                                messageUnit || (messageUnit = match[2]);
+                                break;
+                            case 'INPR':
+                                if (ARIA2.ALWAYS_RESUME) {
+                                    break;
+                                }
+                            case 'ERR':
+                                fs.unlink(file, err => err && !silent && !this[kSingleton] && this.writeFail(["Unable to delete file" /* ERR_MESSAGE.DELETE_FILE */, path.basename(file)], err, { type: 32 /* LOG_TYPE.FILE */, fatal: false }));
+                                break;
+                        }
+                    }
+                    if (result.length && !silent && LOG_HTTP && LOG_TIMEPROCESS) {
+                        this.writeTimeProcess("aria2" /* VALUES.ARIA2 */, uri, startTime, { type: 1024 /* LOG_TYPE.HTTP */, queue: true, messageUnit, messageUnitMinWidth: 9 });
+                    }
+                    this.addLog(result.length ? types_1.STATUS_TYPE.INFO : types_1.STATUS_TYPE.ERROR, out, currentTime, currentTime - startTime, "aria2" /* VALUES.ARIA2 */, uri);
+                    resolve(result);
+                }
+                else {
+                    reject((0, types_1.errorValue)(message || "Unknown" /* ERR_MESSAGE.UNKNOWN */, 'Exit status: ' + code));
+                }
+            })
+                .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.default.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();
+                            return;
+                        }
+                        for (const item of ARIA2.PID_QUEUE) {
+                            try {
+                                process.kill(item[0], 0);
+                            }
+                            catch {
+                                closeTorrent(item[0]);
+                            }
+                        }
+                        if (ARIA2.UPDATE_STATUS && !silent) {
+                            const item = ARIA2.PID_QUEUE.shift();
+                            if (item) {
+                                const broadcastId = item[2];
+                                if (!ARIA2.UPDATE_BROADCAST_ONLY || broadcastId) {
+                                    let progressBar;
+                                    if (item[2]) {
+                                        progressBar = true;
+                                    }
+                                    else {
+                                        const current = (0, types_1.getLogCurrent)();
+                                        progressBar = current?.type === 128 /* LOG_TYPE.TIME_ELAPSED */ && current.title === "aria2" /* VALUES.ARIA2 */;
+                                    }
+                                    this.formatMessage(128 /* LOG_TYPE.TIME_ELAPSED */, "aria2" /* VALUES.ARIA2 */, ['Downloading...', (0, types_1.formatTime)(startTime, true)], (PLATFORM_WIN32 ? 'taskkill /f /pid' : 'kill') + ` ${item[0]} -> ` + item[1], { ...module_1.default.LOG_STYLE_INFO, progressBar, broadcastId });
+                                }
+                                ARIA2.PID_QUEUE.push(item);
+                            }
+                            else {
+                                clearTimer();
+                            }
+                        }
+                    }, (ARIA2.UPDATE_STATUS || 30) * 1000 /* TIME.S */);
+                }
+                ARIA2.PID_QUEUE.push([pid, uri, this.broadcastId || undefined]);
+            }
+        });
+    }
+    json(uri, options = {}) {
+        options.format = 'json';
+        return this.get(uri, options);
+    }
+    pipe(uri, to, options = {}) {
+        options.pipeTo = to;
+        return this.get(uri, options);
+    }
+    opts(url, options) {
+        var _l, _m, _o, _p;
+        if (typeof url === 'string') {
+            url = new URL(url);
+        }
+        let host;
+        if (this.host) {
+            host = (_l = HTTP.HOST)[_m = url.origin] || (_l[_m] = new host_1.default(url, HTTP.VERSION));
+        }
+        else {
+            host = (_o = this[kHostInfo])[_p = url.origin] || (_o[_p] = new host_1.default(url, this.httpVersion || 1));
+        }
+        return { ...options, host, url };
+    }
+    open(uri, options) {
+        var _l, _m;
+        let { host, url, httpVersion, method = 'GET', encoding, format, headers, postData, keepAlive, agentTimeout, socketPath, timeout = this._config.connectTimeout, outStream } = options;
+        const getting = method === 'GET';
+        const posting = method === 'POST';
+        if (format) {
+            let parser;
+            if ((0, types_1.isObject)(format)) {
+                ({ out: format = 'json', parser } = format);
+            }
+            if (format.includes('/')) {
+                format = format.split('/').pop().split('-').pop();
+            }
+            headers || (headers = {});
+            switch (format = format.trim().toLowerCase()) {
+                case 'yaml':
+                    headers['accept'] = 'application/yaml, application/x-yaml, text/yaml, text/x-yaml';
+                    break;
+                case 'json5':
+                    headers['accept'] = 'application/json5, application/json, text/javascript';
+                    break;
+                case 'xml':
+                    headers['accept'] = 'application/xml, text/xml';
+                    break;
+                case 'toml':
+                    headers['accept'] = 'application/toml';
+                    break;
+                default:
+                    headers['accept'] = 'application/json, text/javascript';
+                    format = 'json';
+                    break;
+            }
+            headers['accept'] += ', text/plain';
+            options.encoding = (0, types_1.getEncoding)(encoding);
+            options.outFormat = { out: format, parser };
+        }
+        if (typeof uri !== 'string') {
+            url = uri;
+            uri = url.toString();
+        }
+        if (!host) {
+            ({ host, url } = this.opts(url || uri));
+            options.host = host;
+            options.url = url;
+        }
+        else if (!url) {
+            url = new URL(uri);
+            options.url = url;
+        }
+        const checkEncoding = (response, statusCode, contentEncoding = '') => {
+            switch (statusCode) {
+                case 206 /* HTTP_STATUS.PARTIAL_CONTENT */:
+                    request.emit('error', new Error('[ABORT] Partial content'));
+                case 204 /* HTTP_STATUS.NO_CONTENT */:
+                    return;
+            }
+            const chunkSize = outStream?.writableHighWaterMark;
+            let pipeTo;
+            switch (contentEncoding.trim().toLowerCase()) {
+                case 'gzip':
+                    pipeTo = zlib.createGunzip({ chunkSize });
+                    break;
+                case 'br':
+                    pipeTo = zlib.createBrotliDecompress({ chunkSize });
+                    break;
+                case 'deflate':
+                    pipeTo = zlib.createInflate({ chunkSize });
+                    break;
+                case 'deflate-raw':
+                    pipeTo = zlib.createInflateRaw({ chunkSize });
+                    break;
+            }
+            if (pipeTo) {
+                if (outStream) {
+                    stream.pipeline(response, pipeTo, outStream, err => err && response.emit('error', err));
+                }
+                else {
+                    stream.pipeline(response, pipeTo, err => err && response.emit('error', err));
+                }
+                return pipeTo;
+            }
+        };
+        const { hostname, origin } = host;
+        const pathname = url.pathname + (socketPath ? '' : url.search);
+        const proxy = this.proxyOf(uri, host.localhost);
+        let request, ca, cert, key, minVersion, baseHeaders = this.headersOf(uri);
+        if (getting && this.acceptEncoding && !host.localhost && !baseHeaders?.['accept-encoding']) {
+            (_l = (headers || (headers = {})))['accept-encoding'] || (_l['accept-encoding'] = 'gzip, deflate, br');
+        }
+        if (host.secure) {
+            const secure = this[kCerts]?.[0][origin] || (this.host ? TLS.TEXT[origin] : null);
+            if (secure) {
+                ({ ca, cert, key, version: minVersion } = secure);
+            }
+        }
+        if (!proxy && httpVersion !== 1 && ((httpVersion || host.version) === 2 && this.httpVersion !== 1 || host.secure && this.httpVersion === 2 && host.failed(2, true) === 0)) {
+            request = ((_m = this[kSession][0])[origin] || (_m[origin] = http2.connect(origin, { lookup: this.lookupDns(hostname), ca, cert, key, minVersion }))).request({ ...baseHeaders, ...host_1.default.getBasicAuth(url), ...headers, ':path': pathname, ':method': method });
+            if (getting) {
+                const listenerMap = {};
+                const onEvent = request.on.bind(request);
+                const onceEvent = request.once.bind(request);
+                let connected, emitter;
+                request.on('response', response => {
+                    connected = true;
+                    const statusCode = response[':status'];
+                    if (statusCode >= 200 /* HTTP_STATUS.OK */ && statusCode < 300 /* HTTP_STATUS.MULTIPLE_CHOICES */) {
+                        if (emitter = checkEncoding(request, statusCode, response['content-encoding'])) {
+                            for (const event in listenerMap) {
+                                listenerMap[event].forEach(listener => {
+                                    const [name, type] = event.split('-');
+                                    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));
+                            }
+                            if (encoding) {
+                                request.setEncoding((0, types_1.getEncoding)(encoding));
+                            }
+                        }
+                        if (LOG_HTTP) {
+                            this[kConnectHttp][1][origin] = (this[kConnectHttp][1][origin] || 0) + 1;
+                        }
+                    }
+                    request.setTimeout(this._config.timeout);
+                });
+                request.on = function (event, listener) {
+                    var _l;
+                    switch (event) {
+                        case 'data':
+                        case 'error':
+                        case 'end':
+                            if (emitter) {
+                                emitter.on(event === 'end' ? 'finish' : event, listener);
+                                break;
+                            }
+                            if (!connected) {
+                                (listenerMap[_l = event + '-on'] || (listenerMap[_l] = [])).push(listener);
+                            }
+                        default:
+                            onEvent(event, listener);
+                            break;
+                    }
+                    return this;
+                };
+                request.once = function (event, listener) {
+                    var _l;
+                    switch (event) {
+                        case 'data':
+                        case 'error':
+                        case 'end':
+                            if (emitter) {
+                                emitter.once(event === 'end' ? 'finish' : event, listener);
+                                break;
+                            }
+                            if (!connected) {
+                                (listenerMap[_l = event + '-once'] || (listenerMap[_l] = [])).push(listener);
+                            }
+                        default:
+                            onceEvent(event, listener);
+                            break;
+                    }
+                    return this;
+                };
+            }
+            options.httpVersion = 2;
+        }
+        else {
+            let agent;
+            if (!socketPath) {
+                if (proxy) {
+                    const pkg = host.secure ? 'https-proxy-agent' : 'http-proxy-agent';
+                    try {
+                        const { protocol, hostname: proxyname, port, username, password, href } = proxy.host;
+                        keepAlive ?? (keepAlive = proxy.keepAlive || false);
+                        agentTimeout ?? (agentTimeout = proxy.agentTimeout);
+                        agent = require(pkg)(keepAlive || agentTimeout > 0 ? { protocol, hostname: proxyname, port, username, password, keepAlive, timeout: agentTimeout } : href);
+                        const proxyHeaders = this[kHeaders] && getBaseHeaders(href, this[kHeaders]) || getBaseHeaders(href, HTTP.HEADERS);
+                        if (proxyHeaders) {
+                            baseHeaders = { ...baseHeaders, ...proxyHeaders };
+                        }
+                    }
+                    catch (err) {
+                        this.checkPackage(err, pkg, "Unknown" /* ERR_MESSAGE.UNKNOWN */);
+                    }
+                }
+                else if (keepAlive === false) {
+                    agent = new (host.secure ? https.Agent : http.Agent)({ keepAlive: false });
+                }
+                else if (keepAlive === true || agentTimeout > 0) {
+                    agent = new (host.secure ? https.Agent : http.Agent)({ keepAlive: true, timeout: agentTimeout });
+                }
+                else if (agentTimeout !== 0) {
+                    keepAlive = this.keepAlive || false;
+                    agentTimeout ?? (agentTimeout = this.agentTimeout);
+                    if (keepAlive || agentTimeout > 0) {
+                        agent = new (host.secure ? https.Agent : http.Agent)({ keepAlive, timeout: agentTimeout });
+                    }
+                }
+            }
+            const basicAuth = host_1.default.getBasicAuth(url);
+            if (baseHeaders || basicAuth) {
+                headers = { ...baseHeaders, ...basicAuth, ...headers };
+            }
+            request = (host.secure ? https : http).request(socketPath ? { socketPath, path: pathname } : {
+                protocol: host.protocol,
+                hostname,
+                port: host.port,
+                path: pathname,
+                method,
+                ca,
+                cert,
+                key,
+                minVersion,
+                headers,
+                lookup: this.lookupDns(hostname),
+                agent
+            }, response => {
+                const statusCode = response.statusCode;
+                if ((getting || posting) && statusCode >= 200 /* HTTP_STATUS.OK */ && statusCode < 300 /* HTTP_STATUS.MULTIPLE_CHOICES */) {
+                    let source = checkEncoding(response, statusCode, response.headers['content-encoding']);
+                    if (source) {
+                        source.once('finish', () => request.emit('end'));
+                    }
+                    else {
+                        if (encoding) {
+                            response.setEncoding((0, types_1.getEncoding)(encoding));
+                        }
+                        if (outStream) {
+                            stream.pipeline(response, outStream, err => {
+                                if (!err) {
+                                    request.emit('end');
+                                }
+                                else {
+                                    request.emit('error', err);
+                                }
+                            });
+                        }
+                        else {
+                            response.once('end', () => request.emit('end'));
+                        }
+                        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));
+                    if (response !== source) {
+                        source.on('error', err => request.emit('error', err));
+                    }
+                    if (!posting && !host.didAltSvc(1)) {
+                        host.upgrade(1, response.headers['alt-svc']);
+                    }
+                    if (LOG_HTTP) {
+                        this[kConnectHttp][0][origin] = (this[kConnectHttp][0][origin] || 0) + 1;
+                    }
+                }
+                else {
+                    response
+                        .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'));
+                }
+            });
+            options.httpVersion = 1;
+        }
+        if (timeout > 0) {
+            request.setTimeout(timeout);
+        }
+        if ((getting || posting) && SUPPORT_ABORTSIGNAL) {
+            const ac = new AbortController();
+            this[kDownloading].add(options.outAbort = ac);
+            stream.addAbortSignal(ac.signal, request);
+            this.signal.addEventListener('abort', () => ac.abort(), { once: true });
+        }
+        if (posting) {
+            if ((0, types_1.isString)(postData) || Buffer.isBuffer(postData)) {
+                request.write(postData);
+            }
+            else if (postData instanceof stream.Stream) {
+                postData.pipe(request);
+            }
+        }
+        request.end();
+        return request;
+    }
+    head(uri, options) {
+        const out = this.opts(uri, options);
+        out.method = 'HEAD';
+        out.httpVersion = 1;
+        return this.open(out.url, out);
+    }
+    async post(uri, data, contentType, options) {
+        let parts;
+        if (Array.isArray(contentType)) {
+            parts = contentType;
+            contentType = undefined;
+        }
+        else {
+            if ((0, types_1.isPlainObject)(contentType)) {
+                options = contentType;
+                contentType = undefined;
+            }
+            if (Array.isArray(data) && (!contentType || contentType === "multipart/form-data" /* MIME.MULTIPART */)) {
+                parts = data;
+                data = undefined;
+            }
+        }
+        let dataEncoding;
+        if ((0, types_1.isPlainObject)(options)) {
+            let formData;
+            ({ formData, dataEncoding } = options);
+            if (formData) {
+                (parts || (parts = [])).push(...Array.isArray(formData) ? formData : [formData]);
+            }
+            else {
+                contentType || (contentType = options.contentType);
+            }
+        }
+        else {
+            options = {};
+        }
+        const headers = options.headers || (options.headers = {});
+        for (const attr in headers) {
+            switch (attr.toLowerCase()) {
+                case 'content-type':
+                case 'content-length':
+                    delete headers[attr];
+                    break;
+            }
+        }
+        if (parts || contentType === "multipart/form-data" /* MIME.MULTIPART */ || contentType === 'form-data') {
+            let valid;
+            if ((0, types_1.isArray)(parts)) {
+                const write = combined.create();
+                const boundary = (0, types_1.generateUUID)().replace(/-/g, '');
+                contentType = "multipart/form-data" /* MIME.MULTIPART */ + `; boundary="${boundary}"`;
+                let contentLength = 0;
+                const createPart = (name, filename, type) => {
+                    const form = ["--" /* FORM_DATA.BOUNDARY_HASH */ + boundary, `Content-Disposition: form-data; name="${escapeQuote(name)}"` + (filename ? `; filename="${escapeQuote(filename)}"` : ''), "\r\n" /* FORM_DATA.CRLF */];
+                    if (type) {
+                        form.splice(2, 0, 'Content-Type: ' + type);
+                    }
+                    return form.join("\r\n" /* FORM_DATA.CRLF */);
+                };
+                const addValue = (name, value) => {
+                    if (value !== undefined) {
+                        const disposition = createPart(name) + module_1.default.asString(value) + "\r\n" /* FORM_DATA.CRLF */;
+                        write.append(disposition);
+                        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]);
+                    }
+                }
+                for (let { name, data: target, value, contentType: type, filename } of parts) {
+                    if ((0, types_1.isString)(name)) {
+                        if (target) {
+                            try {
+                                if (typeof target === 'string') {
+                                    filename || (filename = path.basename(target));
+                                    type || (type = module_1.default.lookupMime(filename));
+                                    target = fs.readFileSync(target);
+                                }
+                                else if (target instanceof stream.Readable) {
+                                    const chunks = [];
+                                    for await (const chunk of target) {
+                                        chunks.push(chunk);
+                                    }
+                                    target = Buffer.concat(chunks);
+                                }
+                                if (!Buffer.isBuffer(target)) {
+                                    throw (0, types_1.errorMessage)('File', "Unknown" /* ERR_MESSAGE.UNKNOWN */, "multipart/form-data" /* MIME.MULTIPART */);
+                                }
+                                if (!type || !filename) {
+                                    const result = await module_1.default.resolveMime(target);
+                                    let ext;
+                                    if (result) {
+                                        type || (type = result.mime);
+                                        ext = result.ext;
+                                    }
+                                    else if (type) {
+                                        ext = module_1.default.lookupMime(type, true);
+                                    }
+                                    if (ext && !filename) {
+                                        filename = (0, types_1.generateUUID)() + '.' + ext;
+                                    }
+                                }
+                                const disposition = createPart(name, filename, type || "application/octet-stream" /* MIME.OCTET_STREAM */);
+                                write.append(disposition);
+                                write.append(target);
+                                write.append("\r\n" /* FORM_DATA.CRLF */);
+                                contentLength += Buffer.byteLength(disposition) + target.length + 2 /* FORM_DATA.CRLF_LENGTH */;
+                                valid = true;
+                            }
+                            catch (err) {
+                                return Promise.reject(err);
+                            }
+                        }
+                        else {
+                            addValue(name, value);
+                        }
+                    }
+                }
+                if (valid) {
+                    write.append("--" /* FORM_DATA.BOUNDARY_HASH */ + boundary + "--" /* FORM_DATA.BOUNDARY_HASH */ + "\r\n" /* FORM_DATA.CRLF */);
+                    headers['content-length'] = (contentLength + 38 /* FORM_DATA.BOUNDARY_LENGTH */).toString();
+                    data = write;
+                }
+            }
+            if (!valid) {
+                return Promise.reject((0, types_1.errorValue)('No files were detected', "multipart/form-data" /* MIME.MULTIPART */));
+            }
+        }
+        else {
+            if (contentType && !contentType.includes('/')) {
+                contentType = 'application/' + contentType.trim();
+            }
+            if ((0, types_1.isPlainObject)(data)) {
+                if (contentType === "application/x-www-form-urlencoded" /* MIME.URLENCODED */) {
+                    data = qs.stringify(data);
+                }
+                else {
+                    data = JSON.stringify(data);
+                    contentType || (contentType = "application/json" /* MIME.JSON */);
+                }
+            }
+            else {
+                data = module_1.default.asString(data);
+            }
+            headers['content-length'] = Buffer.byteLength(data, (0, types_1.getEncoding)(dataEncoding)).toString();
+        }
+        options.method = 'POST';
+        options.httpVersion = 1;
+        options.postData = data;
+        headers['content-type'] = contentType || "text/plain" /* MIME.TEXT */;
+        return this.get(uri, options);
+    }
+    get(uri, options = {}) {
+        const opts = (typeof options === 'string' ? { format: options, encoding: 'utf-8' } : options);
+        if (this.readExpect === 'string') {
+            opts.encoding = (0, types_1.getEncoding)(opts?.encoding);
+        }
+        return new Promise((resolve, reject) => {
+            const { silent = this[kSingleton], pipeTo } = opts;
+            const log = LOG_HTTP && LOG_TIMEPROCESS && !silent;
+            const startTime = log ? process.hrtime() : 0;
+            let retries = 0, redirects = 0, closed, timeout, outStream;
+            const throwError = (err, outAbort) => {
+                if (!closed) {
+                    closed = true;
+                    if (outStream && (0, types_1.isString)(pipeTo)) {
+                        (0, lib_v4_1.cleanupStream)(outStream, pipeTo);
+                    }
+                    reject(typeof err === 'string' ? new Error(err) : err);
+                }
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                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, lib_v4_1.cleanupStream)(outStream, pipeTo);
+                    }
+                    if (pipeTo) {
+                        if ((0, types_1.isString)(pipeTo)) {
+                            outStream = fs.createWriteStream(pipeTo, { emitClose: false, highWaterMark: request.host.localhost ? 65536 /* CONSTANTS.CHUNK_SIZE_LOCAL */ : 4096 /* CONSTANTS.CHUNK_SIZE */ });
+                            request.outStream = outStream;
+                        }
+                        else {
+                            request.outStream = pipeTo;
+                        }
+                    }
+                    if (httpVersion) {
+                        request.httpVersion = httpVersion;
+                    }
+                    const client = this.open(href, request);
+                    const { host, url, encoding, 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 /* HTTP_STATUS.MISDIRECTED_REQUEST */ || value === 505 /* HTTP_STATUS.HTTP_VERSION_NOT_SUPPORTED */;
+                    const isDowngrade = (err) => err instanceof Error && (err.code === 'ERR_HTTP2_ERROR' || isUnsupported(Math.abs(err.errno)));
+                    const formatWarning = (message) => LOG_HTTP && !silent && this.formatMessage(1024 /* LOG_TYPE.HTTP */, 'HTTP' + httpVersion, [message, host.origin], url.toString(), { titleBgColor: 'bgGrey', titleColor: 'yellow' });
+                    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 = () => {
+                        formatWarning(`Connection timeout (${retries} / ${this._config.retryLimit})`);
+                        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 buffering = request.connected?.call(client, headers);
+                        const pipeline = pipeTo ? !(0, types_1.isString)(pipeTo) : false;
+                        const enabled = buffering !== false && !pipeline;
+                        let mibsTime, delayTime;
+                        if (log || this.readTimeout > 0) {
+                            client.once('readable', () => {
+                                if (this.readTimeout > 0) {
+                                    timeout = setTimeout(() => {
+                                        abortResponse();
+                                        throwError((0, types_1.errorValue)("Timeout was exceeded" /* ERR_MESSAGE.TIMEOUT */, href.toString()));
+                                    }, this.readTimeout);
+                                }
+                                if (log) {
+                                    if (buffering === false) {
+                                        mibsTime = process.hrtime();
+                                    }
+                                    switch (this.settings?.time_format || LOG_TIMEFORMAT) {
+                                        case 'readable':
+                                            delayTime = process.hrtime(startTime);
+                                            break;
+                                        case 'relative':
+                                            delayTime = Date.now() - this.startTime;
+                                            break;
+                                    }
+                                }
+                            });
+                        }
+                        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 {
+                                    if (log) {
+                                        mibsTime = process.hrtime();
+                                    }
+                                    buffer = typeof chunk === 'string' ? chunk : [chunk];
+                                }
+                            });
+                        }
+                        client.once('end', () => {
+                            if (closed || aborted) {
+                                return;
+                            }
+                            if (timeout) {
+                                clearTimeout(timeout);
+                            }
+                            if (outAbort) {
+                                this[kDownloading].delete(outAbort);
+                            }
+                            closed = true;
+                            let messageUnit, titleBgColor;
+                            let result;
+                            if (buffer) {
+                                if (Array.isArray(buffer)) {
+                                    buffer = Buffer.concat(buffer);
+                                    if (encoding) {
+                                        buffer = buffer.toString(encoding);
+                                    }
+                                }
+                                if (mibsTime) {
+                                    const unit = (Buffer.byteLength(buffer, encoding) * 8) / ((0, types_1.convertTime)(process.hrtime(mibsTime)) * 1000 /* TIME.S */);
+                                    if (unit < 1) {
+                                        messageUnit = Math.ceil(unit * 1000 /* TIME.S */) + 'KiB/s';
+                                    }
+                                    else if (unit < 1000 /* TIME.S */) {
+                                        messageUnit = unit.toPrecision(3) + 'MiB/s';
+                                    }
+                                    else {
+                                        messageUnit = (unit / 1000 /* TIME.S */).toPrecision(3) + 'GiB/s';
+                                    }
+                                }
+                                if (typeof buffer === 'string') {
+                                    if (buffer[0] === '\uFEFF' && encoding !== 'utf16le') {
+                                        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 (!silent && !this[kSingleton] && !(packageName && this.checkPackage(err, packageName))) {
+                                                this.writeFail(['Unable to parse URI response', format], err, 1024 /* LOG_TYPE.HTTP */);
+                                            }
+                                            result = null;
+                                        }
+                                    }
+                                }
+                                if (result === undefined) {
+                                    result = buffer;
+                                }
+                            }
+                            else if (enabled && this.readExpect === 'always') {
+                                throwError('No data received');
+                                return;
+                            }
+                            else {
+                                result = encoding && !pipeline ? '' : null;
+                                titleBgColor = 'bgBlue';
+                            }
+                            resolve(result);
+                            if (log) {
+                                this.writeTimeProcess('HTTP' + httpVersion, request.statusMessage || url.toString(), startTime, { type: 1024 /* LOG_TYPE.HTTP */, queue: !!this.host, titleBgColor, messageUnit, messageUnitMinWidth: 9, delayTime, bypassLog: true });
+                            }
+                        });
+                        host.success(httpVersion);
+                    };
+                    const redirectResponse = (statusCode, location) => {
+                        abortResponse();
+                        if (location) {
+                            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 ((0, util_1.checkRetryable)(err) && ++retries <= this._config.retryLimit) {
+                            if (isConnectionTimeout(err)) {
+                                retryTimeout();
+                            }
+                            else {
+                                setTimeout(() => downloadUri.call(this, href), this._config.retryWait);
+                            }
+                        }
+                        else {
+                            if (err instanceof Error && !err.message.startsWith('[ABORT]')) {
+                                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) {
+                                    formatWarning(`Retry After (${retryAfter})`);
+                                    setTimeout(() => downloadUri.call(this, href), offset);
+                                }
+                                else {
+                                    throwError(formatStatus(statusCode));
+                                }
+                                return;
+                            }
+                        }
+                        formatWarning(Request.fromStatusCode(statusCode) + ` (${retries} / ${this._config.retryLimit})`);
+                        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 (!silent) {
+                                        this.formatMessage(1024 /* LOG_TYPE.HTTP */, '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 /* HTTP_STATUS.MULTIPLE_CHOICES */) {
+                                acceptResponse(headers);
+                            }
+                            else if (statusCode < 400 /* HTTP_STATUS.BAD_REQUEST */) {
+                                redirectResponse(statusCode, headers.location);
+                            }
+                            else if (statusCode === 401 /* HTTP_STATUS.UNAUTHORIZED */ ||
+                                statusCode === 402 /* HTTP_STATUS.PAYMENT_REQUIRED */ ||
+                                statusCode === 403 /* HTTP_STATUS.FORBIDDEN */ ||
+                                statusCode === 404 /* HTTP_STATUS.NOT_FOUND */ ||
+                                statusCode === 407 /* HTTP_STATUS.PROXY_AUTHENTICATION_REQUIRED */ ||
+                                statusCode === 410 /* HTTP_STATUS.GONE */) {
+                                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;
+                            }
+                            switch (!isDowngrade(err) && await host.hasProtocol(2)) {
+                                case 1 /* QUERY_RESULT.OK */:
+                                    errorResponse(err);
+                                    break;
+                                case 2 /* QUERY_RESULT.TIMEOUT */:
+                                    retryDownload(false, err);
+                                    break;
+                                default:
+                                    retryDownload(true, err);
+                                    break;
+                            }
+                        });
+                    }
+                    else {
+                        client
+                            .on('response', res => {
+                            if (isAborted()) {
+                                return;
+                            }
+                            const statusCode = res.statusCode;
+                            if (statusCode < 300 /* HTTP_STATUS.MULTIPLE_CHOICES */) {
+                                acceptResponse(res.headers);
+                            }
+                            else if (statusCode < 400 /* HTTP_STATUS.BAD_REQUEST */) {
+                                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 /* HTTP_STATUS.REQUEST_TIMEOUT */));
+                        }
+                    });
+                }
+                catch (err) {
+                    throwError(err, outAbort);
+                }
+            }).bind(this)(uri);
+        });
+    }
+    reset() {
+        this[kPendingDns] = Object.create(null);
+        this[kDownloading].clear();
+    }
+    close() {
+        const session = this[kSession];
+        session.forEach((protocol, index) => {
+            for (const host in protocol) {
+                protocol[host].close();
+            }
+            session[index] = Object.create(null);
+        });
+        this[kDownloading].clear();
+    }
+    set agentTimeout(value) {
+        if (value > 0) {
+            this[kAgentTimeout] = value;
+            this.keepAlive ?? (this.keepAlive = true);
+        }
+        else {
+            this[kAgentTimeout] = 0;
+            this.keepAlive ?? (this.keepAlive = false);
+        }
+    }
+    get agentTimeout() {
+        return this[kAgentTimeout];
+    }
+    set httpVersion(value) {
+        switch (value) {
+            case 1:
+            case 2:
+                this[kHttpVersion] = value;
+                break;
+        }
+    }
+    get httpVersion() {
+        return this[kHttpVersion];
+    }
+    set ipVersion(value) {
+        switch (value) {
+            case 0:
+            case 4:
+            case 6:
+                this[kIpVersion] = value;
+                break;
+        }
+    }
+    get ipVersion() {
+        return this[kIpVersion];
+    }
+    get settings() {
+        var _l;
+        return (_l = this.module).settings || (_l.settings = {});
+    }
+}
+_a = kSingleton, _b = kHttpVersion, _c = kHeaders, _d = kCerts, _e = kConnectDns, _f = kPendingDns, _g = kConnectHttp, _h = kDownloading, _j = kHostInfo, _k = kSession;
+exports.default = Request;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}