@nktkas/hyperliquid 0.13.1 → 0.13.2

package/script/deps/jsr.io/@std/encoding/1.0.7/_validate_binary_like.js

@@ -0,0 +1,39 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.validateBinaryLike = validateBinaryLike;
+    const encoder = new TextEncoder();
+    function getTypeName(value) {
+        const type = typeof value;
+        if (type !== "object") {
+            return type;
+        }
+        else if (value === null) {
+            return "null";
+        }
+        else {
+            return value?.constructor?.name ?? "object";
+        }
+    }
+    function validateBinaryLike(source) {
+        if (typeof source === "string") {
+            return encoder.encode(source);
+        }
+        else if (source instanceof Uint8Array) {
+            return source;
+        }
+        else if (source instanceof ArrayBuffer) {
+            return new Uint8Array(source);
+        }
+        throw new TypeError(`Cannot validate the input as it must be a Uint8Array, a string, or an ArrayBuffer: received a value of the type ${getTypeName(source)}`);
+    }
+});

package/{esm/deps/jsr.io/@std/encoding/1.0.6 → script/deps/jsr.io/@std/encoding/1.0.7}/hex.d.ts

@@ -1,3 +1,5 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
 /**
  * Converts data into a hex-encoded string.
  *
@@ -33,5 +35,5 @@ export declare function encodeHex(src: string | Uint8Array | ArrayBuffer): strin
  * );
  * ```
  */
-export declare function decodeHex(src: string): Uint8Array;
+export declare function decodeHex(src: string): Uint8Array_;
 //# sourceMappingURL=hex.d.ts.map

package/script/deps/jsr.io/@std/encoding/1.0.7/hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.7/hex.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AA4B5B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,CAUxE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAiBlD"}

package/script/deps/jsr.io/@std/encoding/1.0.7/hex.js

@@ -0,0 +1,123 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// https://github.com/golang/go/blob/master/LICENSE
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./_validate_binary_like.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.encodeHex = encodeHex;
+    exports.decodeHex = decodeHex;
+    /**
+     * Port of the Go
+     * {@link https://github.com/golang/go/blob/go1.12.5/src/encoding/hex/hex.go | encoding/hex}
+     * library.
+     *
+     * ```ts
+     * import {
+     *   decodeHex,
+     *   encodeHex,
+     * } from "@std/encoding/hex";
+     * import { assertEquals } from "@std/assert";
+     *
+     * assertEquals(encodeHex("abc"), "616263");
+     *
+     * assertEquals(
+     *   decodeHex("616263"),
+     *   new TextEncoder().encode("abc"),
+     * );
+     * ```
+     *
+     * @module
+     */
+    const _validate_binary_like_js_1 = require("./_validate_binary_like.js");
+    const hexTable = new TextEncoder().encode("0123456789abcdef");
+    const textEncoder = new TextEncoder();
+    const textDecoder = new TextDecoder();
+    function errInvalidByte(byte) {
+        return new TypeError(`Invalid byte '${String.fromCharCode(byte)}'`);
+    }
+    function errLength(len) {
+        return new RangeError(`Cannot decode the hex string as the input length should be even: length is ${len}`);
+    }
+    /** Converts a hex character into its value. */
+    function fromHexChar(byte) {
+        // '0' <= byte && byte <= '9'
+        if (48 <= byte && byte <= 57)
+            return byte - 48;
+        // 'a' <= byte && byte <= 'f'
+        if (97 <= byte && byte <= 102)
+            return byte - 97 + 10;
+        // 'A' <= byte && byte <= 'F'
+        if (65 <= byte && byte <= 70)
+            return byte - 65 + 10;
+        throw errInvalidByte(byte);
+    }
+    /**
+     * Converts data into a hex-encoded string.
+     *
+     * @param src The data to encode.
+     *
+     * @returns The hex-encoded string.
+     *
+     * @example Usage
+     * ```ts
+     * import { encodeHex } from "@std/encoding/hex";
+     * import { assertEquals } from "@std/assert";
+     *
+     * assertEquals(encodeHex("abc"), "616263");
+     * ```
+     */
+    function encodeHex(src) {
+        const u8 = (0, _validate_binary_like_js_1.validateBinaryLike)(src);
+        const dst = new Uint8Array(u8.length * 2);
+        for (let i = 0; i < u8.length; i++) {
+            const v = u8[i];
+            dst[i * 2] = hexTable[v >> 4];
+            dst[i * 2 + 1] = hexTable[v & 0x0f];
+        }
+        return textDecoder.decode(dst);
+    }
+    /**
+     * Decodes the given hex-encoded string. If the input is malformed, an error is
+     * thrown.
+     *
+     * @param src The hex-encoded string to decode.
+     *
+     * @returns The decoded data.
+     *
+     * @example Usage
+     * ```ts
+     * import { decodeHex } from "@std/encoding/hex";
+     * import { assertEquals } from "@std/assert";
+     *
+     * assertEquals(
+     *   decodeHex("616263"),
+     *   new TextEncoder().encode("abc"),
+     * );
+     * ```
+     */
+    function decodeHex(src) {
+        const u8 = textEncoder.encode(src);
+        const dst = new Uint8Array(u8.length / 2);
+        for (let i = 0; i < dst.length; i++) {
+            const a = fromHexChar(u8[i * 2]);
+            const b = fromHexChar(u8[i * 2 + 1]);
+            dst[i] = (a << 4) | b;
+        }
+        if (u8.length % 2 === 1) {
+            // Check for invalid char before reporting bad length,
+            // since the invalid char (if present) is an earlier problem.
+            fromHexChar(u8[dst.length * 2]);
+            throw errLength(u8.length);
+        }
+        return dst;
+    }
+});

