playsocketjs 1.0.14 → 1.1.1

package/dist/playsocket-server.js

@@ -7,6 +7,2163 @@ function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
+function getAugmentedNamespace(n) {
+  if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+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 {
+    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 {
+    constructor() {
+        // built-in extensions
+        this.builtInEncoders = [];
+        this.builtInDecoders = [];
+        // custom extensions
+        this.encoders = [];
+        this.decoders = [];
+        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);
+        }
+    }
+}
+ExtensionCodec.defaultCodec = new ExtensionCodec();
+
+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 {
+    constructor(options) {
+        this.entered = false;
+        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 {
+    constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+        this.hit = 0;
+        this.miss = 0;
+        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 {
+    constructor() {
+        this.stack = [];
+        this.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 {
+    constructor(options) {
+        this.totalPos = 0;
+        this.pos = 0;
+        this.view = EMPTY_VIEW;
+        this.bytes = EMPTY_BYTES;
+        this.headByte = HEAD_BYTE_REQUIRED;
+        this.stack = new StackPool();
+        this.entered = false;
+        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 decodeStream}, 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);
+}
+/**
+ * It decodes multiple MessagePack objects in a buffer.
+ * This is corresponding to {@link decodeMultiStream}.
+ *
+ * @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 decodeMulti(buffer, options) {
+    const decoder = new Decoder(options);
+    return decoder.decodeMulti(buffer);
+}
+
+// utility for whatwg streams
+function isAsyncIterable(object) {
+    return object[Symbol.asyncIterator] != null;
+}
+async function* asyncIterableFromStream(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return;
+            }
+            yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function ensureAsyncIterable(streamLike) {
+    if (isAsyncIterable(streamLike)) {
+        return streamLike;
+    }
+    else {
+        return asyncIterableFromStream(streamLike);
+    }
+}
+
+/**
+ * @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.
+ */
+async function decodeAsync(streamLike, options) {
+    const stream = ensureAsyncIterable(streamLike);
+    const decoder = new Decoder(options);
+    return decoder.decodeAsync(stream);
+}
+/**
+ * @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 decodeArrayStream(streamLike, options) {
+    const stream = ensureAsyncIterable(streamLike);
+    const decoder = new Decoder(options);
+    return decoder.decodeArrayStream(stream);
+}
+/**
+ * @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 decodeMultiStream(streamLike, options) {
+    const stream = ensureAsyncIterable(streamLike);
+    const decoder = new Decoder(options);
+    return decoder.decodeStream(stream);
+}
+
+// Main Functions:
+
+var dist_esm = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	DecodeError: DecodeError,
+	Decoder: Decoder,
+	EXT_TIMESTAMP: EXT_TIMESTAMP,
+	Encoder: Encoder,
+	ExtData: ExtData,
+	ExtensionCodec: ExtensionCodec,
+	decode: decode,
+	decodeArrayStream: decodeArrayStream,
+	decodeAsync: decodeAsync,
+	decodeMulti: decodeMulti,
+	decodeMultiStream: decodeMultiStream,
+	decodeTimestampExtension: decodeTimestampExtension,
+	decodeTimestampToTimeSpec: decodeTimestampToTimeSpec,
+	encode: encode,
+	encodeDateToTimeSpec: encodeDateToTimeSpec,
+	encodeTimeSpecToTimestamp: encodeTimeSpecToTimestamp,
+	encodeTimestampExtension: encodeTimestampExtension
+});
+
+var require$$2 = /*@__PURE__*/getAugmentedNamespace(dist_esm);
+
+var crdtManager;
+var hasRequiredCrdtManager;
+
+function requireCrdtManager () {
+	if (hasRequiredCrdtManager) return crdtManager;
+	hasRequiredCrdtManager = 1;
+	// Custom conflict-free replicated data type system with vector clocks
+
+	const CONSOLE_PREFIX = "CRDT Manager: ";
+
+	class CRDTManager {
+	    // Storage
+	    #replicaId;
+	    #keyOperations = new Map();
+	    #vectorClock = new Map();
+
+	    // Local only
+	    #propertyStore = {}; // Current local values per key, as 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 {string} replicaId - Choose a uuid (falls back to random uuid)
+	     */
+	    constructor(replicaId, debug) {
+	        if (!replicaId) return console.error("No replicaId provided!");
+	        if (debug) this.#debug = true;
+	        this.#replicaId = replicaId;
+	        this.#vectorClock.set(this.#replicaId, 0);
+	    }
+
+	    /**
+	     * Import the entire state of the CRDT manager (this overwrites the old state)
+	     * @param {Object} state
+	     */
+	    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 map
+	            this.#vectorClock = new Map(vectorClock); // Also rebuild the map here
+	            if (!this.#vectorClock.has(this.#replicaId)) this.#vectorClock.set(this.#replicaId, 0); // Reset own vector clock if it wasn't present in the imported state
+
+	            // Map operation uuids to 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 - Data to import
+	     */
+	    importPropertyUpdate(data) {
+	        try {
+	            const { key, operation, vectorClock } = data;
+	            if (this.#debug) console.log(CONSOLE_PREFIX + "Importing update:", data); // Debug
+
+	            // 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);
+	                }
+	            }
+
+	            // Saveguard
+	            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:", error);
+	        }
+	    }
+
+	    /**
+	     * Update a property
+	     * @param {string} key 
+	     * @param {string} operation 
+	     * @param {*} value 
+	     * @param {*} updateValue 
+	     * @returns {Object} - Returns the property update
+	     */
+	    updateProperty(key, operation, value, updateValue) {
+	        try {
+	            // Debug log
+	            if (this.#debug) console.log(CONSOLE_PREFIX + `Updating property with key ${key}, operation ${operation}, 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({ operation, 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);
+	        }
+	    }
+
+	    #checkGarbageCollection() {
+	        const MIN_GC_DELAY = 1000; // Minimum 1s delay between garbage collection runs
+	        const MIN_AGE_FOR_GC = 5000; // Garbage collect ops that are older than 5s
+
+	        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)) > MIN_AGE_FOR_GC) {
+	                    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;
+	                    if (op.data.operation.startsWith('array') && !Array.isArray(baselineValue)) baselineValue = []; // Initialize array if required
+	                    baselineValue = this.#handleOperation(
+	                        baselineValue,
+	                        op.data.operation,
+	                        op.data.value,
+	                        op.data.updateValue
+	                    );
+	                }
+
+	                // Create a compact operation with baseline value and appropriate vector clock
+	                const compactOp = this.#createOperation({ operation: "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]);
+	            }
+	        }
+	    }
+
+	    /**
+	     * Create an operation object
+	     * @param {Object} data 
+	     * @param {Array} vectorClock 
+	     * @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 
+	     */
+	    #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;
+	                if (op.data.operation.startsWith('array') && !Array.isArray(value)) value = []; // Initialize array if required
+	                value = this.#handleOperation(
+	                    value,
+	                    op.data.operation,
+	                    op.data.value,
+	                    op.data.updateValue
+	                );
+	            }
+
+	            this.#propertyStore[key] = value; // Save locally
+	        } catch (error) {
+	            console.error(CONSOLE_PREFIX + `Failed to process property for "${key}":`, error);
+	        }
+	    }
+
+	    // Sort by vector clock (causal order)
+	    #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
+	    #handleOperation(curValue, operation, value, updateValue) {
+	        try {
+	            // Clone to avoid reference issues
+	            curValue = JSON.parse(JSON.stringify(curValue || null));
+
+	            // Set operation
+	            if (operation === "set") return value;
+
+	            // Array operations
+	            if (operation.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 (operation) {
+	                    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 process operation with curValue ${curValue}:`, error);
+	            return curValue;
+	        }
+	    }
+
+	    // Get property store
+	    get getPropertyStore() {
+	        try {
+	            return JSON.parse(JSON.stringify(this.#propertyStore)); // Return full copy
+	        } catch {
+	            console.error(CONSOLE_PREFIX + "Failed to parse property store");
+	            return {};
+	        }
+	    }
+
+	    // Check for changes in the local property store
+	    get didPropertiesChange() {
+	        try {
+	            if (JSON.stringify(this.#propertyStore) !== JSON.stringify(this.#lastPropertyStore)) {
+	                this.#lastPropertyStore = JSON.parse(JSON.stringify(this.#propertyStore));
+	                return true;
+	            }
+	        } catch { }
+	        return false;
+	    }
+
+	    // Get state (can be imported using importState, converts the maps to arrays for serialization)
+	    get getState() {
+	        return {
+	            keyOperations: [...this.#keyOperations.entries()],
+	            vectorClock: [...this.#vectorClock.entries()]
+	        };
+	    }
+	}
+
+	crdtManager = { CRDTManager };
+	return crdtManager;
+}
+
 var server$1;
 var hasRequiredServer;
 
@@ -15,6 +2172,8 @@ function requireServer () {
 	hasRequiredServer = 1;
 	const WebSocket = require$$0;
 	const http = require$$1;
+	const { encode, decode } = require$$2;
+	const { CRDTManager } = requireCrdtManager();
 
 	/**
 	 * PlaySocketServer - WebSocket server for PlaySocket multiplayer library
@@ -31,6 +2190,10 @@ function requireServer () {
 	    #heartbeatInterval;
 	    #pendingDisconnects = new Map(); // ClientId -> {timeout, roomId}
 	    #clientTokens = new Map(); // ClientId -> Token
+	    #roomVersions = new Map(); // RoomId -> Version
+
+	    // Debug
+	    #debug = false;
 
 	    /**
 	     * Create a new PlaySocketServer instance
@@ -40,7 +2203,9 @@ function requireServer () {
 	     * @param {string} [options.path='/socket'] - WebSocket endpoint path
 	     */
 	    constructor(options = {}) {
-	        const { server, port = 3000, path = '/' } = options;
+	        const { server, port = 3000, path = '/', debug = false } = options;
+
+	        if (debug) this.#debug = true; // Enable extra logging
 
 	        // Handle server creation / usage
 	        if (server) {
@@ -49,7 +2214,7 @@ function requireServer () {
 	            this.#ownsServer = true;
 	            this.#server = http.createServer(); // Create HTTP server and start it
 	            this.#server.listen(port, () => {
-	                console.log(`PlaySocket server running on port ${port}`);
+	                console.log(`PlaySocket server running on port ${port}.`);
 	            });
 	        }
 
@@ -83,7 +2248,7 @@ function requireServer () {
 	     */
 	    #handleMessage(ws, message) {
 	        try {
-	            const data = JSON.parse(message);
+	            const data = decode(message);
 
 	            // Apply rate limiting after client is registered
 	            if (ws.clientId && !this.#checkRateLimit(ws.clientId, data.type)) {
@@ -95,14 +2260,14 @@ function requireServer () {
 	                    // Register client ID
 	                    if (!data.id) return;
 	                    if (this.#clients.get(data.id)) {
-	                        ws.send(JSON.stringify({ type: 'id_taken' }));
+	                        ws.send(encode({ type: 'id_taken' }), { binary: true });
 	                        return;
 	                    }
 	                    ws.clientId = data.id; // Adds the provided id to the ws object as clientId
 	                    this.#clients.set(data.id, ws);
 	                    const sessionToken = this.#generateSessionToken();
 	                    this.#clientTokens.set(data.id, sessionToken); // Token is used when reconnecting to prevent impersonation attacks
-	                    ws.send(JSON.stringify({ type: 'registered', sessionToken, serverTime: Date.now(), clientTime: data.clientTime }));
+	                    ws.send(encode({ type: 'registered', sessionToken }), { binary: true });
 	                    this.#triggerEvent("clientRegistered", data.id, data.customData);
 	                    break;
 
@@ -111,7 +2276,10 @@ function requireServer () {
 	                    const pd = this.#pendingDisconnects.get(data.id);
 	                    if (pd && data.sessionToken) {
 	                        if (data.sessionToken !== this.#clientTokens.get(data.id)) {
-	                            ws.send(JSON.stringify({ type: 'reconnection_failed', reason: "Session token does not match" }));
+	                            ws.send(encode({
+	                                type: 'reconnection_failed',
+	                                reason: "Session token does not match"
+	                            }), { binary: true });
 	                            return;
 	                        }
 	                        clearTimeout(pd.timeout);
@@ -123,19 +2291,33 @@ function requireServer () {
 
 	                        // If they were in a room, provide updated room data
 	                        let roomData;
-	                        const formerRoom = this.#rooms[this.#clientRooms.get(data.id)];
+	                        const formerRoomId = this.#clientRooms.get(data.id);
+	                        const formerRoom = this.#rooms[formerRoomId];
 	                        if (formerRoom) {
+	                            if (this.#debug) console.log(`State sent for reconnection for room ${formerRoomId}:`, formerRoom.crdtManager.getState);
 	                            roomData = {
-	                                storage: formerRoom.storage,
-	                                storageTimestamps: formerRoom.storageTimestamps,
+	                                state: formerRoom.crdtManager.getState,
 	                                participantCount: formerRoom.participants.length,
-	                                host: formerRoom.participants[0]
+	                                host: formerRoom.participants[0],
+	                                version: this.#roomVersions.get(formerRoomId)
 	                            };
 	                        }
 
-	                        ws.send(JSON.stringify({ type: 'reconnected', roomData }));
+	                        ws.send(encode({ type: 'reconnected', roomData }), { binary: true });
 	                    } else {
-	                        ws.send(JSON.stringify({ type: 'reconnection_failed', reason: "Client unknown to server" }));
+	                        ws.send(encode({ type: 'reconnection_failed', reason: "Client unknown to server" }), { binary: true });
+	                    }
+	                    break;
+
+	                case 'request_state':
+	                    const stateRoomId = this.#clientRooms.get(ws.clientId);
+	                    const stateRoom = stateRoomId ? this.#rooms[stateRoomId] : null;
+	                    if (stateRoom) {
+	                        ws.send(encode({
+	                            type: 'state_sync',
+	                            state: stateRoom.crdtManager.getState,
+	                            version: this.#roomVersions.get(stateRoomId)
+	                        }), { binary: true });
 	                    }
 	                    break;
 
@@ -143,22 +2325,29 @@ function requireServer () {
 	                    if (!ws.clientId) return;
 	                    const newRoomId = ws.clientId;
 	                    if (this.#clientRooms.get(ws.clientId) || this.#rooms[newRoomId]) {
-	                        ws.send(JSON.stringify({
+	                        ws.send(encode({
 	                            type: 'room_creation_failed',
 	                            reason: this.#clientRooms.get(ws.clientId) ? 'Already in a room' : 'Room id is taken'
-	                        }));
+	                        }), { binary: true });
 	                        return;
 	                    }
 
+	                    // Create room
+	                    this.#roomVersions.set(newRoomId, 0); // Start with version 0
 	                    this.#rooms[newRoomId] = {
 	                        participants: [ws.clientId],
 	                        maxSize: data.size || null,
-	                        storage: data.storage || {},
-	                        storageTimestamps: {},
+	                        crdtManager: new CRDTManager(crypto.randomUUID(), this.#debug)
 	                    };
 
-	                    this.#clientRooms.set(ws.clientId, newRoomId);
-	                    ws.send(JSON.stringify({ type: 'room_created' }));
+	                    // Load state if provided
+	                    if (data.state) {
+	                        this.#rooms[newRoomId].crdtManager.importState(data.state);
+	                        if (this.#debug) console.log("Room created with initial state:", data.state);
+	                    }
+
+	                    this.#clientRooms.set(ws.clientId, newRoomId); // Add client to their room
+	                    ws.send(encode({ type: 'room_created' }), { binary: true });
 	                    this.#triggerEvent("roomCreated", ws.clientId); // Client id = room id
 	                    break;
 
@@ -170,12 +2359,12 @@ function requireServer () {
 	                    if (!room ||
 	                        (room.maxSize && room.participants.length >= room.maxSize) ||
 	                        this.#clientRooms.get(ws.clientId)) {
-	                        ws.send(JSON.stringify({
+	                        ws.send(encode({
 	                            type: 'join_rejected',
 	                            reason: !room ? 'Room not found' :
 	                                room.maxSize && room.participants.length >= room.maxSize ? 'Room full' :
 	                                    'Already in a room'
-	                        }));
+	                        }), { binary: true });
 	                        return;
 	                    }
 
@@ -183,53 +2372,53 @@ function requireServer () {
 	                    this.#clientRooms.set(ws.clientId, roomId);
 
 	                    // Notify joiner with initial storage
-	                    ws.send(JSON.stringify({
+	                    if (this.#debug) console.log("Room state sent for join:", room.crdtManager.getState);
+	                    ws.send(encode({
 	                        type: 'join_accepted',
-	                        storage: room.storage,
-	                        storageTimestamps: room.storageTimestamps,
+	                        state: room.crdtManager.getState,
 	                        participantCount: room.participants.length,
-	                        host: room.participants[0]
-	                    }));
+	                        host: room.participants[0],
+	                        version: this.#roomVersions.get(roomId)
+	                    }), { binary: true });
 
 	                    // Notify existing participants
 	                    room.participants.forEach(p => {
 	                        if (p === ws.clientId) return;
 	                        const client = this.#clients.get(p);
 	                        if (client) {
-	                            client.send(JSON.stringify({
+	                            client.send(encode({
 	                                type: 'client_connected',
 	                                client: ws.clientId,
 	                                participantCount: room.participants.length
-	                            }));
+	                            }), { binary: true });
 	                        }
 	                    });
 	                    this.#triggerEvent("roomJoined", ws.clientId, roomId);
 	                    break;
 
-	                case 'room_storage_update':
+	                case 'property_update':
 	                    const updateRoomId = this.#clientRooms.get(ws.clientId);
 	                    const updateRoom = updateRoomId ? this.#rooms[updateRoomId] : null;
-	                    if (updateRoom && data.key) {
-	                        const existingTimestamp = updateRoom.storageTimestamps[data.key] || 0;
-	                        if (data.timestamp > existingTimestamp && JSON.stringify(updateRoom.storage[data.key]) !== JSON.stringify(data.value)) {
-	                            updateRoom.storage[data.key] = data.value;
-	                            updateRoom.storageTimestamps[data.key] = data.timestamp;
-	                            this.#syncRoomStorageKey(updateRoom, data.key, data.timestamp);
-	                        }
-	                    }
-	                    break;
 
-	                case 'room_storage_array_update':
-	                    const arrayRoomId = this.#clientRooms.get(ws.clientId);
-	                    const arrayRoom = arrayRoomId ? this.#rooms[arrayRoomId] : null;
-	                    if (arrayRoom && data.key) {
-	                        // No timestamp check for array operations as they are designed to work unordered
-	                        const updatedArray = this.#arrayUpdate(arrayRoom.storage, data.key, data.operation, data.value, data.updateValue);
-	                        if (JSON.stringify(arrayRoom.storage[data.key]) !== JSON.stringify(updatedArray)) {
-	                            arrayRoom.storage[data.key] = updatedArray;
-	                            arrayRoom.storageTimestamps[data.key] = Date.now(); // Assign new date to ensure that this update is always being applied
-	                            this.#syncRoomStorageOperation(arrayRoom, ws.clientId, data.key, data.operation, data.value, data.updateValue, Date.now());
-	                        }
+	                    if (updateRoom && data.key && data.update && data.uuid) {
+	                        updateRoom.crdtManager.importPropertyUpdate(data.update);
+
+	                        // Increment version for this room
+	                        const currentVersion = this.#roomVersions.get(updateRoomId) + 1;
+	                        this.#roomVersions.set(updateRoomId, currentVersion);
+
+	                        if (this.#debug) console.log("Property update received and imported:", data.update);
+	                        updateRoom.participants?.forEach(p => {
+	                            const client = this.#clients.get(p);
+	                            if (client) {
+	                                client.send(encode({
+	                                    type: 'property_update',
+	                                    update: data.update,
+	                                    version: currentVersion,
+	                                    uuid: data.uuid
+	                                }), { binary: true });
+	                            }
+	                        });
 	                    }
 	                    break;
 
@@ -281,87 +2470,6 @@ function requireServer () {
 	        return true;
 	    }
 
-	    /**
-	     * Sync storage key with all clients in room
-	     * @private
-	     * @param {string} room
-	     * @param {string} requesterId - Client id of whom initiated the operation
-	     * @param {string} key 
-	     * @param {number} timestamp - In milliseconds
-	     */
-	    #syncRoomStorageKey(room, key, timestamp) {
-	        room?.participants?.forEach(p => {
-	            const client = this.#clients.get(p);
-	            if (client) {
-	                client.send(JSON.stringify({
-	                    type: 'storage_sync',
-	                    key,
-	                    value: room?.storage[key],
-	                    timestamp
-	                }));
-	            }
-	        });
-	    }
-
-	    /**
-	     * Sync storage operations with all clients in room
-	     * @private
-	     * @param {string} room
-	     * @param {string} requesterId - Client id of whom initiated the operation
-	     * @param {string} key 
-	     * @param {string} operation 
-	     * @param {*} value 
-	     * @param {*} updateValue 
-	     * @param {number} timestamp - In milliseconds
-	     */
-	    #syncRoomStorageOperation(room, requesterId, key, operation, value, updateValue, timestamp) {
-	        room?.participants?.forEach(p => {
-	            if (p == requesterId) return; // Don't send the operation to the requester
-	            const client = this.#clients.get(p);
-	            if (client) {
-	                client.send(JSON.stringify({
-	                    type: 'storage_operation',
-	                    key,
-	                    operation,
-	                    value,
-	                    updateValue,
-	                    timestamp
-	                }));
-	            }
-	        });
-	    }
-
-	    /**
-	     * Handle array operations
-	     * @private
-	     */
-	    #arrayUpdate(storage, key, operation, value, updateValue) {
-	        let array = (!storage[key] || !Array.isArray(storage[key])) ? [] : [...storage[key]];
-	        const isObject = typeof value === 'object' && value !== null;
-	        const compare = (item) => isObject ? JSON.stringify(item) === JSON.stringify(value) : item === value;
-
-	        switch (operation) {
-	            case 'add':
-	                array.push(value);
-	                break;
-
-	            case 'add-unique':
-	                if (!array.some(compare)) array.push(value);
-	                break;
-
-	            case 'remove-matching':
-	                array = array.filter(item => !compare(item));
-	                break;
-
-	            case 'update-matching':
-	                const index = array.findIndex(compare);
-	                if (index !== -1) array[index] = updateValue;
-	                break;
-	        }
-
-	        return array;
-	    }
-
 	    /**
 	     * Handle client disconnection
 	     * @private
@@ -400,16 +2508,18 @@ function requireServer () {
 
 	            if (room.participants?.length === 0) {
 	                delete this.#rooms[roomId]; // Delete room if now empty
+	                this.#roomVersions.delete(roomId); // Delete room version
+	                if (this.#debug) console.log("Deleted room with id " + roomId + ".");
 	            } else {
 	                // Notify remaining participants
 	                room.participants.forEach(p => {
 	                    const client = this.#clients.get(p);
-	                    if (client) client.send(JSON.stringify({
+	                    if (client) client.send(encode({
 	                        type: 'client_disconnected',
 	                        client: ws.clientId,
 	                        host: room.participants[0],
 	                        participantCount: room.participants.length
-	                    }));
+	                    }), { binary: true });
 	                });
 	            }
 	        }
@@ -451,7 +2561,7 @@ function requireServer () {
 	        }
 	        if (this.#server && this.#ownsServer) {
 	            this.#server.close(() => {
-	                console.log('PlaySocket server stopped');
+	                console.log('PlaySocket server stopped.');
 	            });
 	        }
 	        this.#pendingDisconnects.forEach((data) => {