ccxt 4.2.11 → 4.2.12

package/dist/cjs/js/src/static_dependencies/node-fetch/response.js

@@ -0,0 +1,139 @@
+'use strict';
+
+var headers = require('./headers.js');
+var body = require('./body.js');
+var isRedirect = require('./utils/is-redirect.js');
+
+/**
+ * Response.js
+ *
+ * Response class provides content decoding
+ */
+const INTERNALS = Symbol('Response internals');
+/**
+ * Response class
+ *
+ * Ref: https://fetch.spec.whatwg.org/#response-class
+ *
+ * @param   Stream  body  Readable stream
+ * @param   Object  opts  Response options
+ * @return  Void
+ */
+class Response extends body["default"] {
+    constructor(body$1 = null, options = {}) {
+        super(body$1, options);
+        // eslint-disable-next-line no-eq-null, eqeqeq, no-negated-condition
+        const status = options.status != null ? options.status : 200;
+        const headers$1 = new headers["default"](options.headers);
+        if (body$1 !== null && !headers$1.has('Content-Type')) {
+            const contentType = body.extractContentType(body$1);
+            if (contentType) {
+                headers$1.append('Content-Type', contentType);
+            }
+        }
+        this[INTERNALS] = {
+            type: 'default',
+            url: options.url,
+            status,
+            statusText: options.statusText || '',
+            headers: headers$1,
+            counter: options.counter,
+            highWaterMark: options.highWaterMark
+        };
+    }
+    get type() {
+        return this[INTERNALS].type;
+    }
+    get url() {
+        return this[INTERNALS].url || '';
+    }
+    get status() {
+        return this[INTERNALS].status;
+    }
+    /**
+     * Convenience property representing if the request ended normally
+     */
+    get ok() {
+        return this[INTERNALS].status >= 200 && this[INTERNALS].status < 300;
+    }
+    get redirected() {
+        return this[INTERNALS].counter > 0;
+    }
+    get statusText() {
+        return this[INTERNALS].statusText;
+    }
+    get headers() {
+        return this[INTERNALS].headers;
+    }
+    get highWaterMark() {
+        return this[INTERNALS].highWaterMark;
+    }
+    /**
+     * Clone this response
+     *
+     * @return  Response
+     */
+    clone() {
+        return new Response(body.clone(this, this.highWaterMark), {
+            type: this.type,
+            url: this.url,
+            status: this.status,
+            statusText: this.statusText,
+            headers: this.headers,
+            ok: this.ok,
+            redirected: this.redirected,
+            size: this.size,
+            highWaterMark: this.highWaterMark
+        });
+    }
+    /**
+     * @param {string} url    The URL that the new response is to originate from.
+     * @param {number} status An optional status code for the response (e.g., 302.)
+     * @returns {Response}    A Response object.
+     */
+    static redirect(url, status = 302) {
+        if (!isRedirect.isRedirect(status)) {
+            throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
+        }
+        return new Response(null, {
+            headers: {
+                location: new URL(url).toString()
+            },
+            status
+        });
+    }
+    static error() {
+        const response = new Response(null, { status: 0, statusText: '' });
+        response[INTERNALS].type = 'error';
+        return response;
+    }
+    static json(data = undefined, init = {}) {
+        const body = JSON.stringify(data);
+        if (body === undefined) {
+            throw new TypeError('data is not JSON serializable');
+        }
+        const headers$1 = new headers["default"](init && init.headers);
+        if (!headers$1.has('content-type')) {
+            headers$1.set('content-type', 'application/json');
+        }
+        return new Response(body, {
+            ...init,
+            headers: headers$1
+        });
+    }
+    get [Symbol.toStringTag]() {
+        return 'Response';
+    }
+}
+Object.defineProperties(Response.prototype, {
+    type: { enumerable: true },
+    url: { enumerable: true },
+    status: { enumerable: true },
+    ok: { enumerable: true },
+    redirected: { enumerable: true },
+    statusText: { enumerable: true },
+    headers: { enumerable: true },
+    clone: { enumerable: true }
+});
+
+module.exports = Response;

