@e-mc/request 0.11.8 → 0.12.0

package/index.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
 const path = require("node:path");
 const fs = require("node:fs");
 const crypto = require("node:crypto");
@@ -20,22 +19,7 @@ const module_1 = require("@e-mc/module");
 const util_1 = require("@e-mc/request/util");
 const host_1 = require("@e-mc/request/http/host");
 const adapter_1 = require("@e-mc/request/http/adapter");
-const kSession = Symbol('session');
-const kHttpVersion = Symbol('httpVersion');
-const kIpVersion = Symbol('ipVersion');
-const kAgentTimeout = Symbol('agentTimeout');
-const kHeaders = Symbol('headers');
-const kCerts = Symbol('certs');
-const kBaseURL = Symbol('baseURL');
-const kDownloading = Symbol('downloading');
-const kSingleton = Symbol('singleton');
-const kHostInfo = Symbol('hostInfo');
-const kConnectDns = Symbol('connectDns');
-const kPendingDns = Symbol('pendingDns');
-const kConnectHttp = Symbol('connectHttp');
-const kStatusOn = Symbol('statusOn');
-const kHeadersOn = Symbol('headersOn');
-const kAdapter = Symbol('adapter');
+const kRequest = Symbol.for('request:constructor');
 const SUPPORTED_NODE20 = (0, types_1.supported)(20);
 const SUPPORTED_ZSTD = (0, types_1.supported)(23, 8) && typeof zlib.createZstdDecompress === 'function';
 const REGEXP_PEMCERT = /^-{3,}[ \t]*BEGIN[ \t].+\n-{3,}[ \t]*END[ \t][^-]+-{3,}$/s;
@@ -75,8 +59,46 @@ const ARIA2 = {
     LOWEST_SPEED_LIMIT: null,
     ALWAYS_RESUME: false,
     FILE_ALLOCATION: 'none',
+    PROXY: {},
+    NO_PROXY: '',
     CONF_PATH: ''
 };
+const RCLONE = {
+    BIN: which.sync(module_1.PLATFORM_WIN32 ? 'rclone.exe' : 'rclone', { nothrow: true }) || '',
+    EXEC_UID: undefined,
+    EXEC_GID: undefined,
+    CHECK_FIRST: false,
+    CHECKSUM: false,
+    CUTOFF_MODE: '',
+    IGNORE_CASE_SYNC: false,
+    IGNORE_CHECKSUM: false,
+    IGNORE_EXISTING: false,
+    IGNORE_SIZE: false,
+    IGNORE_TIMES: false,
+    IMMUTABLE: false,
+    INPLACE: false,
+    MAX_BACKLOG: 0,
+    MAX_DURATION: '',
+    MAX_TRANSFER: '',
+    METADATA: false,
+    MODIFY_WINDOW: '',
+    MULTI_THREAD_CHUNK_SIZE: '',
+    MULTI_THREAD_CUTOFF: '',
+    MULTI_THREAD_STREAMS: 0,
+    MULTI_THREAD_WRITE_BUFFER_SIZE: '',
+    NO_CHECK_DEST: false,
+    NO_TRAVERSE: false,
+    NO_UPDATE_DIR_MODTIME: false,
+    REFRESH_TIMES: false,
+    SIZE_ONLY: false,
+    UPDATE: false,
+    FAST_LIST: false,
+    BIND: '',
+    CONTIMEOUT: '',
+    DISABLE_HTTP2: false,
+    TIMEOUT: '',
+    CONFIG: ''
+};
 let HTTP_ADAPTER = adapter_1;
 let KEEP_ALIVE = null;
 let ACCEPT_ENCODING = false;
@@ -335,15 +357,6 @@ function decompressEncoding(value, chunkSize) {
             break;
     }
 }
-function abortHeaders(href, request, options, statusCode = '', message) {
-    const reason = (0, types_1.errorMessage)(statusCode, message || "Aborted by client", href);
-    const outAbort = options.outAbort;
-    if (outAbort) {
-        outAbort.abort(reason);
-        this[kDownloading].delete(outAbort);
-    }
-    request.destroy(reason);
-}
 function resetAria2() {
     clearInterval(ARIA2.PID_TIMER);
     ARIA2.PID_TIMER = null;
@@ -363,27 +376,187 @@ function failedDns(err, pending) {
     }
     pending.length = 0;
 }
