ccxt-ir 4.10.0 → 4.11.0

package/js/src/src/static_dependencies/ethers/utils/utf8.d.ts

@@ -0,0 +1,95 @@
+import type { BytesLike } from "./index.js";
+/**
+ *  The stanard normalization forms.
+ */
+export declare type UnicodeNormalizationForm = "NFC" | "NFD" | "NFKC" | "NFKD";
+/**
+ *  When using the UTF-8 error API the following errors can be intercepted
+ *  and processed as the %%reason%% passed to the [[Utf8ErrorFunc]].
+ *
+ *  **``"UNEXPECTED_CONTINUE"``** - a continuation byte was present where there
+ *  was nothing to continue.
+ *
+ *  **``"BAD_PREFIX"``** - an invalid (non-continuation) byte to start a
+ *  UTF-8 codepoint was found.
+ *
+ *  **``"OVERRUN"``** - the string is too short to process the expected
+ *  codepoint length.
+ *
+ *  **``"MISSING_CONTINUE"``** - a missing continuation byte was expected but
+ *  not found. The %%offset%% indicates the index the continuation byte
+ *  was expected at.
+ *
+ *  **``"OUT_OF_RANGE"``** - the computed code point is outside the range
+ *  for UTF-8. The %%badCodepoint%% indicates the computed codepoint, which was
+ *  outside the valid UTF-8 range.
+ *
+ *  **``"UTF16_SURROGATE"``** - the UTF-8 strings contained a UTF-16 surrogate
+ *  pair. The %%badCodepoint%% is the computed codepoint, which was inside the
+ *  UTF-16 surrogate range.
+ *
+ *  **``"OVERLONG"``** - the string is an overlong representation. The
+ *  %%badCodepoint%% indicates the computed codepoint, which has already
+ *  been bounds checked.
+ *
+ *
+ *  @returns string
+ */
+export declare type Utf8ErrorReason = "UNEXPECTED_CONTINUE" | "BAD_PREFIX" | "OVERRUN" | "MISSING_CONTINUE" | "OUT_OF_RANGE" | "UTF16_SURROGATE" | "OVERLONG";
+/**
+ *  A callback that can be used with [[toUtf8String]] to analysis or
+ *  recovery from invalid UTF-8 data.
+ *
+ *  Parsing UTF-8 data is done through a simple Finite-State Machine (FSM)
+ *  which calls the ``Utf8ErrorFunc`` if a fault is detected.
+ *
+ *  The %%reason%% indicates where in the FSM execution the fault
+ *  occurred and the %%offset%% indicates where the input failed.
+ *
+ *  The %%bytes%% represents the raw UTF-8 data that was provided and
+ *  %%output%% is the current array of UTF-8 code-points, which may
+ *  be updated by the ``Utf8ErrorFunc``.
+ *
+ *  The value of the %%badCodepoint%% depends on the %%reason%%. See
+ *  [[Utf8ErrorReason]] for details.
+ *
+ *  The function should return the number of bytes that should be skipped
+ *  when control resumes to the FSM.
+ */
+export declare type Utf8ErrorFunc = (reason: Utf8ErrorReason, offset: number, bytes: Uint8Array, output: Array<number>, badCodepoint?: number) => number;
+/**
+ *  A handful of popular, built-in UTF-8 error handling strategies.
+ *
+ *  **``"error"``** - throws on ANY illegal UTF-8 sequence or
+ *  non-canonical (overlong) codepoints (this is the default)
+ *
+ *  **``"ignore"``** - silently drops any illegal UTF-8 sequence
+ *  and accepts non-canonical (overlong) codepoints
+ *
+ *  **``"replace"``** - replace any illegal UTF-8 sequence with the
+ *  UTF-8 replacement character (i.e. ``"\\ufffd"``) and accepts
+ *  non-canonical (overlong) codepoints
+ *
+ *  @returns: Record<"error" | "ignore" | "replace", Utf8ErrorFunc>
+ */
+export declare const Utf8ErrorFuncs: Readonly<Record<"error" | "ignore" | "replace", Utf8ErrorFunc>>;
+/**
+ *  Returns the UTF-8 byte representation of %%str%%.
+ *
+ *  If %%form%% is specified, the string is normalized.
+ */
+export declare function toUtf8Bytes(str: string, form?: UnicodeNormalizationForm): Uint8Array;
+/**
+ *  Returns the string represented by the UTF-8 data %%bytes%%.
+ *
+ *  When %%onError%% function is specified, it is called on UTF-8
+ *  errors allowing recovery using the [[Utf8ErrorFunc]] API.
+ *  (default: [error](Utf8ErrorFuncs))
+ */
+export declare function toUtf8String(bytes: BytesLike, onError?: Utf8ErrorFunc): string;
+/**
+ *  Returns the UTF-8 code-points for %%str%%.
+ *
+ *  If %%form%% is specified, the string is normalized.
+ */
+export declare function toUtf8CodePoints(str: string, form?: UnicodeNormalizationForm): Array<number>;