package/script/deps/jsr.io/@std/msgpack/1.0.3/_types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Proxy type of {@code Uint8Array<ArrayBuffer} or {@code Uint8Array} in TypeScript 5.7 or below respectively.
+ *
+ * This type is internal utility type and should not be used directly.
+ *
+ * @internal @private
+ */
+export type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
+//# sourceMappingURL=_types.d.ts.map

package/script/deps/jsr.io/@std/msgpack/1.0.3/_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/msgpack/1.0.3/_types.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC"}

package/script/deps/jsr.io/@std/msgpack/1.0.3/_types.js

@@ -0,0 +1,13 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/script/deps/jsr.io/@std/msgpack/{1.0.2 → 1.0.3}/encode.d.ts

@@ -1,3 +1,5 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
 /**
  * Value types that can be encoded to MessagePack.
  */
@@ -33,5 +35,5 @@ export interface ValueMap {
  * @param object Value to encode to MessagePack binary format.
  * @returns Encoded MessagePack binary data.
  */
-export declare function encode(object: ValueType): Uint8Array;
+export declare function encode(object: ValueType): Uint8Array_;
 //# sourceMappingURL=encode.d.ts.map

package/script/deps/jsr.io/@std/msgpack/1.0.3/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/msgpack/1.0.3/encode.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,UAAU,GACV,SAAS,SAAS,EAAE,GACpB,QAAQ,CAAC;AAEb;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,sBAAsB;IACtB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACrC;AAeD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,WAAW,CAIrD"}

package/script/deps/jsr.io/@std/msgpack/1.0.3/encode.js

@@ -0,0 +1,250 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../bytes/1.0.5/concat.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.encode = encode;
+    const concat_js_1 = require("../../bytes/1.0.5/concat.js");
+    const FOUR_BITS = 16;
+    const FIVE_BITS = 32;
+    const SEVEN_BITS = 128;
+    const EIGHT_BITS = 256;
+    const FIFTEEN_BITS = 32768;
+    const SIXTEEN_BITS = 65536;
+    const THIRTY_ONE_BITS = 2147483648;
+    const THIRTY_TWO_BITS = 4294967296;
+    const SIXTY_THREE_BITS = 9223372036854775808n;
+    const SIXTY_FOUR_BITS = 18446744073709551616n;
+    const encoder = new TextEncoder();
+    /**
+     * Encode a value to {@link https://msgpack.org/ | MessagePack} binary format.
+     *
+     * @example Usage
+     * ```ts
+     * import { encode } from "@std/msgpack/encode";
+     * import { assertEquals } from "@std/assert";
+     *
+     * const obj = {
+     *   str: "deno",
+     *   arr: [1, 2, 3],
+     *   map: {
+     *     foo: "bar"
+     *   }
+     * }
+     *
+     * const encoded = encode(obj);
+     *
+     * assertEquals(encoded.length, 31);
+     * ```
+     *
+     * @param object Value to encode to MessagePack binary format.
+     * @returns Encoded MessagePack binary data.
+     */
+    function encode(object) {
+        const byteParts = [];
+        encodeSlice(object, byteParts);
+        return (0, concat_js_1.concat)(byteParts);
+    }
+    function encodeFloat64(num) {
+        const dataView = new DataView(new ArrayBuffer(9));
+        dataView.setFloat64(1, num);
+        dataView.setUint8(0, 0xcb);
+        return new Uint8Array(dataView.buffer);
+    }
+    function encodeNumber(num) {
+        if (!Number.isInteger(num)) { // float 64
+            return encodeFloat64(num);
+        }
+        if (num < 0) {
+            if (num >= -FIVE_BITS) { // negative fixint
+                return new Uint8Array([num]);
+            }
+            if (num >= -SEVEN_BITS) { // int 8
+                return new Uint8Array([0xd0, num]);
+            }
+            if (num >= -FIFTEEN_BITS) { // int 16
+                const dataView = new DataView(new ArrayBuffer(3));
+                dataView.setInt16(1, num);
+                dataView.setUint8(0, 0xd1);
+                return new Uint8Array(dataView.buffer);
+            }
+            if (num >= -THIRTY_ONE_BITS) { // int 32
+                const dataView = new DataView(new ArrayBuffer(5));
+                dataView.setInt32(1, num);
+                dataView.setUint8(0, 0xd2);
+                return new Uint8Array(dataView.buffer);
+            }
+            // float 64
+            return encodeFloat64(num);
+        }
+        // if the number fits within a positive fixint, use it
+        if (num <= 0x7f) {
+            return new Uint8Array([num]);
+        }
+        if (num < EIGHT_BITS) { // uint8
+            return new Uint8Array([0xcc, num]);
+        }
+        if (num < SIXTEEN_BITS) { // uint16
+            const dataView = new DataView(new ArrayBuffer(3));
+            dataView.setUint16(1, num);
+            dataView.setUint8(0, 0xcd);
+            return new Uint8Array(dataView.buffer);
+        }
+        if (num < THIRTY_TWO_BITS) { // uint32
+            const dataView = new DataView(new ArrayBuffer(5));
+            dataView.setUint32(1, num);
+            dataView.setUint8(0, 0xce);
+            return new Uint8Array(dataView.buffer);
+        }
+        // float 64
+        return encodeFloat64(num);
+    }
+    function encodeSlice(object, byteParts) {
+        if (object === null) {
+            byteParts.push(new Uint8Array([0xc0]));
+            return;
+        }
+        if (object === false) {
+            byteParts.push(new Uint8Array([0xc2]));
+            return;
+        }
+        if (object === true) {
+            byteParts.push(new Uint8Array([0xc3]));
+            return;
+        }
+        if (typeof object === "number") {
+            byteParts.push(encodeNumber(object));
+            return;
+        }
+        if (typeof object === "bigint") {
+            if (object < 0) {
+                if (object < -SIXTY_THREE_BITS) {
+                    throw new Error("Cannot safely encode bigint larger than 64 bits");
+                }
+                const dataView = new DataView(new ArrayBuffer(9));
+                dataView.setBigInt64(1, object);
+                dataView.setUint8(0, 0xd3);
+                byteParts.push(new Uint8Array(dataView.buffer));
+                return;
+            }
+            if (object >= SIXTY_FOUR_BITS) {
+                throw new Error("Cannot safely encode bigint larger than 64 bits");
+            }
+            const dataView = new DataView(new ArrayBuffer(9));
+            dataView.setBigUint64(1, object);
+            dataView.setUint8(0, 0xcf);
+            byteParts.push(new Uint8Array(dataView.buffer));
+            return;
+        }
+        if (typeof object === "string") {
+            const encoded = encoder.encode(object);
+            const len = encoded.length;
+            if (len < FIVE_BITS) { // fixstr
+                byteParts.push(new Uint8Array([0xa0 | len]));
+            }
+            else if (len < EIGHT_BITS) { // str 8
+                byteParts.push(new Uint8Array([0xd9, len]));
+            }
+            else if (len < SIXTEEN_BITS) { // str 16
+                const dataView = new DataView(new ArrayBuffer(3));
+                dataView.setUint16(1, len);
+                dataView.setUint8(0, 0xda);
+                byteParts.push(new Uint8Array(dataView.buffer));
+            }
+            else if (len < THIRTY_TWO_BITS) { // str 32
+                const dataView = new DataView(new ArrayBuffer(5));
+                dataView.setUint32(1, len);
+                dataView.setUint8(0, 0xdb);
+                byteParts.push(new Uint8Array(dataView.buffer));
+            }
+            else {
+                throw new Error("Cannot safely encode string with size larger than 32 bits");
+            }
+            byteParts.push(encoded);
+            return;
+        }
+        if (object instanceof Uint8Array) {
+            if (object.length < EIGHT_BITS) { // bin 8
+                byteParts.push(new Uint8Array([0xc4, object.length]));
+            }
+            else if (object.length < SIXTEEN_BITS) { // bin 16
+                const dataView = new DataView(new ArrayBuffer(3));
+                dataView.setUint16(1, object.length);
+                dataView.setUint8(0, 0xc5);
+                byteParts.push(new Uint8Array(dataView.buffer));
+            }
+            else if (object.length < THIRTY_TWO_BITS) { // bin 32
+                const dataView = new DataView(new ArrayBuffer(5));
+                dataView.setUint32(1, object.length);
+                dataView.setUint8(0, 0xc6);
+                byteParts.push(new Uint8Array(dataView.buffer));
+            }
+            else {
+                throw new Error("Cannot safely encode Uint8Array with size larger than 32 bits");
+            }
+            byteParts.push(object);
+            return;
+        }
+        if (Array.isArray(object)) {
+            if (object.length < FOUR_BITS) { // fixarray
+                byteParts.push(new Uint8Array([0x90 | object.length]));
+            }
+            else if (object.length < SIXTEEN_BITS) { // array 16
+                const dataView = new DataView(new ArrayBuffer(3));
+                dataView.setUint16(1, object.length);
+                dataView.setUint8(0, 0xdc);
+                byteParts.push(new Uint8Array(dataView.buffer));
+            }
+            else if (object.length < THIRTY_TWO_BITS) { // array 32
+                const dataView = new DataView(new ArrayBuffer(5));
+                dataView.setUint32(1, object.length);
+                dataView.setUint8(0, 0xdd);
+                byteParts.push(new Uint8Array(dataView.buffer));
+            }
+            else {
+                throw new Error("Cannot safely encode array with size larger than 32 bits");
+            }
+            for (const obj of object) {
+                encodeSlice(obj, byteParts);
+            }
+            return;
+        }
+        // If object is a plain object
+        const prototype = Object.getPrototypeOf(object);
+        if (prototype === null || prototype === Object.prototype) {
+            const numKeys = Object.keys(object).length;
+            if (numKeys < FOUR_BITS) { // fixarray
+                byteParts.push(new Uint8Array([0x80 | numKeys]));
+            }
+            else if (numKeys < SIXTEEN_BITS) { // map 16
+                const dataView = new DataView(new ArrayBuffer(3));
+                dataView.setUint16(1, numKeys);
+                dataView.setUint8(0, 0xde);
+                byteParts.push(new Uint8Array(dataView.buffer));
+            }
+            else if (numKeys < THIRTY_TWO_BITS) { // map 32
+                const dataView = new DataView(new ArrayBuffer(5));
+                dataView.setUint32(1, numKeys);
+                dataView.setUint8(0, 0xdf);
+                byteParts.push(new Uint8Array(dataView.buffer));
+            }
+            else {
+                throw new Error("Cannot safely encode map with size larger than 32 bits");
+            }
+            for (const [key, value] of Object.entries(object)) {
+                encodeSlice(key, byteParts);
+                encodeSlice(value, byteParts);
+            }
+            return;
+        }
+        throw new Error("Cannot safely encode value into messagepack");
+    }
+});

