ccxt 4.2.11 → 4.2.13

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

@@ -0,0 +1,354 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Stream = require('node:stream');
+var node_util = require('node:util');
+var node_buffer = require('node:buffer');
+var fetchError = require('./errors/fetch-error.js');
+var base = require('./errors/base.js');
+var is = require('./utils/is.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var Stream__default = /*#__PURE__*/_interopDefaultLegacy(Stream);
+
+/**
+ * Body.js
+ *
+ * Body interface provides common methods for Request and Response
+ */
+const pipeline = node_util.promisify(Stream__default["default"].pipeline);
+const INTERNALS = Symbol('Body internals');
+/**
+ * Body mixin
+ *
+ * Ref: https://fetch.spec.whatwg.org/#body
+ *
+ * @param   Stream  body  Readable stream
+ * @param   Object  opts  Response options
+ * @return  Void
+ */
+class Body {
+    constructor(body, { size = 0 } = {}) {
+        let boundary = null;
+        if (body === null) {
+            // Body is undefined or null
+            body = null;
+        }
+        else if (is.isURLSearchParameters(body)) {
+            // Body is a URLSearchParams
+            body = node_buffer.Buffer.from(body.toString());
+        }
+        else if (is.isBlob(body)) ;
+        else if (node_buffer.Buffer.isBuffer(body)) ;
+        else if (node_util.types.isAnyArrayBuffer(body)) {
+            // Body is ArrayBuffer
+            body = node_buffer.Buffer.from(body);
+        }
+        else if (ArrayBuffer.isView(body)) {
+            // Body is ArrayBufferView
+            body = node_buffer.Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+        }
+        else if (body instanceof Stream__default["default"]) ; /* else if (body instanceof FormData) {
+            Body is FormData
+            body = formDataToBlob(body);
+            boundary = body.type.split('=')[1];
+        } */
+        else {
+            // None of the above
+            // coerce to string then buffer
+            body = node_buffer.Buffer.from(String(body));
+        }
+        let stream = body;
+        if (node_buffer.Buffer.isBuffer(body)) {
+            stream = Stream__default["default"].Readable.from(body);
+        }
+        else if (is.isBlob(body)) {
+            stream = Stream__default["default"].Readable.from(body.stream());
+        }
+        this[INTERNALS] = {
+            body,
+            stream,
+            boundary,
+            disturbed: false,
+            error: null
+        };
+        this.size = size;
+        if (body instanceof Stream__default["default"]) {
+            body.on('error', error_ => {
+                const error = error_ instanceof base.FetchBaseError ?
+                    error_ :
+                    new fetchError.FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, 'system', error_);
+                this[INTERNALS].error = error;
+            });
+        }
+    }
+    get body() {
+        return this[INTERNALS].stream;
+    }
+    get bodyUsed() {
+        return this[INTERNALS].disturbed;
+    }
+    /**
+     * Decode response as ArrayBuffer
+     *
+     * @return  Promise
+     */
+    async arrayBuffer() {
+        const { buffer, byteOffset, byteLength } = await consumeBody(this);
+        return buffer.slice(byteOffset, byteOffset + byteLength);
+    }
+    /*async formData() {
+        const ct = this.headers.get('content-type');
+
+        if (ct.startsWith('application/x-www-form-urlencoded')) {
+            const formData = new FormData();
+            const parameters = new URLSearchParams(await this.text());
+
+            for (const [name, value] of parameters) {
+                formData.append(name, value);
+            }
+
+            return formData;
+        }
+
+        const {toFormData} = await import('./utils/multipart-parser.js');
+        return toFormData(this.body, ct);
+    }*/
+    /**
+     * Return raw response as Blob
+     *
+     * @return Promise
+     */
+    async blob() {
+        const ct = (this.headers && this.headers.get('content-type')) || (this[INTERNALS].body && this[INTERNALS].body.type) || '';
+        const buf = await this.arrayBuffer();
+        return new Blob([buf], {
+            type: ct
+        });
+    }
+    /**
+     * Decode response as json
+     *
+     * @return  Promise
+     */
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+    /**
+     * Decode response as text
+     *
+     * @return  Promise
+     */
+    async text() {
+        const buffer = await consumeBody(this);
+        return new TextDecoder().decode(buffer);
+    }
+    /**
+     * Decode response as buffer (non-spec api)
+     *
+     * @return  Promise
+     */
+    buffer() {
+        return consumeBody(this);
+    }
+}
+Body.prototype.buffer = node_util.deprecate(Body.prototype.buffer, 'Please use \'response.arrayBuffer()\' instead of \'response.buffer()\'', 'node-fetch#buffer');
+// In browsers, all properties are enumerable.
+Object.defineProperties(Body.prototype, {
+    body: { enumerable: true },
+    bodyUsed: { enumerable: true },
+    arrayBuffer: { enumerable: true },
+    blob: { enumerable: true },
+    json: { enumerable: true },
+    text: { enumerable: true },
+    data: { get: node_util.deprecate(() => { }, 'data doesn\'t exist, use json(), text(), arrayBuffer(), or body instead', 'https://github.com/node-fetch/node-fetch/issues/1000 (response)') }
+});
+/**
+ * Consume and convert an entire Body to a Buffer.
+ *
+ * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
+ *
+ * @return Promise
+ */
+async function consumeBody(data) {
+    if (data[INTERNALS].disturbed) {
+        throw new TypeError(`body used already for: ${data.url}`);
+    }
+    data[INTERNALS].disturbed = true;
+    if (data[INTERNALS].error) {
+        throw data[INTERNALS].error;
+    }
+    const { body } = data;
+    // Body is null
+    if (body === null) {
+        return node_buffer.Buffer.alloc(0);
+    }
+    /* c8 ignore next 3 */
+    if (!(body instanceof Stream__default["default"])) {
+        return node_buffer.Buffer.alloc(0);
+    }
+    // Body is stream
+    // get ready to actually consume the body
+    const accum = [];
+    let accumBytes = 0;
+    try {
+        for await (const chunk of body) {
+            if (data.size > 0 && accumBytes + chunk.length > data.size) {
+                const error = new fetchError.FetchError(`content size at ${data.url} over limit: ${data.size}`, 'max-size');
+                body.destroy(error);
+                throw error;
+            }
+            accumBytes += chunk.length;
+            accum.push(chunk);
+        }
+    }
+    catch (error) {
+        const error_ = error instanceof base.FetchBaseError ? error : new fetchError.FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, 'system', error);
+        throw error_;
+    }
+    if (body.readableEnded === true || body._readableState.ended === true) {
+        try {
+            if (accum.every(c => typeof c === 'string')) {
+                return node_buffer.Buffer.from(accum.join(''));
+            }
+            return node_buffer.Buffer.concat(accum, accumBytes);
+        }
+        catch (error) {
+            throw new fetchError.FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, 'system', error);
+        }
+    }
+    else {
+        throw new fetchError.FetchError(`Premature close of server response while trying to fetch ${data.url}`);
+    }
+}
+/**
+ * Clone body given Res/Req instance
+ *
+ * @param   Mixed   instance       Response or Request instance
+ * @param   String  highWaterMark  highWaterMark for both PassThrough body streams
+ * @return  Mixed
+ */
+const clone = (instance, highWaterMark) => {
+    let p1;
+    let p2;
+    let { body } = instance[INTERNALS];
+    // Don't allow cloning a used body
+    if (instance.bodyUsed) {
+        throw new Error('cannot clone body after it is used');
+    }
+    // Check that body is a stream and not form-data object
+    // note: we can't clone the form-data object without having it as a dependency
+    if ((body instanceof Stream__default["default"]) && (typeof body.getBoundary !== 'function')) {
+        // Tee instance body
+        p1 = new Stream.PassThrough({ highWaterMark });
+        p2 = new Stream.PassThrough({ highWaterMark });
+        body.pipe(p1);
+        body.pipe(p2);
+        // Set instance body to teed body and return the other teed body
+        instance[INTERNALS].stream = p1;
+        body = p2;
+    }
+    return body;
+};
+const getNonSpecFormDataBoundary = node_util.deprecate(body => body.getBoundary(), 'form-data doesn\'t follow the spec and requires special treatment. Use alternative package', 'https://github.com/node-fetch/node-fetch/issues/1167');
+/**
+ * Performs the operation "extract a `Content-Type` value from |object|" as
+ * specified in the specification:
+ * https://fetch.spec.whatwg.org/#concept-bodyinit-extract
+ *
+ * This function assumes that instance.body is present.
+ *
+ * @param {any} body Any options.body input
+ * @returns {string | null}
+ */
+const extractContentType = (body, request) => {
+    // Body is null or undefined
+    if (body === null) {
+        return null;
+    }
+    // Body is string
+    if (typeof body === 'string') {
+        return 'text/plain;charset=UTF-8';
+    }
+    // Body is a URLSearchParams
+    if (is.isURLSearchParameters(body)) {
+        return 'application/x-www-form-urlencoded;charset=UTF-8';
+    }
+    // Body is blob
+    if (is.isBlob(body)) {
+        return body.type || null;
+    }
+    // Body is a Buffer (Buffer, ArrayBuffer or ArrayBufferView)
+    if (node_buffer.Buffer.isBuffer(body) || node_util.types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+        return null;
+    }
+    // if (body instanceof FormData) {
+    // 	return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
+    // }
+    // Detect form data input from form-data module
+    if (body && typeof body.getBoundary === 'function') {
+        return `multipart/form-data;boundary=${getNonSpecFormDataBoundary(body)}`;
+    }
+    // Body is stream - can't really do much about this
+    if (body instanceof Stream__default["default"]) {
+        return null;
+    }
+    // Body constructor defaults other things to string
+    return 'text/plain;charset=UTF-8';
+};
+/**
+ * The Fetch Standard treats this as if "total bytes" is a property on the body.
+ * For us, we have to explicitly get it with a function.
+ *
+ * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
+ *
+ * @param {any} obj.body Body object from the Body instance.
+ * @returns {number | null}
+ */
+const getTotalBytes = request => {
+    const { body } = request[INTERNALS];
+    // Body is null or undefined
+    if (body === null) {
+        return 0;
+    }
+    // Body is Blob
+    if (is.isBlob(body)) {
+        return body.size;
+    }
+    // Body is Buffer
+    if (node_buffer.Buffer.isBuffer(body)) {
+        return body.length;
+    }
+    // Detect form data input from form-data module
+    if (body && typeof body.getLengthSync === 'function') {
+        return body.hasKnownLength && body.hasKnownLength() ? body.getLengthSync() : null;
+    }
+    // Body is stream
+    return null;
+};
+/**
+ * Write a Body to a Node.js WritableStream (e.g. http.Request) object.
+ *
+ * @param {Stream.Writable} dest The stream to write to.
+ * @param obj.body Body object from the Body instance.
+ * @returns {Promise<void>}
+ */
+const writeToStream = async (dest, { body }) => {
+    if (body === null) {
+        // Body is null
+        dest.end();
+    }
+    else {
+        // Body is stream
+        await pipeline(body, dest);
+    }
+};
+
+exports.clone = clone;
+exports["default"] = Body;
+exports.extractContentType = extractContentType;
+exports.getTotalBytes = getTotalBytes;
+exports.writeToStream = writeToStream;