package/dist/cjs/js/src/static_dependencies/node-fetch/utils/get-search.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const getSearch = parsedURL => {
+    if (parsedURL.search) {
+        return parsedURL.search;
+    }
+    const lastOffset = parsedURL.href.length - 1;
+    const hash = parsedURL.hash || (parsedURL.href[lastOffset] === '#' ? '#' : '');
+    return parsedURL.href[lastOffset - hash.length] === '?' ? '?' : '';
+};
+
+exports.getSearch = getSearch;

package/dist/cjs/js/src/static_dependencies/node-fetch/utils/is-redirect.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const redirectStatus = new Set([301, 302, 303, 307, 308]);
+/**
+ * Redirect code matching
+ *
+ * @param {number} code - Status code
+ * @return {boolean}
+ */
+const isRedirect = code => {
+    return redirectStatus.has(code);
+};
+
+exports.isRedirect = isRedirect;

package/dist/cjs/js/src/static_dependencies/node-fetch/utils/is.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Is.js
+ *
+ * Object type checks.
+ */
+const NAME = Symbol.toStringTag;
+/**
+ * Check if `obj` is a URLSearchParams object
+ * ref: https://github.com/node-fetch/node-fetch/issues/296#issuecomment-307598143
+ * @param {*} object - Object to check for
+ * @return {boolean}
+ */
+const isURLSearchParameters = object => {
+    return (typeof object === 'object' &&
+        typeof object.append === 'function' &&
+        typeof object.delete === 'function' &&
+        typeof object.get === 'function' &&
+        typeof object.getAll === 'function' &&
+        typeof object.has === 'function' &&
+        typeof object.set === 'function' &&
+        typeof object.sort === 'function' &&
+        object[NAME] === 'URLSearchParams');
+};
+/**
+ * Check if `object` is a W3C `Blob` object (which `File` inherits from)
+ * @param {*} object - Object to check for
+ * @return {boolean}
+ */
+const isBlob = object => {
+    return (object &&
+        typeof object === 'object' &&
+        typeof object.arrayBuffer === 'function' &&
+        typeof object.type === 'string' &&
+        typeof object.stream === 'function' &&
+        typeof object.constructor === 'function' &&
+        /^(Blob|File)$/.test(object[NAME]));
+};
+/**
+ * Check if `obj` is an instance of AbortSignal.
+ * @param {*} object - Object to check for
+ * @return {boolean}
+ */
+const isAbortSignal = object => {
+    return (typeof object === 'object' && (object[NAME] === 'AbortSignal' ||
+        object[NAME] === 'EventTarget'));
+};
+/**
+ * isDomainOrSubdomain reports whether sub is a subdomain (or exact match) of
+ * the parent domain.
+ *
+ * Both domains must already be in canonical form.
+ * @param {string|URL} original
+ * @param {string|URL} destination
+ */
+const isDomainOrSubdomain = (destination, original) => {
+    const orig = new URL(original).hostname;
+    const dest = new URL(destination).hostname;
+    return orig === dest || orig.endsWith(`.${dest}`);
+};
+/**
+ * isSameProtocol reports whether the two provided URLs use the same protocol.
+ *
+ * Both domains must already be in canonical form.
+ * @param {string|URL} original
+ * @param {string|URL} destination
+ */
+const isSameProtocol = (destination, original) => {
+    const orig = new URL(original).protocol;
+    const dest = new URL(destination).protocol;
+    return orig === dest;
+};
+
+exports.isAbortSignal = isAbortSignal;
+exports.isBlob = isBlob;
+exports.isDomainOrSubdomain = isDomainOrSubdomain;
+exports.isSameProtocol = isSameProtocol;
+exports.isURLSearchParameters = isURLSearchParameters;

package/dist/cjs/js/src/static_dependencies/node-fetch/utils/referrer.js