package/js/src/src/static_dependencies/ethers/utils/utf8.js

@@ -0,0 +1,225 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/**
+ *  Using strings in Ethereum (or any security-basd system) requires
+ *  additional care. These utilities attempt to mitigate some of the
+ *  safety issues as well as provide the ability to recover and analyse
+ *  strings.
+ *
+ *  @_subsection api/utils:Strings and UTF-8  [about-strings]
+ */
+import { getBytes } from "./data.js";
+import { assertArgument, assertNormalize } from "./errors.js";
+function errorFunc(reason, offset, bytes, output, badCodepoint) {
+    assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes);
+}
+function ignoreFunc(reason, offset, bytes, output, badCodepoint) {
+    // If there is an invalid prefix (including stray continuation), skip any additional continuation bytes
+    if (reason === "BAD_PREFIX" || reason === "UNEXPECTED_CONTINUE") {
+        let i = 0;
+        for (let o = offset + 1; o < bytes.length; o++) {
+            if (bytes[o] >> 6 !== 0x02) {
+                break;
+            }
+            i++;
+        }
+        return i;
+    }
+    // This byte runs us past the end of the string, so just jump to the end
+    // (but the first byte was read already read and therefore skipped)
+    if (reason === "OVERRUN") {
+        return bytes.length - offset - 1;
+    }
+    // Nothing to skip
+    return 0;
+}
+function replaceFunc(reason, offset, bytes, output, badCodepoint) {
+    // Overlong representations are otherwise "valid" code points; just non-deistingtished
+    if (reason === "OVERLONG") {
+        assertArgument(typeof (badCodepoint) === "number", "invalid bad code point for replacement", "badCodepoint", badCodepoint);
+        output.push(badCodepoint);
+        return 0;
+    }
+    // Put the replacement character into the output
+    output.push(0xfffd);
+    // Otherwise, process as if ignoring errors
+    return ignoreFunc(reason, offset, bytes, output, badCodepoint);
+}
+/**
+ *  A handful of popular, built-in UTF-8 error handling strategies.
+ *
+ *  **``"error"``** - throws on ANY illegal UTF-8 sequence or
+ *  non-canonical (overlong) codepoints (this is the default)
+ *
+ *  **``"ignore"``** - silently drops any illegal UTF-8 sequence
+ *  and accepts non-canonical (overlong) codepoints
+ *
+ *  **``"replace"``** - replace any illegal UTF-8 sequence with the
+ *  UTF-8 replacement character (i.e. ``"\\ufffd"``) and accepts
+ *  non-canonical (overlong) codepoints
+ *
+ *  @returns: Record<"error" | "ignore" | "replace", Utf8ErrorFunc>
+ */
+export const Utf8ErrorFuncs = Object.freeze({
+    error: errorFunc,
+    ignore: ignoreFunc,
+    replace: replaceFunc
+});
+// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499
+function getUtf8CodePoints(_bytes, onError) {
+    if (onError == null) {
+        onError = Utf8ErrorFuncs.error;
+    }
+    const bytes = getBytes(_bytes, "bytes");
+    const result = [];
+    let i = 0;
+    // Invalid bytes are ignored
+    while (i < bytes.length) {
+        const c = bytes[i++];
+        // 0xxx xxxx
+        if (c >> 7 === 0) {
+            result.push(c);
+            continue;
+        }
+        // Multibyte; how many bytes left for this character?
+        let extraLength = null;
+        let overlongMask = null;
+        // 110x xxxx 10xx xxxx
+        if ((c & 0xe0) === 0xc0) {
+            extraLength = 1;
+            overlongMask = 0x7f;
+            // 1110 xxxx 10xx xxxx 10xx xxxx
+        }
+        else if ((c & 0xf0) === 0xe0) {
+            extraLength = 2;
+            overlongMask = 0x7ff;
+            // 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx
+        }
+        else if ((c & 0xf8) === 0xf0) {
+            extraLength = 3;
+            overlongMask = 0xffff;
+        }
+        else {
+            if ((c & 0xc0) === 0x80) {
+                i += onError("UNEXPECTED_CONTINUE", i - 1, bytes, result);
+            }
+            else {
+                i += onError("BAD_PREFIX", i - 1, bytes, result);
+            }
+            continue;
+        }
+        // Do we have enough bytes in our data?
+        if (i - 1 + extraLength >= bytes.length) {
+            i += onError("OVERRUN", i - 1, bytes, result);
+            continue;
+        }
+        // Remove the length prefix from the char
+        let res = c & ((1 << (8 - extraLength - 1)) - 1);
+        for (let j = 0; j < extraLength; j++) {
+            let nextChar = bytes[i];
+            // Invalid continuation byte
+            if ((nextChar & 0xc0) != 0x80) {
+                i += onError("MISSING_CONTINUE", i, bytes, result);
+                res = null;
+                break;
+            }
+            ;
+            res = (res << 6) | (nextChar & 0x3f);
+            i++;
+        }
+        // See above loop for invalid continuation byte
+        if (res === null) {
+            continue;
+        }
+        // Maximum code point
+        if (res > 0x10ffff) {
+            i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes, result, res);
+            continue;
+        }
+        // Reserved for UTF-16 surrogate halves
+        if (res >= 0xd800 && res <= 0xdfff) {
+            i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes, result, res);
+            continue;
+        }
+        // Check for overlong sequences (more bytes than needed)
+        if (res <= overlongMask) {
+            i += onError("OVERLONG", i - 1 - extraLength, bytes, result, res);
+            continue;
+        }
+        result.push(res);
+    }
+    return result;
+}
+// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array
+/**
+ *  Returns the UTF-8 byte representation of %%str%%.
+ *
+ *  If %%form%% is specified, the string is normalized.
+ */
+export function toUtf8Bytes(str, form) {
+    if (form != null) {
+        assertNormalize(form);
+        str = str.normalize(form);
+    }
+    let result = [];
+    for (let i = 0; i < str.length; i++) {
+        const c = str.charCodeAt(i);
+        if (c < 0x80) {
+            result.push(c);
+        }
+        else if (c < 0x800) {
+            result.push((c >> 6) | 0xc0);
+            result.push((c & 0x3f) | 0x80);
+        }
+        else if ((c & 0xfc00) == 0xd800) {
+            i++;
+            const c2 = str.charCodeAt(i);
+            assertArgument(i < str.length && ((c2 & 0xfc00) === 0xdc00), "invalid surrogate pair", "str", str);
+            // Surrogate Pair
+            const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);
+            result.push((pair >> 18) | 0xf0);
+            result.push(((pair >> 12) & 0x3f) | 0x80);
+            result.push(((pair >> 6) & 0x3f) | 0x80);
+            result.push((pair & 0x3f) | 0x80);
+        }
+        else {
+            result.push((c >> 12) | 0xe0);
+            result.push(((c >> 6) & 0x3f) | 0x80);
+            result.push((c & 0x3f) | 0x80);
+        }
+    }
+    return new Uint8Array(result);
+}
+;
+//export 
+function _toUtf8String(codePoints) {
+    return codePoints.map((codePoint) => {
+        if (codePoint <= 0xffff) {
+            return String.fromCharCode(codePoint);
+        }
+        codePoint -= 0x10000;
+        return String.fromCharCode((((codePoint >> 10) & 0x3ff) + 0xd800), ((codePoint & 0x3ff) + 0xdc00));
+    }).join("");
+}
+/**
+ *  Returns the string represented by the UTF-8 data %%bytes%%.
+ *
+ *  When %%onError%% function is specified, it is called on UTF-8
+ *  errors allowing recovery using the [[Utf8ErrorFunc]] API.
+ *  (default: [error](Utf8ErrorFuncs))
+ */
+export function toUtf8String(bytes, onError) {
+    return _toUtf8String(getUtf8CodePoints(bytes, onError));
+}
+/**
+ *  Returns the UTF-8 code-points for %%str%%.
+ *
+ *  If %%form%% is specified, the string is normalized.
+ */
+export function toUtf8CodePoints(str, form) {
+    return getUtf8CodePoints(toUtf8Bytes(str, form));
+}

