ccxt 4.2.18 → 4.2.20

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

@@ -1,354 +0,0 @@
-'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

@@ -1,16 +0,0 @@
-'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

@@ -1,20 +0,0 @@
-'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

@@ -1,30 +0,0 @@
-'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

@@ -1,239 +0,0 @@
-'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;