@rfkit/json-rpc-websocket 0.1.0 → 0.2.1

package/index.js

@@ -1 +1,885 @@
-var __webpack_modules__={"./src/msgpack/index.js":function(module,__unused_webpack_exports,__webpack_require__){module=__webpack_require__.nmd(module);(function(){"use strict";function serialize(data,options){if(options&&options.multiple&&!Array.isArray(data))throw new Error("Invalid argument type: Expected an Array to serialize multiple values.");const pow32=0x100000000;let floatBuffer,floatView;let array=new Uint8Array(128);let length=0;if(options&&options.multiple)for(let i=0;i<data.length;i++)append(data[i]);else append(data);return array.subarray(0,length);function append(data,isReplacement){switch(typeof data){case"undefined":appendNull(data);break;case"boolean":appendBoolean(data);break;case"number":appendNumber(data);break;case"string":appendString(data);break;case"object":if(null===data)appendNull(data);else if(data instanceof Date)appendDate(data);else if(Array.isArray(data))appendArray(data);else if(data instanceof Uint8Array||data instanceof Uint8ClampedArray)appendBinArray(data);else if(data instanceof Int8Array||data instanceof Int16Array||data instanceof Uint16Array||data instanceof Int32Array||data instanceof Uint32Array||data instanceof Float32Array||data instanceof Float64Array)appendArray(data);else appendObject(data);break;default:if(!isReplacement&&options&&options.invalidTypeReplacement)"function"==typeof options.invalidTypeReplacement?append(options.invalidTypeReplacement(data),true):append(options.invalidTypeReplacement,true);else throw new Error("Invalid argument type: The type '"+typeof data+"' cannot be serialized.")}}function appendNull(data){appendByte(192)}function appendBoolean(data){appendByte(data?195:194)}function appendNumber(data){if(isFinite(data)&&Math.floor(data)===data){if(data>=0&&data<=127)appendByte(data);else if(data<0&&data>=-32)appendByte(data);else if(data>0&&data<=255)appendBytes([204,data]);else if(data>=-128&&data<=127)appendBytes([208,data]);else if(data>0&&data<=65535)appendBytes([205,data>>>8,data]);else if(data>=-32768&&data<=32767)appendBytes([209,data>>>8,data]);else if(data>0&&data<=0xffffffff)appendBytes([206,data>>>24,data>>>16,data>>>8,data]);else if(data>=-0x80000000&&data<=0x7fffffff)appendBytes([210,data>>>24,data>>>16,data>>>8,data]);else if(data>0&&data<=0xffffffffffffffff){let hi=data/pow32;let lo=data%pow32;appendBytes([211,hi>>>24,hi>>>16,hi>>>8,hi,lo>>>24,lo>>>16,lo>>>8,lo])}else if(data>=-0x8000000000000000&&data<=0x8000000000000000){appendByte(211);appendInt64(data)}else data<0?appendBytes([211,128,0,0,0,0,0,0,0]):appendBytes([207,255,255,255,255,255,255,255,255])}else{if(!floatView){floatBuffer=new ArrayBuffer(8);floatView=new DataView(floatBuffer)}floatView.setFloat64(0,data);appendByte(203);appendBytes(new Uint8Array(floatBuffer))}}function appendString(data){let bytes=encodeUtf8(data);let length=bytes.length;if(length<=31)appendByte(160+length);else if(length<=255)appendBytes([217,length]);else length<=65535?appendBytes([218,length>>>8,length]):appendBytes([219,length>>>24,length>>>16,length>>>8,length]);appendBytes(bytes)}function appendArray(data){let length=data.length;if(length<=15)appendByte(144+length);else length<=65535?appendBytes([220,length>>>8,length]):appendBytes([221,length>>>24,length>>>16,length>>>8,length]);for(let index=0;index<length;index++)append(data[index])}function appendBinArray(data){let length=data.length;if(length<=15)appendBytes([196,length]);else length<=65535?appendBytes([197,length>>>8,length]):appendBytes([198,length>>>24,length>>>16,length>>>8,length]);appendBytes(data)}function appendObject(data){let length=0;for(let key in data)if(void 0!==data[key])length++;if(length<=15)appendByte(128+length);else length<=65535?appendBytes([222,length>>>8,length]):appendBytes([223,length>>>24,length>>>16,length>>>8,length]);for(let key in data){let value=data[key];if(void 0!==value){append(key);append(value)}}}function appendDate(data){let sec=data.getTime()/1e3;if(0===data.getMilliseconds()&&sec>=0&&sec<0x100000000)appendBytes([214,255,sec>>>24,sec>>>16,sec>>>8,sec]);else if(sec>=0&&sec<0x400000000){let ns=1e6*data.getMilliseconds();appendBytes([215,255,ns>>>22,ns>>>14,ns>>>6,ns<<2>>>0|sec/pow32,sec>>>24,sec>>>16,sec>>>8,sec])}else{let ns=1e6*data.getMilliseconds();appendBytes([199,12,255,ns>>>24,ns>>>16,ns>>>8,ns]);appendInt64(sec)}}function appendByte(byte){if(array.length<length+1){let newLength=2*array.length;while(newLength<length+1)newLength*=2;let newArray=new Uint8Array(newLength);newArray.set(array);array=newArray}array[length]=byte;length++}function appendBytes(bytes){if(array.length<length+bytes.length){let newLength=2*array.length;while(newLength<length+bytes.length)newLength*=2;let newArray=new Uint8Array(newLength);newArray.set(array);array=newArray}array.set(bytes,length);length+=bytes.length}function appendInt64(value){let hi,lo;if(value>=0){hi=value/pow32;lo=value%pow32}else{value++;hi=Math.abs(value)/pow32;lo=Math.abs(value)%pow32;hi=~hi;lo=~lo}appendBytes([hi>>>24,hi>>>16,hi>>>8,hi,lo>>>24,lo>>>16,lo>>>8,lo])}}function deserialize(array,options){const pow32=0x100000000;let pos=0;if(array instanceof ArrayBuffer)array=new Uint8Array(array);if("object"!=typeof array||void 0===array.length)throw new Error("Invalid argument type: Expected a byte array (Array or Uint8Array) to deserialize.");if(!array.length)throw new Error("Invalid argument: The byte array to deserialize is empty.");if(!(array instanceof Uint8Array))array=new Uint8Array(array);let data;if(options&&options.multiple){data=[];while(pos<array.length)data.push(read())}else data=read();return data;function read(){const byte=array[pos++];if(byte>=0&&byte<=127)return byte;if(byte>=128&&byte<=143)return readMap(byte-128);if(byte>=144&&byte<=159)return readArray(byte-144);if(byte>=160&&byte<=191)return readStr(byte-160);if(192===byte)return null;if(193===byte)throw new Error("Invalid byte code 0xc1 found.");if(194===byte)return false;if(195===byte)return true;if(196===byte)return readBin(-1,1);if(197===byte)return readBin(-1,2);if(198===byte)return readBin(-1,4);if(199===byte)return readExt(-1,1);if(200===byte)return readExt(-1,2);if(201===byte)return readExt(-1,4);if(202===byte)return readFloat(4);if(203===byte)return readFloat(8);if(204===byte)return readUInt(1);if(205===byte)return readUInt(2);if(206===byte)return readUInt(4);if(207===byte)return readUInt(8);if(208===byte)return readInt(1);if(209===byte)return readInt(2);if(210===byte)return readInt(4);if(211===byte)return readInt(8);if(212===byte)return readExt(1);if(213===byte)return readExt(2);if(214===byte)return readExt(4);if(215===byte)return readExt(8);if(216===byte)return readExt(16);if(217===byte)return readStr(-1,1);if(218===byte)return readStr(-1,2);if(219===byte)return readStr(-1,4);if(220===byte)return readArray(-1,2);if(221===byte)return readArray(-1,4);if(222===byte)return readMap(-1,2);if(223===byte)return readMap(-1,4);if(byte>=224&&byte<=255)return byte-256;console.debug("msgpack array:",array);throw new Error("Invalid byte value '"+byte+"' at index "+(pos-1)+" in the MessagePack binary data (length "+array.length+"): Expecting a range of 0 to 255. This is not a byte array.")}function readInt(size){let value=0;let first=true;while(size-- >0)if(first){let byte=array[pos++];value+=127&byte;if(128&byte)value-=128;first=false}else{value*=256;value+=array[pos++]}return value}function readUInt(size){let value=0;while(size-- >0){value*=256;value+=array[pos++]}return value}function readFloat(size){let view=new DataView(array.buffer,pos+array.byteOffset,size);pos+=size;if(4===size)return view.getFloat32(0,false);if(8===size)return view.getFloat64(0,false)}function readBin(size,lengthSize){if(size<0)size=readUInt(lengthSize);let data=array.subarray(pos,pos+size);pos+=size;return data}function readMap(size,lengthSize){if(size<0)size=readUInt(lengthSize);let data={};while(size-- >0){let key=read();data[key]=read()}return data}function readArray(size,lengthSize){if(size<0)size=readUInt(lengthSize);let data=[];while(size-- >0)data.push(read());return data}function readStr(size,lengthSize){if(size<0)size=readUInt(lengthSize);let start=pos;pos+=size;return decodeUtf8(array,start,size)}function readExt(size,lengthSize){if(size<0)size=readUInt(lengthSize);let type=readUInt(1);let data=readBin(size);switch(type){case 255:return readExtDate(data)}return{type:type,data:data}}function readExtDate(data){if(4===data.length){let sec=(data[0]<<24>>>0)+(data[1]<<16>>>0)+(data[2]<<8>>>0)+data[3];return new Date(1e3*sec)}if(8===data.length){let ns=(data[0]<<22>>>0)+(data[1]<<14>>>0)+(data[2]<<6>>>0)+(data[3]>>>2);let sec=(3&data[3])*pow32+(data[4]<<24>>>0)+(data[5]<<16>>>0)+(data[6]<<8>>>0)+data[7];return new Date(1e3*sec+ns/1e6)}if(12===data.length){let ns=(data[0]<<24>>>0)+(data[1]<<16>>>0)+(data[2]<<8>>>0)+data[3];pos-=8;let sec=readInt(8);return new Date(1e3*sec+ns/1e6)}throw new Error("Invalid data length for a date value.")}}function encodeUtf8(str){let ascii=true,length=str.length;for(let x=0;x<length;x++)if(str.charCodeAt(x)>127){ascii=false;break}let i=0,bytes=new Uint8Array(str.length*(ascii?1:4));for(let ci=0;ci!==length;ci++){let c=str.charCodeAt(ci);if(c<128){bytes[i++]=c;continue}if(c<2048)bytes[i++]=c>>6|192;else{if(c>55295&&c<56320){if(++ci>=length)throw new Error("UTF-8 encode: incomplete surrogate pair");let c2=str.charCodeAt(ci);if(c2<56320||c2>57343)throw new Error("UTF-8 encode: second surrogate character 0x"+c2.toString(16)+" at index "+ci+" out of range");c=65536+((1023&c)<<10)+(1023&c2);bytes[i++]=c>>18|240;bytes[i++]=c>>12&63|128}else bytes[i++]=c>>12|224;bytes[i++]=c>>6&63|128}bytes[i++]=63&c|128}return ascii?bytes:bytes.subarray(0,i)}function decodeUtf8(bytes,start,length){let i=start,str="";length+=start;while(i<length){let c=bytes[i++];if(c>127){if(c>191&&c<224){if(i>=length)throw new Error("UTF-8 decode: incomplete 2-byte sequence");c=(31&c)<<6|63&bytes[i++]}else if(c>223&&c<240){if(i+1>=length)throw new Error("UTF-8 decode: incomplete 3-byte sequence");c=(15&c)<<12|(63&bytes[i++])<<6|63&bytes[i++]}else if(c>239&&c<248){if(i+2>=length)throw new Error("UTF-8 decode: incomplete 4-byte sequence");c=(7&c)<<18|(63&bytes[i++])<<12|(63&bytes[i++])<<6|63&bytes[i++]}else throw new Error("UTF-8 decode: unknown multibyte start 0x"+c.toString(16)+" at index "+(i-1))}if(c<=65535)str+=String.fromCharCode(c);else if(c<=1114111){c-=65536;str+=String.fromCharCode(c>>10|55296);str+=String.fromCharCode(1023&c|56320)}else throw new Error("UTF-8 decode: code point 0x"+c.toString(16)+" exceeds UTF-16 reach")}return str}let msgpack={serialize:serialize,deserialize:deserialize,encode:serialize,decode:deserialize};if(module&&"object"==typeof module.exports)module.exports=msgpack;else window[window.msgpackJsName||"msgpack"]=msgpack})()}};var __webpack_module_cache__={};function __webpack_require__(moduleId){var cachedModule=__webpack_module_cache__[moduleId];if(void 0!==cachedModule)return cachedModule.exports;var module=__webpack_module_cache__[moduleId]={id:moduleId,loaded:false,exports:{}};__webpack_modules__[moduleId](module,module.exports,__webpack_require__);module.loaded=true;return module.exports}(()=>{__webpack_require__.nmd=function(module){module.paths=[];if(!module.children)module.children=[];return module}})();var msgpack=__webpack_require__("./src/msgpack/index.js");const generateHexSegment=()=>((1+Math.random())*65536|0).toString(16).substring(1);const generateUUID=()=>[generateHexSegment()+generateHexSegment(),generateHexSegment(),generateHexSegment(),generateHexSegment(),generateHexSegment()+generateHexSegment()+generateHexSegment()].join("-");const generateId=(length=8)=>{let result="";const characters="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";const charactersLength=characters.length;for(let i=0;i<length;i++)result+=characters.charAt(Math.floor(Math.random()*charactersLength));return result};const defaultProps={onopen:()=>{},onmessage:()=>{},onclose:()=>{},onerror:()=>{}};class Socket{props;guidStorage=[];callbackStorage={};ws;streamID="";constructor(props){this.props={jsonrpc:"2.0",...defaultProps,...props};this.ws=this.setupWS()}setupWS(){const ws=new WebSocket(this.props.url,this.props.protocols);ws.binaryType="arraybuffer";ws.onopen=e=>this.props.onopen(e);ws.onmessage=e=>this.onmessage(e);ws.onclose=e=>this.props.onclose(e);ws.onerror=e=>this.props.onerror(e);return ws}saveGUID(guid){this.guidStorage.push(guid);return guid}deleteGUID(guid){const arr=this.guidStorage;const index=arr.indexOf(guid);if(-1!==index){arr.splice(index,1);return true}return false}touchTimeout(id,time=15e3,onerror=()=>{}){setTimeout(()=>{if(this.guidStorage.includes(id)){onerror({code:408,message:"发送数据链接超时"});this.deleteGUID(id)}},time)}saveResponse(callback,id){this.callbackStorage[id]=callback}finishResponse(res,id){const callback=this.callbackStorage[id];if(void 0!==this.callbackStorage[id]&&callback){callback(res);if(id!==this.streamID)delete this.callbackStorage[id]}return id}onmessage(e){const response=(0,msgpack.decode)(Array.prototype.slice.call(new Uint8Array(e.data)));if(!response)return;const{id}=response;if(id&&this.deleteGUID(id))this.finishResponse(response,id);this.props.onmessage(response)}send=data=>{const{id:paramId,method,isInform,callback,onerror,params,timeout}=data;if(1!==this.ws.readyState){if(onerror)onerror({code:3,message:"连接已关闭或者没有链接成功"});return}if(void 0===method)return;let guid={};const id=this.saveGUID(paramId||generateUUID());if(!isInform){guid={id};if(callback)this.saveResponse(callback,id)}this.touchTimeout(id,timeout,onerror);this.ws.send((0,msgpack.encode)({jsonrpc:this.props.jsonrpc,params,method,...guid}))};stream=data=>{const{id:paramId,method,callback,params}=data;if(void 0===method||!callback||1!==this.ws.readyState)return;const id=this.saveGUID(paramId||generateUUID());if(callback)this.saveResponse(callback,id);this.ws.send((0,msgpack.encode)({jsonrpc:this.props.jsonrpc,params,method,id:this.streamID}));return{id:this.streamID,close:(code,reason)=>{this.streamID="";this.close(code,reason)}}};close=(code,reason)=>this.ws.close(code,reason);withUrl=url=>{this.close();this.guidStorage=[];this.callbackStorage={};this.streamID="";this.props.url=url;this.ws=this.setupWS()}}const src=Socket;export{src as default};
+function encodeUtf8(str) {
+    const length = str.length;
+    let ascii = true;
+    for(let i = 0; i < length; i++)if (str.charCodeAt(i) > 127) {
+        ascii = false;
+        break;
+    }
+    if (ascii) {
+        const bytes = new Uint8Array(length);
+        for(let i = 0; i < length; i++)bytes[i] = str.charCodeAt(i);
+        return bytes;
+    }
+    let bytes = new Uint8Array(2 * length);
+    let pos = 0;
+    for(let i = 0; i < length; i++){
+        let code = str.charCodeAt(i);
+        if (pos + 4 > bytes.length) {
+            const newBytes = new Uint8Array(Math.ceil(1.5 * bytes.length));
+            newBytes.set(bytes);
+            bytes = newBytes;
+        }
+        if (code < 0x80) bytes[pos++] = code;
+        else if (code < 0x800) {
+            bytes[pos++] = 0xc0 | code >>> 6;
+            bytes[pos++] = 0x80 | 0x3f & code;
+        } else if (code >= 0xd800 && code < 0xdc00) {
+            if (i + 1 >= length) throw new Error('UTF-8 encode: incomplete surrogate pair');
+            const code2 = str.charCodeAt(++i);
+            if (code2 < 0xdc00 || code2 > 0xdfff) throw new Error(`UTF-8 encode: second surrogate character 0x${code2.toString(16)} at index ${i} out of range`);
+            code = 0x10000 + ((0x3ff & code) << 10) + (0x3ff & code2);
+            bytes[pos++] = 0xf0 | code >>> 18;
+            bytes[pos++] = 0x80 | code >>> 12 & 0x3f;
+            bytes[pos++] = 0x80 | code >>> 6 & 0x3f;
+            bytes[pos++] = 0x80 | 0x3f & code;
+        } else {
+            bytes[pos++] = 0xe0 | code >>> 12;
+            bytes[pos++] = 0x80 | code >>> 6 & 0x3f;
+            bytes[pos++] = 0x80 | 0x3f & code;
+        }
+    }
+    return bytes.subarray(0, pos);
+}
+function decodeUtf8(bytes, start, length) {
+    const end = start + length;
+    let ascii = true;
+    for(let i = start; i < end; i++)if (bytes[i] > 127) {
+        ascii = false;
+        break;
+    }
+    if (ascii) return String.fromCharCode(...bytes.subarray(start, end));
+    let str = '';
+    let i = start;
+    while(i < end){
+        const byte1 = bytes[i++];
+        if (byte1 < 0x80) str += String.fromCharCode(byte1);
+        else if (byte1 < 0xe0) {
+            if (i >= end) throw new Error('UTF-8 decode: incomplete 2-byte sequence');
+            const byte2 = bytes[i++];
+            str += String.fromCharCode((0x1f & byte1) << 6 | 0x3f & byte2);
+        } else if (byte1 < 0xf0) {
+            if (i + 1 >= end) throw new Error('UTF-8 decode: incomplete 3-byte sequence');
+            const byte2 = bytes[i++];
+            const byte3 = bytes[i++];
+            str += String.fromCharCode((0x0f & byte1) << 12 | (0x3f & byte2) << 6 | 0x3f & byte3);
+        } else {
+            if (i + 2 >= end) throw new Error('UTF-8 decode: incomplete 4-byte sequence');
+            const byte2 = bytes[i++];
+            const byte3 = bytes[i++];
+            const byte4 = bytes[i++];
+            let code = (0x07 & byte1) << 18 | (0x3f & byte2) << 12 | (0x3f & byte3) << 6 | 0x3f & byte4;
+            if (code <= 0xffff) str += String.fromCharCode(code);
+            else if (code <= 0x10ffff) {
+                code -= 0x10000;
+                str += String.fromCharCode(0xd800 | code >>> 10);
+                str += String.fromCharCode(0xdc00 | 0x3ff & code);
+            } else throw new Error(`UTF-8 decode: code point 0x${code.toString(16)} exceeds UTF-16 reach`);
+        }
+    }
+    return str;
+}
+const POW32 = 0x100000000;
+function deserialize(array, options) {
+    let bytes;
+    if (array instanceof ArrayBuffer) bytes = new Uint8Array(array);
+    else if (array instanceof Uint8Array) bytes = array;
+    else if ('object' == typeof array && void 0 !== array.length) bytes = new Uint8Array(array);
+    else throw new Error('Invalid argument type: Expected a byte array (Array or Uint8Array) to deserialize.');
+    if (0 === bytes.length) throw new Error('Invalid argument: The byte array to deserialize is empty.');
+    let pos = 0;
+    if (null == options ? void 0 : options.multiple) {
+        const results = [];
+        while(pos < bytes.length)results.push(read());
+        return results;
+    }
+    return read();
+    function checkBounds(needed) {
+        if (pos + needed > bytes.length) throw new Error(`Buffer overflow: trying to read ${needed} bytes at position ${pos}, but only ${bytes.length - pos} bytes available`);
+    }
+    function read() {
+        checkBounds(1);
+        const byte = bytes[pos++];
+        if (byte >= 0x00 && byte <= 0x7f) return byte;
+        if (byte >= 0x80 && byte <= 0x8f) return readMap(byte - 0x80);
+        if (byte >= 0x90 && byte <= 0x9f) return readArray(byte - 0x90);
+        if (byte >= 0xa0 && byte <= 0xbf) return readStr(byte - 0xa0);
+        if (byte >= 0xe0 && byte <= 0xff) return byte - 256;
+        if (0xc0 === byte) return null;
+        if (0xc2 === byte) return false;
+        if (0xc3 === byte) return true;
+        if (0xc4 === byte) return readBin(-1, 1);
+        if (0xc5 === byte) return readBin(-1, 2);
+        if (0xc6 === byte) return readBin(-1, 4);
+        if (0xc7 === byte) return readExt(-1, 1);
+        if (0xc8 === byte) return readExt(-1, 2);
+        if (0xc9 === byte) return readExt(-1, 4);
+        if (0xd4 === byte) return readExt(1);
+        if (0xd5 === byte) return readExt(2);
+        if (0xd6 === byte) return readExt(4);
+        if (0xd7 === byte) return readExt(8);
+        if (0xd8 === byte) return readExt(16);
+        if (0xca === byte) return readFloat(4);
+        if (0xcb === byte) return readFloat(8);
+        if (0xcc === byte) return readUInt(1);
+        if (0xcd === byte) return readUInt(2);
+        if (0xce === byte) return readUInt(4);
+        if (0xcf === byte) return readUInt(8);
+        if (0xd0 === byte) return readInt(1);
+        if (0xd1 === byte) return readInt(2);
+        if (0xd2 === byte) return readInt(4);
+        if (0xd3 === byte) return readInt(8);
+        if (0xd9 === byte) return readStr(-1, 1);
+        if (0xda === byte) return readStr(-1, 2);
+        if (0xdb === byte) return readStr(-1, 4);
+        if (0xdc === byte) return readArray(-1, 2);
+        if (0xdd === byte) return readArray(-1, 4);
+        if (0xde === byte) return readMap(-1, 2);
+        if (0xdf === byte) return readMap(-1, 4);
+        if (0xc1 === byte) throw new Error('Invalid byte code 0xc1 found.');
+        throw new Error(`Invalid byte value '${byte}' at index ${pos - 1} in the MessagePack binary data (length ${bytes.length}): Expecting a range of 0 to 255. This is not a byte array.`);
+    }
+    function readInt(count) {
+        checkBounds(count);
+        let value = 0;
+        let first = true;
+        for(let i = 0; i < count; i++)if (first) {
+            const byte = bytes[pos++];
+            value += 0x7f & byte;
+            if (0x80 & byte) value -= 0x80;
+            first = false;
+        } else value = 256 * value + bytes[pos++];
+        return value;
+    }
+    function readUInt(count) {
+        checkBounds(count);
+        let value = 0;
+        for(let i = 0; i < count; i++)value = 256 * value + bytes[pos++];
+        return value;
+    }
+    function readFloat(size) {
+        checkBounds(size);
+        const view = new DataView(bytes.buffer, pos + bytes.byteOffset, size);
+        pos += size;
+        if (4 === size) return view.getFloat32(0, false);
+        if (8 === size) return view.getFloat64(0, false);
+        return 0;
+    }
+    function readBin(length, lengthSize) {
+        const finalLength = length < 0 ? readUInt(lengthSize) : length;
+        checkBounds(finalLength);
+        const data = bytes.subarray(pos, pos + finalLength);
+        pos += finalLength;
+        return data;
+    }
+    function readMap(length, lengthSize) {
+        const finalLength = length < 0 && void 0 !== lengthSize ? readUInt(lengthSize) : length;
+        const data = {};
+        for(let i = 0; i < finalLength; i++){
+            const key = read();
+            if ('string' != typeof key) throw new Error(`Invalid map key type: expected string, got ${typeof key}`);
+            data[key] = read();
+        }
+        return data;
+    }
+    function readArray(length, lengthSize) {
+        const finalLength = length < 0 && void 0 !== lengthSize ? readUInt(lengthSize) : length;
+        const data = [];
+        for(let i = 0; i < finalLength; i++)data.push(read());
+        return data;
+    }
+    function readStr(length, lengthSize) {
+        const finalLength = length < 0 && void 0 !== lengthSize ? readUInt(lengthSize) : length;
+        checkBounds(finalLength);
+        const str = decodeUtf8(bytes, pos, finalLength);
+        pos += finalLength;
+        return str;
+    }
+    function readExt(length, lengthSize) {
+        const finalLength = length < 0 && void 0 !== lengthSize ? readUInt(lengthSize) : length;
+        checkBounds(1 + finalLength);
+        const type = readUInt(1);
+        const data = readBin(finalLength, 0);
+        if (255 === type) return readExtDate(data);
+        return {
+            type,
+            data
+        };
+    }
+    function readExtDate(data) {
+        if (4 === data.length) {
+            const sec = (data[0] << 24 >>> 0) + (data[1] << 16 >>> 0) + (data[2] << 8 >>> 0) + data[3];
+            return new Date(1000 * sec);
+        }
+        if (8 === data.length) {
+            const ns = (data[0] << 22 >>> 0) + (data[1] << 14 >>> 0) + (data[2] << 6 >>> 0) + (data[3] >>> 2);
+            const sec = (0x3 & data[3]) * POW32 + (data[4] << 24 >>> 0) + (data[5] << 16 >>> 0) + (data[6] << 8 >>> 0) + data[7];
+            return new Date(1000 * sec + ns / 1000000);
+        }
+        if (12 === data.length) {
+            const ns = (data[0] << 24 >>> 0) + (data[1] << 16 >>> 0) + (data[2] << 8 >>> 0) + data[3];
+            pos -= 8;
+            const sec = readInt(8);
+            return new Date(1000 * sec + ns / 1000000);
+        }
+        throw new Error('Invalid data length for a date value.');
+    }
+}
+const serializer_POW32 = 0x100000000;
+const MAX_SAFE_INTEGER_HIGH = 0x1fffffffffffff;
+function serialize(data, options) {
+    if ((null == options ? void 0 : options.multiple) && !Array.isArray(data)) throw new Error('Invalid argument type: Expected an Array to serialize multiple values.');
+    let floatBuffer;
+    let floatView;
+    let buffer = new Uint8Array(256);
+    let length = 0;
+    if ((null == options ? void 0 : options.multiple) && Array.isArray(data)) for (const item of data)append(item);
+    else append(data);
+    return buffer.subarray(0, length);
+    function append(value, isReplacement = false) {
+        const type = typeof value;
+        switch(type){
+            case 'undefined':
+                appendNull();
+                break;
+            case 'boolean':
+                appendBoolean(value);
+                break;
+            case 'number':
+                appendNumber(value);
+                break;
+            case 'string':
+                appendString(value);
+                break;
+            case 'object':
+                if (null === value) appendNull();
+                else if (value instanceof Date) appendDate(value);
+                else if (Array.isArray(value)) appendArray(value);
+                else if (value instanceof Uint8Array || value instanceof Uint8ClampedArray) appendBinArray(value);
+                else if (value instanceof Int8Array || value instanceof Int16Array || value instanceof Uint16Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Float32Array || value instanceof Float64Array) appendArray(Array.from(value));
+                else appendObject(value);
+                break;
+            default:
+                if (!isReplacement && (null == options ? void 0 : options.invalidTypeReplacement)) {
+                    const replacement = 'function' == typeof options.invalidTypeReplacement ? options.invalidTypeReplacement(value) : options.invalidTypeReplacement;
+                    append(replacement, true);
+                } else throw new Error(`Invalid argument type: The type '${type}' cannot be serialized.`);
+        }
+    }
+    function appendNull() {
+        appendByte(0xc0);
+    }
+    function appendBoolean(value) {
+        appendByte(value ? 0xc3 : 0xc2);
+    }
+    function appendNumber(value) {
+        if (Number.isFinite(value) && Math.floor(value) === value) {
+            if (value >= 0 && value <= 0x7f) appendByte(value);
+            else if (value < 0 && value >= -32) appendByte(value);
+            else if (value > 0 && value <= 0xff) appendBytes([
+                0xcc,
+                value
+            ]);
+            else if (value >= -128 && value <= 0x7f) appendBytes([
+                0xd0,
+                value
+            ]);
+            else if (value > 0 && value <= 0xffff) appendBytes([
+                0xcd,
+                value >>> 8,
+                value
+            ]);
+            else if (value >= -32768 && value <= 0x7fff) appendBytes([
+                0xd1,
+                value >>> 8,
+                value
+            ]);
+            else if (value > 0 && value <= 0xffffffff) appendBytes([
+                0xce,
+                value >>> 24,
+                value >>> 16,
+                value >>> 8,
+                value
+            ]);
+            else if (value >= -2147483648 && value <= 0x7fffffff) appendBytes([
+                0xd2,
+                value >>> 24,
+                value >>> 16,
+                value >>> 8,
+                value
+            ]);
+            else if (value > 0 && value <= MAX_SAFE_INTEGER_HIGH) {
+                const hi = Math.floor(value / serializer_POW32);
+                const lo = Math.floor(value % serializer_POW32);
+                appendBytes([
+                    0xd3,
+                    hi >>> 24,
+                    hi >>> 16,
+                    hi >>> 8,
+                    hi,
+                    lo >>> 24,
+                    lo >>> 16,
+                    lo >>> 8,
+                    lo
+                ]);
+            } else if (value >= -MAX_SAFE_INTEGER_HIGH && value <= -2147483649) {
+                appendByte(0xd3);
+                appendInt64(value);
+            } else value < 0 ? appendBytes([
+                0xd3,
+                0x80,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0
+            ]) : appendBytes([
+                0xcf,
+                0xff,
+                0xff,
+                0xff,
+                0xff,
+                0xff,
+                0xff,
+                0xff,
+                0xff
+            ]);
+        } else {
+            if (!floatView) {
+                floatBuffer = new ArrayBuffer(8);
+                floatView = new DataView(floatBuffer);
+            }
+            floatView.setFloat64(0, value);
+            appendByte(0xcb);
+            appendBytes(new Uint8Array(floatBuffer));
+        }
+    }
+    function appendString(value) {
+        const bytes = encodeUtf8(value);
+        const len = bytes.length;
+        if (len <= 0x1f) appendByte(0xa0 + len);
+        else if (len <= 0xff) appendBytes([
+            0xd9,
+            len
+        ]);
+        else len <= 0xffff ? appendBytes([
+            0xda,
+            len >>> 8,
+            len
+        ]) : appendBytes([
+            0xdb,
+            len >>> 24,
+            len >>> 16,
+            len >>> 8,
+            len
+        ]);
+        appendBytes(bytes);
+    }
+    function appendArray(value) {
+        const len = value.length;
+        if (len <= 0xf) appendByte(0x90 + len);
+        else len <= 0xffff ? appendBytes([
+            0xdc,
+            len >>> 8,
+            len
+        ]) : appendBytes([
+            0xdd,
+            len >>> 24,
+            len >>> 16,
+            len >>> 8,
+            len
+        ]);
+        for (const item of value)append(item);
+    }
+    function appendBinArray(value) {
+        const len = value.length;
+        if (len <= 0xff) appendBytes([
+            0xc4,
+            len
+        ]);
+        else len <= 0xffff ? appendBytes([
+            0xc5,
+            len >>> 8,
+            len
+        ]) : appendBytes([
+            0xc6,
+            len >>> 24,
+            len >>> 16,
+            len >>> 8,
+            len
+        ]);
+        appendBytes(value);
+    }
+    function appendObject(value) {
+        let count = 0;
+        for(const key in value)if (void 0 !== value[key]) count++;
+        if (count <= 0xf) appendByte(0x80 + count);
+        else count <= 0xffff ? appendBytes([
+            0xde,
+            count >>> 8,
+            count
+        ]) : appendBytes([
+            0xdf,
+            count >>> 24,
+            count >>> 16,
+            count >>> 8,
+            count
+        ]);
+        for(const key in value){
+            const val = value[key];
+            if (void 0 !== val) {
+                append(key);
+                append(val);
+            }
+        }
+    }
+    function appendDate(value) {
+        const sec = value.getTime() / 1000;
+        if (0 === value.getMilliseconds() && sec >= 0 && sec < serializer_POW32) {
+            const secInt = Math.floor(sec);
+            appendBytes([
+                0xd6,
+                0xff,
+                secInt >>> 24,
+                secInt >>> 16,
+                secInt >>> 8,
+                secInt
+            ]);
+        } else if (sec >= 0 && sec < 4 * serializer_POW32) {
+            const ns = 1000000 * value.getMilliseconds();
+            const secInt = Math.floor(sec);
+            const secHigh = Math.floor(secInt / serializer_POW32);
+            appendBytes([
+                0xd7,
+                0xff,
+                ns >>> 22,
+                ns >>> 14,
+                ns >>> 6,
+                ns << 2 >>> 0 | secHigh,
+                secInt >>> 24,
+                secInt >>> 16,
+                secInt >>> 8,
+                secInt
+            ]);
+        } else {
+            const ns = 1000000 * value.getMilliseconds();
+            appendBytes([
+                0xc7,
+                12,
+                0xff,
+                ns >>> 24,
+                ns >>> 16,
+                ns >>> 8,
+                ns
+            ]);
+            appendInt64(sec);
+        }
+    }
+    function appendByte(byte) {
+        if (buffer.length < length + 1) expandBuffer(length + 1);
+        buffer[length++] = byte;
+    }
+    function appendBytes(bytes) {
+        const needed = length + bytes.length;
+        if (buffer.length < needed) expandBuffer(needed);
+        buffer.set(bytes, length);
+        length += bytes.length;
+    }
+    function expandBuffer(minSize) {
+        let newSize = Math.ceil(1.5 * buffer.length);
+        while(newSize < minSize)newSize = Math.ceil(1.5 * newSize);
+        const newBuffer = new Uint8Array(newSize);
+        newBuffer.set(buffer);
+        buffer = newBuffer;
+    }
+    function appendInt64(num) {
+        let hi;
+        let lo;
+        if (num >= 0) {
+            hi = Math.floor(num / serializer_POW32);
+            lo = Math.floor(num % serializer_POW32);
+        } else {
+            const absValue = Math.abs(num + 1);
+            hi = ~Math.floor(absValue / serializer_POW32);
+            lo = ~Math.floor(absValue % serializer_POW32);
+        }
+        appendBytes([
+            hi >>> 24,
+            hi >>> 16,
+            hi >>> 8,
+            hi,
+            lo >>> 24,
+            lo >>> 16,
+            lo >>> 8,
+            lo
+        ]);
+    }
+}
+const pack_serialize = serialize;
+const pack_deserialize = deserialize;
+const encode = serialize;
+const decode = deserialize;
+const generateHexSegment = ()=>((1 + Math.random()) * 0x10000 | 0).toString(16).substring(1);
+const generateUUID = ()=>[
+        generateHexSegment() + generateHexSegment(),
+        generateHexSegment(),
+        generateHexSegment(),
+        generateHexSegment(),
+        generateHexSegment() + generateHexSegment() + generateHexSegment()
+    ].join('-');
+var jsonrpc_JsonRpcErrorCode = /*#__PURE__*/ function(JsonRpcErrorCode) {
+    JsonRpcErrorCode[JsonRpcErrorCode["ParseError"] = -32700] = "ParseError";
+    JsonRpcErrorCode[JsonRpcErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
+    JsonRpcErrorCode[JsonRpcErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
+    JsonRpcErrorCode[JsonRpcErrorCode["InvalidParams"] = -32602] = "InvalidParams";
+    JsonRpcErrorCode[JsonRpcErrorCode["InternalError"] = -32603] = "InternalError";
+    JsonRpcErrorCode[JsonRpcErrorCode["ServerError"] = -32000] = "ServerError";
+    JsonRpcErrorCode[JsonRpcErrorCode["Timeout"] = -32001] = "Timeout";
+    JsonRpcErrorCode[JsonRpcErrorCode["ConnectionClosed"] = -32002] = "ConnectionClosed";
+    return JsonRpcErrorCode;
+}({});
+var socket_ConnectionState = /*#__PURE__*/ function(ConnectionState) {
+    ConnectionState[ConnectionState["Connecting"] = 0] = "Connecting";
+    ConnectionState[ConnectionState["Open"] = 1] = "Open";
+    ConnectionState[ConnectionState["Closing"] = 2] = "Closing";
+    ConnectionState[ConnectionState["Closed"] = 3] = "Closed";
+    return ConnectionState;
+}({});
+const SocketEvent = {
+    Open: 'open',
+    Close: 'close',
+    Error: 'error',
+    Message: 'message',
+    Reconnecting: 'reconnecting',
+    Reconnected: 'reconnected',
+    ReconnectFailed: 'reconnect_failed'
+};
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class EventEmitter {
+    on(event, listener) {
+        var _this_listeners_get;
+        if (!this.listeners.has(event)) this.listeners.set(event, new Set());
+        null === (_this_listeners_get = this.listeners.get(event)) || void 0 === _this_listeners_get || _this_listeners_get.add(listener);
+        return ()=>this.off(event, listener);
+    }
+    once(event, listener) {
+        const wrapper = (data)=>{
+            this.off(event, wrapper);
+            listener(data);
+        };
+        return this.on(event, wrapper);
+    }
+    off(event, listener) {
+        const eventListeners = this.listeners.get(event);
+        if (eventListeners) {
+            eventListeners.delete(listener);
+            if (0 === eventListeners.size) this.listeners.delete(event);
+        }
+    }
+    emit(event, data) {
+        const eventListeners = this.listeners.get(event);
+        if (eventListeners) for (const listener of eventListeners)try {
+            listener(data);
+        } catch (error) {
+            console.error(`Error in event listener for "${String(event)}":`, error);
+        }
+    }
+    removeAllListeners(event) {
+        if (event) this.listeners.delete(event);
+        else this.listeners.clear();
+    }
+    listenerCount(event) {
+        var _this_listeners_get;
+        return (null === (_this_listeners_get = this.listeners.get(event)) || void 0 === _this_listeners_get ? void 0 : _this_listeners_get.size) ?? 0;
+    }
+    constructor(){
+        _define_property(this, "listeners", new Map());
+    }
+}
+function client_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_OPTIONS = {
+    autoReconnect: true,
+    reconnectInterval: 3000,
+    maxReconnectAttempts: 5,
+    defaultTimeout: 15000,
+    heartbeatInterval: 0,
+    heartbeatMethod: 'ping',
+    debug: false
+};
+class JsonRpcWebSocketClient extends EventEmitter {
+    get state() {
+        var _this_ws;
+        return (null === (_this_ws = this.ws) || void 0 === _this_ws ? void 0 : _this_ws.readyState) ?? socket_ConnectionState.Closed;
+    }
+    get isConnected() {
+        return this.state === socket_ConnectionState.Open;
+    }
+    getStats() {
+        return {
+            ...this.stats,
+            pendingRequests: this.pendingRequests.size
+        };
+    }
+    connect() {
+        if (this.ws && this.ws.readyState === socket_ConnectionState.Connecting) return;
+        try {
+            this.ws = new WebSocket(this.options.url, this.options.protocols);
+            this.ws.binaryType = 'arraybuffer';
+            this.ws.onopen = this.handleOpen.bind(this);
+            this.ws.onmessage = this.handleMessage.bind(this);
+            this.ws.onclose = this.handleClose.bind(this);
+            this.ws.onerror = this.handleError.bind(this);
+        } catch (error) {
+            this.log('Connection error:', error);
+            this.scheduleReconnect();
+        }
+    }
+    handleOpen(event) {
+        this.log('Connection opened');
+        this.reconnectAttempts = 0;
+        this.startHeartbeat();
+        this.emit(SocketEvent.Open, event);
+    }
+    handleMessage(event) {
+        try {
+            const rawData = event.data;
+            const response = decode(new Uint8Array(rawData));
+            this.log('Received:', response);
+            this.stats.responsesReceived++;
+            if ('error' in response) this.stats.errors++;
+            if (null !== response.id) {
+                const streamCallback = this.streamCallbacks.get(response.id);
+                if (streamCallback) {
+                    streamCallback(response);
+                    this.emit(SocketEvent.Message, {
+                        data: response,
+                        rawData
+                    });
+                    return;
+                }
+                const metadata = this.pendingRequests.get(response.id);
+                if (metadata) {
+                    clearTimeout(metadata.timeoutId);
+                    this.pendingRequests.delete(response.id);
+                    const responseTime = Date.now() - metadata.timestamp;
+                    this.updateResponseTime(responseTime);
+                    if ('error' in response) metadata.reject(new Error(`${response.error.message} (${response.error.code})`));
+                    else metadata.resolve(response.result);
+                }
+            }
+            this.emit(SocketEvent.Message, {
+                data: response,
+                rawData
+            });
+        } catch (error) {
+            this.log('Failed to decode message:', error);
+        }
+    }
+    handleClose(event) {
+        this.log('Connection closed:', event.code, event.reason);
+        this.stopHeartbeat();
+        this.emit(SocketEvent.Close, event);
+        this.rejectAllPendingRequests(new Error('Connection closed'), jsonrpc_JsonRpcErrorCode.ConnectionClosed);
+        if (this.options.autoReconnect) this.scheduleReconnect();
+    }
+    handleError(event) {
+        this.log('Connection error:', event);
+        this.emit(SocketEvent.Error, event);
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimeoutId) return;
+        if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+            this.log('Max reconnect attempts reached');
+            this.emit(SocketEvent.ReconnectFailed, void 0);
+            return;
+        }
+        this.reconnectAttempts++;
+        this.stats.reconnectCount++;
+        this.log(`Reconnecting in ${this.options.reconnectInterval}ms (attempt ${this.reconnectAttempts}/${this.options.maxReconnectAttempts})`);
+        this.emit(SocketEvent.Reconnecting, {
+            attempt: this.reconnectAttempts,
+            maxAttempts: this.options.maxReconnectAttempts
+        });
+        this.reconnectTimeoutId = setTimeout(()=>{
+            this.reconnectTimeoutId = null;
+            this.connect();
+        }, this.options.reconnectInterval);
+    }
+    startHeartbeat() {
+        if (this.options.heartbeatInterval <= 0 || null !== this.heartbeatIntervalId) return;
+        this.heartbeatIntervalId = setInterval(()=>{
+            if (this.isConnected) this.notify({
+                method: this.options.heartbeatMethod
+            }).catch((error)=>{
+                this.log('Heartbeat failed:', error);
+            });
+        }, this.options.heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatIntervalId) {
+            clearInterval(this.heartbeatIntervalId);
+            this.heartbeatIntervalId = null;
+        }
+    }
+    rejectAllPendingRequests(error, code) {
+        for (const [id, metadata] of this.pendingRequests){
+            clearTimeout(metadata.timeoutId);
+            metadata.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
+    updateResponseTime(time) {
+        this.responseTimes.push(time);
+        if (this.responseTimes.length > 100) this.responseTimes.shift();
+        this.stats.averageResponseTime = this.responseTimes.reduce((sum, t)=>sum + t, 0) / this.responseTimes.length;
+    }
+    async request(options) {
+        if (!this.isConnected) throw new Error('WebSocket is not connected');
+        const id = options.id ?? generateUUID();
+        const request = {
+            jsonrpc: '2.0',
+            method: options.method,
+            params: options.params,
+            id
+        };
+        return new Promise((resolve, reject)=>{
+            const timeout = options.timeout ?? this.options.defaultTimeout;
+            const timeoutId = setTimeout(()=>{
+                this.pendingRequests.delete(id);
+                this.stats.timeouts++;
+                reject(new Error(`Request timeout after ${timeout}ms`));
+            }, timeout);
+            this.pendingRequests.set(id, {
+                id,
+                timestamp: Date.now(),
+                timeoutId,
+                resolve: resolve,
+                reject
+            });
+            try {
+                var _this_ws;
+                const encoded = encode(request);
+                null === (_this_ws = this.ws) || void 0 === _this_ws || _this_ws.send(encoded);
+                this.stats.requestsSent++;
+                this.log('Sent request:', request);
+            } catch (error) {
+                clearTimeout(timeoutId);
+                this.pendingRequests.delete(id);
+                reject(error);
+            }
+        });
+    }
+    async notify(options) {
+        var _this_ws;
+        if (!this.isConnected) throw new Error('WebSocket is not connected');
+        const notification = {
+            jsonrpc: '2.0',
+            method: options.method,
+            params: options.params
+        };
+        const encoded = encode(notification);
+        null === (_this_ws = this.ws) || void 0 === _this_ws || _this_ws.send(encoded);
+        this.log('Sent notification:', notification);
+    }
+    stream(options, callback) {
+        if (!this.isConnected) throw new Error('WebSocket is not connected');
+        const id = options.id ?? generateUUID();
+        const request = {
+            jsonrpc: '2.0',
+            method: options.method,
+            params: options.params,
+            id
+        };
+        let closed = false;
+        this.streamCallbacks.set(id, callback);
+        try {
+            var _this_ws;
+            const encoded = encode(request);
+            null === (_this_ws = this.ws) || void 0 === _this_ws || _this_ws.send(encoded);
+            this.stats.requestsSent++;
+            this.log('Sent stream request:', request);
+        } catch (error) {
+            this.streamCallbacks.delete(id);
+            throw error;
+        }
+        return {
+            id,
+            close: ()=>{
+                if (!closed) {
+                    closed = true;
+                    this.streamCallbacks.delete(id);
+                    this.log('Stream closed:', id);
+                }
+            },
+            get closed () {
+                return closed;
+            }
+        };
+    }
+    sendRaw(data) {
+        var _this_ws;
+        if (!this.isConnected) throw new Error('WebSocket is not connected');
+        null === (_this_ws = this.ws) || void 0 === _this_ws || _this_ws.send(data);
+        this.log('Sent raw data:', data.byteLength, 'bytes');
+    }
+    close(code, reason) {
+        this.options.autoReconnect = false;
+        if (this.reconnectTimeoutId) {
+            clearTimeout(this.reconnectTimeoutId);
+            this.reconnectTimeoutId = null;
+        }
+        this.stopHeartbeat();
+        if (this.ws) {
+            this.ws.close(code, reason);
+            this.ws = null;
+        }
+        this.rejectAllPendingRequests(new Error('Connection closed by client'), jsonrpc_JsonRpcErrorCode.ConnectionClosed);
+        this.removeAllListeners();
+    }
+    reconnectToUrl(url) {
+        this.close();
+        this.options.url = url;
+        this.options.autoReconnect = true;
+        this.reconnectAttempts = 0;
+        this.connect();
+    }
+    log(...args) {
+        if (this.options.debug) console.log('[JsonRpcWebSocket]', ...args);
+    }
+    constructor(options){
+        super(), client_define_property(this, "ws", null), client_define_property(this, "options", void 0), client_define_property(this, "pendingRequests", new Map()), client_define_property(this, "streamCallbacks", new Map()), client_define_property(this, "reconnectAttempts", 0), client_define_property(this, "reconnectTimeoutId", null), client_define_property(this, "heartbeatIntervalId", null), client_define_property(this, "stats", {
+            requestsSent: 0,
+            responsesReceived: 0,
+            timeouts: 0,
+            errors: 0,
+            averageResponseTime: 0,
+            pendingRequests: 0,
+            reconnectCount: 0
+        }), client_define_property(this, "responseTimes", []);
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            ...options
+        };
+        this.connect();
+    }
+}
+export { JsonRpcWebSocketClient, decode, JsonRpcWebSocketClient as default, pack_deserialize as deserialize, encode, generateUUID, pack_serialize as serialize };