package/dist/cjs/js/src/static_dependencies/node-fetch/errors/abort-error.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var base = require('./base.js');
+
+/**
+ * AbortError interface for cancelled requests
+ */
+class AbortError extends base.FetchBaseError {
+    constructor(message, type = 'aborted') {
+        super(message, type);
+    }
+}
+
+exports.AbortError = AbortError;

package/dist/cjs/js/src/static_dependencies/node-fetch/errors/base.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class FetchBaseError extends Error {
+    constructor(message, type) {
+        super(message);
+        // Hide custom error implementation details from end-users
+        Error.captureStackTrace(this, this.constructor);
+        this.type = type;
+    }
+    get name() {
+        return this.constructor.name;
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+}
+
+exports.FetchBaseError = FetchBaseError;

package/dist/cjs/js/src/static_dependencies/node-fetch/errors/fetch-error.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var base = require('./base.js');
+
+/**
+ * @typedef {{ address?: string, code: string, dest?: string, errno: number, info?: object, message: string, path?: string, port?: number, syscall: string}} SystemError
+*/
+/**
+ * FetchError interface for operational errors
+ */
+class FetchError extends base.FetchBaseError {
+    /**
+     * @param  {string} message -      Error message for human
+     * @param  {string} [type] -        Error type for machine
+     * @param  {SystemError} [systemError] - For Node.js system error
+     */
+    constructor(message, type, systemError) {
+        super(message, type);
+        // When err.type is `system`, err.erroredSysCall contains system error and err.code contains system error code
+        if (systemError) {
+            // eslint-disable-next-line no-multi-assign
+            this.code = this.errno = systemError.code;
+            this.erroredSysCall = systemError.syscall;
+        }
+    }
+}
+
+exports.FetchError = FetchError;

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

@@ -0,0 +1,239 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var node_util = require('node:util');
+var http = require('node:http');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+
+/**
+ * Headers.js
+ *
+ * Headers class offers convenient helpers
+ */
+/* c8 ignore next 9 */
+const validateHeaderName = typeof http__default["default"].validateHeaderName === 'function' ?
+    http__default["default"].validateHeaderName :
+    name => {
+        if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) {
+            const error = new TypeError(`Header name must be a valid HTTP token [${name}]`);
+            Object.defineProperty(error, 'code', { value: 'ERR_INVALID_HTTP_TOKEN' });
+            throw error;
+        }
+    };
+/* c8 ignore next 9 */
+const validateHeaderValue = typeof http__default["default"].validateHeaderValue === 'function' ?
+    http__default["default"].validateHeaderValue :
+    (name, value) => {
+        if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
+            const error = new TypeError(`Invalid character in header content ["${name}"]`);
+            Object.defineProperty(error, 'code', { value: 'ERR_INVALID_CHAR' });
+            throw error;
+        }
+    };
+/**
+ * @typedef {Headers | Record<string, string> | Iterable<readonly [string, string]> | Iterable<Iterable<string>>} HeadersInit
+ */
+/**
+ * This Fetch API interface allows you to perform various actions on HTTP request and response headers.
+ * These actions include retrieving, setting, adding to, and removing.
+ * A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.
+ * You can add to this using methods like append() (see Examples.)
+ * In all methods of this interface, header names are matched by case-insensitive byte sequence.
+ *
+ */
+class Headers extends URLSearchParams {
+    /**
+     * Headers class
+     *
+     * @constructor
+     * @param {HeadersInit} [init] - Response headers
+     */
+    constructor(init) {
+        // Validate and normalize init object in [name, value(s)][]
+        /** @type {string[][]} */
+        let result = [];
+        if (init instanceof Headers) {
+            const raw = init.raw();
+            for (const [name, values] of Object.entries(raw)) {
+                result.push(...values.map(value => [name, value]));
+            }
+        }
+        else if (init == null) ;
+        else if (typeof init === 'object' && !node_util.types.isBoxedPrimitive(init)) {
+            const method = init[Symbol.iterator];
+            // eslint-disable-next-line no-eq-null, eqeqeq
+            if (method == null) {
+                // Record<ByteString, ByteString>
+                result.push(...Object.entries(init));
+            }
+            else {
+                if (typeof method !== 'function') {
+                    throw new TypeError('Header pairs must be iterable');
+                }
+                // Sequence<sequence<ByteString>>
+                // Note: per spec we have to first exhaust the lists then process them
+                result = [...init]
+                    .map(pair => {
+                    if (typeof pair !== 'object' || node_util.types.isBoxedPrimitive(pair)) {
+                        throw new TypeError('Each header pair must be an iterable object');
+                    }
+                    return [...pair];
+                }).map(pair => {
+                    if (pair.length !== 2) {
+                        throw new TypeError('Each header pair must be a name/value tuple');
+                    }
+                    return [...pair];
+                });
+            }
+        }
+        else {
+            throw new TypeError('Failed to construct \'Headers\': The provided value is not of type \'(sequence<sequence<ByteString>> or record<ByteString, ByteString>)');
+        }
+        // Validate and lowercase
+        result =
+            result.length > 0 ?
+                result.map(([name, value]) => {
+                    validateHeaderName(name);
+                    validateHeaderValue(name, String(value));
+                    return [String(name).toLowerCase(), String(value)];
+                }) :
+                undefined;
+        super(result);
+        // Returning a Proxy that will lowercase key names, validate parameters and sort keys
+        // eslint-disable-next-line no-constructor-return
+        return new Proxy(this, {
+            get(target, p, receiver) {
+                switch (p) {
+                    case 'append':
+                    case 'set':
+                        return (name, value) => {
+                            validateHeaderName(name);
+                            validateHeaderValue(name, String(value));
+                            return URLSearchParams.prototype[p].call(target, String(name).toLowerCase(), String(value));
+                        };
+                    case 'delete':
+                    case 'has':
+                    case 'getAll':
+                        return name => {
+                            validateHeaderName(name);
+                            return URLSearchParams.prototype[p].call(target, String(name).toLowerCase());
+                        };
+                    case 'keys':
+                        return () => {
+                            target.sort();
+                            return new Set(URLSearchParams.prototype.keys.call(target)).keys();
+                        };
+                    default:
+                        return Reflect.get(target, p, receiver);
+                }
+            }
+        });
+        /* c8 ignore next */
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+    toString() {
+        return Object.prototype.toString.call(this);
+    }
+    get(name) {
+        const values = this.getAll(name);
+        if (values.length === 0) {
+            return null;
+        }
+        let value = values.join(', ');
+        if (/^content-encoding$/i.test(name)) {
+            value = value.toLowerCase();
+        }
+        return value;
+    }
+    forEach(callback, thisArg = undefined) {
+        for (const name of this.keys()) {
+            Reflect.apply(callback, thisArg, [this.get(name), name, this]);
+        }
+    }
+    *values() {
+        for (const name of this.keys()) {
+            yield this.get(name);
+        }
+    }
+    /**
+     * @type {() => IterableIterator<[string, string]>}
+     */
+    *entries() {
+        for (const name of this.keys()) {
+            yield [name, this.get(name)];
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * Node-fetch non-spec method
+     * returning all headers and their values as array
+     * @returns {Record<string, string[]>}
+     */
+    raw() {
+        return [...this.keys()].reduce((result, key) => {
+            result[key] = this.getAll(key);
+            return result;
+        }, {});
+    }
+    /**
+     * For better console.log(headers) and also to convert Headers into Node.js Request compatible format
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return [...this.keys()].reduce((result, key) => {
+            const values = this.getAll(key);
+            // Http.request() only supports string as Host header.
+            // This hack makes specifying custom Host header possible.
+            if (key === 'host') {
+                result[key] = values[0];
+            }
+            else {
+                result[key] = values.length > 1 ? values : values[0];
+            }
+            return result;
+        }, {});
+    }
+}
+/**
+ * Re-shaping object for Web IDL tests
+ * Only need to do it for overridden methods
+ */
+Object.defineProperties(Headers.prototype, ['get', 'entries', 'forEach', 'values'].reduce((result, property) => {
+    result[property] = { enumerable: true };
+    return result;
+}, {}));
+/**
+ * Create a Headers object from an http.IncomingMessage.rawHeaders, ignoring those that do
+ * not conform to HTTP grammar productions.
+ * @param {import('http').IncomingMessage['rawHeaders']} headers
+ */
+function fromRawHeaders(headers = []) {
+    return new Headers(headers
+        // Split into pairs
+        .reduce((result, value, index, array) => {
+        if (index % 2 === 0) {
+            result.push(array.slice(index, index + 2));
+        }
+        return result;
+    }, [])
+        .filter(([name, value]) => {
+        try {
+            validateHeaderName(name);
+            validateHeaderValue(name, String(value));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }));
+}
+
+exports["default"] = Headers;
+exports.fromRawHeaders = fromRawHeaders;