-function successDns(instance, value, pending, connected) {
-    instance[kConnectDns][value] = connected;
-    setDnsCache(value, connected, null);
-    if (SUPPORTED_NODE20) {
-        for (const cb of pending) {
-            cb(null, connected);
+function setBinExec(settings, target) {
+    let { bin, exec } = settings;
+    if (bin === false) {
+        target.BIN = '';
+    }
+    else if (bin && module_1.isPath(bin = path.resolve(bin), true)) {
+        target.BIN = bin;
+    }
+    if ((0, types_1.isPlainObject)(exec)) {
+        let { uid, gid } = exec;
+        target.EXEC_UID = (uid = (0, util_1.asInt)(uid)) >= 0 ? uid : undefined;
+        target.EXEC_GID = (gid = (0, util_1.asInt)(gid)) >= 0 ? gid : undefined;
+    }
+}
+function parseBinOpts(instance, options, ignore, skip) {
+    let pathname = options.pathname, binOpts;
+    if (!(0, types_1.isString)(pathname)) {
+        if (!instance.host) {
+            return [];
+        }
+        pathname = process.cwd();
+    }
+    if ((0, types_1.isArray)(options.binOpts)) {
+        let next = false;
+        binOpts = options.binOpts.filter(opt => !((0, types_1.isString)(opt) && /^-[a-z].*$/i.test(opt.trim()))).map((opt) => {
+            if (next) {
+                if (!module_1.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*(.*)$/s.exec(value);
+                        if (match) {
+                            if (ignore.includes(match[1])) {
+                                return [];
+                            }
+                            if (skip.includes(match[1])) {
+                                if (!match[2]) {
+                                    next = true;
+                                }
+                                return [];
+                            }
+                            switch (match[1]) {
+                                case '--version':
+                                case '--help':
+                                    return [];
+                                default:
+                                    return match[3] ? [match[1], (0, types_1.sanitizeArgs)(match[3])] : [match[1]];
+                            }
+                        }
+                    }
+                    else if (value) {
+                        return [(0, types_1.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 => (0, types_1.sanitizeArgs)(item));
+                    }
+                    break;
+            }
+            return [];
+        }).flat();
+    }
+    return [pathname, (0, util_1.parseOutgoingHeaders)(options.headers), binOpts];
+}
+function checkBinTarget(instance, name, uri, pathname, command, binOpts) {
+    if (!(0, types_1.isString)(pathname)) {
+        throw (0, types_1.errorMessage)(name, "Invalid parameters", 'pathname');
+    }
+    pathname = path.resolve(pathname);
+    if ((instance.host || instance.hasPermission('fs') || process.permission) && !instance.canWrite(pathname)) {
+        throw (0, types_1.errorMessage)(name, "Unsupported access", pathname);
+    }
+    let target;
+    switch (command) {
+        case 'copyurl':
+            if (module_1.isDir(pathname) || isDirEnd(pathname)) {
+                target = pathname;
+                if (!binOpts || !binOpts.includes('--auto-filename') && !binOpts.includes('--header-filename')) {
+                    pathname = path.join(pathname, path.basename(new URL(uri).pathname));
+                }
+                break;
+            }
+        case 'copyto':
+            target = isDirEnd(pathname) ? pathname : path.dirname(pathname);
+            break;
+        default:
+            target = pathname;
+            break;
+    }
+    if (!module_1.createDir(target)) {
+        throw (0, types_1.errorMessage)(name, "Path is not a directory", target);
+    }
+    return pathname;
+}
+function checkBinOpts(init, binOpts) {
+    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 {
-        const { address, family } = connected[0];
-        for (const cb of pending) {
-            cb(null, address, family);
+}
+function setBinHeaders(args, headers) {
+    for (const name in headers) {
+        let items = headers[name];
+        if (!Array.isArray(items)) {
+            items = [items.toString()];
         }
+        args.push(...items.map(value => `--header="${name}: ${escapeShellQuote(value)}"`));
+    }
+}
+function finalizeBinArgs(instance, name, bin, args, opts, binOpts, cmd = []) {
+    if ((0, types_1.isArray)(binOpts)) {
+        for (const leading of binOpts) {
+            if (leading.startsWith('-')) {
+                const pattern = new RegExp(`^${leading}(?:=|$)`);
+                for (let i = 0; i < opts.length; ++i) {
+                    if (pattern.test(opts[i])) {
+                        opts.splice(i--, i);
+                        break;
+                    }
+                }
+            }
+        }
+        args = binOpts.concat(args);
+    }
+    if (args.length > 0) {
+        if (module_1.hasLogType(32768)) {
+            instance.formatMessage(32768, name.toUpperCase(), [bin].concat(cmd).join(' '), args.join(' '), { ...module_1.LOG_STYLE_WARN });
+        }
+        else {
+            instance.addLog(types_1.STATUS_TYPE.INFO, path.basename(bin) + ' ' + args.join(' '), name);
+        }
+    }
+    return args;
+}
+function addAria2Proxy(args, protocol, host) {
+    const { origin, username, password } = host;
+    args.push(`--${protocol}-proxy="${origin}"`);
+    if (username) {
+        args.push(`--${protocol}-proxy-user="${escapeShellQuote(decodeURIComponent(username))}"`);
+    }
+    if (password) {
+        args.push(`--${protocol}-proxy-passwd="${escapeShellQuote(decodeURIComponent(password))}"`);
     }
-    pending.length = 0;
 }
-const isFunction = (value) => typeof value === 'function';
+const isConstructor = (value) => typeof value === 'function';
+const isDirEnd = (value) => value.endsWith('/') || value.endsWith(path.sep);
+const trimCharEnd = (value) => value.substring(0, value.length - 1);
 const configureDns = (family, options) => family === 0 ? options : { family, hints: family === 6 ? dns.V4MAPPED : 0 };
-const ignoreOpt = (opts, ...values) => !opts?.some(item => values.includes(item));
+const ignoreOpt = (opts, ...values) => !opts?.some(opt => values.some(value => opt === value || opt.startsWith(value + '=')));
 const escapeQuote = (value) => value.replace(/[\\"]/g, capture => '\\' + capture);
+const rcloneSize = (value) => (0, types_1.isString)(value) ? /^\d+(?:B|K|M|G|T|P)$/.exec(value)?.[0] : undefined;
+const rcloneDuration = (value) => (0, types_1.isString)(value) ? /^\d+(?:h|m|s|ms|ns)$/.exec(value)?.[0] : undefined;
 class Request extends module_1 {
+    static [kRequest] = true;
     static async purgeMemory(percent = 1, limit = 0, parent) {
         if (percent >= 1) {
             resetHttpHost(0);
@@ -403,18 +576,8 @@ class Request extends module_1 {
         }
         const { request, download } = settings;
         if (download?.aria2) {
-            let { bin, exec, update_status, max_concurrent_downloads, max_connection_per_server, check_integrity, bt_stop_timeout, bt_tracker_connect_timeout, bt_tracker_timeout, min_split_size, disk_cache, lowest_speed_limit, always_resume, file_allocation, conf_path } = download.aria2;
-            if (bin === false) {
-                ARIA2.BIN = '';
-            }
-            else if (bin && this.isPath(bin = path.resolve(bin), true)) {
-                ARIA2.BIN = bin;
-            }
-            if ((0, types_1.isPlainObject)(exec)) {
-                let { uid, gid } = exec;
-                ARIA2.EXEC_UID = (uid = (0, util_1.asInt)(uid)) >= 0 ? uid : undefined;
-                ARIA2.EXEC_GID = (gid = (0, util_1.asInt)(gid)) >= 0 ? gid : undefined;
-            }
+            let { update_status, max_concurrent_downloads, max_connection_per_server, check_integrity, bt_stop_timeout, bt_tracker_connect_timeout, bt_tracker_timeout, min_split_size, disk_cache, lowest_speed_limit, always_resume, file_allocation, proxy, no_proxy, conf_path } = download.aria2;
+            setBinExec(download.aria2, ARIA2);
             if ((0, types_1.isPlainObject)(update_status)) {
                 const { interval, broadcast_only } = update_status;
                 if (typeof broadcast_only === 'boolean') {
@@ -425,12 +588,12 @@ class Request extends module_1 {
             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 (typeof check_integrity === 'boolean') {
                 ARIA2.CHECK_INTEGRITY = check_integrity;
             }
+            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;
             }
@@ -466,10 +629,130 @@ class Request extends module_1 {
                         break;
                 }
             }
+            if (proxy) {
+                try {
+                    for (const uri in proxy) {
+                        const host = new URL(uri);
+                        ARIA2.PROXY[trimCharEnd(host.protocol)] = { host };
+                    }
+                }
+                catch {
+                }
+            }
+            else if (proxy === false) {
+                ARIA2.PROXY = {};
+            }
+            if (no_proxy === '' || (0, types_1.isString)(no_proxy)) {
+                ARIA2.NO_PROXY = no_proxy;
+            }
             if (conf_path === '' || (0, types_1.isString)(conf_path) && this.isPath(conf_path = path.resolve(conf_path))) {
                 ARIA2.CONF_PATH = conf_path;
             }
         }
+        if (download?.rclone) {
+            let { check_first, checksum, cutoff_mode, ignore_case_sync, ignore_checksum, ignore_existing, ignore_size, ignore_times, immutable, inplace, max_backlog, max_duration, max_transfer, metadata, modify_window, multi_thread_chunk_size, multi_thread_cutoff, multi_thread_streams, multi_thread_write_buffer_size, no_check_dest, no_traverse, no_update_dir_modtime, refresh_times, size_only, update, fast_list, bind, contimeout, disable_http2, timeout, config } = download.rclone;
+            setBinExec(download.rclone, RCLONE);
+            if (typeof check_first === 'boolean') {
+                RCLONE.CHECK_FIRST = check_first;
+            }
+            if (typeof checksum === 'boolean') {
+                RCLONE.CHECKSUM = checksum;
+            }
+            if ((0, types_1.isString)(cutoff_mode)) {
+                const value = cutoff_mode.toUpperCase();
+                switch (value) {
+                    case 'HARD':
+                    case 'SOFT':
+                    case 'CAUTIOUS':
+                        RCLONE.CUTOFF_MODE = value;
+                        break;
+                }
+            }
+            if (typeof ignore_case_sync === 'boolean') {
+                RCLONE.IGNORE_CASE_SYNC = ignore_case_sync;
+            }
+            if (typeof ignore_checksum === 'boolean') {
+                RCLONE.IGNORE_CHECKSUM = ignore_checksum;
+            }
+            if (typeof ignore_existing === 'boolean') {
+                RCLONE.IGNORE_EXISTING = ignore_existing;
+            }
+            if (typeof ignore_size === 'boolean') {
+                RCLONE.IGNORE_SIZE = ignore_size;
+            }
+            if (typeof ignore_times === 'boolean') {
+                RCLONE.IGNORE_TIMES = ignore_times;
+            }
+            if (typeof immutable === 'boolean') {
+                RCLONE.IMMUTABLE = immutable;
+            }
+            if (typeof inplace === 'boolean') {
+                RCLONE.INPLACE = inplace;
+            }
+            if ((max_backlog = (0, util_1.asInt)(max_backlog)) > 0) {
+                RCLONE.MAX_BACKLOG = max_backlog;
+            }
+            if (max_duration = rcloneDuration(max_duration)) {
+                RCLONE.MAX_DURATION = max_duration;
+            }
+            if (max_transfer = rcloneSize(max_transfer)) {
+                RCLONE.MAX_TRANSFER = max_transfer;
+            }
+            if (typeof metadata === 'boolean') {
+                RCLONE.METADATA = metadata;
+            }
+            if (modify_window = rcloneDuration(modify_window)) {
+                RCLONE.MODIFY_WINDOW = modify_window;
+            }
+            if (multi_thread_chunk_size = rcloneSize(multi_thread_chunk_size)) {
+                RCLONE.MULTI_THREAD_CHUNK_SIZE = multi_thread_chunk_size;
+            }
+            if (multi_thread_cutoff = rcloneSize(multi_thread_cutoff)) {
+                RCLONE.MULTI_THREAD_CUTOFF = multi_thread_cutoff;
+            }
+            if ((multi_thread_streams = (0, util_1.asInt)(multi_thread_streams)) > 0) {
+                RCLONE.MULTI_THREAD_STREAMS = multi_thread_streams;
+            }
+            if (multi_thread_write_buffer_size = rcloneSize(multi_thread_write_buffer_size)) {
+                RCLONE.MULTI_THREAD_WRITE_BUFFER_SIZE = multi_thread_write_buffer_size;
+            }
+            if (typeof no_check_dest === 'boolean') {
+                RCLONE.NO_CHECK_DEST = no_check_dest;
+            }
+            if (typeof no_traverse === 'boolean') {
+                RCLONE.NO_TRAVERSE = no_traverse;
+            }
+            if (typeof no_update_dir_modtime === 'boolean') {
+                RCLONE.NO_UPDATE_DIR_MODTIME = no_update_dir_modtime;
+            }
+            if (typeof refresh_times === 'boolean') {
+                RCLONE.REFRESH_TIMES = refresh_times;
+            }
+            if (typeof size_only === 'boolean') {
+                RCLONE.SIZE_ONLY = size_only;
+            }
+            if (typeof update === 'boolean') {
+                RCLONE.UPDATE = update;
+            }
+            if (typeof fast_list === 'boolean') {
+                RCLONE.FAST_LIST = fast_list;
+            }
+            if (contimeout = rcloneDuration(contimeout)) {
+                RCLONE.CONTIMEOUT = contimeout;
+            }
+            if (typeof bind === 'string') {
+                RCLONE.BIND = bind;
+            }
+            if (typeof disable_http2 === 'boolean') {
+                RCLONE.DISABLE_HTTP2 = disable_http2;
+            }
+            if (timeout = rcloneDuration(timeout)) {
+                RCLONE.TIMEOUT = timeout;
+            }
+            if (config === '' || (0, types_1.isString)(config) && this.isPath(config = path.resolve(config), true)) {
+                RCLONE.CONFIG = config;
+            }
+        }
         if (request) {
             let { read_timeout, agent, use, headers, certs } = request, agent_timeout;
             if ((read_timeout = (0, util_1.fromSeconds)(read_timeout)) >= 0) {
@@ -585,42 +868,51 @@ class Request extends module_1 {
         }
     }
     static defineHttpAdapter(module) {
-        if (isFunction(module) && module.prototype instanceof adapter_1) {
+        if (isConstructor(module) && module.prototype instanceof adapter_1) {
             HTTP_ADAPTER = module;
         }
     }
     static getAria2Path() {
         return ARIA2.BIN;
     }
+    static getRclonePath() {
+        return RCLONE.BIN;
+    }
+    startTime = Date.now();
+    acceptEncoding;
+    keepAlive;
+    readExpect = 'none';
+    readTimeout;
+    proxy = null;
+    module;
+    _moduleName = "request";
+    _threadable = true;
+    _config = {
+        timeout: 60000,
+        connectTimeout: 20 * 1000,
+        redirectLimit: 10,
+        retryWait: 1000,
+        retryAfter: 30 * 1000,
+        retryLimit: 5
+    };
+    #singleton = false;
+    #httpVersion = null;
+    #ipVersion;
+    #agentTimeout;
+    #headers = null;
+    #certs = null;
+    #baseUrl = null;
+    #connectDns = Object.create(null);
+    #pendingDns = Object.create(null);
+    #connectHttp = [{}, {}];
+    #statusOn = null;
+    #headersOn = null;
+    #adapter = HTTP_ADAPTER;
+    #downloading = new Set();
+    #hostInfo = {};
+    #session = [Object.create(null)];
     constructor(data) {
         super();
-        this.startTime = Date.now();
-        this.readExpect = 'none';
-        this.proxy = null;
-        this._moduleName = "request";
-        this._threadable = true;
-        this._config = {
-            timeout: 60000,
-            connectTimeout: 20 * 1000,
-            redirectLimit: 10,
-            retryWait: 1000,
-            retryAfter: 30 * 1000,
-            retryLimit: 5
-        };
-        this[_a] = false;
-        this[_b] = null;
-        this[_c] = null;
-        this[_d] = null;
-        this[_e] = null;
-        this[_f] = Object.create(null);
-        this[_g] = Object.create(null);
-        this[_h] = [{}, {}];
-        this[_j] = null;
-        this[_k] = null;
-        this[_l] = HTTP_ADAPTER;
-        this[_m] = new Set();
-        this[_o] = {};
-        this[_p] = [Object.create(null)];
         if ((0, types_1.isPlainObject)(data)) {
             const { headers, read_timeout, agent, use, connect, certs } = data;
             const timeout = (0, util_1.fromSeconds)(data.timeout);
@@ -629,14 +921,14 @@ class Request extends module_1 {
             this.keepAlive = typeof (value = agent?.keep_alive) === 'boolean' ? value : KEEP_ALIVE;
             this.acceptEncoding = typeof (value = use?.accept_encoding) === 'boolean' ? value : ACCEPT_ENCODING;
             if ((value = (0, util_1.asInt)(use?.http_version)) === 1 || value === 2) {
-                this[kHttpVersion] = value;
+                this.#httpVersion = value;
             }
-            this[kIpVersion] = (value = (0, util_1.asInt)(data.dns?.family)) && (value === 4 || value === 6) ? value : 0;
+            this.#ipVersion = (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;
+                this.#agentTimeout = value;
             }
             else {
-                this[kAgentTimeout] = AGENT_TIMEOUT;
+                this.#agentTimeout = AGENT_TIMEOUT;
                 value = undefined;
             }
             const proxy = getProxySettings(data, value);
@@ -644,10 +936,10 @@ class Request extends module_1 {
                 this.proxy = proxy;
             }
             if ((0, types_1.isObject)(headers)) {
-                setOutgoingHeaders(this[kHeaders] = {}, headers);
+                setOutgoingHeaders(this.#headers = {}, headers);
             }
             if ((0, types_1.isObject)(certs)) {
-                this[kCerts] = validateCerts(certs);
+                this.#certs = validateCerts(certs);
             }
             if ((0, types_1.isObject)(connect)) {
                 this.apply({ client: {
@@ -668,21 +960,21 @@ class Request extends module_1 {
             this.readTimeout = READ_TIMEOUT;
             this.keepAlive = KEEP_ALIVE;
             this.acceptEncoding = ACCEPT_ENCODING;
-            this[kAgentTimeout] = AGENT_TIMEOUT;
-            this[kIpVersion] = DNS.FAMILY;
+            this.#agentTimeout = AGENT_TIMEOUT;
+            this.#ipVersion = DNS.FAMILY;
         }
         this.module = data;
     }
     flushLog() {
         const log = this._logQueued;
-        if (this[kSingleton]) {
+        if (this.#singleton) {
             log.length = 0;
         }
         else {
             if (log.length > 0 && !this.host?.aborted) {
                 const output = [];
                 let count = 0;
-                this[kConnectHttp].forEach((protocol, index) => {
+                this.#connectHttp.forEach((protocol, index) => {
                     const title = 'HTTP' + (index + 1);
                     for (const origin in protocol) {
                         const value = protocol[origin];
@@ -731,22 +1023,22 @@ class Request extends module_1 {
             }
             super.flushLog();
         }
-        this[kConnectHttp] = [{}, {}];
+        this.#connectHttp = [{}, {}];
     }
     detach(singleton) {
         if (typeof singleton === 'boolean') {
-            this[kSingleton] = singleton;
+            this.#singleton = singleton;
         }
         if (singleton !== false) {
             super.detach();
         }
     }
     abort(reason) {
-        for (const item of this[kDownloading]) {
+        for (const item of this.#downloading) {
             item.abort(reason);
         }
         this.close();
-        if (!this[kSingleton]) {
+        if (!this.#singleton) {
             super.abort(reason);
         }
     }
@@ -754,7 +1046,7 @@ class Request extends module_1 {
         if (config) {
             const { headers, httpVersion, ipVersion, readTimeout } = config;
             if ((0, types_1.isObject)(headers)) {
-                setOutgoingHeaders(this[kHeaders] ||= {}, headers);
+                setOutgoingHeaders(this.#headers ||= {}, headers);
             }
             if (httpVersion !== undefined) {
                 this.httpVersion = httpVersion;
@@ -841,10 +1133,10 @@ class Request extends module_1 {
                 }
                 break;
         }
-        setDnsCache(hostname, this[kConnectDns][hostname] = [{ address, family }], timeout);
+        setDnsCache(hostname, this.#connectDns[hostname] = [{ address, family }], timeout);
     }
     lookupDns(hostname) {
-        const resolved = this[kConnectDns][hostname] || DNS.CACHE[hostname];
+        const resolved = this.#connectDns[hostname] || DNS.CACHE[hostname];
         if (resolved) {
             return (...args) => {
                 if (SUPPORTED_NODE20) {
@@ -855,13 +1147,29 @@ class Request extends module_1 {
                 }
             };
         }
-        const pending = this[kPendingDns][hostname] ||= [];
+        const pending = this.#pendingDns[hostname] ||= [];
+        const successDns = (value, connected) => {
+            this.#connectDns[value] = connected;
+            setDnsCache(value, connected, null);
+            if (SUPPORTED_NODE20) {
+                for (const cb of pending) {
+                    cb(null, connected);
+                }
+            }
+            else {
+                const { address, family } = connected[0];
+                for (const cb of pending) {
+                    cb(null, address, family);
+                }
+            }
+            pending.length = 0;
+        };
         return (value, options, callback) => {
             if (pending.push(callback) === 1) {
                 let ipVersion = this.ipVersion;
                 dns.lookup(value, configureDns(ipVersion, options), (err, address, family) => {
                     if (!err) {
-                        successDns(this, value, pending, typeof address === 'string' ? [{ address, family }] : address);
+                        successDns(value, typeof address === 'string' ? [{ address, family }] : address);
                         return;
                     }
                     switch (err.code) {
@@ -886,7 +1194,7 @@ class Request extends module_1 {
                     }
                     dns.lookup(value, configureDns(ipVersion, options), (err, address, family) => {
                         if (!err) {
-                            successDns(this, value, pending, typeof address === 'string' ? [{ address, family }] : address);
+                            successDns(value, typeof address === 'string' ? [{ address, family }] : address);
                         }
                         else {
                             failedDns(err, pending);
@@ -932,7 +1240,7 @@ class Request extends module_1 {
             globUrl = '*';
         }
         if ((0, types_1.isString)(globUrl) && typeof callback === 'function') {
-            const on = this[kStatusOn] ||= new Map();
+            const on = this.#statusOn ||= new Map();
             for (const item of !Array.isArray(code) ? [code] : code) {
                 let status = on.get(item);
                 if (!status) {
@@ -948,7 +1256,7 @@ class Request extends module_1 {
             globUrl = '*';
         }
         if ((0, types_1.isString)(globUrl) && typeof callback === 'function') {
-            const on = this[kHeadersOn] ||= new Map();
+            const on = this.#headersOn ||= new Map();
             for (const item of !Array.isArray(name) ? [name] : name) {
                 let headers = on.get(item);
                 if (!headers) {
@@ -959,86 +1267,31 @@ class Request extends module_1 {
         }
     }
     headersOf(uri) {
-        const headers = this[kHeaders];
+        const headers = this.#headers;
         return headers && getBaseHeaders(uri, headers) || (this.host ? getBaseHeaders(uri, HTTP.HEADERS) : undefined);
     }
-    async aria2c(uri, options) {
+    async aria2c(uri, options = {}) {
         if (!ARIA2.BIN) {
             return Promise.reject((0, types_1.errorMessage)("aria2", "Binary not found"));
         }
-        if (typeof uri === 'string' && module_1.isURL(uri)) {
-            uri = new URL(uri);
-        }
         let pathname, headers, binOpts, signal, silent;
-        if (options) {
-            if (typeof options === 'string') {
-                pathname = options;
-            }
-            else {
-                ({ pathname, binOpts, signal, silent } = options);
-                headers = (0, util_1.parseOutgoingHeaders)(options.headers);
-                if ((0, types_1.isArray)(binOpts)) {
-                    let next = false;
-                    binOpts = binOpts.filter(opt => !((0, types_1.isString)(opt) && /^-[a-z].*$/i.test(opt.trim()))).map((opt) => {
-                        if (next) {
-                            if (!module_1.asString(opt).startsWith('--')) {
-                                return [];
-                            }
-                            next = false;
-                        }
-                        switch (typeof opt) {
-                            case 'string': {
-                                const value = opt.trim();
-                                if (value.startsWith('--')) {
-                                    const match = /^(--[a-z]+[a-z0-9-]*)(=)?\s*(.*)$/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.sanitizeArgs(match[3])] : [match[1]];
-                                        }
-                                    }
-                                }
-                                else if (value) {
-                                    return [module_1.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.sanitizeArgs(item));
-                                }
-                                break;
-                        }
-                        return [];
-                    }).flat();
-                }
-            }
+        if ((0, types_1.isString)(options)) {
+            pathname = options;
         }
-        if (!pathname) {
-            if (this.host) {
-                return Promise.reject((0, types_1.errorMessage)("aria2", "Invalid parameters", 'pathname'));
-            }
-            pathname = process.cwd();
+        else {
+            ({ signal, silent } = options);
+            [pathname, headers, binOpts] = parseBinOpts(this, options, ['--daemon'], ['--input-file']);
         }
-        if ((this.host || this.hasOwnPermission()) && !this.canWrite(pathname = path.resolve(pathname.trim()))) {
-            return Promise.reject((0, types_1.errorMessage)("aria2", "Unsupported access", pathname));
+        try {
+            if (typeof uri === 'string' && module_1.isURL(uri)) {
+                uri = new URL(uri);
+            }
+            pathname = checkBinTarget(this, "aria2", uri, pathname, 'aria2', binOpts);
         }
-        if (!module_1.createDir(pathname)) {
-            return Promise.reject((0, types_1.errorMessage)("aria2", "Path is not a directory", pathname));
+        catch (err) {
+            return Promise.reject(err);
         }
-        silent ??= this[kSingleton];
+        silent ??= this.#singleton;
         return new Promise((resolve, reject) => {
             let protocol, origin, username, password;
             if (uri instanceof URL) {
@@ -1059,31 +1312,7 @@ class Request extends module_1 {
                 '--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;
-            }
+            checkBinOpts(init, binOpts);
             const { connectTimeout, timeout, retryWait, retryLimit } = this._config;
             const opts = [
                 '--log-level=warn',
@@ -1093,6 +1322,7 @@ class Request extends module_1 {
                 '--file-allocation=' + ARIA2.FILE_ALLOCATION,
                 '--max-tries=' + (retryLimit + 1)
             ];
+            let args = [];
             if (ARIA2.MAX_CONCURRENT_DOWNLOADS) {
                 opts.push('--max-concurrent-downloads=' + ARIA2.MAX_CONCURRENT_DOWNLOADS);
             }
@@ -1126,6 +1356,10 @@ class Request extends module_1 {
             if (retryWait > 0) {
                 opts.push('--retry-wait=' + Math.min(Math.ceil(retryWait / 1000), 600));
             }
+            if (ARIA2.NO_PROXY) {
+                opts.push(`--no-proxy="${ARIA2.NO_PROXY}"`);
+            }
+            let proxy;
             if (protocol) {
                 if (this.agentTimeout === 0) {
                     opts.push('--enable-http-keep-alive=false');
@@ -1135,16 +1369,10 @@ class Request extends module_1 {
                     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}: ${escapeShellQuote(value)}"`));
-                    }
+                    setBinHeaders(args, headers);
                 }
                 if (origin) {
-                    const secure = this[kCerts]?.[1][origin] || this.host && TLS.FILE[origin];
+                    const secure = this.#certs?.[1][origin] || this.host && TLS.FILE[origin];
                     if (secure) {
                         if (secure.ca && ignoreOpt(binOpts, '--ca-certificate')) {
                             args.push(`--ca-certificate="${escapeShellQuote(secure.ca)}"`);
@@ -1157,7 +1385,7 @@ class Request extends module_1 {
                         }
                     }
                 }
-                switch (protocol = protocol.substring(0, protocol.length - 1)) {
+                switch (protocol = trimCharEnd(protocol)) {
                     case 'http':
                     case 'https':
                         if (ignoreOpt(binOpts, '--http-no-cache')) {
@@ -1173,54 +1401,33 @@ class Request extends module_1 {
                                 args.push(`--${prefix}-passwd="${escapeShellQuote(decodeURIComponent(password))}"`);
                             }
                         }
-                        const proxy = this.proxyOf(uri);
-                        if (proxy && ignoreOpt(binOpts, `--${protocol}-proxy-user`, `--${protocol}-proxy-passwd`)) {
-                            ({ origin, username, password } = proxy.host);
-                            if (ignoreOpt(binOpts, `--${protocol}-proxy`)) {
-                                args.push(`--${protocol}-proxy="${origin}"`);
-                            }
-                            if (username) {
-                                args.push(`--${protocol}-proxy-user="${escapeShellQuote(decodeURIComponent(username))}"`);
-                            }
-                            if (password) {
-                                args.push(`--${protocol}-proxy-passwd="${escapeShellQuote(decodeURIComponent(password))}"`);
-                            }
+                        if (ignoreOpt(binOpts, `--${protocol}-proxy`, `--${protocol}-proxy-user`, `--${protocol}-proxy-passwd`)) {
+                            proxy = this.proxyOf(uri) || ARIA2.PROXY[protocol];
                         }
                         break;
                     }
                 }
             }
-            if (binOpts) {
-                for (const leading of binOpts) {
-                    if (leading.startsWith('-')) {
-                        const pattern = new RegExp(`^${leading}(?:=|$)`);
-                        for (let i = 0; i < opts.length; ++i) {
-                            if (pattern.test(opts[i])) {
-                                opts.splice(i--, i);
-                                break;
-                            }
-                        }
-                    }
-                }
-                args = binOpts.concat(args);
+            if (proxy) {
+                addAria2Proxy(args, protocol, proxy.host);
             }
-            if (args.length > 0) {
-                if (module_1.hasLogType(32768)) {
-                    this.formatMessage(32768, 'ARIA2', ARIA2.BIN, args.join(' '), { ...module_1.LOG_STYLE_WARN });
-                }
-                else {
-                    this.addLog(types_1.STATUS_TYPE.INFO, path.basename(ARIA2.BIN) + ' ' + args.join(' '), "aria2");
-                }
+            else if (ARIA2.PROXY.all) {
+                addAria2Proxy(opts, 'all', ARIA2.PROXY.all.host);
             }
+            args = finalizeBinArgs(this, "aria2", ARIA2.BIN, args, opts, binOpts);
             opts.push(`"${escapeShellQuote(uri)}"`);
             args = args.concat(init, opts);
             const startTime = Date.now();
             let out = '', message = '';
+            const commitLog = (type, msg) => {
+                const timeStamp = Date.now();
+                this.addLog(type, msg, { timeStamp, duration: timeStamp - startTime, from: "aria2", source: uri });
+            };
             const errorResponse = (pid, err) => {
                 closeTorrent(pid);
                 reject(err);
             };
-            const { pid, stdout, stderr } = child_process.spawn(module_1.sanitizeCmd(ARIA2.BIN), args, { cwd: pathname, shell: true, signal: this.signal, uid: ARIA2.EXEC_UID, gid: ARIA2.EXEC_GID })
+            const { pid, stdout, stderr } = child_process.spawn((0, types_1.sanitizeCmd)(ARIA2.BIN), args, { cwd: pathname, shell: true, signal: signal || this.signal, uid: ARIA2.EXEC_UID, gid: ARIA2.EXEC_GID })
                 .on('exit', code => {
                 closeTorrent(pid);
                 if (this.aborted) {
@@ -1231,7 +1438,6 @@ class Request extends module_1 {
                     reject((0, types_1.errorValue)(message || "Unknown", 'Exit status: ' + code));
                     return;
                 }
-                const currentTime = Date.now();
                 const result = [];
                 let messageUnit;
                 for (const match of out.matchAll(/\|(OK|ERR|INPR)\s*\|\s*([^|]+)\|\s*(\d+)\|([^\n]+)/g)) {
@@ -1250,7 +1456,7 @@ class Request extends module_1 {
                                 }
                             case 'ERR':
                                 fs.unlink(file, err => {
-                                    if (err && !silent && !this[kSingleton]) {
+                                    if (err && !silent && !this.#singleton) {
                                         this.writeFail(["Unable to delete file", path.basename(file)], err, { type: 32, fatal: false });
                                     }
                                 });
@@ -1262,18 +1468,18 @@ class Request extends module_1 {
                     if (!silent && LOG_HTTP && LOG_TIMEPROCESS) {
                         this.writeTimeProcess("aria2", uri, startTime, { type: 1024, queue: true, messageUnit, messageUnitMinWidth: 9, bypassLog: true });
                     }
-                    this.addLog(types_1.STATUS_TYPE.INFO, out, currentTime, currentTime - startTime, "aria2", uri);
+                    commitLog(types_1.STATUS_TYPE.INFO, out);
                 }
                 else {
-                    this.addLog(types_1.STATUS_TYPE.ERROR, "No files were successfully downloaded", currentTime, currentTime - startTime, "aria2", uri);
+                    commitLog(types_1.STATUS_TYPE.ERROR, "No files were successfully downloaded");
                 }
                 resolve(result);
             })
                 .on('error', err => {
                 errorResponse(pid, err);
             });
-            stdout.setEncoding('utf-8').on('data', (value) => out += value);
-            stderr.setEncoding('utf-8').on('data', (value) => message += value);
+            stdout.setEncoding('utf8').on('data', (value) => out += value);
+            stderr.setEncoding('utf8').on('data', (value) => message += value);
             if (pid !== undefined && module_1.isFile(uri, 'torrent')) {
                 if (!ARIA2.PID_TIMER) {
                     ARIA2.PID_TIMER = setInterval(() => {
@@ -1320,6 +1526,231 @@ class Request extends module_1 {
             }
         });
     }
+    async rclone(uri, options = {}) {
+        if (!RCLONE.BIN) {
+            return Promise.reject((0, types_1.errorMessage)("rclone", "Binary not found"));
+        }
+        let pathname, headers, binOpts, silent;
+        if ((0, types_1.isString)(options)) {
+            pathname = options;
+            options = {};
+        }
+        else {
+            silent = options.silent;
+            [pathname, headers, binOpts] = parseBinOpts(this, options, ['--interactive', '--dry-run'], ['--partial-suffix', '--verbose']);
+        }
+        const command = options.command || 'copy';
+        let source;
+        switch (command) {
+            case 'copy':
+            case 'copyto':
+                if (module_1.isURL(source = uri.replace(/^rclone:\?/i, ''))) {
+                    return Promise.reject((0, types_1.errorMessage)("rclone", "Unsupported protocol", uri));
+                }
+                break;
+            case 'copyurl':
+                if (!module_1.isURL(source = uri)) {
+                    return Promise.reject((0, types_1.errorMessage)("rclone", "Unsupported protocol", uri));
+                }
+                break;
+            default:
+                return Promise.reject((0, types_1.errorMessage)("rclone", "Invalid command", command || uri));
+        }
+        try {
+            pathname = checkBinTarget(this, "rclone", uri, pathname, command, binOpts);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+        silent ??= this.#singleton;
+        return new Promise((resolve, reject) => {
+            const init = [
+                '--links=false',
+                '--delete-excluded=false',
+                '--interactive=false',
+                '--dry-run=false',
+                '--log-level=INFO',
+                '--use-json-log'
+            ];
+            const opts = [];
+            let args = [];
+            if (typeof options.update === 'boolean') {
+                init.push('--update=' + options.update.toString());
+                checkBinOpts(init, binOpts);
+            }
+            else {
+                checkBinOpts(init, binOpts);
+                if (RCLONE.UPDATE) {
+                    opts.push('--update');
+                }
+            }
+            if (RCLONE.CHECK_FIRST) {
+                opts.push('--check-first');
+            }
+            if (RCLONE.CHECKSUM) {
+                opts.push('--checksum');
+            }
+            if (RCLONE.CUTOFF_MODE) {
+                opts.push('--cutoff-mode=' + RCLONE.CUTOFF_MODE);
+            }
+            if (RCLONE.IGNORE_CASE_SYNC) {
+                opts.push('--ignore-case-sync');
+            }
+            if (RCLONE.IGNORE_CHECKSUM) {
+                opts.push('--ignore-checksum');
+            }
+            if (RCLONE.IGNORE_EXISTING) {
+                opts.push('--ignore-existing');
+            }
+            if (RCLONE.IGNORE_SIZE) {
+                opts.push('--ignore-size');
+            }
+            if (RCLONE.IGNORE_TIMES) {
+                opts.push('--ignore-times');
+            }
+            if (RCLONE.IMMUTABLE) {
+                opts.push('--immutable');
+            }
+            if (RCLONE.INPLACE) {
+                opts.push('--inplace');
+            }
+            if (RCLONE.MAX_BACKLOG > 0) {
+                opts.push('--max-backlog=' + RCLONE.MAX_BACKLOG);
+            }
+            if (RCLONE.MAX_DURATION) {
+                opts.push('--max-duration=' + RCLONE.MAX_DURATION);
+            }
+            if (RCLONE.MAX_TRANSFER) {
+                opts.push('--max-transfer=' + RCLONE.MAX_TRANSFER);
+            }
+            if (RCLONE.METADATA) {
+                opts.push('--metadata');
+            }
+            if (RCLONE.MODIFY_WINDOW) {
+                opts.push('--modify-window=' + RCLONE.MODIFY_WINDOW);
+            }
+            if (RCLONE.MULTI_THREAD_CHUNK_SIZE) {
+                opts.push('--multi-thread-chunk-size=' + RCLONE.MULTI_THREAD_CHUNK_SIZE);
+            }
+            if (RCLONE.MULTI_THREAD_CUTOFF) {
+                opts.push('--multi-thread-chunk-size=' + RCLONE.MULTI_THREAD_CUTOFF);
+            }
+            if (RCLONE.MULTI_THREAD_STREAMS) {
+                opts.push('--multi-thread-streams=' + RCLONE.MULTI_THREAD_STREAMS);
+            }
+            if (RCLONE.MULTI_THREAD_WRITE_BUFFER_SIZE) {
+                opts.push('--multi-thread-buffer-size=' + RCLONE.MULTI_THREAD_WRITE_BUFFER_SIZE);
+            }
+            if (RCLONE.NO_CHECK_DEST) {
+                opts.push('--no-check-dest');
+            }
+            if (RCLONE.NO_TRAVERSE) {
+                opts.push('--no-traverse');
+            }
+            if (RCLONE.NO_UPDATE_DIR_MODTIME) {
+                opts.push('--no-update-dir-modtime');
+            }
+            if (RCLONE.REFRESH_TIMES) {
+                opts.push('--refresh-times');
+            }
+            if (RCLONE.SIZE_ONLY) {
+                opts.push('--size-only');
+            }
+            if (RCLONE.FAST_LIST) {
+                opts.push('--fast-list');
+            }
+            if (RCLONE.BIND) {
+                opts.push('--bind=' + RCLONE.BIND);
+            }
+            if (RCLONE.CONTIMEOUT) {
+                opts.push('--contimeout=' + RCLONE.CONTIMEOUT);
+            }
+            else if (this._config.connectTimeout > 0) {
+                opts.push(`--contimeout=${this._config.connectTimeout}ms`);
+            }
+            if (RCLONE.DISABLE_HTTP2) {
+                opts.push('--disable-http2');
+            }
+            if (RCLONE.TIMEOUT) {
+                opts.push('--timeout=' + RCLONE.TIMEOUT);
+            }
+            else if (this._config.timeout > 0) {
+                opts.push(`--timeout=${this._config.timeout}ms`);
+            }
+            if (RCLONE.CONFIG) {
+                opts.push(`--config="${escapeShellQuote(RCLONE.CONFIG)}"`);
+            }
+            setBinHeaders(args, headers);
+            const cwd = module_1.isDir(pathname) ? pathname : path.dirname(pathname);
+            const cmd = [source, pathname];
+            args = finalizeBinArgs(this, "rclone", RCLONE.BIN, args, opts, binOpts, cmd).concat(init, opts);
+            args.push(...cmd.map(value => (0, types_1.sanitizeCmd)(value)));
+            args.unshift(command);
+            const startTime = Date.now();
+            const out = [];
+            const commitLog = (type, msg) => {
+                const timeStamp = Date.now();
+                this.addLog(type, msg, { timeStamp, duration: timeStamp - startTime, from: "rclone", source });
+            };
+            const parseOutput = (value) => {
+                try {
+                    const data = JSON.parse(value);
+                    if ((0, types_1.isPlainObject)(data)) {
+                        switch (data.level) {
+                            case 'info':
+                                if (data.size > 0 && (0, types_1.isString)(data.object)) {
+                                    out.push(data);
+                                }
+                                else if ((0, types_1.isPlainObject)(data.stats)) {
+                                    if (data.stats.fatalError) {
+                                        commitLog(types_1.STATUS_TYPE.ERROR, data.msg);
+                                    }
+                                    else {
+                                        if (command === 'copyurl' && data.stats.totalTransfers > 0) {
+                                            data.object = module_1.isPath(pathname, true) ? pathname : '';
+                                            out.push(data);
+                                        }
+                                        commitLog(types_1.STATUS_TYPE.INFO, data.msg);
+                                    }
+                                }
+                                break;
+                            case 'error':
+                                commitLog(types_1.STATUS_TYPE.ERROR, data.msg);
+                                break;
+                        }
+                    }
+                }
+                catch (err) {
+                    commitLog(types_1.STATUS_TYPE.ERROR, err);
+                }
+            };
+            const { stdout, stderr } = child_process.spawn((0, types_1.sanitizeCmd)(RCLONE.BIN), args, { cwd, shell: true, signal: this.signal, uid: RCLONE.EXEC_UID, gid: RCLONE.EXEC_GID })
+                .on('exit', code => {
+                if (options.signal || this.aborted) {
+                    reject((0, types_1.createAbortError)());
+                    return;
+                }
+                if (code) {
+                    reject((0, types_1.errorValue)("Unknown", 'Exit status: ' + code));
+                    return;
+                }
+                if (out.length > 0 && !silent && LOG_HTTP && LOG_TIMEPROCESS) {
+                    this.writeTimeProcess("rclone", source, startTime, { type: 1024, queue: true, bypassLog: true });
+                }
+                const result = out.map(item => command === 'copyurl' ? item.object : path.join(cwd, item.object));
+                if (out.length > 0) {
+                    commitLog(types_1.STATUS_TYPE.INFO, result);
+                }
+                else {
+                    commitLog(types_1.STATUS_TYPE.ERROR, "No files were successfully downloaded");
+                }
+                resolve(result);
+            })
+                .on('error', reject);
+            stdout.setEncoding('utf8').on('data', parseOutput);
+            stderr.setEncoding('utf8').on('data', parseOutput);
+        });
+    }
     async json(uri, options = {}) {
         options.format = 'json';
         return this.get(uri, options);
@@ -1329,7 +1760,7 @@ class Request extends module_1 {
         return this.get(uri, options);
     }
     opts(url, options) {
-        const base = this[kBaseURL];
+        const base = this.#baseUrl;
         if (base) {
             if (typeof url === 'string') {
                 url = new URL(url, base[0]);
@@ -1346,7 +1777,7 @@ class Request extends module_1 {
             host = HTTP.HOST[url.origin] ||= new host_1(url, HTTP.VERSION);
         }
         else {
-            host = this[kHostInfo][url.origin] ||= new host_1(url, this.httpVersion || 1);
+            host = this.#hostInfo[url.origin] ||= new host_1(url, this.httpVersion || 1);
         }
         return { ...options, host, url };
     }
@@ -1397,7 +1828,7 @@ class Request extends module_1 {
             url = uri;
             uri = url.toString();
         }
-        const base = this[kBaseURL];
+        const base = this.#baseUrl;
         if (!host) {
             ({ host, url } = this.opts(url || uri, { base: options.base }));
             options.host = host;
@@ -1416,7 +1847,7 @@ class Request extends module_1 {
             options.url = url;
         }
         if (options.base) {
-            this[kBaseURL] = [url, httpVersion, headers];
+            this.#baseUrl = [url, httpVersion, headers];
         }
         else if (base) {
             httpVersion ??= base[1];
@@ -1458,13 +1889,13 @@ class Request extends module_1 {
             expectContinue = false;
         }
         if (secure) {
-            const certs = this[kCerts]?.[0][origin] || this.host && TLS.TEXT[origin];
+            const certs = this.#certs?.[0][origin] || this.host && TLS.TEXT[origin];
             if (certs) {
                 ({ ca, cert, key, ciphers, version: minVersion } = certs);
             }
         }
         if (!proxy && httpVersion !== 1 && ((httpVersion || host.version) === 2 && version !== 1 || secure && version === 2 && host.failed(2, true) === 0)) {
-            request = (this[kSession][0][origin] ||= http2.connect(origin, { lookup: this.lookupDns(hostname), ca, cert, key, ciphers, minVersion, settings: host.localhost ? { maxFrameSize: 16777215, enablePush: false } : { enablePush: false } })).request({ ...baseHeaders, ...host_1.getBasicAuth(url), ...headers, ':path': pathname, ':method': method });
+            request = (this.#session[0][origin] ||= http2.connect(origin, { lookup: this.lookupDns(hostname), ca, cert, key, ciphers, minVersion, settings: host.localhost ? { maxFrameSize: 16777215, enablePush: false } : { enablePush: false } })).request({ ...baseHeaders, ...host_1.getBasicAuth(url), ...headers, ':path': pathname, ':method': method });
             if (getting) {
                 const listenerMap = {};
                 const onEvent = request.on.bind(request);
@@ -1473,7 +1904,7 @@ class Request extends module_1 {
                 request.on('response', response => {
                     const statusCode = response[':status'];
                     if (expectContinue) {
-                        abortHeaders.call(this, url.href, request, options, statusCode, "Did not receive continue acknowledgment");
+                        this.abortHeaders(url.href, request, options, statusCode, "Did not receive continue acknowledgment");
                         return;
                     }
                     connected = true;
@@ -1502,7 +1933,7 @@ class Request extends module_1 {
                             }
                         }
                         if (LOG_HTTP) {
-                            this[kConnectHttp][1][origin] = (this[kConnectHttp][1][origin] || 0) + 1;
+                            this.#connectHttp[1][origin] = (this.#connectHttp[1][origin] || 0) + 1;
                         }
                     }
                     this.matchHeaders(url, response, request, options);
@@ -1556,7 +1987,7 @@ class Request extends module_1 {
                     try {
                         keepAlive ??= proxy.keepAlive;
                         agentTimeout ??= proxy.agentTimeout;
-                        const proxyHeaders = this[kHeaders] && getBaseHeaders(proxy.host.href, this[kHeaders]) || getBaseHeaders(proxy.host.href, HTTP.HEADERS);
+                        const proxyHeaders = this.#headers && getBaseHeaders(proxy.host.href, this.#headers) || getBaseHeaders(proxy.host.href, HTTP.HEADERS);
                         agent = require(pkg)(proxy.host, (typeof keepAlive === 'boolean' || agentTimeout > 0) && agentTimeout !== 0 ? { keepAlive: keepAlive ?? true, timeout: agentTimeout, headers: proxyHeaders } : { headers: proxyHeaders });
                     }
                     catch (err) {
@@ -1652,7 +2083,7 @@ class Request extends module_1 {
                         }
                     }
                     if (LOG_HTTP) {
-                        this[kConnectHttp][0][origin] = (this[kConnectHttp][0][origin] || 0) + 1;
+                        this.#connectHttp[0][origin] = (this.#connectHttp[0][origin] || 0) + 1;
                     }
                 }
                 else {
@@ -1667,7 +2098,7 @@ class Request extends module_1 {
                         request.emit('end');
                     });
                     if (expectContinue) {
-                        abortHeaders.call(this, url.href, request, options, statusCode, "Did not receive continue acknowledgment");
+                        this.abortHeaders(url.href, request, options, statusCode, "Did not receive continue acknowledgment");
                         return;
                     }
                 }
@@ -1685,7 +2116,7 @@ class Request extends module_1 {
         }
         if (getting || posting) {
             const ac = new AbortController();
-            this[kDownloading].add(options.outAbort = ac);
+            this.#downloading.add(options.outAbort = ac);
             stream.addAbortSignal(ac.signal, request);
             if (options.signal) {
                 stream.addAbortSignal(options.signal, request);
@@ -1885,11 +2316,11 @@ class Request extends module_1 {
         return this.get(uri, options);
     }
     async get(uri, options) {
-        const opts = (typeof options === 'string' ? { format: options, encoding: 'utf-8' } : options || {});
+        const opts = (typeof options === 'string' ? { format: options, encoding: 'utf8' } : options || {});
         if (this.readExpect === 'string') {
             opts.encoding = (0, types_1.getEncoding)(opts.encoding);
         }
-        const singleton = this[kSingleton];
+        const singleton = this.#singleton;
         const verbose = !opts.silent && !singleton || opts.silent === false;
         const log = verbose && LOG_HTTP && LOG_TIMEPROCESS;
         const state = Object.freeze({
@@ -1898,7 +2329,7 @@ class Request extends module_1 {
             singleton,
             config: this._config
         });
-        return new this[kAdapter](this, state, uri, opts).start();
+        return new this.#adapter(this, state, uri, opts).start();
     }
     reset(adapter) {
         if (adapter) {
@@ -1908,26 +2339,26 @@ class Request extends module_1 {
             }
             const ac = adapter.abortController;
             if (ac) {
-                this[kDownloading].delete(ac);
+                this.#downloading.delete(ac);
                 adapter.abortController = null;
             }
             return;
         }
-        this[kPendingDns] = Object.create(null);
-        this[kDownloading].clear();
+        this.#pendingDns = Object.create(null);
+        this.#downloading.clear();
     }
     close() {
-        const session = this[kSession];
+        const session = this.#session;
         session.forEach((protocol, index) => {
             for (const host in protocol) {
                 protocol[host].close();
             }
             session[index] = Object.create(null);
         });
-        this[kDownloading].clear();
+        this.#downloading.clear();
     }
     matchStatus(code, url, headers, request, options) {
-        const status = this[kStatusOn]?.get(code);
+        const status = this.#statusOn?.get(code);
         if (status) {
             const href = url.href;
             const called = new Set();
@@ -1939,7 +2370,7 @@ class Request extends module_1 {
             for (const callback of called) {
                 try {
                     if (callback(code, headers, url) === true) {
-                        abortHeaders.call(this, href, request, options, code);
+                        this.abortHeaders(href, request, options, code);
                         return false;
                     }
                 }
@@ -1951,7 +2382,7 @@ class Request extends module_1 {
         return true;
     }
     matchHeaders(url, headers, request, options) {
-        const on = this[kHeadersOn];
+        const on = this.#headersOn;
         if (on?.size) {
             const href = url.href;
             const called = new Map();
@@ -1971,7 +2402,7 @@ class Request extends module_1 {
             for (const [callback, data] of called) {
                 try {
                     if (callback(data, url) === true) {
-                        abortHeaders.call(this, href, request, options);
+                        this.abortHeaders(href, request, options);
                         return false;
                     }
                 }
@@ -1982,50 +2413,58 @@ class Request extends module_1 {
         }
         return true;
     }
+    abortHeaders(href, request, options, statusCode = '', message = "Aborted by client") {
+        const reason = (0, types_1.errorMessage)(statusCode, message, href);
+        const outAbort = options.outAbort;
+        if (outAbort) {
+            outAbort.abort(reason);
+            this.#downloading.delete(outAbort);
+        }
+        request.destroy(reason);
+    }
     set adapter(value) {
-        if (isFunction(value) && value.prototype instanceof adapter_1) {
-            this[kAdapter] = value;
+        if (isConstructor(value) && value.prototype instanceof adapter_1) {
+            this.#adapter = value;
         }
     }
     set agentTimeout(value) {
         if (value > 0) {
-            this[kAgentTimeout] = value;
+            this.#agentTimeout = value;
             this.keepAlive ??= true;
         }
         else {
-            this[kAgentTimeout] = 0;
+            this.#agentTimeout = 0;
             this.keepAlive ??= false;
         }
     }
     get agentTimeout() {
-        return this[kAgentTimeout];
+        return this.#agentTimeout;
     }
     set httpVersion(value) {
         switch (value) {
             case 1:
             case 2:
-                this[kHttpVersion] = value;
+                this.#httpVersion = value;
                 break;
         }
     }
     get httpVersion() {
-        return this[kHttpVersion];
+        return this.#httpVersion;
     }
     set ipVersion(value) {
         switch (value) {
             case 0:
             case 4:
             case 6:
-                this[kIpVersion] = value;
+                this.#ipVersion = value;
                 break;
         }
     }
     get ipVersion() {
-        return this[kIpVersion];
+        return this.#ipVersion;
     }
     get settings() {
         return this.module.settings ||= {};
     }
 }
-_a = kSingleton, _b = kHttpVersion, _c = kHeaders, _d = kCerts, _e = kBaseURL, _f = kConnectDns, _g = kPendingDns, _h = kConnectHttp, _j = kStatusOn, _k = kHeadersOn, _l = kAdapter, _m = kDownloading, _o = kHostInfo, _p = kSession;
 module.exports = Request;