package/js/src/src/static_dependencies/ethers/utils/uuid.d.ts

@@ -0,0 +1,7 @@
+import type { BytesLike } from "./index.js";
+/**
+ *  Returns the version 4 [[link-uuid]] for the %%randomBytes%%.
+ *
+ *  @see: https://www.ietf.org/rfc/rfc4122.txt (Section 4.4)
+ */
+export declare function uuidV4(randomBytes: BytesLike): string;

package/js/src/src/static_dependencies/ethers/utils/uuid.js

@@ -0,0 +1,35 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/**
+ *  Explain UUID and link to RFC here.
+ *
+ *  @_subsection: api/utils:UUID  [about-uuid]
+ */
+import { getBytes, hexlify } from "./data.js";
+/**
+ *  Returns the version 4 [[link-uuid]] for the %%randomBytes%%.
+ *
+ *  @see: https://www.ietf.org/rfc/rfc4122.txt (Section 4.4)
+ */
+export function uuidV4(randomBytes) {
+    const bytes = getBytes(randomBytes, "randomBytes");
+    // Section: 4.1.3:
+    // - time_hi_and_version[12:16] = 0b0100
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    // Section 4.4
+    // - clock_seq_hi_and_reserved[6] = 0b0
+    // - clock_seq_hi_and_reserved[7] = 0b1
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const value = hexlify(bytes);
+    return [
+        value.substring(2, 10),
+        value.substring(10, 14),
+        value.substring(14, 18),
+        value.substring(18, 22),
+        value.substring(22, 34),
+    ].join("-");
+}