@@ -0,0 +1,292 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var node_net = require('node:net');
+
+/**
+ * @external URL
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/URL|URL}
+ */
+/**
+ * @module utils/referrer
+ * @private
+ */
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#strip-url|Referrer Policy §8.4. Strip url for use as a referrer}
+ * @param {string} URL
+ * @param {boolean} [originOnly=false]
+ */
+function stripURLForUseAsAReferrer(url, originOnly = false) {
+    // 1. If url is null, return no referrer.
+    if (url == null) { // eslint-disable-line no-eq-null, eqeqeq
+        return 'no-referrer';
+    }
+    url = new URL(url);
+    // 2. If url's scheme is a local scheme, then return no referrer.
+    if (/^(about|blob|data):$/.test(url.protocol)) {
+        return 'no-referrer';
+    }
+    // 3. Set url's username to the empty string.
+    url.username = '';
+    // 4. Set url's password to null.
+    // Note: `null` appears to be a mistake as this actually results in the password being `"null"`.
+    url.password = '';
+    // 5. Set url's fragment to null.
+    // Note: `null` appears to be a mistake as this actually results in the fragment being `"#null"`.
+    url.hash = '';
+    // 6. If the origin-only flag is true, then:
+    if (originOnly) {
+        // 6.1. Set url's path to null.
+        // Note: `null` appears to be a mistake as this actually results in the path being `"/null"`.
+        url.pathname = '';
+        // 6.2. Set url's query to null.
+        // Note: `null` appears to be a mistake as this actually results in the query being `"?null"`.
+        url.search = '';
+    }
+    // 7. Return url.
+    return url;
+}
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#enumdef-referrerpolicy|enum ReferrerPolicy}
+ */
+const ReferrerPolicy = new Set([
+    '',
+    'no-referrer',
+    'no-referrer-when-downgrade',
+    'same-origin',
+    'origin',
+    'strict-origin',
+    'origin-when-cross-origin',
+    'strict-origin-when-cross-origin',
+    'unsafe-url'
+]);
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#default-referrer-policy|default referrer policy}
+ */
+const DEFAULT_REFERRER_POLICY = 'strict-origin-when-cross-origin';
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#referrer-policies|Referrer Policy §3. Referrer Policies}
+ * @param {string} referrerPolicy
+ * @returns {string} referrerPolicy
+ */
+function validateReferrerPolicy(referrerPolicy) {
+    if (!ReferrerPolicy.has(referrerPolicy)) {
+        throw new TypeError(`Invalid referrerPolicy: ${referrerPolicy}`);
+    }
+    return referrerPolicy;
+}
+/**
+ * @see {@link https://w3c.github.io/webappsec-secure-contexts/#is-origin-trustworthy|Referrer Policy §3.2. Is origin potentially trustworthy?}
+ * @param {external:URL} url
+ * @returns `true`: "Potentially Trustworthy", `false`: "Not Trustworthy"
+ */
+function isOriginPotentiallyTrustworthy(url) {
+    // 1. If origin is an opaque origin, return "Not Trustworthy".
+    // Not applicable
+    // 2. Assert: origin is a tuple origin.
+    // Not for implementations
+    // 3. If origin's scheme is either "https" or "wss", return "Potentially Trustworthy".
+    if (/^(http|ws)s:$/.test(url.protocol)) {
+        return true;
+    }
+    // 4. If origin's host component matches one of the CIDR notations 127.0.0.0/8 or ::1/128 [RFC4632], return "Potentially Trustworthy".
+    const hostIp = url.host.replace(/(^\[)|(]$)/g, '');
+    const hostIPVersion = node_net.isIP(hostIp);
+    if (hostIPVersion === 4 && /^127\./.test(hostIp)) {
+        return true;
+    }
+    if (hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp)) {
+        return true;
+    }
+    // 5. If origin's host component is "localhost" or falls within ".localhost", and the user agent conforms to the name resolution rules in [let-localhost-be-localhost], return "Potentially Trustworthy".
+    // We are returning FALSE here because we cannot ensure conformance to
+    // let-localhost-be-loalhost (https://tools.ietf.org/html/draft-west-let-localhost-be-localhost)
+    if (url.host === 'localhost' || url.host.endsWith('.localhost')) {
+        return false;
+    }
+    // 6. If origin's scheme component is file, return "Potentially Trustworthy".
+    if (url.protocol === 'file:') {
+        return true;
+    }
+    // 7. If origin's scheme component is one which the user agent considers to be authenticated, return "Potentially Trustworthy".
+    // Not supported
+    // 8. If origin has been configured as a trustworthy origin, return "Potentially Trustworthy".
+    // Not supported
+    // 9. Return "Not Trustworthy".
+    return false;
+}
+/**
+ * @see {@link https://w3c.github.io/webappsec-secure-contexts/#is-url-trustworthy|Referrer Policy §3.3. Is url potentially trustworthy?}
+ * @param {external:URL} url
+ * @returns `true`: "Potentially Trustworthy", `false`: "Not Trustworthy"
+ */
+function isUrlPotentiallyTrustworthy(url) {
+    // 1. If url is "about:blank" or "about:srcdoc", return "Potentially Trustworthy".
+    if (/^about:(blank|srcdoc)$/.test(url)) {
+        return true;
+    }
+    // 2. If url's scheme is "data", return "Potentially Trustworthy".
+    if (url.protocol === 'data:') {
+        return true;
+    }
+    // Note: The origin of blob: and filesystem: URLs is the origin of the context in which they were
+    // created. Therefore, blobs created in a trustworthy origin will themselves be potentially
+    // trustworthy.
+    if (/^(blob|filesystem):$/.test(url.protocol)) {
+        return true;
+    }
+    // 3. Return the result of executing §3.2 Is origin potentially trustworthy? on url's origin.
+    return isOriginPotentiallyTrustworthy(url);
+}
+/**
+ * Modifies the referrerURL to enforce any extra security policy considerations.
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}, step 7
+ * @callback module:utils/referrer~referrerURLCallback
+ * @param {external:URL} referrerURL
+ * @returns {external:URL} modified referrerURL
+ */
+/**
+ * Modifies the referrerOrigin to enforce any extra security policy considerations.
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}, step 7
+ * @callback module:utils/referrer~referrerOriginCallback
+ * @param {external:URL} referrerOrigin
+ * @returns {external:URL} modified referrerOrigin
+ */
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}
+ * @param {Request} request
+ * @param {object} o
+ * @param {module:utils/referrer~referrerURLCallback} o.referrerURLCallback
+ * @param {module:utils/referrer~referrerOriginCallback} o.referrerOriginCallback
+ * @returns {external:URL} Request's referrer
+ */
+function determineRequestsReferrer(request, { referrerURLCallback, referrerOriginCallback } = {}) {
+    // There are 2 notes in the specification about invalid pre-conditions.  We return null, here, for
+    // these cases:
+    // > Note: If request's referrer is "no-referrer", Fetch will not call into this algorithm.
+    // > Note: If request's referrer policy is the empty string, Fetch will not call into this
+    // > algorithm.
+    if (request.referrer === 'no-referrer' || request.referrerPolicy === '') {
+        return null;
+    }
+    // 1. Let policy be request's associated referrer policy.
+    const policy = request.referrerPolicy;
+    // 2. Let environment be request's client.
+    // not applicable to node.js
+    // 3. Switch on request's referrer:
+    if (request.referrer === 'about:client') {
+        return 'no-referrer';
+    }
+    // "a URL": Let referrerSource be request's referrer.
+    const referrerSource = request.referrer;
+    // 4. Let request's referrerURL be the result of stripping referrerSource for use as a referrer.
+    let referrerURL = stripURLForUseAsAReferrer(referrerSource);
+    // 5. Let referrerOrigin be the result of stripping referrerSource for use as a referrer, with the
+    //    origin-only flag set to true.
+    let referrerOrigin = stripURLForUseAsAReferrer(referrerSource, true);
+    // 6. If the result of serializing referrerURL is a string whose length is greater than 4096, set
+    //    referrerURL to referrerOrigin.
+    if (referrerURL.toString().length > 4096) {
+        referrerURL = referrerOrigin;
+    }
+    // 7. The user agent MAY alter referrerURL or referrerOrigin at this point to enforce arbitrary
+    //    policy considerations in the interests of minimizing data leakage. For example, the user
+    //    agent could strip the URL down to an origin, modify its host, replace it with an empty
+    //    string, etc.
+    if (referrerURLCallback) {
+        referrerURL = referrerURLCallback(referrerURL);
+    }
+    if (referrerOriginCallback) {
+        referrerOrigin = referrerOriginCallback(referrerOrigin);
+    }
+    // 8.Execute the statements corresponding to the value of policy:
+    const currentURL = new URL(request.url);
+    switch (policy) {
+        case 'no-referrer':
+            return 'no-referrer';
+        case 'origin':
+            return referrerOrigin;
+        case 'unsafe-url':
+            return referrerURL;
+        case 'strict-origin':
+            // 1. If referrerURL is a potentially trustworthy URL and request's current URL is not a
+            //    potentially trustworthy URL, then return no referrer.
+            if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
+                return 'no-referrer';
+            }
+            // 2. Return referrerOrigin.
+            return referrerOrigin.toString();
+        case 'strict-origin-when-cross-origin':
+            // 1. If the origin of referrerURL and the origin of request's current URL are the same, then
+            //    return referrerURL.
+            if (referrerURL.origin === currentURL.origin) {
+                return referrerURL;
+            }
+            // 2. If referrerURL is a potentially trustworthy URL and request's current URL is not a
+            //    potentially trustworthy URL, then return no referrer.
+            if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
+                return 'no-referrer';
+            }
+            // 3. Return referrerOrigin.
+            return referrerOrigin;
+        case 'same-origin':
+            // 1. If the origin of referrerURL and the origin of request's current URL are the same, then
+            //    return referrerURL.
+            if (referrerURL.origin === currentURL.origin) {
+                return referrerURL;
+            }
+            // 2. Return no referrer.
+            return 'no-referrer';
+        case 'origin-when-cross-origin':
+            // 1. If the origin of referrerURL and the origin of request's current URL are the same, then
+            //    return referrerURL.
+            if (referrerURL.origin === currentURL.origin) {
+                return referrerURL;
+            }
+            // Return referrerOrigin.
+            return referrerOrigin;
+        case 'no-referrer-when-downgrade':
+            // 1. If referrerURL is a potentially trustworthy URL and request's current URL is not a
+            //    potentially trustworthy URL, then return no referrer.
+            if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
+                return 'no-referrer';
+            }
+            // 2. Return referrerURL.
+            return referrerURL;
+        default:
+            throw new TypeError(`Invalid referrerPolicy: ${policy}`);
+    }
+}
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#parse-referrer-policy-from-header|Referrer Policy §8.1. Parse a referrer policy from a Referrer-Policy header}
+ * @param {Headers} headers Response headers
+ * @returns {string} policy
+ */
+function parseReferrerPolicyFromHeader(headers) {
+    // 1. Let policy-tokens be the result of extracting header list values given `Referrer-Policy`
+    //    and response’s header list.
+    const policyTokens = (headers.get('referrer-policy') || '').split(/[,\s]+/);
+    // 2. Let policy be the empty string.
+    let policy = '';
+    // 3. For each token in policy-tokens, if token is a referrer policy and token is not the empty
+    //    string, then set policy to token.
+    // Note: This algorithm loops over multiple policy values to allow deployment of new policy
+    // values with fallbacks for older user agents, as described in § 11.1 Unknown Policy Values.
+    for (const token of policyTokens) {
+        if (token && ReferrerPolicy.has(token)) {
+            policy = token;
+        }
+    }
+    // 4. Return policy.
+    return policy;
+}
+
+exports.DEFAULT_REFERRER_POLICY = DEFAULT_REFERRER_POLICY;
+exports.ReferrerPolicy = ReferrerPolicy;
+exports.determineRequestsReferrer = determineRequestsReferrer;
+exports.isOriginPotentiallyTrustworthy = isOriginPotentiallyTrustworthy;
+exports.isUrlPotentiallyTrustworthy = isUrlPotentiallyTrustworthy;
+exports.parseReferrerPolicyFromHeader = parseReferrerPolicyFromHeader;
+exports.stripURLForUseAsAReferrer = stripURLForUseAsAReferrer;
+exports.validateReferrerPolicy = validateReferrerPolicy;

