mcbe-ipc 2.0.1 → 3.0.1

package/dist/proto.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * MIT License
+ *
+ * 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export declare namespace PROTO {
+    interface Serializable<T> {
+        serialize(value: T, stream: ByteQueue): Generator<void, void, void>;
+        deserialize(stream: ByteQueue): Generator<void, T, void>;
+    }
+    class ByteQueue {
+        private _buffer;
+        private _data_view;
+        private _length;
+        private _offset;
+        get end(): number;
+        get front(): number;
+        get data_view(): DataView;
+        constructor(size?: number);
+        write(...values: number[]): void;
+        read(amount?: number): number[];
+        ensure_capacity(size: number): void;
+        static from_uint8array(array: Uint8Array): ByteQueue;
+        to_uint8array(): Uint8Array;
+    }
+    namespace MIPS {
+        function serialize(byte_queue: PROTO.ByteQueue): Generator<void, string, void>;
+        function deserialize(str: string): Generator<void, PROTO.ByteQueue, void>;
+    }
+    const Void: PROTO.Serializable<void>;
+    const Int8: PROTO.Serializable<number>;
+    const Int16: PROTO.Serializable<number>;
+    const Int32: PROTO.Serializable<number>;
+    const UInt8: PROTO.Serializable<number>;
+    const UInt16: PROTO.Serializable<number>;
+    const UInt32: PROTO.Serializable<number>;
+    const UVarInt32: PROTO.Serializable<number>;
+    const Float32: PROTO.Serializable<number>;
+    const Float64: PROTO.Serializable<number>;
+    const String: PROTO.Serializable<string>;
+    const Boolean: PROTO.Serializable<boolean>;
+    const UInt8Array: PROTO.Serializable<Uint8Array>;
+    const Date: PROTO.Serializable<Date>;
+    function Object<T extends object>(obj: {
+        [K in keyof T]: PROTO.Serializable<T[K]>;
+    }): PROTO.Serializable<T>;
+    function Array<T>(value: PROTO.Serializable<T>): PROTO.Serializable<T[]>;
+    function Tuple<T extends any[]>(...values: {
+        [K in keyof T]: PROTO.Serializable<T[K]>;
+    }): PROTO.Serializable<T>;
+    function Optional<T>(value: PROTO.Serializable<T>): PROTO.Serializable<T | undefined>;
+    function Map<K, V>(key: PROTO.Serializable<K>, value: PROTO.Serializable<V>): PROTO.Serializable<Map<K, V>>;
+    function Set<V>(value: PROTO.Serializable<V>): PROTO.Serializable<Set<V>>;
+    type Endpoint = string;
+    type Header = {
+        guid: string;
+        encoding: string;
+        index: number;
+        final: boolean;
+    };
+    const Endpoint: PROTO.Serializable<Endpoint>;
+    const Header: PROTO.Serializable<Header>;
+}

package/dist/proto.js

