mcbe-ipc 3.0.0 → 3.0.2

package/dist/ipc.js

@@ -2,7 +2,7 @@
  * @license
  * MIT License
  *
- * Copyright (c) 2024 OmniacDev
+ * Copyright (c) 2025 OmniacDev
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -23,12 +23,18 @@
  * SOFTWARE.
  */
 import { ScriptEventSource, system, world } from '@minecraft/server';
-export var SERDE;
-(function (SERDE) {
-    class ByteArray {
-        get _end() {
+export var PROTO;
+(function (PROTO) {
+    class ByteQueue {
+        get end() {
             return this._length + this._offset;
         }
+        get front() {
+            return this._offset;
+        }
+        get data_view() {
+            return this._data_view;
+        }
         constructor(size = 256) {
             this._buffer = new Uint8Array(size);
             this._data_view = new DataView(this._buffer.buffer);
@@ -36,8 +42,8 @@ export var SERDE;
             this._offset = 0;
         }
         write(...values) {
-            this._ensure_capacity(this._end + values.length);
-            this._buffer.set(values, this._end);
+            this.ensure_capacity(values.length);
+            this._buffer.set(values, this.end);
             this._length += values.length;
         }
         read(amount = 1) {
@@ -46,248 +52,241 @@ export var SERDE;
                 const values = this._buffer.subarray(this._offset, this._offset + max_amount);
                 this._length -= max_amount;
                 this._offset += max_amount;
-                return Array.from(values);
+                return globalThis.Array.from(values);
             }
             return [];
         }
-        write_uint8(value) {
-            this._ensure_capacity(this._end + 1);
-            this._data_view.setUint8(this._end, value);
-            this._length += 1;
-        }
-        read_uint8() {
-            if (this._length >= 1) {
-                const value = this._data_view.getUint8(this._offset);
-                this._length -= 1;
-                this._offset += 1;
-                return value;
-            }
-            return undefined;
-        }
-        write_uint16(value) {
-            this._ensure_capacity(this._end + 2);
-            this._data_view.setUint16(this._end, value);
-            this._length += 2;
-        }
-        read_uint16() {
-            if (this._length >= 2) {
-                const value = this._data_view.getUint16(this._offset);
-                this._length -= 2;
-                this._offset += 2;
-                return value;
-            }
-            return undefined;
-        }
-        write_uint32(value) {
-            this._ensure_capacity(this._end + 4);
-            this._data_view.setUint32(this._end, value);
-            this._length += 4;
-        }
-        read_uint32() {
-            if (this._length >= 4) {
-                const value = this._data_view.getUint32(this._offset);
-                this._length -= 4;
-                this._offset += 4;
-                return value;
-            }
-            return undefined;
-        }
-        write_int8(value) {
-            this._ensure_capacity(this._end + 1);
-            this._data_view.setInt8(this._end, value);
-            this._length += 1;
-        }
-        read_int8() {
-            if (this._length >= 1) {
-                const value = this._data_view.getInt8(this._offset);
-                this._length -= 1;
-                this._offset += 1;
-                return value;
-            }
-            return undefined;
-        }
-        write_int16(value) {
-            this._ensure_capacity(this._end + 2);
-            this._data_view.setInt16(this._end, value);
-            this._length += 2;
-        }
-        read_int16() {
-            if (this._length >= 2) {
-                const value = this._data_view.getInt16(this._offset);
-                this._length -= 2;
-                this._offset += 2;
-                return value;
-            }
-            return undefined;
-        }
-        write_int32(value) {
-            this._ensure_capacity(this._end + 4);
-            this._data_view.setInt32(this._end, value);
-            this._length += 4;
-        }
-        read_int32() {
-            if (this._length >= 4) {
-                const value = this._data_view.getInt32(this._offset);
-                this._length -= 4;
-                this._offset += 4;
-                return value;
-            }
-            return undefined;
-        }
-        write_f32(value) {
-            this._ensure_capacity(this._end + 4);
-            this._data_view.setFloat32(this._end, value);
-            this._length += 4;
-        }
-        read_f32() {
-            if (this._length >= 4) {
-                const value = this._data_view.getFloat32(this._offset);
-                this._length -= 4;
-                this._offset += 4;
-                return value;
-            }
-            return undefined;
-        }
-        write_f64(value) {
-            this._ensure_capacity(this._end + 8);
-            this._data_view.setFloat64(this._end, value);
-            this._length += 8;
-        }
-        read_f64() {
-            if (this._length >= 8) {
-                const value = this._data_view.getFloat64(this._offset);
-                this._length -= 8;
-                this._offset += 8;
-                return value;
-            }
-            return undefined;
-        }
-        _ensure_capacity(size) {
-            if (size > this._buffer.length) {
-                const larger_buffer = new Uint8Array(size * 2);
-                larger_buffer.set(this._buffer.subarray(this._offset, this._end), 0);
+        ensure_capacity(size) {
+            if (this.end + size > this._buffer.length) {
+                const larger_buffer = new Uint8Array((this.end + size) * 2);
+                larger_buffer.set(this._buffer.subarray(this._offset, this.end), 0);
                 this._buffer = larger_buffer;
                 this._offset = 0;
                 this._data_view = new DataView(this._buffer.buffer);
             }
         }
         static from_uint8array(array) {
-            const byte_array = new ByteArray();
-            byte_array._buffer = array;
-            byte_array._length = array.length;
-            byte_array._offset = 0;
-            byte_array._data_view = new DataView(array.buffer);
-            return byte_array;
+            const byte_queue = new ByteQueue();
+            byte_queue._buffer = array;
+            byte_queue._length = array.length;
+            byte_queue._offset = 0;
+            byte_queue._data_view = new DataView(array.buffer);
+            return byte_queue;
         }
         to_uint8array() {
-            return this._buffer.subarray(this._offset, this._end);
-        }
-    }
-    SERDE.ByteArray = ByteArray;
-    function* serialize(byte_array, max_size = Infinity) {
-        const uint8array = byte_array.to_uint8array();
-        const result = [];
-        let acc_str = '';
-        let acc_size = 0;
-        for (let i = 0; i < uint8array.length; i++) {
-            const char_code = uint8array[i] | (uint8array[++i] << 8);
-            const utf16_size = char_code <= 0x7f ? 1 : char_code <= 0x7ff ? 2 : char_code <= 0xffff ? 3 : 4;
-            const char_size = char_code > 0xff ? utf16_size : 3;
-            if (acc_size + char_size > max_size) {
-                result.push(acc_str);
-                acc_str = '';
-                acc_size = 0;
-            }
-            if (char_code > 0xff) {
-                acc_str += String.fromCharCode(char_code);
-                acc_size += utf16_size;
-            }
-            else {
-                acc_str += `?${char_code.toString(16).padStart(2, '0')}`;
-                acc_size += 3;
+            return this._buffer.subarray(this._offset, this.end);
+        }
+    }
+    PROTO.ByteQueue = ByteQueue;
+    let MIPS;
+    (function (MIPS) {
+        function* serialize(byte_queue) {
+            const uint8array = byte_queue.to_uint8array();
+            let str = '(0x';
+            for (let i = 0; i < uint8array.length; i++) {
+                const hex = uint8array[i].toString(16).padStart(2, '0').toUpperCase();
+                str += hex;
+                yield;
             }
-            yield;
+            str += ')';
+            return str;
         }
-        result.push(acc_str);
-        return result;
-    }
-    SERDE.serialize = serialize;
-    function* deserialize(strings) {
-        const result = [];
-        for (let i = 0; i < strings.length; i++) {
-            const str = strings[i];
-            for (let j = 0; j < str.length; j++) {
-                const char_code = str.charCodeAt(j);
-                if (char_code === '?'.charCodeAt(0) && j + 2 < str.length) {
-                    const hex = str.slice(j + 1, j + 3);
-                    const hex_code = parseInt(hex, 16);
-                    result.push(hex_code & 0xff);
-                    result.push(hex_code >> 8);
-                    j += 2;
-                }
-                else {
-                    result.push(char_code & 0xff);
-                    result.push(char_code >> 8);
+        MIPS.serialize = serialize;
+        function* deserialize(str) {
+            if (str.startsWith('(0x') && str.endsWith(')')) {
+                const result = [];
+                const hex_str = str.slice(3, str.length - 1);
+                for (let i = 0; i < hex_str.length; i++) {
+                    const hex = hex_str[i] + hex_str[++i];
+                    result.push(parseInt(hex, 16));
+                    yield;
                 }
-                yield;
+                return ByteQueue.from_uint8array(new Uint8Array(result));
             }
-            yield;
+            return new ByteQueue();
+        }
+        MIPS.deserialize = deserialize;
+    })(MIPS = PROTO.MIPS || (PROTO.MIPS = {}));
+    PROTO.Void = {
+        *serialize() { },
+        *deserialize() { }
+    };
+    PROTO.Null = {
+        *serialize() { },
+        *deserialize() {
+            return null;
+        }
+    };
+    PROTO.Undefined = {
+        *serialize() { },
+        *deserialize() {
+            return undefined;
         }
-        return ByteArray.from_uint8array(new Uint8Array(result));
-    }
-    SERDE.deserialize = deserialize;
-})(SERDE || (SERDE = {}));
-var CRYPTO;
-(function (CRYPTO) {
-    CRYPTO.PRIME = 19893121;
-    CRYPTO.MOD = 341;
-    const to_HEX = (n) => n.toString(16).toUpperCase();
-    const to_NUM = (h) => parseInt(h, 16);
-    function* mod_exp(base, exp, mod) {
-        let result = 1;
-        let b = base % mod;
-        for (let e = exp; e > 0; e = Math.floor(e / 2)) {
-            if (e % 2 === 1) {
-                result = (result * b) % mod;
+    };
+    PROTO.Int8 = {
+        *serialize(value, stream) {
+            const length = 1;
+            stream.write(...globalThis.Array(length).fill(0));
+            stream.data_view.setInt8(stream.end - length, value);
+        },
+        *deserialize(stream) {
+            const value = stream.data_view.getInt8(stream.front);
+            stream.read(1);
+            return value;
+        }
+    };
+    PROTO.Int16 = {
+        *serialize(value, stream) {
+            const length = 2;
+            stream.write(...globalThis.Array(length).fill(0));
+            stream.data_view.setInt16(stream.end - length, value);
+        },
+        *deserialize(stream) {
+            const value = stream.data_view.getInt16(stream.front);
+            stream.read(2);
+            return value;
+        }
+    };
+    PROTO.Int32 = {
+        *serialize(value, stream) {
+            const length = 4;
+            stream.write(...globalThis.Array(length).fill(0));
+            stream.data_view.setInt32(stream.end - length, value);
+        },
+        *deserialize(stream) {
+            const value = stream.data_view.getInt32(stream.front);
+            stream.read(4);
+            return value;
+        }
+    };
+    PROTO.UInt8 = {
+        *serialize(value, stream) {
+            const length = 1;
+            stream.write(...globalThis.Array(length).fill(0));
+            stream.data_view.setUint8(stream.end - length, value);
+        },
+        *deserialize(stream) {
+            const value = stream.data_view.getUint8(stream.front);
+            stream.read(1);
+            return value;
+        }
+    };
+    PROTO.UInt16 = {
+        *serialize(value, stream) {
+            const length = 2;
+            stream.write(...globalThis.Array(length).fill(0));
+            stream.data_view.setUint16(stream.end - length, value);
+        },
+        *deserialize(stream) {
+            const value = stream.data_view.getUint16(stream.front);
+            stream.read(2);
+            return value;
+        }
+    };
+    PROTO.UInt32 = {
+        *serialize(value, stream) {
+            const length = 4;
+            stream.write(...globalThis.Array(length).fill(0));
+            stream.data_view.setUint32(stream.end - length, value);
+        },
+        *deserialize(stream) {
+            const value = stream.data_view.getUint32(stream.front);
+            stream.read(4);
+            return value;
+        }
+    };
+    PROTO.UVarInt32 = {
+        *serialize(value, stream) {
+            while (value >= 0x80) {
+                stream.write((value & 0x7f) | 0x80);
+                value >>= 7;
+                yield;
             }
-            b = (b * b) % mod;
-            yield;
-        }
-        return result;
-    }
-    function make_secret(mod = CRYPTO.MOD) {
-        return Math.floor(Math.random() * (mod - 1)) + 1;
-    }
-    CRYPTO.make_secret = make_secret;
-    function* make_public(secret, mod = CRYPTO.MOD, prime = CRYPTO.PRIME) {
-        return to_HEX(yield* mod_exp(mod, secret, prime));
-    }
-    CRYPTO.make_public = make_public;
-    function* make_shared(secret, other, prime = CRYPTO.PRIME) {
-        return to_HEX(yield* mod_exp(to_NUM(other), secret, prime));
-    }
-    CRYPTO.make_shared = make_shared;
-    function* encrypt(raw, key) {
-        let encrypted = new Uint8Array(raw.length);
-        for (let i = 0; i < raw.length; i++) {
-            encrypted[i] = raw[i] ^ key.charCodeAt(i % key.length);
-            yield;
-        }
-        return encrypted;
-    }
-    CRYPTO.encrypt = encrypt;
-    function* decrypt(encrypted, key) {
-        let decrypted = new Uint8Array(encrypted.length);
-        for (let i = 0; i < encrypted.length; i++) {
-            decrypted[i] = encrypted[i] ^ key.charCodeAt(i % key.length);
-            yield;
-        }
-        return decrypted;
-    }
-    CRYPTO.decrypt = decrypt;
-})(CRYPTO || (CRYPTO = {}));
-export class Proto {
-    static Object(obj) {
+            stream.write(value);
+        },
+        *deserialize(stream) {
+            let value = 0;
+            let size = 0;
+            let byte;
+            do {
+                byte = stream.read()[0];
+                value |= (byte & 0x7f) << (size * 7);
+                size += 1;
+                yield;
+            } while ((byte & 0x80) !== 0 && size < 10);
+            return value;
+        }
+    };
+    PROTO.Float32 = {
+        *serialize(value, stream) {
+            const length = 4;
+            stream.write(...globalThis.Array(length).fill(0));
+            stream.data_view.setFloat32(stream.end - length, value);
+        },
+        *deserialize(stream) {
+            const value = stream.data_view.getFloat32(stream.front);
+            stream.read(4);
+            return value;
+        }
+    };
+    PROTO.Float64 = {
+        *serialize(value, stream) {
+            const length = 8;
+            stream.write(...globalThis.Array(length).fill(0));
+            stream.data_view.setFloat64(stream.end - length, value);
+        },
+        *deserialize(stream) {
+            const value = stream.data_view.getFloat64(stream.front);
+            stream.read(8);
+            return value;
+        }
+    };
+    PROTO.String = {
+        *serialize(value, stream) {
+            yield* PROTO.UVarInt32.serialize(value.length, stream);
+            for (let i = 0; i < value.length; i++) {
+                const code = value.charCodeAt(i);
+                yield* PROTO.UVarInt32.serialize(code, stream);
+            }
+        },
+        *deserialize(stream) {
+            const length = yield* PROTO.UVarInt32.deserialize(stream);
+            let value = '';
+            for (let i = 0; i < length; i++) {
+                const code = yield* PROTO.UVarInt32.deserialize(stream);
+                value += globalThis.String.fromCharCode(code);
+            }
+            return value;
+        }
+    };
+    PROTO.Boolean = {
+        *serialize(value, stream) {
+            stream.write(value ? 1 : 0);
+        },
+        *deserialize(stream) {
+            const value = stream.read()[0];
+            return value === 1;
+        }
+    };
+    PROTO.UInt8Array = {
+        *serialize(value, stream) {
+            yield* PROTO.UVarInt32.serialize(value.length, stream);
+            stream.write(...value);
+        },
+        *deserialize(stream) {
+            const length = yield* PROTO.UVarInt32.deserialize(stream);
+            return new Uint8Array(stream.read(length));
+        }
+    };
+    PROTO.Date = {
+        *serialize(value, stream) {
+            yield* PROTO.Float64.serialize(value.getTime(), stream);
+        },
+        *deserialize(stream) {
+            return new globalThis.Date(yield* PROTO.Float64.deserialize(stream));
+        }
+    };
+    function Object(obj) {
         return {
             *serialize(value, stream) {
                 for (const key in obj) {
@@ -303,68 +302,73 @@ export class Proto {
             }
         };
     }
-    static Array(items) {
+    PROTO.Object = Object;
+    function Array(value) {
         return {
-            *serialize(value, stream) {
-                yield* Proto.VarInt.serialize(value.length, stream);
-                for (const item of value) {
-                    yield* items.serialize(item, stream);
+            *serialize(array, stream) {
+                yield* PROTO.UVarInt32.serialize(array.length, stream);
+                for (const item of array) {
+                    yield* value.serialize(item, stream);
                 }
             },
             *deserialize(stream) {
                 const result = [];
-                const length = yield* Proto.VarInt.deserialize(stream);
+                const length = yield* PROTO.UVarInt32.deserialize(stream);
                 for (let i = 0; i < length; i++) {
-                    result[i] = yield* items.deserialize(stream);
+                    result[i] = yield* value.deserialize(stream);
                 }
                 return result;
             }
         };
     }
-    static Tuple(...items) {
+    PROTO.Array = Array;
+    function Tuple(...values) {
         return {
-            *serialize(value, stream) {
-                for (let i = 0; i < items.length; i++) {
-                    yield* items[i].serialize(value[i], stream);
+            *serialize(tuple, stream) {
+                for (let i = 0; i < values.length; i++) {
+                    yield* values[i].serialize(tuple[i], stream);
                 }
             },
             *deserialize(stream) {
                 const result = [];
-                for (let i = 0; i < items.length; i++) {
-                    result[i] = yield* items[i].deserialize(stream);
+                for (let i = 0; i < values.length; i++) {
+                    result[i] = yield* values[i].deserialize(stream);
                 }
                 return result;
             }
         };
     }
-    static Optional(item) {
+    PROTO.Tuple = Tuple;
+    function Optional(value) {
         return {
-            *serialize(value, stream) {
-                yield* Proto.Boolean.serialize(value !== undefined, stream);
-                if (value !== undefined) {
-                    yield* item.serialize(value, stream);
+            *serialize(optional, stream) {
+                yield* PROTO.Boolean.serialize(value !== undefined, stream);
+                if (optional !== undefined) {
+                    yield* value.serialize(optional, stream);
                 }
             },
             *deserialize(stream) {
-                const defined = yield* Proto.Boolean.deserialize(stream);
+                const defined = yield* PROTO.Boolean.deserialize(stream);
                 if (defined) {
-                    return yield* item.deserialize(stream);
+                    return yield* value.deserialize(stream);
                 }
+                return undefined;
             }
         };
     }
-    static Map(key, value) {
+    PROTO.Optional = Optional;
+    function Map(key, value) {
         return {
             *serialize(map, stream) {
-                yield* Proto.VarInt.serialize(map.size, stream);
+                yield* PROTO.UVarInt32.serialize(map.size, stream);
                 for (const [k, v] of map.entries()) {
                     yield* key.serialize(k, stream);
                     yield* value.serialize(v, stream);
                 }
             },
             *deserialize(stream) {
-                const size = yield* Proto.VarInt.deserialize(stream);
-                const result = new Map();
+                const size = yield* PROTO.UVarInt32.deserialize(stream);
+                const result = new globalThis.Map();
                 for (let i = 0; i < size; i++) {
                     const k = yield* key.deserialize(stream);
                     const v = yield* value.deserialize(stream);
@@ -374,17 +378,18 @@ export class Proto {
             }
         };
     }
-    static Set(value) {
+    PROTO.Map = Map;
+    function Set(value) {
         return {
             *serialize(set, stream) {
-                yield* Proto.VarInt.serialize(set.size, stream);
+                yield* PROTO.UVarInt32.serialize(set.size, stream);
                 for (const [_, v] of set.entries()) {
                     yield* value.serialize(v, stream);
                 }
             },
             *deserialize(stream) {
-                const size = yield* Proto.VarInt.deserialize(stream);
-                const result = new Set();
+                const size = yield* PROTO.UVarInt32.deserialize(stream);
+                const result = new globalThis.Set();
                 for (let i = 0; i < size; i++) {
                     const v = yield* value.deserialize(stream);
                     result.add(v);
@@ -393,164 +398,80 @@ export class Proto {
             }
         };
     }
-}
-Proto.Int8 = {
-    *serialize(value, stream) {
-        stream.write_int8(value);
-    },
-    *deserialize(stream) {
-        return stream.read_int8();
-    }
-};
-Proto.Int16 = {
-    *serialize(value, stream) {
-        stream.write_int16(value);
-    },
-    *deserialize(stream) {
-        return stream.read_int16();
-    }
-};
-Proto.Int32 = {
-    *serialize(value, stream) {
-        stream.write_int32(value);
-    },
-    *deserialize(stream) {
-        return stream.read_int32();
-    }
-};
-Proto.UInt8 = {
-    *serialize(value, stream) {
-        stream.write_uint8(value);
-    },
-    *deserialize(stream) {
-        return stream.read_uint8();
-    }
-};
-Proto.UInt16 = {
-    *serialize(value, stream) {
-        stream.write_uint16(value);
-    },
-    *deserialize(stream) {
-        return stream.read_uint16();
-    }
-};
-Proto.UInt32 = {
-    *serialize(value, stream) {
-        stream.write_uint32(value);
-    },
-    *deserialize(stream) {
-        return stream.read_uint32();
-    }
-};
-Proto.Float32 = {
-    *serialize(value, stream) {
-        stream.write_f32(value);
-    },
-    *deserialize(stream) {
-        return stream.read_f32();
-    }
-};
-Proto.Float64 = {
-    *serialize(value, stream) {
-        stream.write_f64(value);
-    },
-    *deserialize(stream) {
-        return stream.read_f64();
-    }
-};
-Proto.VarInt = {
-    *serialize(value, stream) {
-        while (value >= 0x80) {
-            stream.write((value & 0x7f) | 0x80);
-            value >>= 7;
+    PROTO.Set = Set;
+    PROTO.Endpoint = PROTO.String;
+    PROTO.Header = PROTO.Object({
+        guid: PROTO.String,
+        encoding: PROTO.String,
+        index: PROTO.UVarInt32,
+        final: PROTO.Boolean
+    });
+})(PROTO || (PROTO = {}));
+export var NET;
+(function (NET) {
+    const FRAG_MAX = 2048;
+    const ENCODING = 'mcbe-ipc:v3';
+    const ENDPOINTS = new Map();
+    function* serialize(byte_queue, max_size = Infinity) {
+        const uint8array = byte_queue.to_uint8array();
+        const result = [];
+        let acc_str = '';
+        let acc_size = 0;
+        for (let i = 0; i < uint8array.length; i++) {
+            const char_code = uint8array[i] | (uint8array[++i] << 8);
+            const utf16_size = char_code <= 0x7f ? 1 : char_code <= 0x7ff ? 2 : char_code <= 0xffff ? 3 : 4;
+            const char_size = char_code > 0xff ? utf16_size : 3;
+            if (acc_size + char_size > max_size) {
+                result.push(acc_str);
+                acc_str = '';
+                acc_size = 0;
+            }
+            if (char_code > 0xff) {
+                acc_str += String.fromCharCode(char_code);
+                acc_size += utf16_size;
+            }
+            else {
+                acc_str += char_code.toString(16).padStart(2, '0').toUpperCase();
+                acc_size += 2;
+            }
             yield;
         }
-        stream.write(value);
-    },
-    *deserialize(stream) {
-        let value = 0;
-        let shift = 0;
-        let byte;
-        do {
-            byte = stream.read()[0];
-            value |= (byte & 0x7f) << shift;
-            shift += 7;
-            yield;
-        } while (byte & 0x80);
-        return value;
-    }
-};
-Proto.String = {
-    *serialize(value, stream) {
-        yield* Proto.VarInt.serialize(value.length, stream);
-        for (let i = 0; i < value.length; i++) {
-            const code = value.charCodeAt(i);
-            yield* Proto.VarInt.serialize(code, stream);
-        }
-    },
-    *deserialize(stream) {
-        const length = yield* Proto.VarInt.deserialize(stream);
-        let value = '';
-        for (let i = 0; i < length; i++) {
-            const code = yield* Proto.VarInt.deserialize(stream);
-            value += String.fromCharCode(code);
-        }
-        return value;
-    }
-};
-Proto.Boolean = {
-    *serialize(value, stream) {
-        stream.write(value ? 1 : 0);
-    },
-    *deserialize(stream) {
-        const value = stream.read()[0];
-        return value === 1;
+        result.push(acc_str);
+        return result;
     }
-};
-Proto.UInt8Array = {
-    *serialize(value, stream) {
-        yield* Proto.VarInt.serialize(value.length, stream);
-        for (const item of value) {
-            stream.write_uint8(item);
+    NET.serialize = serialize;
+    function* deserialize(strings) {
+        const result = [];
+        for (let i = 0; i < strings.length; i++) {
+            const str = strings[i];
+            for (let j = 0; j < str.length; j++) {
+                const char_code = str.charCodeAt(j);
+                if (char_code <= 0xff) {
+                    const hex = str[j] + str[++j];
+                    const hex_code = parseInt(hex, 16);
+                    result.push(hex_code & 0xff);
+                    result.push(hex_code >> 8);
+                }
+                else {
+                    result.push(char_code & 0xff);
+                    result.push(char_code >> 8);
+                }
+                yield;
+            }
             yield;
         }
-    },
-    *deserialize(stream) {
-        const length = yield* Proto.VarInt.deserialize(stream);
-        const result = new Uint8Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = stream.read_uint8();
-        }
-        return result;
-    }
-};
-Proto.Date = {
-    *serialize(value, stream) {
-        yield* Proto.VarInt.serialize(value.getTime(), stream);
-    },
-    *deserialize(stream) {
-        return new Date(yield* Proto.VarInt.deserialize(stream));
+        return PROTO.ByteQueue.from_uint8array(new Uint8Array(result));
     }
-};
-export var NET;
-(function (NET) {
-    var ByteArray = SERDE.ByteArray;
-    const FRAG_MAX = 2048;
-    const Header = Proto.Object({
-        guid: Proto.String,
-        index: Proto.VarInt,
-        final: Proto.Boolean
-    });
-    const endpoint_map = new Map();
+    NET.deserialize = deserialize;
     system.afterEvents.scriptEventReceive.subscribe(event => {
         system.runJob((function* () {
             const [serialized_endpoint, serialized_header] = event.id.split(':');
-            const endpoint_stream = yield* SERDE.deserialize([serialized_endpoint]);
-            const endpoint = yield* Proto.String.deserialize(endpoint_stream);
-            const listeners = endpoint_map.get(endpoint);
+            const endpoint_stream = yield* PROTO.MIPS.deserialize(serialized_endpoint);
+            const endpoint = yield* PROTO.Endpoint.deserialize(endpoint_stream);
+            const listeners = ENDPOINTS.get(endpoint);
             if (event.sourceType === ScriptEventSource.Server && listeners) {
-                const header_stream = yield* SERDE.deserialize([serialized_header]);
-                const header = yield* Header.deserialize(header_stream);
+                const header_stream = yield* PROTO.MIPS.deserialize(serialized_header);
+                const header = yield* PROTO.Header.deserialize(header_stream);
                 for (let i = 0; i < listeners.length; i++) {
                     yield* listeners[i](header, event.message);
                 }
@@ -558,10 +479,10 @@ export var NET;
         })());
     });
     function create_listener(endpoint, listener) {
-        let listeners = endpoint_map.get(endpoint);
+        let listeners = ENDPOINTS.get(endpoint);
         if (!listeners) {
             listeners = new Array();
-            endpoint_map.set(endpoint, listeners);
+            ENDPOINTS.set(endpoint, listeners);
         }
         listeners.push(listener);
         return () => {
@@ -569,7 +490,7 @@ export var NET;
             if (idx !== -1)
                 listeners.splice(idx, 1);
             if (listeners.length === 0) {
-                endpoint_map.delete(endpoint);
+                ENDPOINTS.delete(endpoint);
             }
         };
     }
@@ -582,23 +503,23 @@ export var NET;
     }
     function* emit(endpoint, serializer, value) {
         const guid = generate_id();
-        const endpoint_stream = new ByteArray();
-        yield* Proto.String.serialize(endpoint, endpoint_stream);
-        const [serialized_endpoint] = yield* SERDE.serialize(endpoint_stream);
+        const endpoint_stream = new PROTO.ByteQueue();
+        yield* PROTO.Endpoint.serialize(endpoint, endpoint_stream);
+        const serialized_endpoint = yield* PROTO.MIPS.serialize(endpoint_stream);
         const RUN = function* (header, serialized_packet) {
-            const header_stream = new SERDE.ByteArray();
-            yield* Header.serialize(header, header_stream);
-            const [serialized_header] = yield* SERDE.serialize(header_stream);
+            const header_stream = new PROTO.ByteQueue();
+            yield* PROTO.Header.serialize(header, header_stream);
+            const serialized_header = yield* PROTO.MIPS.serialize(header_stream);
             world
                 .getDimension('overworld')
                 .runCommand(`scriptevent ${serialized_endpoint}:${serialized_header} ${serialized_packet}`);
         };
-        const packet_stream = new ByteArray();
+        const packet_stream = new PROTO.ByteQueue();
         yield* serializer.serialize(value, packet_stream);
-        const serialized_packets = yield* SERDE.serialize(packet_stream, FRAG_MAX);
+        const serialized_packets = yield* serialize(packet_stream, FRAG_MAX);
         for (let i = 0; i < serialized_packets.length; i++) {
             const serialized_packet = serialized_packets[i];
-            yield* RUN({ guid, index: i, final: i === serialized_packets.length - 1 }, serialized_packet);
+            yield* RUN({ guid, encoding: ENCODING, index: i, final: i === serialized_packets.length - 1 }, serialized_packet);
         }
     }
     NET.emit = emit;
@@ -616,7 +537,7 @@ export var NET;
             fragment.serialized_packets[payload.index] = serialized_packet;
             fragment.data_size += payload.index + 1;
             if (fragment.size !== -1 && fragment.data_size === (fragment.size * (fragment.size + 1)) / 2) {
-                const stream = yield* SERDE.deserialize(fragment.serialized_packets);
+                const stream = yield* deserialize(fragment.serialized_packets);
                 const value = yield* serializer.deserialize(stream);
                 yield* callback(value);
                 buffer.delete(payload.guid);
@@ -628,296 +549,6 @@ export var NET;
 })(NET || (NET = {}));
 export var IPC;
 (function (IPC) {
-    const ConnectionSerializer = Proto.Object({
-        from: Proto.String,
-        bytes: Proto.UInt8Array
-    });
-    const HandshakeSynchronizeSerializer = Proto.Object({
-        from: Proto.String,
-        encryption_enabled: Proto.Boolean,
-        encryption_public_key: Proto.String,
-        encryption_prime: Proto.VarInt,
-        encryption_modulus: Proto.VarInt
-    });
-    const HandshakeAcknowledgeSerializer = Proto.Object({
-        from: Proto.String,
-        encryption_enabled: Proto.Boolean,
-        encryption_public_key: Proto.String
-    });
-    class Connection {
-        *MAYBE_ENCRYPT(bytes) {
-            return this._enc !== false ? yield* CRYPTO.encrypt(bytes, this._enc) : bytes;
-        }
-        *MAYBE_DECRYPT(bytes) {
-            return this._enc !== false ? yield* CRYPTO.decrypt(bytes, this._enc) : bytes;
-        }
-        get from() {
-            return this._from;
-        }
-        get to() {
-            return this._to;
-        }
-        constructor(from, to, encryption) {
-            this._from = from;
-            this._to = to;
-            this._enc = encryption;
-            this._terminators = new Array();
-        }
-        terminate(notify = true) {
-            const $ = this;
-            $._terminators.forEach(terminate => terminate());
-            $._terminators.length = 0;
-            if (notify) {
-                system.runJob(NET.emit(`ipc:${$._to}:terminate`, Proto.String, $._from));
-            }
-        }
-        send(channel, serializer, value) {
-            const $ = this;
-            system.runJob((function* () {
-                const stream = new SERDE.ByteArray();
-                yield* serializer.serialize(value, stream);
-                const bytes = yield* $.MAYBE_ENCRYPT(stream.to_uint8array());
-                yield* NET.emit(`ipc:${$._to}:${channel}:send`, ConnectionSerializer, {
-                    from: $._from,
-                    bytes
-                });
-            })());
-        }
-        invoke(channel, serializer, value, deserializer) {
-            const $ = this;
-            system.runJob((function* () {
-                const stream = new SERDE.ByteArray();
-                yield* serializer.serialize(value, stream);
-                const bytes = yield* $.MAYBE_ENCRYPT(stream.to_uint8array());
-                yield* NET.emit(`ipc:${$._to}:${channel}:invoke`, ConnectionSerializer, {
-                    from: $._from,
-                    bytes
-                });
-            })());
-            return new Promise(resolve => {
-                const terminate = NET.listen(`ipc:${$._from}:${channel}:handle`, ConnectionSerializer, function* (data) {
-                    if (data.from === $._to) {
-                        const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
-                        const stream = SERDE.ByteArray.from_uint8array(bytes);
-                        const value = yield* deserializer.deserialize(stream);
-                        resolve(value);
-                        terminate();
-                    }
-                });
-            });
-        }
-        on(channel, deserializer, listener) {
-            const $ = this;
-            const terminate = NET.listen(`ipc:${$._from}:${channel}:send`, ConnectionSerializer, function* (data) {
-                if (data.from === $._to) {
-                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
-                    const stream = SERDE.ByteArray.from_uint8array(bytes);
-                    const value = yield* deserializer.deserialize(stream);
-                    listener(value);
-                }
-            });
-            $._terminators.push(terminate);
-            return terminate;
-        }
-        once(channel, deserializer, listener) {
-            const $ = this;
-            const terminate = NET.listen(`ipc:${$._from}:${channel}:send`, ConnectionSerializer, function* (data) {
-                if (data.from === $._to) {
-                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
-                    const stream = SERDE.ByteArray.from_uint8array(bytes);
-                    const value = yield* deserializer.deserialize(stream);
-                    listener(value);
-                    terminate();
-                }
-            });
-            $._terminators.push(terminate);
-            return terminate;
-        }
-        handle(channel, deserializer, serializer, listener) {
-            const $ = this;
-            const terminate = NET.listen(`ipc:${$._from}:${channel}:invoke`, ConnectionSerializer, function* (data) {
-                if (data.from === $._to) {
-                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes);
-                    const stream = SERDE.ByteArray.from_uint8array(bytes);
-                    const value = yield* deserializer.deserialize(stream);
-                    const result = listener(value);
-                    const return_stream = new SERDE.ByteArray();
-                    yield* serializer.serialize(result, return_stream);
-                    const return_bytes = yield* $.MAYBE_ENCRYPT(return_stream.to_uint8array());
-                    yield* NET.emit(`ipc:${$._to}:${channel}:handle`, ConnectionSerializer, {
-                        from: $._from,
-                        bytes: return_bytes
-                    });
-                }
-            });
-            $._terminators.push(terminate);
-            return terminate;
-        }
-    }
-    IPC.Connection = Connection;
-    class ConnectionManager {
-        *MAYBE_ENCRYPT(bytes, encryption) {
-            return encryption !== false ? yield* CRYPTO.encrypt(bytes, encryption) : bytes;
-        }
-        *MAYBE_DECRYPT(bytes, encryption) {
-            return encryption !== false ? yield* CRYPTO.decrypt(bytes, encryption) : bytes;
-        }
-        get id() {
-            return this._id;
-        }
-        constructor(id, force_encryption = false) {
-            const $ = this;
-            this._id = id;
-            this._enc_map = new Map();
-            this._con_map = new Map();
-            this._enc_force = force_encryption;
-            NET.listen(`ipc:${this._id}:handshake:synchronize`, HandshakeSynchronizeSerializer, function* (data) {
-                const secret = CRYPTO.make_secret(data.encryption_modulus);
-                const public_key = yield* CRYPTO.make_public(secret, data.encryption_modulus, data.encryption_prime);
-                const enc = data.encryption_enabled || $._enc_force
-                    ? yield* CRYPTO.make_shared(secret, data.encryption_public_key, data.encryption_prime)
-                    : false;
-                $._enc_map.set(data.from, enc);
-                yield* NET.emit(`ipc:${data.from}:handshake:acknowledge`, HandshakeAcknowledgeSerializer, {
-                    from: $._id,
-                    encryption_public_key: public_key,
-                    encryption_enabled: $._enc_force
-                });
-            });
-            NET.listen(`ipc:${this._id}:terminate`, Proto.String, function* (value) {
-                $._enc_map.delete(value);
-            });
-        }
-        connect(to, encrypted = false, timeout = 20) {
-            const $ = this;
-            return new Promise((resolve, reject) => {
-                const con = this._con_map.get(to);
-                if (con !== undefined) {
-                    con.terminate(false);
-                    resolve(con);
-                }
-                else {
-                    const secret = CRYPTO.make_secret();
-                    system.runJob((function* () {
-                        const public_key = yield* CRYPTO.make_public(secret);
-                        yield* NET.emit(`ipc:${to}:handshake:synchronize`, HandshakeSynchronizeSerializer, {
-                            from: $._id,
-                            encryption_enabled: encrypted,
-                            encryption_public_key: public_key,
-                            encryption_prime: CRYPTO.PRIME,
-                            encryption_modulus: CRYPTO.MOD
-                        });
-                    })());
-                    function clear() {
-                        terminate();
-                        system.clearRun(timeout_handle);
-                    }
-                    const timeout_handle = system.runTimeout(() => {
-                        reject();
-                        clear();
-                    }, timeout);
-                    const terminate = NET.listen(`ipc:${this._id}:handshake:acknowledge`, HandshakeAcknowledgeSerializer, function* (data) {
-                        if (data.from === to) {
-                            const enc = data.encryption_enabled || encrypted
-                                ? yield* CRYPTO.make_shared(secret, data.encryption_public_key)
-                                : false;
-                            const new_con = new Connection($._id, to, enc);
-                            $._con_map.set(to, new_con);
-                            resolve(new_con);
-                            clear();
-                        }
-                    });
-                }
-            });
-        }
-        send(channel, serializer, value) {
-            const $ = this;
-            system.runJob((function* () {
-                for (const [key, enc] of $._enc_map) {
-                    const stream = new SERDE.ByteArray();
-                    yield* serializer.serialize(value, stream);
-                    const bytes = yield* $.MAYBE_ENCRYPT(stream.to_uint8array(), enc);
-                    yield* NET.emit(`ipc:${key}:${channel}:send`, ConnectionSerializer, {
-                        from: $._id,
-                        bytes
-                    });
-                }
-            })());
-        }
-        invoke(channel, serializer, value, deserializer) {
-            const $ = this;
-            const promises = [];
-            for (const [key, enc] of $._enc_map) {
-                system.runJob((function* () {
-                    const stream = new SERDE.ByteArray();
-                    yield* serializer.serialize(value, stream);
-                    const bytes = yield* $.MAYBE_ENCRYPT(stream.to_uint8array(), enc);
-                    yield* NET.emit(`ipc:${key}:${channel}:invoke`, ConnectionSerializer, {
-                        from: $._id,
-                        bytes
-                    });
-                })());
-                promises.push(new Promise(resolve => {
-                    const terminate = NET.listen(`ipc:${$._id}:${channel}:handle`, ConnectionSerializer, function* (data) {
-                        if (data.from === key) {
-                            const bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
-                            const stream = SERDE.ByteArray.from_uint8array(bytes);
-                            const value = yield* deserializer.deserialize(stream);
-                            resolve(value);
-                            terminate();
-                        }
-                    });
-                }));
-            }
-            return promises;
-        }
-        on(channel, deserializer, listener) {
-            const $ = this;
-            return NET.listen(`ipc:${$._id}:${channel}:send`, ConnectionSerializer, function* (data) {
-                const enc = $._enc_map.get(data.from);
-                if (enc !== undefined) {
-                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
-                    const stream = SERDE.ByteArray.from_uint8array(bytes);
-                    const value = yield* deserializer.deserialize(stream);
-                    listener(value);
-                }
-            });
-        }
-        once(channel, deserializer, listener) {
-            const $ = this;
-            const terminate = NET.listen(`ipc:${$._id}:${channel}:send`, ConnectionSerializer, function* (data) {
-                const enc = $._enc_map.get(data.from);
-                if (enc !== undefined) {
-                    const bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
-                    const stream = SERDE.ByteArray.from_uint8array(bytes);
-                    const value = yield* deserializer.deserialize(stream);
-                    listener(value);
-                    terminate();
-                }
-            });
-            return terminate;
-        }
-        handle(channel, deserializer, serializer, listener) {
-            const $ = this;
-            return NET.listen(`ipc:${$._id}:${channel}:invoke`, ConnectionSerializer, function* (data) {
-                const enc = $._enc_map.get(data.from);
-                if (enc !== undefined) {
-                    const input_bytes = yield* $.MAYBE_DECRYPT(data.bytes, enc);
-                    const input_stream = SERDE.ByteArray.from_uint8array(input_bytes);
-                    const input_value = yield* deserializer.deserialize(input_stream);
-                    const result = listener(input_value);
-                    const output_stream = new SERDE.ByteArray();
-                    yield* serializer.serialize(result, output_stream);
-                    const output_bytes = yield* $.MAYBE_ENCRYPT(output_stream.to_uint8array(), enc);
-                    yield* NET.emit(`ipc:${data.from}:${channel}:handle`, ConnectionSerializer, {
-                        from: $._id,
-                        bytes: output_bytes
-                    });
-                }
-            });
-        }
-    }
-    IPC.ConnectionManager = ConnectionManager;
     /** Sends a message with `args` to `channel` */
     function send(channel, serializer, value) {
         system.runJob(NET.emit(`ipc:${channel}:send`, serializer, value));