package/dist/cjs/js/src/static_dependencies/proxies/agent-base/index.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var http = require('http');
+require('https');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var http__namespace = /*#__PURE__*/_interopNamespace(http);
+
+function isSecureEndpoint() {
+    const { stack } = new Error();
+    if (typeof stack !== 'string')
+        return false;
+    return stack
+        .split('\n')
+        .some((l) => l.indexOf('(https.js:') !== -1 ||
+        l.indexOf('node:https:') !== -1);
+}
+const INTERNAL = Symbol('AgentBaseInternalState');
+class Agent extends http__namespace.Agent {
+    constructor(opts) {
+        super(opts);
+        this[INTERNAL] = {};
+    }
+    createSocket(req, options, cb) {
+        // Need to determine whether this is an `http` or `https` request.
+        // First check the `secureEndpoint` property explicitly, since this
+        // means that a parent `Agent` is "passing through" to this instance.
+        let secureEndpoint = typeof options.secureEndpoint === 'boolean'
+            ? options.secureEndpoint
+            : undefined;
+        // If no explicit `secure` endpoint, check if `protocol` property is
+        // set. This will usually be the case since using a full string URL
+        // or `URL` instance should be the most common case.
+        if (typeof secureEndpoint === 'undefined' &&
+            typeof options.protocol === 'string') {
+            secureEndpoint = options.protocol === 'https:';
+        }
+        // Finally, if no `protocol` property was set, then fall back to
+        // checking the stack trace of the current call stack, and try to
+        // detect the "https" module.
+        if (typeof secureEndpoint === 'undefined') {
+            secureEndpoint = isSecureEndpoint();
+        }
+        const connectOpts = { ...options, secureEndpoint };
+        Promise.resolve()
+            .then(() => this.connect(req, connectOpts))
+            .then((socket) => {
+            if (socket instanceof http__namespace.Agent) {
+                // @ts-expect-error `addRequest()` isn't defined in `@types/node`
+                return socket.addRequest(req, connectOpts);
+            }
+            this[INTERNAL].currentSocket = socket;
+            // @ts-expect-error `createSocket()` isn't defined in `@types/node`
+            super.createSocket(req, options, cb);
+        }, cb);
+    }
+    createConnection() {
+        const socket = this[INTERNAL].currentSocket;
+        this[INTERNAL].currentSocket = undefined;
+        if (!socket) {
+            throw new Error('No socket was returned in the `connect()` function');
+        }
+        return socket;
+    }
+    get defaultPort() {
+        return (this[INTERNAL].defaultPort ??
+            (this.protocol === 'https:' ? 443 : 80));
+    }
+    set defaultPort(v) {
+        if (this[INTERNAL]) {
+            this[INTERNAL].defaultPort = v;
+        }
+    }
+    get protocol() {
+        return (this[INTERNAL].protocol ?? (isSecureEndpoint() ? 'https:' : 'http:'));
+    }
+    set protocol(v) {
+        if (this[INTERNAL]) {
+            this[INTERNAL].protocol = v;
+        }
+    }
+}
+
+exports.Agent = Agent;