@@ -0,0 +1,396 @@
+/**
+ * @license
+ * MIT License
+ *
+ * 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+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);
+            this._length = 0;
+            this._offset = 0;
+        }
+        write(...values) {
+            this.ensure_capacity(values.length);
+            this._buffer.set(values, this.end);
+            this._length += values.length;
+        }
+        read(amount = 1) {
+            if (this._length > 0) {
+                const max_amount = amount > this._length ? this._length : amount;
+                const values = this._buffer.subarray(this._offset, this._offset + max_amount);
+                this._length -= max_amount;
+                this._offset += max_amount;
+                return globalThis.Array.from(values);
+            }
+            return [];
+        }
+        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_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);
+        }
+    }
+    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;
+            }
+            str += ')';
+            return str;
+        }
+        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;
+                }
+                return ByteQueue.from_uint8array(new Uint8Array(result));
+            }
+            return new ByteQueue();
+        }
+        MIPS.deserialize = deserialize;
+    })(MIPS = PROTO.MIPS || (PROTO.MIPS = {}));
+    PROTO.Void = {
+        *serialize() { },
+        *deserialize() { }
+    };
+    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;
+            }
+            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) {
+                    yield* obj[key].serialize(value[key], stream);
+                }
+            },
+            *deserialize(stream) {
+                const result = {};
+                for (const key in obj) {
+                    result[key] = yield* obj[key].deserialize(stream);
+                }
+                return result;
+            }
+        };
+    }
+    PROTO.Object = Object;
+    function Array(value) {
+        return {
+            *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.UVarInt32.deserialize(stream);
+                for (let i = 0; i < length; i++) {
+                    result[i] = yield* value.deserialize(stream);
+                }
+                return result;
+            }
+        };
+    }
+    PROTO.Array = Array;
+    function Tuple(...values) {
+        return {
+            *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 < values.length; i++) {
+                    result[i] = yield* values[i].deserialize(stream);
+                }
+                return result;
+            }
+        };
+    }
+    PROTO.Tuple = Tuple;
+    function Optional(value) {
+        return {
+            *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);
+                if (defined) {
+                    return yield* value.deserialize(stream);
+                }
+                return undefined;
+            }
+        };
+    }
+    PROTO.Optional = Optional;
+    function Map(key, value) {
+        return {
+            *serialize(map, 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.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);
+                    result.set(k, v);
+                }
+                return result;
+            }
+        };
+    }
+    PROTO.Map = Map;
+    function Set(value) {
+        return {
+            *serialize(set, 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.UVarInt32.deserialize(stream);
+                const result = new globalThis.Set();
+                for (let i = 0; i < size; i++) {
+                    const v = yield* value.deserialize(stream);
+                    result.add(v);
+                }
+                return result;
+            }
+        };
+    }
+    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 = {}));

package/package.json

@@ -3,7 +3,7 @@
   "author": "OmniacDev",
   "description": "IPC system for MCBE Script API projects",
   "license": "MIT",
-  "version": "2.0.1",
+  "version": "3.0.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/OmniacDev/mcbe-ipc.git"
@@ -15,17 +15,17 @@
   "type": "module",
   "main": "dist/ipc.js",
   "types": "dist/ipc.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "tsc && uglifyjs dist/ipc.js --mangle --compress --output dist/ipc.min.js",
+    "build": "tsc",
     "format": "prettier --write src",
-    "build-clean": "tsc",
-    "prepublishOnly": "npm run build-clean"
+    "prepublishOnly": "npm run build"
   },
   "devDependencies": {
     "prettier": "^3.3.3",
-    "typescript": "^5.5.4",
-    "uglify-js": "^3.19.3"
+    "typescript": "^5.5.4"
   },
   "dependencies": {
     "@minecraft/server": "^1.13.0"

package/dist/ipc.min.js

@@ -1 +0,0 @@
-import{world,system,ScriptEventSource}from"@minecraft/server";var IPC,SERDE,CRYPTO,NET;(e=>{class _{*MAYBE_ENCRYPT(e){return!1!==this._enc?yield*CRYPTO.encrypt(JSON.stringify(e),this._enc):e}*MAYBE_DECRYPT(e){return!1!==this._enc?JSON.parse(yield*CRYPTO.decrypt(e[1],this._enc)):e[1]}get from(){return this._from}get to(){return this._to}constructor(e,t,n){this._from=e,this._to=t,this._enc=n,this._terminators=new Array}terminate(e=!0){var t=this;t._terminators.forEach(e=>e()),t._terminators.length=0,e&&system.runJob(NET.emit("ipc",t._to+":terminate",[t._from]))}send(t,...n){let i=this;system.runJob(function*(){var e=yield*i.MAYBE_ENCRYPT(n);yield*NET.emit("ipc",i._to+`:${t}:send`,[i._from,e])}())}invoke(i,...t){let r=this;return system.runJob(function*(){var e=yield*r.MAYBE_ENCRYPT(t);yield*NET.emit("ipc",r._to+`:${i}:invoke`,[r._from,e])}()),new Promise(t=>{let n=NET.listen("ipc",r._from+`:${i}:handle`,function*(e){e[0]===r._to&&(e=yield*r.MAYBE_DECRYPT(e),t(e),n())})})}on(e,t){let n=this;e=NET.listen("ipc",n._from+`:${e}:send`,function*(e){e[0]===n._to&&(e=yield*n.MAYBE_DECRYPT(e),t(...e))});return n._terminators.push(e),e}once(e,t){let n=this,i=NET.listen("ipc",n._from+`:${e}:send`,function*(e){e[0]===n._to&&(e=yield*n.MAYBE_DECRYPT(e),t(...e),i())});return n._terminators.push(i),i}handle(t,n){let i=this;var e=NET.listen("ipc",i._from+`:${t}:invoke`,function*(e){e[0]===i._to&&(e=yield*i.MAYBE_DECRYPT(e),e=n(...e),e=yield*i.MAYBE_ENCRYPT([e]),yield*NET.emit("ipc",i._to+`:${t}:handle`,[i._from,e]))});return i._terminators.push(e),e}}e.Connection=_,e.ConnectionManager=class{*MAYBE_ENCRYPT(e,t){return!1!==t?yield*CRYPTO.encrypt(JSON.stringify(e),t):e}*MAYBE_DECRYPT(e,t){return!1!==t?JSON.parse(yield*CRYPTO.decrypt(e[1],t)):e[1]}get id(){return this._id}constructor(e,t=!1){let i=this;this._id=e,this._enc_map=new Map,this._con_map=new Map,this._enc_force=t,NET.listen("ipc",this._id+":handshake:SYN",function*(e){var t=CRYPTO.make_secret(e[4]),n=yield*CRYPTO.make_public(t,e[4],e[3]),t=!(1!==e[1]&&!i._enc_force)&&(yield*CRYPTO.make_shared(t,e[2],e[3]));i._enc_map.set(e[0],t),yield*NET.emit("ipc",e[0]+":handshake:ACK",[i._id,i._enc_force?1:0,n])}),NET.listen("ipc",this._id+":terminate",function*(e){i._enc_map.delete(e[0])})}connect(l,d=!1,c=20){let a=this;return new Promise((r,o)=>{var e=this._con_map.get(l);if(void 0!==e)e.terminate(!1),r(e);else{let t=CRYPTO.make_secret(),n=d?1:0;function s(){i(),system.clearRun(e)}system.runJob(function*(){var e=yield*CRYPTO.make_public(t);yield*NET.emit("ipc",l+":handshake:SYN",[a._id,n,e,CRYPTO.PRIME,CRYPTO.MOD])}());let e=system.runTimeout(()=>{o(),s()},c),i=NET.listen("ipc",this._id+":handshake:ACK",function*(e){e[0]===l&&(e=!(1!==e[1]&&!d)&&(yield*CRYPTO.make_shared(t,e[2])),e=new _(a._id,l,e),a._con_map.set(l,e),r(e),s())})}})}send(n,...i){let r=this;system.runJob(function*(){for(var[e,t]of r._enc_map){t=yield*r.MAYBE_ENCRYPT(i,t);yield*NET.emit("ipc",e+`:${n}:send`,[r._id,t])}}())}invoke(o,...t){let s=this;var e=[];for(let[i,r]of s._enc_map)system.runJob(function*(){var e=yield*s.MAYBE_ENCRYPT(t,r);yield*NET.emit("ipc",i+`:${o}:invoke`,[s._id,e])}()),e.push(new Promise(t=>{let n=NET.listen("ipc",s._id+`:${o}:handle`,function*(e){e[0]===i&&(e=yield*s.MAYBE_DECRYPT(e,r),t(e),n())})}));return e}on(e,n){let i=this;return NET.listen("ipc",i._id+`:${e}:send`,function*(e){var t=i._enc_map.get(e[0]);void 0!==t&&(e=yield*i.MAYBE_DECRYPT(e,t),n(...e))})}once(e,n){let i=this,r=NET.listen("ipc",i._id+`:${e}:send`,function*(e){var t=i._enc_map.get(e[0]);void 0!==t&&(e=yield*i.MAYBE_DECRYPT(e,t),n(...e),r())});return r}handle(i,r){let o=this;return NET.listen("ipc",o._id+`:${i}:invoke`,function*(e){var t,n=o._enc_map.get(e[0]);void 0!==n&&(t=yield*o.MAYBE_DECRYPT(e,n),t=r(...t),t=yield*o.MAYBE_ENCRYPT([t],n),yield*NET.emit("ipc",e[0]+`:${i}:handle`,[o._id,t]))})}},e.send=function(e,...t){system.runJob(NET.emit("ipc",e+":send",t))},e.invoke=function(e,...t){return system.runJob(NET.emit("ipc",e+":invoke",t)),new Promise(t=>{let n=NET.listen("ipc",e+":handle",function*(e){t(e[0]),n()})})},e.on=function(e,t){return NET.listen("ipc",e+":send",function*(e){t(...e)})},e.once=function(e,t){let n=NET.listen("ipc",e+":send",function*(e){t(...e),n()});return n},e.handle=function(t,n){return NET.listen("ipc",t+":invoke",function*(e){e=n(...e);yield*NET.emit("ipc",t+":handle",[e])})}})(IPC=IPC||{});export default IPC;(e=>{let o=[48,49,50,51,52,53,54,55,56,57],s=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,42,43,44,47,58,59,60,61,62,63,64,91,92,93,94,96,123,124,125,126,127],r=/\?[0-9a-zA-Z.\-]{2}|[^?]+/g,l=/^\?[0-9a-zA-Z.\-]{2}$/,d="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-";e.encode=function*(t){let n="";for(let e=0;e<t.length;e++){var i=t.charAt(e),r=i.charCodeAt(0);0===e&&o.includes(r)||s.includes(r)?n+="?"+(yield*function*(t){let n="";for(let e=t.charCodeAt(0);0<e;e=Math.floor(e/64))n=d[e%64]+n,yield;return n}(i)).padStart(2,"0"):n+=i,yield}return n},e.decode=function*(e){let t="";var n=e.match(r)??[];for(let e=0;e<n.length;e++){var i=n[e];i.startsWith("?")&&l.test(i)?t+=yield*function*(t){let n=0;for(let e=0;e<t.length;e++)n+=64**(t.length-1-e)*d.indexOf(t[e]),yield;return String.fromCharCode(n)}(i.slice(1)):t+=i,yield}return t}})(SERDE=SERDE||{}),(i=>{i.PRIME=19893121,i.MOD=341;let r=e=>e.toString(16).toUpperCase();function*o(e,t,n){let i=1,r=e%n;for(let e=t;0<e;e=Math.floor(e/2))e%2==1&&(i=i*r%n),r=r*r%n,yield;return i}i.make_secret=function(e=i.MOD){return Math.floor(Math.random()*(e-1))+1},i.make_public=function*(e,t=i.MOD,n=i.PRIME){return r(yield*o(t,e,n))},i.make_shared=function*(e,t,n=i.PRIME){return r(yield*o(parseInt(t,16),e,n))},i.encrypt=function*(t,n){let i="";for(let e=0;e<t.length;e++)i+=String.fromCharCode(t.charCodeAt(e)^n.charCodeAt(e%n.length)),yield;return i},i.decrypt=function*(t,n){let i="";for(let e=0;e<t.length;e++)i+=String.fromCharCode(t.charCodeAt(e)^n.charCodeAt(e%n.length)),yield;return i}})(CRYPTO=CRYPTO||{}),(e=>{let o=new Map;system.afterEvents.scriptEventReceive.subscribe(r=>{system.runJob(function*(){var e=r.id.split(":"),t=yield*SERDE.decode(e[0]),n=o.get(t);if(r.sourceType===ScriptEventSource.Server&&n){var i=E.fromString(yield*SERDE.decode(e[1]));for(let e=0;e<n.length;e++)yield*n[e](i,r.message)}}())});let E;var t;(t=E=E||{}).toString=function(e){return JSON.stringify(e)},t.fromString=function(e){return JSON.parse(e)},e.emit=function*(e,t,n){var i,r=((255&(i=4294967296*Math.random()>>>0)).toString(16).padStart(2,"0")+(i>>8&255).toString(16).padStart(2,"0")+(i>>16&255).toString(16).padStart(2,"0")+(i>>24&255).toString(16).padStart(2,"0")).toUpperCase();let o=yield*SERDE.encode(e);function*s(e,t){e=yield*SERDE.encode(E.toString(e)),world.getDimension("overworld").runCommand(`scriptevent ${o}:${e} `+t)}var l=yield*SERDE.encode(JSON.stringify(n));let d=0,c="",a=0;for(let e=0;e<l.length;e++){var _=l[e],u=_.charCodeAt(0),u=u<=127?1:u<=2047?2:u<=65535?3:4;a+u<2048?(c+=_,a+=u):(yield*s([t,r,d],c),d++,c=_,a=u),yield}yield*s(0===d?[t,r]:[t,r,d,1],c)},e.listen=function(e,n,s){let l=new Map;{var i=e,r=function*([e,i,t,r],o){if(e===n)if(void 0===t)yield*s(JSON.parse(yield*SERDE.decode(o)));else{let n=l.get(i);if(n||(n={size:-1,data_strs:[],data_size:0},l.set(i,n)),1===r&&(n.size=t+1),n.data_strs[t]=o,n.data_size+=t+1,-1!==n.size&&n.data_size===n.size*(n.size+1)/2){let t="";for(let e=0;e<n.data_strs.length;e++)t+=n.data_strs[e],yield;yield*s(JSON.parse(yield*SERDE.decode(t))),l.delete(i)}}};let t=o.get(i);return t||(t=new Array,o.set(i,t)),t.push(r),()=>{var e=t.indexOf(r);-1!==e&&t.splice(e,1),0===t.length&&o.delete(i)}}}})(NET=NET||{});export{NET};