package/script/mod.d.ts

@@ -15,6 +15,7 @@ export type * from "./src/types/explorer/requests.js";
 export type * from "./src/types/explorer/responses.js";
 export type * from "./src/types/info/accounts.js";
 export type * from "./src/types/info/assets.js";
+export type * from "./src/types/info/delegations.js";
 export type * from "./src/types/info/orders.js";
 export type * from "./src/types/info/requests.js";
 export type * from "./src/types/info/vaults.js";

package/script/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AACA,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,0BAA0B,CAAC;AAEzC,cAAc,yCAAyC,CAAC;AAExD,cAAc,mDAAmD,CAAC;AAClE,YAAY,EACR,qBAAqB,EACrB,4BAA4B,GAC/B,MAAM,sDAAsD,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,4DAA4D,CAAC;AAGnG,mBAAmB,uBAAuB,CAAC;AAE3C,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,mCAAmC,CAAC;AAEvD,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,mCAAmC,CAAC;AAEvD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,4BAA4B,CAAC;AAEhD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,uCAAuC,CAAC;AAG3D,YAAY,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AACA,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,0BAA0B,CAAC;AAEzC,cAAc,yCAAyC,CAAC;AAExD,cAAc,mDAAmD,CAAC;AAClE,YAAY,EACR,qBAAqB,EACrB,4BAA4B,GAC/B,MAAM,sDAAsD,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,4DAA4D,CAAC;AAGnG,mBAAmB,uBAAuB,CAAC;AAE3C,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,mCAAmC,CAAC;AAEvD,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,mCAAmC,CAAC;AAEvD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,iCAAiC,CAAC;AACrD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,4BAA4B,CAAC;AAEhD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,uCAAuC,CAAC;AAG3D,YAAY,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC"}