package/js/src/src/static_dependencies/fflake/browser.d.ts

@@ -0,0 +1,222 @@
+export function deflate(data: any, opts: any, cb: any): () => void;
+/**
+ * Compresses data with DEFLATE without any wrapper
+ * @param data The data to compress
+ * @param opts The compression options
+ * @returns The deflated version of the data
+ */
+export function deflateSync(data: any, opts: any): Uint8Array | Uint16Array | Uint32Array;
+export function inflate(data: any, opts: any, cb: any): () => void;
+/**
+ * Expands DEFLATE data with no wrapper
+ * @param data The data to decompress
+ * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
+ * @returns The decompressed version of the data
+ */
+export function inflateSync(data: any, out?: any): any;
+export function gzip(data: any, opts: any, cb: any): () => void;
+/**
+ * Compresses data with GZIP
+ * @param data The data to compress
+ * @param opts The compression options
+ * @returns The gzipped version of the data
+ */
+export function gzipSync(data: any, opts: any): Uint8Array | Uint16Array | Uint32Array;
+export function gunzip(data: any, opts: any, cb: any): () => void;
+/**
+ * Expands GZIP data
+ * @param data The data to decompress
+ * @param out Where to write the data. GZIP already encodes the output size, so providing this doesn't save memory.
+ * @returns The decompressed version of the data
+ */
+export function gunzipSync(data: any, out?: any): any;
+export function zlib(data: any, opts: any, cb: any): () => void;
+/**
+ * Compress data with Zlib
+ * @param data The data to compress
+ * @param opts The compression options
+ * @returns The zlib-compressed version of the data
+ */
+export function zlibSync(data: any, opts: any): Uint8Array | Uint16Array | Uint32Array;
+export function unzlib(data: any, opts: any, cb: any): () => void;
+/**
+ * Expands Zlib data
+ * @param data The data to decompress
+ * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
+ * @returns The decompressed version of the data
+ */
+export function unzlibSync(data: any, out: any): any;
+export function decompress(data: any, opts: any, cb: any): () => void;
+/**
+ * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format
+ * @param data The data to decompress
+ * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
+ * @returns The decompressed version of the data
+ */
+export function decompressSync(data: any, out: any): any;
+/**
+ * Converts a string into a Uint8Array for use with compression/decompression methods
+ * @param str The string to encode
+ * @param latin1 Whether or not to interpret the data as Latin-1. This should
+ *               not need to be true unless decoding a binary string.
+ * @returns The string encoded in UTF-8/Latin-1 binary
+ */
+export function strToU8(str: any, latin1: any): Uint8Array | Uint16Array | Uint32Array;
+/**
+ * Converts a Uint8Array to a string
+ * @param dat The data to decode to string
+ * @param latin1 Whether or not to interpret the data as Latin-1. This should
+ *               not need to be true unless encoding to binary string.
+ * @returns The original UTF-8/Latin-1 string
+ */
+export function strFromU8(dat: any, latin1: any): string | Uint8Array | Uint16Array | Uint32Array;
+export function zip(data: any, opts: any, cb: any): () => void;
+/**
+ * Synchronously creates a ZIP file. Prefer using `zip` for better performance
+ * with more than one file.
+ * @param data The directory structure for the ZIP archive
+ * @param opts The main options, merged with per-file options
+ * @returns The generated ZIP archive
+ */
+export function zipSync(data: any, opts: any): Uint8Array;
+export function unzip(data: any, opts: any, cb: any): () => void;
+/**
+ * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better
+ * performance with more than one file.
+ * @param data The raw compressed ZIP file
+ * @param opts The ZIP extraction options
+ * @returns The decompressed files
+ */
+export function unzipSync(data: any, opts: any): {};
+export namespace FlateErrorCode {
+    const UnexpectedEOF: number;
+    const InvalidBlockType: number;
+    const InvalidLengthLiteral: number;
+    const InvalidDistance: number;
+    const StreamFinished: number;
+    const NoStreamHandler: number;
+    const InvalidHeader: number;
+    const NoCallback: number;
+    const InvalidUTF8: number;
+    const ExtraFieldTooLong: number;
+    const InvalidDate: number;
+    const FilenameTooLong: number;
+    const StreamFinishing: number;
+    const InvalidZipData: number;
+    const UnknownCompressionMethod: number;
+}
+/**
+ * Streaming DEFLATE compression
+ * @type Class
+ */
+export var Deflate: Class;
+/**
+ * Asynchronous streaming DEFLATE compression
+ * @type Class
+ */
+export var AsyncDeflate: Class;
+/**
+ * Streaming DEFLATE decompression
+ * @type Class
+ */
+export var Inflate: Class;
+/**
+ * @type Class
+ * Asynchronous streaming DEFLATE decompression
+ */
+export var AsyncInflate: Class;
+/**
+ * Streaming GZIP compression
+ * @type Class
+ */
+export var Gzip: Class;
+export function AsyncGzip(opts: any, cb: any): void;
+/**
+ * Streaming GZIP decompression
+ * @type Class
+ */
+export var Gunzip: Class;
+/**
+ * @type Class
+ * Asynchronous streaming GZIP decompression
+ */
+export var AsyncGunzip: Class;
+/**
+ * @type Class
+ * Streaming Zlib compression
+ */
+export var Zlib: Class;
+export function AsyncZlib(opts: any, cb: any): void;
+/**
+ * Streaming Zlib decompression
+ * @type Class
+ */
+export var Unzlib: Class;
+/**
+ * @type Class
+ * Asynchronous streaming Zlib decompression
+ */
+export var AsyncUnzlib: Class;
+/**
+ * @type Class
+ * Streaming GZIP, Zlib, or raw DEFLATE decompression
+ */
+export var Decompress: Class;
+/**
+ * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression
+ * @type Class
+ */
+export var AsyncDecompress: Class;
+/**
+ * @type Class
+ * Streaming UTF-8 decoding
+ */
+export var DecodeUTF8: Class;
+/**
+ * Streaming UTF-8 encoding
+ * @type Class
+ */
+export var EncodeUTF8: Class;
+/**
+ * A pass-through stream to keep data uncompressed in a ZIP archive.
+ * @type Class
+ */
+export var ZipPassThrough: Class;
+/**
+ * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate
+ * for better performance
+ * @type Class
+ */
+export var ZipDeflate: Class;
+/**
+ * Asynchronous streaming DEFLATE compression for ZIP archives
+ * @type Class
+ */
+export var AsyncZipDeflate: Class;
+/**
+ * A zippable archive to which files can incrementally be added
+ * @type Class
+ */
+export var Zip: Class;
+/**
+ * Streaming pass-through decompression for ZIP archives
+ * @type Class
+ */
+export var UnzipPassThrough: Class;
+/**
+ * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for
+ * better performance.
+ * @type Class
+ */
+export var UnzipInflate: Class;
+/**
+ * @type Class
+ * Asynchronous streaming DEFLATE decompression for ZIP archives
+ */
+export var AsyncUnzipInflate: Class;
+/**
+ * A ZIP archive decompression stream that emits files as they are discovered
+ * @type Class
+ */
+export var Unzip: Class;
+export { gzip as compress, AsyncGzip as AsyncCompress, gzipSync as compressSync, Gzip as Compress };