playsocketjs 3.1.2 → 4.0.0

package/dist/playsocket-client.js

@@ -1,2614 +0,0 @@
-function utf8Count(str) {
-    const strLength = str.length;
-    let byteLength = 0;
-    let pos = 0;
-    while (pos < strLength) {
-        let value = str.charCodeAt(pos++);
-        if ((value & 0xffffff80) === 0) {
-            // 1-byte
-            byteLength++;
-            continue;
-        }
-        else if ((value & 0xfffff800) === 0) {
-            // 2-bytes
-            byteLength += 2;
-        }
-        else {
-            // handle surrogate pair
-            if (value >= 0xd800 && value <= 0xdbff) {
-                // high surrogate
-                if (pos < strLength) {
-                    const extra = str.charCodeAt(pos);
-                    if ((extra & 0xfc00) === 0xdc00) {
-                        ++pos;
-                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
-                    }
-                }
-            }
-            if ((value & 0xffff0000) === 0) {
-                // 3-byte
-                byteLength += 3;
-            }
-            else {
-                // 4-byte
-                byteLength += 4;
-            }
-        }
-    }
-    return byteLength;
-}
-function utf8EncodeJs(str, output, outputOffset) {
-    const strLength = str.length;
-    let offset = outputOffset;
-    let pos = 0;
-    while (pos < strLength) {
-        let value = str.charCodeAt(pos++);
-        if ((value & 0xffffff80) === 0) {
-            // 1-byte
-            output[offset++] = value;
-            continue;
-        }
-        else if ((value & 0xfffff800) === 0) {
-            // 2-bytes
-            output[offset++] = ((value >> 6) & 0x1f) | 0xc0;
-        }
-        else {
-            // handle surrogate pair
-            if (value >= 0xd800 && value <= 0xdbff) {
-                // high surrogate
-                if (pos < strLength) {
-                    const extra = str.charCodeAt(pos);
-                    if ((extra & 0xfc00) === 0xdc00) {
-                        ++pos;
-                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
-                    }
-                }
-            }
-            if ((value & 0xffff0000) === 0) {
-                // 3-byte
-                output[offset++] = ((value >> 12) & 0x0f) | 0xe0;
-                output[offset++] = ((value >> 6) & 0x3f) | 0x80;
-            }
-            else {
-                // 4-byte
-                output[offset++] = ((value >> 18) & 0x07) | 0xf0;
-                output[offset++] = ((value >> 12) & 0x3f) | 0x80;
-                output[offset++] = ((value >> 6) & 0x3f) | 0x80;
-            }
-        }
-        output[offset++] = (value & 0x3f) | 0x80;
-    }
-}
-// TextEncoder and TextDecoder are standardized in whatwg encoding:
-// https://encoding.spec.whatwg.org/
-// and available in all the modern browsers:
-// https://caniuse.com/textencoder
-// They are available in Node.js since v12 LTS as well:
-// https://nodejs.org/api/globals.html#textencoder
-const sharedTextEncoder = new TextEncoder();
-// This threshold should be determined by benchmarking, which might vary in engines and input data.
-// Run `npx ts-node benchmark/encode-string.ts` for details.
-const TEXT_ENCODER_THRESHOLD = 50;
-function utf8EncodeTE(str, output, outputOffset) {
-    sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
-}
-function utf8Encode(str, output, outputOffset) {
-    if (str.length > TEXT_ENCODER_THRESHOLD) {
-        utf8EncodeTE(str, output, outputOffset);
-    }
-    else {
-        utf8EncodeJs(str, output, outputOffset);
-    }
-}
-const CHUNK_SIZE = 4096;
-function utf8DecodeJs(bytes, inputOffset, byteLength) {
-    let offset = inputOffset;
-    const end = offset + byteLength;
-    const units = [];
-    let result = "";
-    while (offset < end) {
-        const byte1 = bytes[offset++];
-        if ((byte1 & 0x80) === 0) {
-            // 1 byte
-            units.push(byte1);
-        }
-        else if ((byte1 & 0xe0) === 0xc0) {
-            // 2 bytes
-            const byte2 = bytes[offset++] & 0x3f;
-            units.push(((byte1 & 0x1f) << 6) | byte2);
-        }
-        else if ((byte1 & 0xf0) === 0xe0) {
-            // 3 bytes
-            const byte2 = bytes[offset++] & 0x3f;
-            const byte3 = bytes[offset++] & 0x3f;
-            units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
-        }
-        else if ((byte1 & 0xf8) === 0xf0) {
-            // 4 bytes
-            const byte2 = bytes[offset++] & 0x3f;
-            const byte3 = bytes[offset++] & 0x3f;
-            const byte4 = bytes[offset++] & 0x3f;
-            let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
-            if (unit > 0xffff) {
-                unit -= 0x10000;
-                units.push(((unit >>> 10) & 0x3ff) | 0xd800);
-                unit = 0xdc00 | (unit & 0x3ff);
-            }
-            units.push(unit);
-        }
-        else {
-            units.push(byte1);
-        }
-        if (units.length >= CHUNK_SIZE) {
-            result += String.fromCharCode(...units);
-            units.length = 0;
-        }
-    }
-    if (units.length > 0) {
-        result += String.fromCharCode(...units);
-    }
-    return result;
-}
-const sharedTextDecoder = new TextDecoder();
-// This threshold should be determined by benchmarking, which might vary in engines and input data.
-// Run `npx ts-node benchmark/decode-string.ts` for details.
-const TEXT_DECODER_THRESHOLD = 200;
-function utf8DecodeTD(bytes, inputOffset, byteLength) {
-    const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
-    return sharedTextDecoder.decode(stringBytes);
-}
-function utf8Decode(bytes, inputOffset, byteLength) {
-    if (byteLength > TEXT_DECODER_THRESHOLD) {
-        return utf8DecodeTD(bytes, inputOffset, byteLength);
-    }
-    else {
-        return utf8DecodeJs(bytes, inputOffset, byteLength);
-    }
-}
-
-/**
- * ExtData is used to handle Extension Types that are not registered to ExtensionCodec.
- */
-class ExtData {
-    type;
-    data;
-    constructor(type, data) {
-        this.type = type;
-        this.data = data;
-    }
-}
-
-class DecodeError extends Error {
-    constructor(message) {
-        super(message);
-        // fix the prototype chain in a cross-platform way
-        const proto = Object.create(DecodeError.prototype);
-        Object.setPrototypeOf(this, proto);
-        Object.defineProperty(this, "name", {
-            configurable: true,
-            enumerable: false,
-            value: DecodeError.name,
-        });
-    }
-}
-
-// Integer Utility
-const UINT32_MAX = 4294967295;
-// DataView extension to handle int64 / uint64,
-// where the actual range is 53-bits integer (a.k.a. safe integer)
-function setUint64(view, offset, value) {
-    const high = value / 4294967296;
-    const low = value; // high bits are truncated by DataView
-    view.setUint32(offset, high);
-    view.setUint32(offset + 4, low);
-}
-function setInt64(view, offset, value) {
-    const high = Math.floor(value / 4294967296);
-    const low = value; // high bits are truncated by DataView
-    view.setUint32(offset, high);
-    view.setUint32(offset + 4, low);
-}
-function getInt64(view, offset) {
-    const high = view.getInt32(offset);
-    const low = view.getUint32(offset + 4);
-    return high * 4294967296 + low;
-}
-function getUint64(view, offset) {
-    const high = view.getUint32(offset);
-    const low = view.getUint32(offset + 4);
-    return high * 4294967296 + low;
-}
-
-// https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
-const EXT_TIMESTAMP = -1;
-const TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int
-const TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int
-function encodeTimeSpecToTimestamp({ sec, nsec }) {
-    if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
-        // Here sec >= 0 && nsec >= 0
-        if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
-            // timestamp 32 = { sec32 (unsigned) }
-            const rv = new Uint8Array(4);
-            const view = new DataView(rv.buffer);
-            view.setUint32(0, sec);
-            return rv;
-        }
-        else {
-            // timestamp 64 = { nsec30 (unsigned), sec34 (unsigned) }
-            const secHigh = sec / 0x100000000;
-            const secLow = sec & 0xffffffff;
-            const rv = new Uint8Array(8);
-            const view = new DataView(rv.buffer);
-            // nsec30 | secHigh2
-            view.setUint32(0, (nsec << 2) | (secHigh & 0x3));
-            // secLow32
-            view.setUint32(4, secLow);
-            return rv;
-        }
-    }
-    else {
-        // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
-        const rv = new Uint8Array(12);
-        const view = new DataView(rv.buffer);
-        view.setUint32(0, nsec);
-        setInt64(view, 4, sec);
-        return rv;
-    }
-}
-function encodeDateToTimeSpec(date) {
-    const msec = date.getTime();
-    const sec = Math.floor(msec / 1e3);
-    const nsec = (msec - sec * 1e3) * 1e6;
-    // Normalizes { sec, nsec } to ensure nsec is unsigned.
-    const nsecInSec = Math.floor(nsec / 1e9);
-    return {
-        sec: sec + nsecInSec,
-        nsec: nsec - nsecInSec * 1e9,
-    };
-}
-function encodeTimestampExtension(object) {
-    if (object instanceof Date) {
-        const timeSpec = encodeDateToTimeSpec(object);
-        return encodeTimeSpecToTimestamp(timeSpec);
-    }
-    else {
-        return null;
-    }
-}
-function decodeTimestampToTimeSpec(data) {
-    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    // data may be 32, 64, or 96 bits
-    switch (data.byteLength) {
-        case 4: {
-            // timestamp 32 = { sec32 }
-            const sec = view.getUint32(0);
-            const nsec = 0;
-            return { sec, nsec };
-        }
-        case 8: {
-            // timestamp 64 = { nsec30, sec34 }
-            const nsec30AndSecHigh2 = view.getUint32(0);
-            const secLow32 = view.getUint32(4);
-            const sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;
-            const nsec = nsec30AndSecHigh2 >>> 2;
-            return { sec, nsec };
-        }
-        case 12: {
-            // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
-            const sec = getInt64(view, 4);
-            const nsec = view.getUint32(0);
-            return { sec, nsec };
-        }
-        default:
-            throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
-    }
-}
-function decodeTimestampExtension(data) {
-    const timeSpec = decodeTimestampToTimeSpec(data);
-    return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
-}
-const timestampExtension = {
-    type: EXT_TIMESTAMP,
-    encode: encodeTimestampExtension,
-    decode: decodeTimestampExtension,
-};
-
-// ExtensionCodec to handle MessagePack extensions
-class ExtensionCodec {
-    static defaultCodec = new ExtensionCodec();
-    // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
-    // this will make type errors a lot more clear
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    __brand;
-    // built-in extensions
-    builtInEncoders = [];
-    builtInDecoders = [];
-    // custom extensions
-    encoders = [];
-    decoders = [];
-    constructor() {
-        this.register(timestampExtension);
-    }
-    register({ type, encode, decode, }) {
-        if (type >= 0) {
-            // custom extensions
-            this.encoders[type] = encode;
-            this.decoders[type] = decode;
-        }
-        else {
-            // built-in extensions
-            const index = -1 - type;
-            this.builtInEncoders[index] = encode;
-            this.builtInDecoders[index] = decode;
-        }
-    }
-    tryToEncode(object, context) {
-        // built-in extensions
-        for (let i = 0; i < this.builtInEncoders.length; i++) {
-            const encodeExt = this.builtInEncoders[i];
-            if (encodeExt != null) {
-                const data = encodeExt(object, context);
-                if (data != null) {
-                    const type = -1 - i;
-                    return new ExtData(type, data);
-                }
-            }
-        }
-        // custom extensions
-        for (let i = 0; i < this.encoders.length; i++) {
-            const encodeExt = this.encoders[i];
-            if (encodeExt != null) {
-                const data = encodeExt(object, context);
-                if (data != null) {
-                    const type = i;
-                    return new ExtData(type, data);
-                }
-            }
-        }
-        if (object instanceof ExtData) {
-            // to keep ExtData as is
-            return object;
-        }
-        return null;
-    }
-    decode(data, type, context) {
-        const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
-        if (decodeExt) {
-            return decodeExt(data, type, context);
-        }
-        else {
-            // decode() does not fail, returns ExtData instead.
-            return new ExtData(type, data);
-        }
-    }
-}
-
-function isArrayBufferLike(buffer) {
-    return (buffer instanceof ArrayBuffer || (typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer));
-}
-function ensureUint8Array(buffer) {
-    if (buffer instanceof Uint8Array) {
-        return buffer;
-    }
-    else if (ArrayBuffer.isView(buffer)) {
-        return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    }
-    else if (isArrayBufferLike(buffer)) {
-        return new Uint8Array(buffer);
-    }
-    else {
-        // ArrayLike<number>
-        return Uint8Array.from(buffer);
-    }
-}
-
-const DEFAULT_MAX_DEPTH = 100;
-const DEFAULT_INITIAL_BUFFER_SIZE = 2048;
-class Encoder {
-    extensionCodec;
-    context;
-    useBigInt64;
-    maxDepth;
-    initialBufferSize;
-    sortKeys;
-    forceFloat32;
-    ignoreUndefined;
-    forceIntegerToFloat;
-    pos;
-    view;
-    bytes;
-    entered = false;
-    constructor(options) {
-        this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
-        this.context = options?.context; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined
-        this.useBigInt64 = options?.useBigInt64 ?? false;
-        this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
-        this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;
-        this.sortKeys = options?.sortKeys ?? false;
-        this.forceFloat32 = options?.forceFloat32 ?? false;
-        this.ignoreUndefined = options?.ignoreUndefined ?? false;
-        this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
-        this.pos = 0;
-        this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
-        this.bytes = new Uint8Array(this.view.buffer);
-    }
-    clone() {
-        // Because of slightly special argument `context`,
-        // type assertion is needed.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return new Encoder({
-            extensionCodec: this.extensionCodec,
-            context: this.context,
-            useBigInt64: this.useBigInt64,
-            maxDepth: this.maxDepth,
-            initialBufferSize: this.initialBufferSize,
-            sortKeys: this.sortKeys,
-            forceFloat32: this.forceFloat32,
-            ignoreUndefined: this.ignoreUndefined,
-            forceIntegerToFloat: this.forceIntegerToFloat,
-        });
-    }
-    reinitializeState() {
-        this.pos = 0;
-    }
-    /**
-     * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
-     *
-     * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
-     */
-    encodeSharedRef(object) {
-        if (this.entered) {
-            const instance = this.clone();
-            return instance.encodeSharedRef(object);
-        }
-        try {
-            this.entered = true;
-            this.reinitializeState();
-            this.doEncode(object, 1);
-            return this.bytes.subarray(0, this.pos);
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    /**
-     * @returns Encodes the object and returns a copy of the encoder's internal buffer.
-     */
-    encode(object) {
-        if (this.entered) {
-            const instance = this.clone();
-            return instance.encode(object);
-        }
-        try {
-            this.entered = true;
-            this.reinitializeState();
-            this.doEncode(object, 1);
-            return this.bytes.slice(0, this.pos);
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    doEncode(object, depth) {
-        if (depth > this.maxDepth) {
-            throw new Error(`Too deep objects in depth ${depth}`);
-        }
-        if (object == null) {
-            this.encodeNil();
-        }
-        else if (typeof object === "boolean") {
-            this.encodeBoolean(object);
-        }
-        else if (typeof object === "number") {
-            if (!this.forceIntegerToFloat) {
-                this.encodeNumber(object);
-            }
-            else {
-                this.encodeNumberAsFloat(object);
-            }
-        }
-        else if (typeof object === "string") {
-            this.encodeString(object);
-        }
-        else if (this.useBigInt64 && typeof object === "bigint") {
-            this.encodeBigInt64(object);
-        }
-        else {
-            this.encodeObject(object, depth);
-        }
-    }
-    ensureBufferSizeToWrite(sizeToWrite) {
-        const requiredSize = this.pos + sizeToWrite;
-        if (this.view.byteLength < requiredSize) {
-            this.resizeBuffer(requiredSize * 2);
-        }
-    }
-    resizeBuffer(newSize) {
-        const newBuffer = new ArrayBuffer(newSize);
-        const newBytes = new Uint8Array(newBuffer);
-        const newView = new DataView(newBuffer);
-        newBytes.set(this.bytes);
-        this.view = newView;
-        this.bytes = newBytes;
-    }
-    encodeNil() {
-        this.writeU8(0xc0);
-    }
-    encodeBoolean(object) {
-        if (object === false) {
-            this.writeU8(0xc2);
-        }
-        else {
-            this.writeU8(0xc3);
-        }
-    }
-    encodeNumber(object) {
-        if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
-            if (object >= 0) {
-                if (object < 0x80) {
-                    // positive fixint
-                    this.writeU8(object);
-                }
-                else if (object < 0x100) {
-                    // uint 8
-                    this.writeU8(0xcc);
-                    this.writeU8(object);
-                }
-                else if (object < 0x10000) {
-                    // uint 16
-                    this.writeU8(0xcd);
-                    this.writeU16(object);
-                }
-                else if (object < 0x100000000) {
-                    // uint 32
-                    this.writeU8(0xce);
-                    this.writeU32(object);
-                }
-                else if (!this.useBigInt64) {
-                    // uint 64
-                    this.writeU8(0xcf);
-                    this.writeU64(object);
-                }
-                else {
-                    this.encodeNumberAsFloat(object);
-                }
-            }
-            else {
-                if (object >= -32) {
-                    // negative fixint
-                    this.writeU8(0xe0 | (object + 0x20));
-                }
-                else if (object >= -128) {
-                    // int 8
-                    this.writeU8(0xd0);
-                    this.writeI8(object);
-                }
-                else if (object >= -32768) {
-                    // int 16
-                    this.writeU8(0xd1);
-                    this.writeI16(object);
-                }
-                else if (object >= -2147483648) {
-                    // int 32
-                    this.writeU8(0xd2);
-                    this.writeI32(object);
-                }
-                else if (!this.useBigInt64) {
-                    // int 64
-                    this.writeU8(0xd3);
-                    this.writeI64(object);
-                }
-                else {
-                    this.encodeNumberAsFloat(object);
-                }
-            }
-        }
-        else {
-            this.encodeNumberAsFloat(object);
-        }
-    }
-    encodeNumberAsFloat(object) {
-        if (this.forceFloat32) {
-            // float 32
-            this.writeU8(0xca);
-            this.writeF32(object);
-        }
-        else {
-            // float 64
-            this.writeU8(0xcb);
-            this.writeF64(object);
-        }
-    }
-    encodeBigInt64(object) {
-        if (object >= BigInt(0)) {
-            // uint 64
-            this.writeU8(0xcf);
-            this.writeBigUint64(object);
-        }
-        else {
-            // int 64
-            this.writeU8(0xd3);
-            this.writeBigInt64(object);
-        }
-    }
-    writeStringHeader(byteLength) {
-        if (byteLength < 32) {
-            // fixstr
-            this.writeU8(0xa0 + byteLength);
-        }
-        else if (byteLength < 0x100) {
-            // str 8
-            this.writeU8(0xd9);
-            this.writeU8(byteLength);
-        }
-        else if (byteLength < 0x10000) {
-            // str 16
-            this.writeU8(0xda);
-            this.writeU16(byteLength);
-        }
-        else if (byteLength < 0x100000000) {
-            // str 32
-            this.writeU8(0xdb);
-            this.writeU32(byteLength);
-        }
-        else {
-            throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
-        }
-    }
-    encodeString(object) {
-        const maxHeaderSize = 1 + 4;
-        const byteLength = utf8Count(object);
-        this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
-        this.writeStringHeader(byteLength);
-        utf8Encode(object, this.bytes, this.pos);
-        this.pos += byteLength;
-    }
-    encodeObject(object, depth) {
-        // try to encode objects with custom codec first of non-primitives
-        const ext = this.extensionCodec.tryToEncode(object, this.context);
-        if (ext != null) {
-            this.encodeExtension(ext);
-        }
-        else if (Array.isArray(object)) {
-            this.encodeArray(object, depth);
-        }
-        else if (ArrayBuffer.isView(object)) {
-            this.encodeBinary(object);
-        }
-        else if (typeof object === "object") {
-            this.encodeMap(object, depth);
-        }
-        else {
-            // symbol, function and other special object come here unless extensionCodec handles them.
-            throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
-        }
-    }
-    encodeBinary(object) {
-        const size = object.byteLength;
-        if (size < 0x100) {
-            // bin 8
-            this.writeU8(0xc4);
-            this.writeU8(size);
-        }
-        else if (size < 0x10000) {
-            // bin 16
-            this.writeU8(0xc5);
-            this.writeU16(size);
-        }
-        else if (size < 0x100000000) {
-            // bin 32
-            this.writeU8(0xc6);
-            this.writeU32(size);
-        }
-        else {
-            throw new Error(`Too large binary: ${size}`);
-        }
-        const bytes = ensureUint8Array(object);
-        this.writeU8a(bytes);
-    }
-    encodeArray(object, depth) {
-        const size = object.length;
-        if (size < 16) {
-            // fixarray
-            this.writeU8(0x90 + size);
-        }
-        else if (size < 0x10000) {
-            // array 16
-            this.writeU8(0xdc);
-            this.writeU16(size);
-        }
-        else if (size < 0x100000000) {
-            // array 32
-            this.writeU8(0xdd);
-            this.writeU32(size);
-        }
-        else {
-            throw new Error(`Too large array: ${size}`);
-        }
-        for (const item of object) {
-            this.doEncode(item, depth + 1);
-        }
-    }
-    countWithoutUndefined(object, keys) {
-        let count = 0;
-        for (const key of keys) {
-            if (object[key] !== undefined) {
-                count++;
-            }
-        }
-        return count;
-    }
-    encodeMap(object, depth) {
-        const keys = Object.keys(object);
-        if (this.sortKeys) {
-            keys.sort();
-        }
-        const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
-        if (size < 16) {
-            // fixmap
-            this.writeU8(0x80 + size);
-        }
-        else if (size < 0x10000) {
-            // map 16
-            this.writeU8(0xde);
-            this.writeU16(size);
-        }
-        else if (size < 0x100000000) {
-            // map 32
-            this.writeU8(0xdf);
-            this.writeU32(size);
-        }
-        else {
-            throw new Error(`Too large map object: ${size}`);
-        }
-        for (const key of keys) {
-            const value = object[key];
-            if (!(this.ignoreUndefined && value === undefined)) {
-                this.encodeString(key);
-                this.doEncode(value, depth + 1);
-            }
-        }
-    }
-    encodeExtension(ext) {
-        if (typeof ext.data === "function") {
-            const data = ext.data(this.pos + 6);
-            const size = data.length;
-            if (size >= 0x100000000) {
-                throw new Error(`Too large extension object: ${size}`);
-            }
-            this.writeU8(0xc9);
-            this.writeU32(size);
-            this.writeI8(ext.type);
-            this.writeU8a(data);
-            return;
-        }
-        const size = ext.data.length;
-        if (size === 1) {
-            // fixext 1
-            this.writeU8(0xd4);
-        }
-        else if (size === 2) {
-            // fixext 2
-            this.writeU8(0xd5);
-        }
-        else if (size === 4) {
-            // fixext 4
-            this.writeU8(0xd6);
-        }
-        else if (size === 8) {
-            // fixext 8
-            this.writeU8(0xd7);
-        }
-        else if (size === 16) {
-            // fixext 16
-            this.writeU8(0xd8);
-        }
-        else if (size < 0x100) {
-            // ext 8
-            this.writeU8(0xc7);
-            this.writeU8(size);
-        }
-        else if (size < 0x10000) {
-            // ext 16
-            this.writeU8(0xc8);
-            this.writeU16(size);
-        }
-        else if (size < 0x100000000) {
-            // ext 32
-            this.writeU8(0xc9);
-            this.writeU32(size);
-        }
-        else {
-            throw new Error(`Too large extension object: ${size}`);
-        }
-        this.writeI8(ext.type);
-        this.writeU8a(ext.data);
-    }
-    writeU8(value) {
-        this.ensureBufferSizeToWrite(1);
-        this.view.setUint8(this.pos, value);
-        this.pos++;
-    }
-    writeU8a(values) {
-        const size = values.length;
-        this.ensureBufferSizeToWrite(size);
-        this.bytes.set(values, this.pos);
-        this.pos += size;
-    }
-    writeI8(value) {
-        this.ensureBufferSizeToWrite(1);
-        this.view.setInt8(this.pos, value);
-        this.pos++;
-    }
-    writeU16(value) {
-        this.ensureBufferSizeToWrite(2);
-        this.view.setUint16(this.pos, value);
-        this.pos += 2;
-    }
-    writeI16(value) {
-        this.ensureBufferSizeToWrite(2);
-        this.view.setInt16(this.pos, value);
-        this.pos += 2;
-    }
-    writeU32(value) {
-        this.ensureBufferSizeToWrite(4);
-        this.view.setUint32(this.pos, value);
-        this.pos += 4;
-    }
-    writeI32(value) {
-        this.ensureBufferSizeToWrite(4);
-        this.view.setInt32(this.pos, value);
-        this.pos += 4;
-    }
-    writeF32(value) {
-        this.ensureBufferSizeToWrite(4);
-        this.view.setFloat32(this.pos, value);
-        this.pos += 4;
-    }
-    writeF64(value) {
-        this.ensureBufferSizeToWrite(8);
-        this.view.setFloat64(this.pos, value);
-        this.pos += 8;
-    }
-    writeU64(value) {
-        this.ensureBufferSizeToWrite(8);
-        setUint64(this.view, this.pos, value);
-        this.pos += 8;
-    }
-    writeI64(value) {
-        this.ensureBufferSizeToWrite(8);
-        setInt64(this.view, this.pos, value);
-        this.pos += 8;
-    }
-    writeBigUint64(value) {
-        this.ensureBufferSizeToWrite(8);
-        this.view.setBigUint64(this.pos, value);
-        this.pos += 8;
-    }
-    writeBigInt64(value) {
-        this.ensureBufferSizeToWrite(8);
-        this.view.setBigInt64(this.pos, value);
-        this.pos += 8;
-    }
-}
-
-/**
- * It encodes `value` in the MessagePack format and
- * returns a byte buffer.
- *
- * The returned buffer is a slice of a larger `ArrayBuffer`, so you have to use its `#byteOffset` and `#byteLength` in order to convert it to another typed arrays including NodeJS `Buffer`.
- */
-function encode(value, options) {
-    const encoder = new Encoder(options);
-    return encoder.encodeSharedRef(value);
-}
-
-function prettyByte(byte) {
-    return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
-}
-
-const DEFAULT_MAX_KEY_LENGTH = 16;
-const DEFAULT_MAX_LENGTH_PER_KEY = 16;
-class CachedKeyDecoder {
-    hit = 0;
-    miss = 0;
-    caches;
-    maxKeyLength;
-    maxLengthPerKey;
-    constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
-        this.maxKeyLength = maxKeyLength;
-        this.maxLengthPerKey = maxLengthPerKey;
-        // avoid `new Array(N)`, which makes a sparse array,
-        // because a sparse array is typically slower than a non-sparse array.
-        this.caches = [];
-        for (let i = 0; i < this.maxKeyLength; i++) {
-            this.caches.push([]);
-        }
-    }
-    canBeCached(byteLength) {
-        return byteLength > 0 && byteLength <= this.maxKeyLength;
-    }
-    find(bytes, inputOffset, byteLength) {
-        const records = this.caches[byteLength - 1];
-        FIND_CHUNK: for (const record of records) {
-            const recordBytes = record.bytes;
-            for (let j = 0; j < byteLength; j++) {
-                if (recordBytes[j] !== bytes[inputOffset + j]) {
-                    continue FIND_CHUNK;
-                }
-            }
-            return record.str;
-        }
-        return null;
-    }
-    store(bytes, value) {
-        const records = this.caches[bytes.length - 1];
-        const record = { bytes, str: value };
-        if (records.length >= this.maxLengthPerKey) {
-            // `records` are full!
-            // Set `record` to an arbitrary position.
-            records[(Math.random() * records.length) | 0] = record;
-        }
-        else {
-            records.push(record);
-        }
-    }
-    decode(bytes, inputOffset, byteLength) {
-        const cachedValue = this.find(bytes, inputOffset, byteLength);
-        if (cachedValue != null) {
-            this.hit++;
-            return cachedValue;
-        }
-        this.miss++;
-        const str = utf8DecodeJs(bytes, inputOffset, byteLength);
-        // Ensure to copy a slice of bytes because the bytes may be a NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.
-        const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
-        this.store(slicedCopyOfBytes, str);
-        return str;
-    }
-}
-
-const STATE_ARRAY = "array";
-const STATE_MAP_KEY = "map_key";
-const STATE_MAP_VALUE = "map_value";
-const mapKeyConverter = (key) => {
-    if (typeof key === "string" || typeof key === "number") {
-        return key;
-    }
-    throw new DecodeError("The type of key must be string or number but " + typeof key);
-};
-class StackPool {
-    stack = [];
-    stackHeadPosition = -1;
-    get length() {
-        return this.stackHeadPosition + 1;
-    }
-    top() {
-        return this.stack[this.stackHeadPosition];
-    }
-    pushArrayState(size) {
-        const state = this.getUninitializedStateFromPool();
-        state.type = STATE_ARRAY;
-        state.position = 0;
-        state.size = size;
-        state.array = new Array(size);
-    }
-    pushMapState(size) {
-        const state = this.getUninitializedStateFromPool();
-        state.type = STATE_MAP_KEY;
-        state.readCount = 0;
-        state.size = size;
-        state.map = {};
-    }
-    getUninitializedStateFromPool() {
-        this.stackHeadPosition++;
-        if (this.stackHeadPosition === this.stack.length) {
-            const partialState = {
-                type: undefined,
-                size: 0,
-                array: undefined,
-                position: 0,
-                readCount: 0,
-                map: undefined,
-                key: null,
-            };
-            this.stack.push(partialState);
-        }
-        return this.stack[this.stackHeadPosition];
-    }
-    release(state) {
-        const topStackState = this.stack[this.stackHeadPosition];
-        if (topStackState !== state) {
-            throw new Error("Invalid stack state. Released state is not on top of the stack.");
-        }
-        if (state.type === STATE_ARRAY) {
-            const partialState = state;
-            partialState.size = 0;
-            partialState.array = undefined;
-            partialState.position = 0;
-            partialState.type = undefined;
-        }
-        if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
-            const partialState = state;
-            partialState.size = 0;
-            partialState.map = undefined;
-            partialState.readCount = 0;
-            partialState.type = undefined;
-        }
-        this.stackHeadPosition--;
-    }
-    reset() {
-        this.stack.length = 0;
-        this.stackHeadPosition = -1;
-    }
-}
-const HEAD_BYTE_REQUIRED = -1;
-const EMPTY_VIEW = new DataView(new ArrayBuffer(0));
-const EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
-try {
-    // IE11: The spec says it should throw RangeError,
-    // IE11: but in IE11 it throws TypeError.
-    EMPTY_VIEW.getInt8(0);
-}
-catch (e) {
-    if (!(e instanceof RangeError)) {
-        throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
-    }
-}
-const MORE_DATA = new RangeError("Insufficient data");
-const sharedCachedKeyDecoder = new CachedKeyDecoder();
-class Decoder {
-    extensionCodec;
-    context;
-    useBigInt64;
-    rawStrings;
-    maxStrLength;
-    maxBinLength;
-    maxArrayLength;
-    maxMapLength;
-    maxExtLength;
-    keyDecoder;
-    mapKeyConverter;
-    totalPos = 0;
-    pos = 0;
-    view = EMPTY_VIEW;
-    bytes = EMPTY_BYTES;
-    headByte = HEAD_BYTE_REQUIRED;
-    stack = new StackPool();
-    entered = false;
-    constructor(options) {
-        this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
-        this.context = options?.context; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined
-        this.useBigInt64 = options?.useBigInt64 ?? false;
-        this.rawStrings = options?.rawStrings ?? false;
-        this.maxStrLength = options?.maxStrLength ?? UINT32_MAX;
-        this.maxBinLength = options?.maxBinLength ?? UINT32_MAX;
-        this.maxArrayLength = options?.maxArrayLength ?? UINT32_MAX;
-        this.maxMapLength = options?.maxMapLength ?? UINT32_MAX;
-        this.maxExtLength = options?.maxExtLength ?? UINT32_MAX;
-        this.keyDecoder = options?.keyDecoder !== undefined ? options.keyDecoder : sharedCachedKeyDecoder;
-        this.mapKeyConverter = options?.mapKeyConverter ?? mapKeyConverter;
-    }
-    clone() {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return new Decoder({
-            extensionCodec: this.extensionCodec,
-            context: this.context,
-            useBigInt64: this.useBigInt64,
-            rawStrings: this.rawStrings,
-            maxStrLength: this.maxStrLength,
-            maxBinLength: this.maxBinLength,
-            maxArrayLength: this.maxArrayLength,
-            maxMapLength: this.maxMapLength,
-            maxExtLength: this.maxExtLength,
-            keyDecoder: this.keyDecoder,
-        });
-    }
-    reinitializeState() {
-        this.totalPos = 0;
-        this.headByte = HEAD_BYTE_REQUIRED;
-        this.stack.reset();
-        // view, bytes, and pos will be re-initialized in setBuffer()
-    }
-    setBuffer(buffer) {
-        const bytes = ensureUint8Array(buffer);
-        this.bytes = bytes;
-        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        this.pos = 0;
-    }
-    appendBuffer(buffer) {
-        if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
-            this.setBuffer(buffer);
-        }
-        else {
-            const remainingData = this.bytes.subarray(this.pos);
-            const newData = ensureUint8Array(buffer);
-            // concat remainingData + newData
-            const newBuffer = new Uint8Array(remainingData.length + newData.length);
-            newBuffer.set(remainingData);
-            newBuffer.set(newData, remainingData.length);
-            this.setBuffer(newBuffer);
-        }
-    }
-    hasRemaining(size) {
-        return this.view.byteLength - this.pos >= size;
-    }
-    createExtraByteError(posToShow) {
-        const { view, pos } = this;
-        return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);
-    }
-    /**
-     * @throws {@link DecodeError}
-     * @throws {@link RangeError}
-     */
-    decode(buffer) {
-        if (this.entered) {
-            const instance = this.clone();
-            return instance.decode(buffer);
-        }
-        try {
-            this.entered = true;
-            this.reinitializeState();
-            this.setBuffer(buffer);
-            const object = this.doDecodeSync();
-            if (this.hasRemaining(1)) {
-                throw this.createExtraByteError(this.pos);
-            }
-            return object;
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    *decodeMulti(buffer) {
-        if (this.entered) {
-            const instance = this.clone();
-            yield* instance.decodeMulti(buffer);
-            return;
-        }
-        try {
-            this.entered = true;
-            this.reinitializeState();
-            this.setBuffer(buffer);
-            while (this.hasRemaining(1)) {
-                yield this.doDecodeSync();
-            }
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    async decodeAsync(stream) {
-        if (this.entered) {
-            const instance = this.clone();
-            return instance.decodeAsync(stream);
-        }
-        try {
-            this.entered = true;
-            let decoded = false;
-            let object;
-            for await (const buffer of stream) {
-                if (decoded) {
-                    this.entered = false;
-                    throw this.createExtraByteError(this.totalPos);
-                }
-                this.appendBuffer(buffer);
-                try {
-                    object = this.doDecodeSync();
-                    decoded = true;
-                }
-                catch (e) {
-                    if (!(e instanceof RangeError)) {
-                        throw e; // rethrow
-                    }
-                    // fallthrough
-                }
-                this.totalPos += this.pos;
-            }
-            if (decoded) {
-                if (this.hasRemaining(1)) {
-                    throw this.createExtraByteError(this.totalPos);
-                }
-                return object;
-            }
-            const { headByte, pos, totalPos } = this;
-            throw new RangeError(`Insufficient data in parsing ${prettyByte(headByte)} at ${totalPos} (${pos} in the current buffer)`);
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    decodeArrayStream(stream) {
-        return this.decodeMultiAsync(stream, true);
-    }
-    decodeStream(stream) {
-        return this.decodeMultiAsync(stream, false);
-    }
-    async *decodeMultiAsync(stream, isArray) {
-        if (this.entered) {
-            const instance = this.clone();
-            yield* instance.decodeMultiAsync(stream, isArray);
-            return;
-        }
-        try {
-            this.entered = true;
-            let isArrayHeaderRequired = isArray;
-            let arrayItemsLeft = -1;
-            for await (const buffer of stream) {
-                if (isArray && arrayItemsLeft === 0) {
-                    throw this.createExtraByteError(this.totalPos);
-                }
-                this.appendBuffer(buffer);
-                if (isArrayHeaderRequired) {
-                    arrayItemsLeft = this.readArraySize();
-                    isArrayHeaderRequired = false;
-                    this.complete();
-                }
-                try {
-                    while (true) {
-                        yield this.doDecodeSync();
-                        if (--arrayItemsLeft === 0) {
-                            break;
-                        }
-                    }
-                }
-                catch (e) {
-                    if (!(e instanceof RangeError)) {
-                        throw e; // rethrow
-                    }
-                    // fallthrough
-                }
-                this.totalPos += this.pos;
-            }
-        }
-        finally {
-            this.entered = false;
-        }
-    }
-    doDecodeSync() {
-        DECODE: while (true) {
-            const headByte = this.readHeadByte();
-            let object;
-            if (headByte >= 0xe0) {
-                // negative fixint (111x xxxx) 0xe0 - 0xff
-                object = headByte - 0x100;
-            }
-            else if (headByte < 0xc0) {
-                if (headByte < 0x80) {
-                    // positive fixint (0xxx xxxx) 0x00 - 0x7f
-                    object = headByte;
-                }
-                else if (headByte < 0x90) {
-                    // fixmap (1000 xxxx) 0x80 - 0x8f
-                    const size = headByte - 0x80;
-                    if (size !== 0) {
-                        this.pushMapState(size);
-                        this.complete();
-                        continue DECODE;
-                    }
-                    else {
-                        object = {};
-                    }
-                }
-                else if (headByte < 0xa0) {
-                    // fixarray (1001 xxxx) 0x90 - 0x9f
-                    const size = headByte - 0x90;
-                    if (size !== 0) {
-                        this.pushArrayState(size);
-                        this.complete();
-                        continue DECODE;
-                    }
-                    else {
-                        object = [];
-                    }
-                }
-                else {
-                    // fixstr (101x xxxx) 0xa0 - 0xbf
-                    const byteLength = headByte - 0xa0;
-                    object = this.decodeString(byteLength, 0);
-                }
-            }
-            else if (headByte === 0xc0) {
-                // nil
-                object = null;
-            }
-            else if (headByte === 0xc2) {
-                // false
-                object = false;
-            }
-            else if (headByte === 0xc3) {
-                // true
-                object = true;
-            }
-            else if (headByte === 0xca) {
-                // float 32
-                object = this.readF32();
-            }
-            else if (headByte === 0xcb) {
-                // float 64
-                object = this.readF64();
-            }
-            else if (headByte === 0xcc) {
-                // uint 8
-                object = this.readU8();
-            }
-            else if (headByte === 0xcd) {
-                // uint 16
-                object = this.readU16();
-            }
-            else if (headByte === 0xce) {
-                // uint 32
-                object = this.readU32();
-            }
-            else if (headByte === 0xcf) {
-                // uint 64
-                if (this.useBigInt64) {
-                    object = this.readU64AsBigInt();
-                }
-                else {
-                    object = this.readU64();
-                }
-            }
-            else if (headByte === 0xd0) {
-                // int 8
-                object = this.readI8();
-            }
-            else if (headByte === 0xd1) {
-                // int 16
-                object = this.readI16();
-            }
-            else if (headByte === 0xd2) {
-                // int 32
-                object = this.readI32();
-            }
-            else if (headByte === 0xd3) {
-                // int 64
-                if (this.useBigInt64) {
-                    object = this.readI64AsBigInt();
-                }
-                else {
-                    object = this.readI64();
-                }
-            }
-            else if (headByte === 0xd9) {
-                // str 8
-                const byteLength = this.lookU8();
-                object = this.decodeString(byteLength, 1);
-            }
-            else if (headByte === 0xda) {
-                // str 16
-                const byteLength = this.lookU16();
-                object = this.decodeString(byteLength, 2);
-            }
-            else if (headByte === 0xdb) {
-                // str 32
-                const byteLength = this.lookU32();
-                object = this.decodeString(byteLength, 4);
-            }
-            else if (headByte === 0xdc) {
-                // array 16
-                const size = this.readU16();
-                if (size !== 0) {
-                    this.pushArrayState(size);
-                    this.complete();
-                    continue DECODE;
-                }
-                else {
-                    object = [];
-                }
-            }
-            else if (headByte === 0xdd) {
-                // array 32
-                const size = this.readU32();
-                if (size !== 0) {
-                    this.pushArrayState(size);
-                    this.complete();
-                    continue DECODE;
-                }
-                else {
-                    object = [];
-                }
-            }
-            else if (headByte === 0xde) {
-                // map 16
-                const size = this.readU16();
-                if (size !== 0) {
-                    this.pushMapState(size);
-                    this.complete();
-                    continue DECODE;
-                }
-                else {
-                    object = {};
-                }
-            }
-            else if (headByte === 0xdf) {
-                // map 32
-                const size = this.readU32();
-                if (size !== 0) {
-                    this.pushMapState(size);
-                    this.complete();
-                    continue DECODE;
-                }
-                else {
-                    object = {};
-                }
-            }
-            else if (headByte === 0xc4) {
-                // bin 8
-                const size = this.lookU8();
-                object = this.decodeBinary(size, 1);
-            }
-            else if (headByte === 0xc5) {
-                // bin 16
-                const size = this.lookU16();
-                object = this.decodeBinary(size, 2);
-            }
-            else if (headByte === 0xc6) {
-                // bin 32
-                const size = this.lookU32();
-                object = this.decodeBinary(size, 4);
-            }
-            else if (headByte === 0xd4) {
-                // fixext 1
-                object = this.decodeExtension(1, 0);
-            }
-            else if (headByte === 0xd5) {
-                // fixext 2
-                object = this.decodeExtension(2, 0);
-            }
-            else if (headByte === 0xd6) {
-                // fixext 4
-                object = this.decodeExtension(4, 0);
-            }
-            else if (headByte === 0xd7) {
-                // fixext 8
-                object = this.decodeExtension(8, 0);
-            }
-            else if (headByte === 0xd8) {
-                // fixext 16
-                object = this.decodeExtension(16, 0);
-            }
-            else if (headByte === 0xc7) {
-                // ext 8
-                const size = this.lookU8();
-                object = this.decodeExtension(size, 1);
-            }
-            else if (headByte === 0xc8) {
-                // ext 16
-                const size = this.lookU16();
-                object = this.decodeExtension(size, 2);
-            }
-            else if (headByte === 0xc9) {
-                // ext 32
-                const size = this.lookU32();
-                object = this.decodeExtension(size, 4);
-            }
-            else {
-                throw new DecodeError(`Unrecognized type byte: ${prettyByte(headByte)}`);
-            }
-            this.complete();
-            const stack = this.stack;
-            while (stack.length > 0) {
-                // arrays and maps
-                const state = stack.top();
-                if (state.type === STATE_ARRAY) {
-                    state.array[state.position] = object;
-                    state.position++;
-                    if (state.position === state.size) {
-                        object = state.array;
-                        stack.release(state);
-                    }
-                    else {
-                        continue DECODE;
-                    }
-                }
-                else if (state.type === STATE_MAP_KEY) {
-                    if (object === "__proto__") {
-                        throw new DecodeError("The key __proto__ is not allowed");
-                    }
-                    state.key = this.mapKeyConverter(object);
-                    state.type = STATE_MAP_VALUE;
-                    continue DECODE;
-                }
-                else {
-                    // it must be `state.type === State.MAP_VALUE` here
-                    state.map[state.key] = object;
-                    state.readCount++;
-                    if (state.readCount === state.size) {
-                        object = state.map;
-                        stack.release(state);
-                    }
-                    else {
-                        state.key = null;
-                        state.type = STATE_MAP_KEY;
-                        continue DECODE;
-                    }
-                }
-            }
-            return object;
-        }
-    }
-    readHeadByte() {
-        if (this.headByte === HEAD_BYTE_REQUIRED) {
-            this.headByte = this.readU8();
-            // console.log("headByte", prettyByte(this.headByte));
-        }
-        return this.headByte;
-    }
-    complete() {
-        this.headByte = HEAD_BYTE_REQUIRED;
-    }
-    readArraySize() {
-        const headByte = this.readHeadByte();
-        switch (headByte) {
-            case 0xdc:
-                return this.readU16();
-            case 0xdd:
-                return this.readU32();
-            default: {
-                if (headByte < 0xa0) {
-                    return headByte - 0x90;
-                }
-                else {
-                    throw new DecodeError(`Unrecognized array type byte: ${prettyByte(headByte)}`);
-                }
-            }
-        }
-    }
-    pushMapState(size) {
-        if (size > this.maxMapLength) {
-            throw new DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`);
-        }
-        this.stack.pushMapState(size);
-    }
-    pushArrayState(size) {
-        if (size > this.maxArrayLength) {
-            throw new DecodeError(`Max length exceeded: array length (${size}) > maxArrayLength (${this.maxArrayLength})`);
-        }
-        this.stack.pushArrayState(size);
-    }
-    decodeString(byteLength, headerOffset) {
-        if (!this.rawStrings || this.stateIsMapKey()) {
-            return this.decodeUtf8String(byteLength, headerOffset);
-        }
-        return this.decodeBinary(byteLength, headerOffset);
-    }
-    /**
-     * @throws {@link RangeError}
-     */
-    decodeUtf8String(byteLength, headerOffset) {
-        if (byteLength > this.maxStrLength) {
-            throw new DecodeError(`Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`);
-        }
-        if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
-            throw MORE_DATA;
-        }
-        const offset = this.pos + headerOffset;
-        let object;
-        if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
-            object = this.keyDecoder.decode(this.bytes, offset, byteLength);
-        }
-        else {
-            object = utf8Decode(this.bytes, offset, byteLength);
-        }
-        this.pos += headerOffset + byteLength;
-        return object;
-    }
-    stateIsMapKey() {
-        if (this.stack.length > 0) {
-            const state = this.stack.top();
-            return state.type === STATE_MAP_KEY;
-        }
-        return false;
-    }
-    /**
-     * @throws {@link RangeError}
-     */
-    decodeBinary(byteLength, headOffset) {
-        if (byteLength > this.maxBinLength) {
-            throw new DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`);
-        }
-        if (!this.hasRemaining(byteLength + headOffset)) {
-            throw MORE_DATA;
-        }
-        const offset = this.pos + headOffset;
-        const object = this.bytes.subarray(offset, offset + byteLength);
-        this.pos += headOffset + byteLength;
-        return object;
-    }
-    decodeExtension(size, headOffset) {
-        if (size > this.maxExtLength) {
-            throw new DecodeError(`Max length exceeded: ext length (${size}) > maxExtLength (${this.maxExtLength})`);
-        }
-        const extType = this.view.getInt8(this.pos + headOffset);
-        const data = this.decodeBinary(size, headOffset + 1 /* extType */);
-        return this.extensionCodec.decode(data, extType, this.context);
-    }
-    lookU8() {
-        return this.view.getUint8(this.pos);
-    }
-    lookU16() {
-        return this.view.getUint16(this.pos);
-    }
-    lookU32() {
-        return this.view.getUint32(this.pos);
-    }
-    readU8() {
-        const value = this.view.getUint8(this.pos);
-        this.pos++;
-        return value;
-    }
-    readI8() {
-        const value = this.view.getInt8(this.pos);
-        this.pos++;
-        return value;
-    }
-    readU16() {
-        const value = this.view.getUint16(this.pos);
-        this.pos += 2;
-        return value;
-    }
-    readI16() {
-        const value = this.view.getInt16(this.pos);
-        this.pos += 2;
-        return value;
-    }
-    readU32() {
-        const value = this.view.getUint32(this.pos);
-        this.pos += 4;
-        return value;
-    }
-    readI32() {
-        const value = this.view.getInt32(this.pos);
-        this.pos += 4;
-        return value;
-    }
-    readU64() {
-        const value = getUint64(this.view, this.pos);
-        this.pos += 8;
-        return value;
-    }
-    readI64() {
-        const value = getInt64(this.view, this.pos);
-        this.pos += 8;
-        return value;
-    }
-    readU64AsBigInt() {
-        const value = this.view.getBigUint64(this.pos);
-        this.pos += 8;
-        return value;
-    }
-    readI64AsBigInt() {
-        const value = this.view.getBigInt64(this.pos);
-        this.pos += 8;
-        return value;
-    }
-    readF32() {
-        const value = this.view.getFloat32(this.pos);
-        this.pos += 4;
-        return value;
-    }
-    readF64() {
-        const value = this.view.getFloat64(this.pos);
-        this.pos += 8;
-        return value;
-    }
-}
-
-/**
- * It decodes a single MessagePack object in a buffer.
- *
- * This is a synchronous decoding function.
- * See other variants for asynchronous decoding: {@link decodeAsync}, {@link decodeMultiStream}, or {@link decodeArrayStream}.
- *
- * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
- * @throws {@link DecodeError} if the buffer contains invalid data.
- */
-function decode(buffer, options) {
-    const decoder = new Decoder(options);
-    return decoder.decode(buffer);
-}
-
-/**
- * Heartbeat ping interval in milliseconds
- * Also used as the minimum age for CRDT garbage collection - operations are
- * retained for at least one heartbeat cycle to ensure even slow clients can never 
- * be desynced as a result of gc
- */
-const HEARTBEAT_INTERVAL = 5000;
-
-const CONSOLE_PREFIX = "PlaySocket CRDT manager: ";
-
-/**
- * CRDT Manager
- * Custom conflict-free replicated data type system with vector clocks
- */
-class CRDTManager {
-    // Storage
-    #replicaId;
-    #keyOperations = new Map();
-    #vectorClock = new Map();
-
-    #propertyStore = {}; // Current local values as key/value store object
-    #lastPropertyStore = {}; // Last property store to compare against
-
-    // Local Garbage Collection
-    #lastGCCheck = 0;
-    #opUuidTimestamp = new Map(); // Map every operation to a timestamp for garbage collection
-
-    // Debug
-    #debug = false;
-
-    /**
-     * Create a new instance
-     * @param {boolean} [debug=false] - Enable debug logging
-     */
-    constructor(debug) {
-        if (debug) this.#debug = true;
-        this.#replicaId = crypto.randomUUID();
-        this.#vectorClock.set(this.#replicaId, 0);
-    }
-
-    /**
-     * Import the entire state of the CRDT manager (this overwrites the old state)
-     * @param {object} state - Full state of the CRDT manager
-     */
-    importState(state) {
-        try {
-            const { keyOperations, vectorClock } = state;
-            if (this.#debug) console.log(CONSOLE_PREFIX + "Importing state:", state);
-
-            // Resets
-            this.#opUuidTimestamp.clear();
-            this.#propertyStore = {};
-            this.#lastPropertyStore = {};
-
-            this.#keyOperations = new Map(keyOperations); // Rebuild the operations map
-            this.#vectorClock = new Map(vectorClock); // Rebuild the vector clock map
-            if (!this.#vectorClock.has(this.#replicaId)) this.#vectorClock.set(this.#replicaId, 0); // Add own vector clock if it wasn't present in the imported state
-
-            // Map all operation uuids to current timestamp
-            this.#keyOperations.forEach((value, _key) => {
-                value?.forEach((operation) => {
-                    this.#opUuidTimestamp.set(operation?.uuid, Date.now());
-                });
-            });
-
-            // Process each key to update local values
-            for (const key of this.#keyOperations.keys()) this.#processLocalProperty(key);
-
-        } catch (error) {
-            console.error(CONSOLE_PREFIX + "Failed to import state:", error);
-        }
-    }
-
-    /**
-     * Import property update
-     * @param {object} data - Property update data
-     */
-    importPropertyUpdate(data) {
-        try {
-            const { key, operation: rawOperation, vectorClock } = data;
-            const operation = this.#sanitizeValue(rawOperation);
-            if (this.#debug) console.log(CONSOLE_PREFIX + "Importing update:", data); // Debug
-
-            // Check key limit to afeguard against too many keys
-            if (this.#keyOperations.size >= 100 && !this.#keyOperations.has(key)) throw new Error('Key limit exceeded!');
-
-            // Get COPY of current ops (or empty array if none yet)
-            const currentOps = [...(this.#keyOperations.get(key) || [])];
-            // Merge vector clocks (always take max value)
-            for (const [id, counter] of vectorClock) {
-                if (!this.#vectorClock.has(id) || this.#vectorClock.get(id) < counter) {
-                    this.#vectorClock.set(id, counter);
-                }
-            }
-
-            // Safeguard against massive vector clocks
-            if (this.#vectorClock.size > 1000) this.#vectorClock = new Map([...this.#vectorClock].slice(-100));
-
-            // Add new operation if it's not already added
-            const existingUuids = new Set(currentOps.map(op => op.uuid));
-            if (operation.uuid && !existingUuids.has(operation.uuid)) {
-                currentOps.push({ ...operation }); // Add operation
-                this.#opUuidTimestamp.set(operation.uuid, Date.now()); // Add timestamp for gc
-            }
-
-            // Sort, update operations & local value
-            this.#keyOperations.set(key, this.#sortByVectorClock(currentOps));
-            this.#processLocalProperty(key);
-            this.#checkGarbageCollection();
-
-        } catch (error) {
-            console.error(CONSOLE_PREFIX + "Failed to import property update:", error);
-        }
-    }
-
-    /**
-     * Update a property
-     * @param {string} key - Storage key
-     * @param {string} type - Operation type
-     * @param {*} value - New value, or value to match
-     * @param {*} updateValue - New value for 'matching' operations
-     * @returns {object | undefined} - Returns the property update
-     */
-    updateProperty(key, type, value, updateValue) {
-        try {
-            // Sanitize inputs
-            value = this.#sanitizeValue(value);
-            updateValue = this.#sanitizeValue(updateValue);
-
-            // Debug log
-            if (this.#debug) console.log(CONSOLE_PREFIX + `Updating property with key ${key}, type ${type}, value ${value} and updateValue ${updateValue}.`);
-
-            // Increment vector clock
-            const counter = this.#vectorClock.get(this.#replicaId) || 0;
-            this.#vectorClock.set(this.#replicaId, counter + 1);
-
-            // Assign shallow COPY of currennt ops or fall back to empty array
-            const currentOps = [...(this.#keyOperations.get(key) || [])];
-
-            // Add operation
-            const newOp = this.#createOperation({ type, value, updateValue }, Array.from(this.#vectorClock.entries()));
-            currentOps.push(newOp);
-            this.#keyOperations.set(key, currentOps); // Update the operations (no need to sort via vector clock since local updates are always the latest)
-            this.#processLocalProperty(key); // Process local value
-            this.#checkGarbageCollection();
-
-            // Return the property update with the new operation (this can be imported using importPropertyUpdate)
-            return {
-                key,
-                operation: { ...newOp },
-                vectorClock: Array.from(this.#vectorClock.entries())
-            };
-
-        } catch (error) {
-            console.error(CONSOLE_PREFIX + `Failed to add operation for key "${key}":`, error);
-        }
-    }
-
-    /**
-     * Check if garbage collected can be performed & run it
-     */
-    #checkGarbageCollection() {
-        const MIN_GC_DELAY = 1000; // Minimum 1s delay between garbage collection runs
-
-        try {
-            if (Date.now() - this.#lastGCCheck < MIN_GC_DELAY) return;
-            this.#lastGCCheck = Date.now();
-
-            for (const [key, operations] of this.#keyOperations.entries()) {
-                if (operations?.length < 5) continue; // Min op amount per key for garbage collection to run (otherwise not worth it)
-
-                let retainCount = operations.length;
-                operations.forEach((op, index) => {
-                    // Count how many ops, from last to latest, are older than the min-age in a row
-                    if (op.uuid && this.#opUuidTimestamp.has(op.uuid) && (Date.now() - this.#opUuidTimestamp.get(op.uuid)) > HEARTBEAT_INTERVAL) {
-                        const removeCount = index + 1;
-                        retainCount = operations.length - removeCount;
-                        this.#opUuidTimestamp.delete(op.uuid); // Remove from timestamps if set to be deleted
-                    }
-                });
-
-                if (retainCount < operations.length) {
-                    if (this.#debug) console.log(CONSOLE_PREFIX + `Running garbage collection for key ${key} with current operations:`, operations);
-                    const retainOps = operations.slice(-retainCount); // Newest ops
-                    const removeOps = operations.slice(0, -retainCount); // Oldest ops (start =  idx 0, end = retainCount counted from right side)
-                    const baselineVectorClock = removeOps[removeOps.length - 1]?.vectorClock || []; // Use the vector clock from the last operation that we remove/overwrite
-
-                    // Calculate the value at the point where retained operations start
-                    let baselineValue = null;
-                    for (const op of removeOps) {
-                        if (!op.data) continue;
-                        baselineValue = this.#handleOperation(
-                            baselineValue,
-                            op.data.type,
-                            op.data.value,
-                            op.data.updateValue
-                        );
-                    }
-
-                    // Create a compact operation with baseline value and appropriate vector clock
-                    const compactOp = this.#createOperation({ type: "set", value: baselineValue }, baselineVectorClock);
-
-                    // Debug log
-                    if (this.#debug) console.log(CONSOLE_PREFIX + "Operations after garbage collection for this key:", [compactOp, ...retainOps]);
-
-                    // Combine compact op with retained operations
-                    this.#keyOperations.set(key, [compactOp, ...retainOps]);
-                }
-            }
-        } catch (error) {
-            console.error(CONSOLE_PREFIX + "Error running garbage collection:", error);
-        }
-    }
-
-    /**
-     * Create an operation object
-     * @param {object} data - Operation data, consists of type, value and updateValue
-     * @param {Array} vectorClock - Vector clock of the replica/client
-     * @returns {object} - Operation object
-     */
-    #createOperation(data, vectorClock) {
-        const newOperation = {
-            data,
-            vectorClock,
-            source: this.#replicaId,
-            uuid: crypto.randomUUID()
-        };
-        this.#opUuidTimestamp.set(newOperation.uuid, Date.now());
-        return newOperation;
-    }
-
-    /**
-     * Process a property's value by applying all operations and set it in the property store
-     * @param {string} key - Storage key
-     */
-    #processLocalProperty(key) {
-        try {
-            const ops = this.#keyOperations.get(key);
-            if (!ops?.length) return;
-
-            // Apply all operations in order
-            let value = null;
-
-            for (const op of ops) {
-                if (!op.data) continue;
-                value = this.#handleOperation(
-                    value,
-                    op.data.type,
-                    op.data.value,
-                    op.data.updateValue
-                );
-            }
-
-            this.#propertyStore[key] = value; // Save locally
-        } catch (error) {
-            console.error(CONSOLE_PREFIX + `Failed to process property for key ${key}:`, error);
-        }
-    }
-
-    /**
-     * Sort operations by vector clock (causal order)
-     * @param {Array} operations - Full operations that include vector clocks, data and a source
-     * @returns {Array} - Sorted operations
-     */
-    #sortByVectorClock(operations) {
-        return [...operations].sort((a, b) => {
-            const clockA = new Map(a.vectorClock || []);
-            const clockB = new Map(b.vectorClock || []);
-
-            // First sort by causal relationship
-            let aGreater = false, bGreater = false;
-
-            const allIds = new Set([...clockA.keys(), ...clockB.keys()]);
-            for (const id of allIds) {
-                const countA = clockA.get(id) || 0;
-                const countB = clockB.get(id) || 0;
-
-                if (countA > countB) aGreater = true;
-                if (countA < countB) bGreater = true;
-            }
-
-            // Determine causal relationship (if one is greater, and the other is smaller, it's clear)
-            if (aGreater && !bGreater) return 1;     // a happens after b
-            if (!aGreater && bGreater) return -1;    // a happens before b
-
-            // Concurrent (unclear): Compare highest counter in each (sort by which one is ahead)
-            const maxA = Math.max(...Array.from(clockA.values()), 0);
-            const maxB = Math.max(...Array.from(clockB.values()), 0);
-            if (maxA !== maxB) return maxA - maxB;
-
-            // Final tiebreak: Sort by ID of Replica that actually generated the operation
-            return a.source.localeCompare(b.source);
-        });
-    }
-
-    /**
-     * Handle an operation
-     * @param {*} curValue - Current value of the storage key
-     * @param {string} type - Operation type
-     * @param {*} value - New value, or value to match
-     * @param {*} [updateValue] - New value for 'matching' operations
-     * @returns {*} - Value after the operation
-     */
-    #handleOperation(curValue, type, value, updateValue) {
-        try {
-            // Deep copy to avoid reference issues in case value is or contains object(s)
-            curValue = structuredClone(curValue);
-
-            // Set operation
-            if (type === "set") return value;
-
-            // Array operations
-            if (type.startsWith('array')) {
-                if (!Array.isArray(curValue)) curValue = []; // Auto-convert to array if current value isn't one
-
-                // Comparison function
-                const isObject = typeof value === 'object' && value !== null;
-                const compare = (item) => {
-                    if (isObject && typeof item === 'object' && item !== null) return JSON.stringify(item) === JSON.stringify(value); // Deep comparison
-                    return item === value; // Value comparison
-                };
-
-                switch (type) {
-                    case 'array-add':
-                        curValue.push(value);
-                        break;
-                    case 'array-add-unique':
-                        if (!curValue.some(compare)) curValue.push(value);
-                        break;
-                    case 'array-remove-matching':
-                        curValue = curValue.filter(item => !compare(item));
-                        break;
-                    case 'array-update-matching': {
-                        const index = curValue.findIndex(compare);
-                        if (index !== -1) curValue[index] = updateValue;
-                        break;
-                    }
-                }
-            }
-
-            return curValue;
-
-        } catch (error) {
-            console.error(CONSOLE_PREFIX + `Failed to handle operation with curValue ${curValue}:`, error);
-            return curValue;
-        }
-    }
-
-    /**
-     * Remove HTML to prevent XSS and enforce size limits
-     * @param {*} value - Value to sanitize
-     * @returns {*} - Sanitized value
-     */
-    #sanitizeValue(value) {
-        // Check total serialized size
-        const jsonString = JSON.stringify(value);
-        if (jsonString?.length > 50000) throw new Error('Value too large!'); // 50KB limit
-
-        if (typeof value === 'string') return (value.includes('<') || value.includes('>')) ? value.replace(/[<>]/g, '') : value;
-        if (Array.isArray(value)) return value.map(item => this.#sanitizeValue(item));
-        if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, this.#sanitizeValue(v)]));
-        return value;
-    }
-
-    /**
-     * Get property store
-     * @returns {Record<string, any>} - Object with key value pairs
-     */
-    get propertyStore() {
-        try {
-            return structuredClone(this.#propertyStore); // Return deep clone
-        } catch {
-            console.error(CONSOLE_PREFIX + "Failed to parse property store");
-            return {}
-        }
-    }
-
-    /**
-     * Check for changes in the local property store
-     * @returns {boolean} - Check if any values changed going from the last to the current property update
-     */
-    get didPropertiesChange() {
-        try {
-            if (JSON.stringify(this.#propertyStore) !== JSON.stringify(this.#lastPropertyStore)) {
-                this.#lastPropertyStore = structuredClone(this.#propertyStore);
-                return true;
-            }
-        } catch {
-            console.error(CONSOLE_PREFIX + "Failed to stringify and compare property stores");
-        }
-        return false;
-    }
-
-    /**
-     * Export state (can be imported using importState, converts the maps to arrays for serialization)
-     * @returns {object} - State
-     */
-    get state() {
-        return {
-            keyOperations: [...this.#keyOperations.entries()],
-            vectorClock: [...this.#vectorClock.entries()]
-        };
-    }
-}
-
-const ERROR_PREFIX = "PlaySocket error: ";
-const WARNING_PREFIX = "PlaySocket warning: ";
-const LOG_PREFIX = "PlaySocket log: ";
-const TIMEOUT_MS = 3000; // 3 second timeout for WS messages
-
-/**
- * PlaySocket Client
- */
-class PlaySocket {
-    // Core properties
-    #id; // Unique client ID
-    #sessionToken; // Unique session token
-    #endpoint;
-    #socket; // WebSocket connection
-    #initialized = false; // Initialization status
-    #customData;
-
-    // Room properties
-    #roomHost;
-    #inRoom; // If the client is currently in  a room or not
-    #participantCount = 0;
-    #crdtManager;
-    #roomVersion = 0; // Update version (used to compare local vs. remote state to detect package loss)
-
-    // Event handling
-    #callbacks = new Map(); // Event callbacks
-
-    // Async server operations
-    #pendingJoin;
-    #pendingCreate;
-    #pendingRegistration;
-    #pendingConnect;
-    #pendingReconnect;
-
-    // Timeouts or intervals
-    #reconnectTimeout;
-    #reconnectCount = 0;
-    #isReconnecting = false;
-
-    // Debug
-    #debug = false;
-
-    /**
-     * Create a new PlaySocket instance
-     * @param {string} id - Unique identifier for this client
-     * @param {object} options - Connection options
-     * @param {string} options.endpoint - WebSocket endpoint path
-     * @param {object} [options.customData] - Custom registration data
-     * @param {boolean} [options.debug=false] - Enable debug logging
-     */
-    constructor(id, options = {}) {
-        this.#id = id;
-        if (options.endpoint) this.#endpoint = options.endpoint;
-        if (options.customData) this.#customData = { ...options.customData };
-        if (options.debug) this.#debug = true; // Enabling extra logging
-        this.#crdtManager = new CRDTManager(this.#debug);
-    }
-
-    /**
-     * Helper to create timeout promises for create room, join room etc.
-     * @param {string} name - Name of the timeout
-     * @returns {Promise} - Promise that rejects after the timeout
-     * @private
-     */
-    #createTimeout(name) {
-        return new Promise((_, reject) =>
-            setTimeout(() => reject(new Error(`${name} timed out.`)), TIMEOUT_MS)
-        );
-    }
-
-    /**
-     * Register an event callback
-     * @param {string} event - Event name
-     * @param {Function} callback - Callback function
-     */
-    onEvent(event, callback) {
-        const validEvents = ["status", "error", "moved", "instanceDestroyed", "storageUpdated", "hostMigrated", "clientJoined", "clientLeft"];
-        if (!validEvents.includes(event)) {
-            console.warn(WARNING_PREFIX + `Invalid event type "${event}".`);
-            return;
-        }        if (!this.#callbacks.has(event)) this.#callbacks.set(event, []);
-        this.#callbacks.get(event).push(callback);
-    }
-
-    /**
-     * Trigger an event to registered callbacks
-     * @param {string} event - Event name
-     * @param {...*} args - Arguments
-     * @private
-     */
-    #triggerEvent(event, ...args) {
-        const callbacks = this.#callbacks.get(event);
-        callbacks?.forEach(callback => {
-            try {
-                callback(...args);
-            } catch (error) {
-                console.error(ERROR_PREFIX + `${event} callback error:`, error);
-            }
-        });
-    }
-
-    /**
-     * Initialize the PlaySocket instance by connecting to the WS server
-     * @returns {Promise} Resolves when connection is established
-     */
-    async init() {
-        if (this.#initialized) return Promise.reject(new Error("Already initialized!"));
-        if (!this.#endpoint) return Promise.reject(new Error("No websocket endpoint provided!"));
-        this.#triggerEvent("status", "Initializing...");
-
-        // Connect to WS server
-        await this.#connect();
-
-        // Register with server
-        const id = await Promise.race([
-            new Promise((resolve, reject) => {
-                this.#pendingRegistration = { resolve, reject }; // Resolve or reject depending on answer to registration msg
-
-                // Register with server
-                this.#sendToServer({
-                    type: 'register',
-                    id: this.#id,
-                    customData: this.#customData || undefined
-                });
-            }),
-            this.#createTimeout("Registration")
-        ]).finally(() => {
-            this.#pendingRegistration = null;
-        });
-
-        // If the server sent out an id, store and return that
-        if (id) this.#id = id;
-        return this.#id;
-    }
-
-    /**
-     * Connect to the WS server and
-     * @returns {Promise} Resolves when the connection was established
-     * @private 
-     */
-    async #connect() {
-        return Promise.race([
-            new Promise((resolve, reject) => {
-                this.#pendingConnect = { reject };
-                this.#socket = new WebSocket(this.#endpoint);
-                this.#socket.binaryType = 'arraybuffer'; // Important for MessagePack binary data
-                this.#setupSocketHandlers(); // Message & close events
-                this.#socket.onopen = resolve;
-            }),
-            this.#createTimeout("Connection attempt")
-        ]).finally(() => {
-            this.#pendingConnect = null;
-        });
-    }
-
-    /**
-     * Set up WebSocket message & close handlers
-     * @private
-     */
-    #setupSocketHandlers() {
-        this.#socket.onmessage = (event) => {
-            try {
-                const message = decode(new Uint8Array(event.data));
-                if (!message.type) return;
-
-                switch (message.type) {
-                    case 'registration_failed':
-                        this.#triggerEvent("error", "Failed to register: " + message.reason);
-                        if (this.#pendingRegistration) this.#pendingRegistration.reject(new Error("Failed to register: " + message.reason));
-                        break;
-
-                    case 'registered':
-                        this.#sessionToken = message.sessionToken;
-                        this.#initialized = true;
-                        if (this.#pendingRegistration) this.#pendingRegistration.resolve(message.id);
-                        this.#triggerEvent("status", "Connected to server.");
-                        break;
-
-                    case 'join_accepted':
-                        // Connected to room
-                        if (this.#debug) console.log(LOG_PREFIX + "State received for join:", message.state);
-                        this.#inRoom = true;
-                        this.#crdtManager.importState(message.state);
-                        this.#participantCount = message.participantCount;
-                        this.#roomHost = message.host;
-                        this.#roomVersion = message.version;
-                        this.#triggerEvent("storageUpdated", this.storage);
-                        if (this.#pendingJoin) {
-                            this.#triggerEvent("status", "Connected to room.");
-                            this.#pendingJoin.resolve();
-                        } else {
-                            this.#triggerEvent("status", "Moved to room.");
-                            this.#triggerEvent("moved", message.roomId);
-                        }
-                        break;
-
-                    case 'join_rejected':
-                        // Connection to room failed
-                        this.#triggerEvent("status", "Failed to join room: " + message.reason);
-                        if (this.#pendingJoin) this.#pendingJoin.reject(new Error("Failed to join room: " + message.reason));
-                        break;
-
-                    case 'reconnected':
-                        // Successfully reconnected
-                        this.#isReconnecting = false;
-                        this.#reconnectCount = 0;
-                        if (message.roomData) {
-                            if (this.#debug) console.log(LOG_PREFIX + "State received for reconnect:", message.roomData.state);
-                            this.#crdtManager.importState(message.roomData.state);
-                            this.#roomVersion = message.roomData.version;
-                            this.#participantCount = message.roomData.participantCount;
-                            this.#setHost(message.roomData.host); // Set host before in case there are .isHost checks in the storageUpdate fallback
-                            this.#triggerEvent("storageUpdated", this.storage);
-                        } else if (this.#inRoom) {
-                            // If no room data received, but client thinks they were in a room...
-                            this.#triggerEvent("error", "Reconnected, but room no longer exists.");
-                            return this.destroy();
-                        }
-                        this.#triggerEvent("status", "Reconnected.");
-                        if (this.#pendingReconnect) this.#pendingReconnect.resolve();
-                        break;
-
-                    case 'reconnection_failed':
-                        if (this.#pendingReconnect) this.#pendingReconnect.reject(new Error("Server rejected reconnection: " + message.reason));
-                        break;
-
-                    case 'room_created':
-                        this.#inRoom = true;
-                        this.#participantCount = message.participantCount;
-                        this.#triggerEvent("status", `Room created.`);
-                        this.#crdtManager.importState(message.state);
-                        this.#triggerEvent("storageUpdated", this.storage);
-                        if (this.#pendingCreate) this.#pendingCreate.resolve(message.roomId);
-                        break;
-
-                    case 'room_creation_failed':
-                        this.#triggerEvent("error", "Failed to create room: " + message.reason);
-                        if (this.#pendingCreate) this.#pendingCreate.reject(new Error("Failed to create room: " + message.reason));
-                        break;
-
-                    case 'property_updated':
-                        this.#roomVersion++; // Increment room version
-                        if (this.#debug) console.log(LOG_PREFIX + "Property update received:", message.update);
-                        this.#crdtManager.importPropertyUpdate(message.update);
-                        if (this.#crdtManager.didPropertiesChange) this.#triggerEvent("storageUpdated", this.storage);
-                        if (this.#roomVersion != message.version && this.#initialized && this.#socket?.readyState === WebSocket.OPEN) {
-                            this.#triggerEvent("error", "Detected skipped update – forcing reconnect.");
-                            this.#socket?.close();
-                        }
-                        break;
-
-                    case 'property_update_rejected':
-                        this.#triggerEvent("error", "Property update rejected. Re-syncing state.");
-                        this.#crdtManager.importState(message.state);
-                        this.#triggerEvent("storageUpdated", this.storage);
-                        break;
-
-                    case 'kicked':
-                        this.#triggerEvent("error", `Kicked out of room: ${message.reason || "No reason provided."}`);
-                        this.destroy();
-                        break;
-
-                    case 'host_migrated':
-                        this.#setHost(message.newHost);
-                        break;
-
-                    case 'client_left':
-                        this.#participantCount = message.participantCount;
-                        this.#triggerEvent("clientLeft", message.client);
-                        this.#triggerEvent("status", `Client ${message.client} disconnected.`);
-                        break;
-
-                    case 'client_joined':
-                        this.#participantCount = message.participantCount;
-                        this.#triggerEvent("clientJoined", message.client);
-                        this.#triggerEvent("status", `Client ${message.client} connected.`);
-                        break;
-                }
-            } catch (error) {
-                console.error(ERROR_PREFIX + "Error handling message:", error);
-            }
-        };
-
-        // Handle socket errors
-        this.#socket.onerror = () => {
-            this.#triggerEvent("error", "WebSocket error.");
-            if (this.#pendingConnect) this.#pendingConnect.reject(new Error("WebSocket error!"));
-        };
-
-        // Handle socket close & attempt reconnect
-        this.#socket.onclose = () => {
-            if (!this.#initialized || this.#isReconnecting) return;
-            this.#triggerEvent("status", "Disconnected.");
-            this.#reconnectCount = 0;
-            this.#attemptReconnect();
-        };
-    };
-
-    /**
-     * Attempt to reconnect with a fixed number of retries
-     * @private
-     */
-    async #attemptReconnect() {
-        this.#reconnectCount++;
-        if (this.#reconnectCount > 9) {
-            this.#triggerEvent("error", "Disconnected from server.");
-            this.destroy();
-            return;
-        }
-
-        this.#triggerEvent("status", `Attempting to reconnect... (${this.#reconnectCount})`);
-        this.#isReconnecting = true;
-        try {
-            await this.#connect();
-            await Promise.race([
-                new Promise((resolve, reject) => {
-                    this.#pendingReconnect = { resolve, reject };
-                    this.#sendToServer({
-                        type: 'reconnect',
-                        id: this.#id,
-                        sessionToken: this.#sessionToken
-                    });
-                }),
-                this.#createTimeout("Reconnection request")
-            ]).finally(() => {
-                this.#pendingReconnect = null;
-            });
-        } catch (error) {
-            if (!this.#initialized) return;
-            this.#triggerEvent("status", "Reconnection failed: " + error.message);
-            this.#reconnectTimeout = setTimeout(() => this.#attemptReconnect(), 500);
-        }
-    }
-
-    /**
-     * Update the host in case a new one was chosen
-     * @param {string} hostId - Client ID of new host
-     * @private
-     */
-    #setHost(hostId) {
-        if (this.#roomHost != hostId) {
-            this.#roomHost = hostId;
-            this.#triggerEvent("hostMigrated", hostId);
-        }
-    }
-
-    /**
-     * Send a message to the server
-     * @param {object} data - The data to send to the server
-     * @private
-     */
-    #sendToServer(data) {
-        if (!this.#socket || this.#socket?.readyState !== WebSocket.OPEN) {
-            console.warn(WARNING_PREFIX + "Failed to send message - not connected.");
-            return;
-        }
-        try {
-            this.#socket.send(encode(data));
-        } catch (error) {
-            console.error(ERROR_PREFIX + "Error sending message:", error);
-            this.#triggerEvent("error", "Error sending message: " + error.message);
-        }
-    }
-
-    /**
-     * Create a new room and become host
-     * @param {object} initialStorage - Initial state
-     * @param {number} size - Max number of participants
-     * @returns {Promise} Resolves with room ID
-     */
-    async createRoom(initialStorage = {}, size) {
-        if (!this.#initialized) {
-            this.#triggerEvent("error", "Failed to create room - not initialized");
-            return Promise.reject(new Error("Not initialized!"));
-        }
-
-        return Promise.race([
-            new Promise((resolve, reject) => {
-                this.#roomHost = this.#id;
-                this.#pendingCreate = { resolve, reject };
-                this.#sendToServer({
-                    type: 'create_room',
-                    initialStorage,
-                    size
-                });
-            }),
-            this.#createTimeout("Room creation")
-        ]).finally(() => {
-            this.#pendingCreate = null;
-        });
-    }
-
-    /**
-     * Join an existing room
-     * @param {string} roomId - ID of the room
-     * @returns {Promise} - Resolves when connected
-     */
-    async joinRoom(roomId) {
-        if (!this.#initialized) {
-            this.#triggerEvent("error", "Failed to join room - not initialized");
-            return Promise.reject(new Error("Not initialized!"));
-        }
-
-        return Promise.race([
-            new Promise((resolve, reject) => {
-                this.#pendingJoin = { resolve, reject };
-
-                // Send connection request
-                this.#triggerEvent("status", `Connecting to room ${roomId}...`);
-                this.#sendToServer({
-                    type: 'join_room',
-                    roomId
-                });
-            }),
-            this.#createTimeout("Room join")
-        ]).finally(() => {
-            this.#pendingJoin = null;
-        });
-    }
-
-    /**
-     * Update a value in the shared storage
-     * @param {string} key - Storage key
-     * @param {'set' | 'array-add' | 'array-add-unique' | 'array-remove-matching' | 'array-update-matching'} type - Operation type
-     * @param {*} value - New value or value to operate on
-     * @param {*} updateValue - New value for update-matching
-     */
-    updateStorage(key, type, value, updateValue) {
-        if (!this.#inRoom) {
-            this.#triggerEvent("error", "Failed to update storage - not in a room.");
-            return;
-        }        if (this.#debug) console.log(LOG_PREFIX + `Property update for key ${key}, operation ${type}, value ${value} and updateValue ${updateValue}.`);
-        const propUpdate = this.#crdtManager.updateProperty(key, type, value, updateValue);
-        this.#sendToServer({
-            type: 'update_property',
-            update: propUpdate
-        });
-        if (this.#crdtManager.didPropertiesChange) this.#triggerEvent("storageUpdated", this.storage); // Always trigger callback AFTER send in case msgs are sent in the callback (which would break the order)
-    }
-
-    /**
-     * Send a custom request to the server
-     * @param {string} name - Name of the request
-     * @param {*} [data] - Custom data
-     */
-    sendRequest(name, data) {
-        if (this.#debug) console.log(LOG_PREFIX + `Server request with name ${name} and data:`, data);
-        this.#sendToServer({
-            type: 'request',
-            request: { name, data }
-        });
-    }
-
-    /**
-     * Destroy the PlaySocket instance and disconnect
-     */
-    destroy() {
-        this.#initialized = false; // Set this immediately to prevent automatic reconnection
-
-        if (this.#socket) {
-            // Signal to the server that it can immediately remove this user
-            if (this.#socket.readyState === WebSocket.OPEN) this.#sendToServer({ type: 'disconnect' });
-            this.#socket.close();
-            this.#socket.onmessage = null;
-            this.#socket.onerror = null;
-            this.#socket.onclose = null;
-            this.#socket = null;
-
-            // Trigger events
-            this.#triggerEvent("status", "Destroyed.");
-            this.#triggerEvent("instanceDestroyed");
-        }
-
-        // Reset state
-        clearTimeout(this.#reconnectTimeout);
-        this.#roomHost = null;
-        this.#inRoom = false;
-        this.#participantCount = 0;
-        this.#isReconnecting = false;
-        this.#reconnectCount = 0;
-        this.#roomVersion = 0;
-
-        // Reject timeouts if currently active
-        if (this.#pendingJoin) this.#pendingJoin.reject();
-        if (this.#pendingCreate) this.#pendingCreate.reject();
-        if (this.#pendingRegistration) this.#pendingRegistration.reject();
-        if (this.#pendingConnect) this.#pendingConnect.reject();
-        if (this.#pendingReconnect) this.#pendingReconnect.reject();
-    }
-
-    // Public getters
-    get participantCount() { return this.#participantCount; }
-    get storage() { return this.#crdtManager.propertyStore; }
-    get isHost() { return this.#id == this.#roomHost; }
-    get id() { return this.#id; }
-}
-
-export { PlaySocket as default };