package/script/mod.js

@@ -1,4 +1,3 @@
-"use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -13,15 +12,26 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketRequestError = void 0;
-// Clients
-__exportStar(require("./src/clients/event.js"), exports);
-__exportStar(require("./src/clients/public.js"), exports);
-__exportStar(require("./src/clients/wallet.js"), exports);
-// Transports
-__exportStar(require("./src/transports/base.js"), exports);
-__exportStar(require("./src/transports/http/http_transport.js"), exports);
-__exportStar(require("./src/transports/websocket/websocket_transport.js"), exports);
-var websocket_request_dispatcher_js_1 = require("./src/transports/websocket/websocket_request_dispatcher.js");
-Object.defineProperty(exports, "WebSocketRequestError", { enumerable: true, get: function () { return websocket_request_dispatcher_js_1.WebSocketRequestError; } });
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./src/clients/event.js", "./src/clients/public.js", "./src/clients/wallet.js", "./src/transports/base.js", "./src/transports/http/http_transport.js", "./src/transports/websocket/websocket_transport.js", "./src/transports/websocket/websocket_request_dispatcher.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.WebSocketRequestError = void 0;
+    // Clients
+    __exportStar(require("./src/clients/event.js"), exports);
+    __exportStar(require("./src/clients/public.js"), exports);
+    __exportStar(require("./src/clients/wallet.js"), exports);
+    // Transports
+    __exportStar(require("./src/transports/base.js"), exports);
+    __exportStar(require("./src/transports/http/http_transport.js"), exports);
+    __exportStar(require("./src/transports/websocket/websocket_transport.js"), exports);
+    var websocket_request_dispatcher_js_1 = require("./src/transports/websocket/websocket_request_dispatcher.js");
+    Object.defineProperty(exports, "WebSocketRequestError", { enumerable: true, get: function () { return websocket_request_dispatcher_js_1.WebSocketRequestError; } });
+});