sonic-ws 1.3.2 → 1.3.3

package/dist/ws/server/SonicWSServer.js

@@ -1,6 +1,307 @@
-/**
+"use strict";
+/*
  * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
-
-var e,t=this&&this.__createBinding||(Object.create?function(e,t,s,n){void 0===n&&(n=s);var i=Object.getOwnPropertyDescriptor(t,s);i&&!("get"in i?!t.__esModule:i.writable||i.configurable)||(i={enumerable:!0,get:function(){return t[s]}}),Object.defineProperty(e,n,i)}:function(e,t,s,n){void 0===n&&(n=s),e[n]=t[s]}),s=this&&this.__setModuleDefault||(Object.create?function(e,t){Object.defineProperty(e,"default",{enumerable:!0,value:t})}:function(e,t){e.default=t}),n=this&&this.__importStar||(e=function(t){return e=Object.getOwnPropertyNames||function(e){var t=[];for(var s in e)Object.prototype.hasOwnProperty.call(e,s)&&(t[t.length]=s);return t},e(t)},function(n){if(n&&n.__esModule)return n;var i={};if(null!=n)for(var a=e(n),r=0;r<a.length;r++)"default"!==a[r]&&t(i,n,a[r]);return s(i,n),i});Object.defineProperty(exports,"__esModule",{value:!0}),exports.SonicWSServer=void 0;const i=n(require("ws")),a=require("./SonicWSConnection"),r=require("../util/packets/PacketHolder"),c=require("../util/packets/CompressionUtil"),o=require("../../version"),l=require("../util/packets/PacketUtils"),h=require("../PacketProcessor"),d=require("../util/packets/HashUtil"),u=require("../Connection"),g=require("../debug/DebugServer");class p extends h.MiddlewareHolder{wss;availableIds=[];lastId=0;connectListeners=[];clientPackets;serverPackets;connections=[];connectionMap={};clientRateLimit=500;serverRateLimit=500;handshakePacket=null;tags=new Map;tagsInv=new Map;serverwideSendQueue=[!1,[],void 0];constructor(e){super();const{clientPackets:t=[],serverPackets:s=[],websocketOptions:n={}}=e;this.wss=new i.WebSocketServer(n),this.clientPackets=new r.PacketHolder(t),this.serverPackets=new r.PacketHolder(s);const l=this.clientPackets.serialize(),h=this.serverPackets.serialize(),g=[...o.SERVER_SUFFIX_NUMS,o.VERSION],p=[...(0,c.convertVarInt)(l.length),...l,...h];(0,d.setHashFunc)(e.sonicServerSettings?.bit64Hash??!0),this.wss.on("connection",async e=>{const t=new a.SonicWSConnection(e,this,this.generateSocketID(),this.handshakePacket,this.clientRateLimit,this.serverRateLimit);if(await this.callMiddleware("onClientConnect",t))return t.close(u.CloseCodes.MIDDLEWARE,"Connection blocked by middleware."),this.callMiddleware("onClientDisconnect",t,u.CloseCodes.MIDDLEWARE,Buffer.from("Connection blocked by middleware.")),void this.availableIds.push(t.id);const s=new Uint8Array([...(0,c.convertVarInt)(t.id),...p]);e.send([...g,...await(0,c.compressGzip)(s)]),this.connections.push(t),this.connectionMap[t.id]=t,this.connectListeners.forEach(e=>e(t)),e.on("close",(e,s)=>{if(this.connections.splice(this.connections.indexOf(t),1),delete this.connectionMap[t.id],this.availableIds.push(t.id),this.tags.has(t)){for(const e of this.tags.get(t))this.tagsInv.get(e)?.delete(t);this.tags.delete(t)}this.callMiddleware("onClientDisconnect",t,e,s)})}),(e.sonicServerSettings?.checkForUpdates??1)&&fetch("https://raw.githubusercontent.com/liwybloc/sonic-ws/refs/heads/main/release/version").then(e=>e.text()).then(e=>{parseInt(e)>o.VERSION&&console.warn(`SonicWS is currently running outdated! (current: ${o.VERSION}, latest: ${e}) Update with "npm update sonic-ws"`)}).catch(e=>{console.error(e),console.warn("Could not check SonicWS version.")})}generateSocketID(){return 0==this.availableIds.length&&this.availableIds.push(this.lastId+1),this.lastId=this.availableIds.shift(),this.lastId}requireHandshake(e){if(!this.clientPackets.hasTag(e))throw new Error(`The client does not send "${e}" and so it cannot use it as a handshake!`);if(0!=this.clientPackets.getPacket(e).dataBatching)throw new Error(`The packet "${e}" is a batched packet, and cannot be used as a handshake!`);this.handshakePacket=e}setClientRateLimit(e){e>c.MAX_BYTE&&(e=0,console.warn(`A rate limit above ${c.MAX_BYTE} is considered infinite.`)),this.clientRateLimit=e}setServerRateLimit(e){e>c.MAX_BYTE&&(e=0,console.warn(`A rate limit above ${c.MAX_BYTE} is considered infinite.`)),this.serverRateLimit=e}enablePacket(e){this.clientPackets.getPacket(e).defaultEnabled=!0,this.connections.forEach(t=>t.enablePacket(e))}disablePacket(e){this.clientPackets.getPacket(e).defaultEnabled=!1,this.connections.forEach(t=>t.disablePacket(e))}on_connect(e){this.connectListeners.push(e)}on_ready(e){this.wss.on("listening",e)}shutdown(e){this.wss.close(e)}async broadcastInternal(e,t,s){let n;if("all"===t.type)n=this.connections;else if("tagged"===t.type){if(!this.tagsInv.has(t.tag))return;n=Array.from(this.tagsInv.get(t.tag))}else n=this.connections.filter(t.filter);if(await this.callMiddleware("onPacketBroadcast_pre",e,{recipients:n,...t},s))return;if(0===n.length)return;const[i,a,r]=await(0,l.processPacket)(this.serverPackets,e,s,this.serverwideSendQueue,-1);await this.callMiddleware("onPacketBroadcast_post",e,{recipients:n,...t},a,a.length)||n.forEach(e=>e.send_processed(i,a,r))}async broadcastTagged(e,t,...s){await this.broadcastInternal(t,{type:"tagged",tag:e},s)}async broadcastFiltered(e,t,...s){await this.broadcastInternal(e,{type:"filter",filter:t},s)}async broadcast(e,...t){await this.broadcastInternal(e,{type:"all"},t)}getConnected(){return this.connections}getSocket(e){return this.connectionMap[e]}closeSocket(e,t=1e3,s){this.getSocket(e).close(t,s)}tag(e,t,s=!0){this.tags.get(e)||this.tags.set(e,new Set),this.tagsInv.get(t)||this.tagsInv.set(t,new Set),s&&this.tags.get(e).forEach(t=>this.tagsInv.get(t)?.delete(e)),this.tags.get(e).add(t),this.tagsInv.get(t).add(e)}debugServer=null;OpenDebug(e){if(null!=this.debugServer)throw new Error("Attempted to open a debug server when one has already been opened.");this.debugServer=new g.DebugServer(this,e)}}exports.SonicWSServer=p;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonicWSServer = void 0;
+const WS = __importStar(require("ws"));
+const SonicWSConnection_1 = require("./SonicWSConnection");
+const PacketHolder_1 = require("../util/packets/PacketHolder");
+const CompressionUtil_1 = require("../util/packets/CompressionUtil");
+const version_1 = require("../../version");
+const PacketUtils_1 = require("../util/packets/PacketUtils");
+const PacketProcessor_1 = require("../PacketProcessor");
+const HashUtil_1 = require("../util/packets/HashUtil");
+const Connection_1 = require("../Connection");
+const DebugServer_1 = require("../debug/DebugServer");
+class SonicWSServer extends PacketProcessor_1.MiddlewareHolder {
+    wss;
+    availableIds = [];
+    lastId = 0;
+    connectListeners = [];
+    clientPackets;
+    serverPackets;
+    connections = [];
+    connectionMap = {};
+    clientRateLimit = 500;
+    serverRateLimit = 500;
+    handshakePacket = null;
+    tags = new Map();
+    tagsInv = new Map();
+    serverwideSendQueue = [false, [], undefined];
+    /**
+     * Initializes and hosts a websocket with sonic protocol
+     * Rate limits can be set with wss.setClientRateLimit(x) and wss.setServerRateLimit(x); it is defaulted at 500/second per both
+     * @param settings Sonic Server Options such as schema data for client and server packets, alongside websocket options
+     */
+    constructor(settings) {
+        super();
+        const { clientPackets = [], serverPackets = [], websocketOptions = {} } = settings;
+        this.wss = new WS.WebSocketServer(websocketOptions);
+        this.clientPackets = new PacketHolder_1.PacketHolder(clientPackets);
+        this.serverPackets = new PacketHolder_1.PacketHolder(serverPackets);
+        const s_clientPackets = this.clientPackets.serialize();
+        const s_serverPackets = this.serverPackets.serialize();
+        const serverData = [...version_1.SERVER_SUFFIX_NUMS, version_1.VERSION];
+        const keyData = [...(0, CompressionUtil_1.convertVarInt)(s_clientPackets.length), ...s_clientPackets, ...s_serverPackets];
+        (0, HashUtil_1.setHashFunc)(settings.sonicServerSettings?.bit64Hash ?? true);
+        this.wss.on('connection', async (socket) => {
+            const sonicConnection = new SonicWSConnection_1.SonicWSConnection(socket, this, this.generateSocketID(), this.handshakePacket, this.clientRateLimit, this.serverRateLimit);
+            if (await this.callMiddleware("onClientConnect", sonicConnection)) {
+                sonicConnection.close(Connection_1.CloseCodes.MIDDLEWARE, "Connection blocked by middleware.");
+                this.callMiddleware("onClientDisconnect", sonicConnection, Connection_1.CloseCodes.MIDDLEWARE, Buffer.from("Connection blocked by middleware."));
+                this.availableIds.push(sonicConnection.id);
+                return;
+            }
+            // send tags to the client so it doesn't have to hard code them in
+            const data = new Uint8Array([...(0, CompressionUtil_1.convertVarInt)(sonicConnection.id), ...keyData]);
+            socket.send([...serverData, ...await (0, CompressionUtil_1.compressGzip)(data)]);
+            this.connections.push(sonicConnection);
+            this.connectionMap[sonicConnection.id] = sonicConnection;
+            this.connectListeners.forEach(l => l(sonicConnection));
+            socket.on('close', (code, reason) => {
+                this.connections.splice(this.connections.indexOf(sonicConnection), 1);
+                delete this.connectionMap[sonicConnection.id];
+                this.availableIds.push(sonicConnection.id);
+                if (this.tags.has(sonicConnection)) {
+                    for (const tag of this.tags.get(sonicConnection))
+                        this.tagsInv.get(tag)?.delete(sonicConnection);
+                    this.tags.delete(sonicConnection);
+                }
+                this.callMiddleware("onClientDisconnect", sonicConnection, code, reason);
+            });
+        });
+        if (settings.sonicServerSettings?.checkForUpdates ?? true) {
+            fetch('https://raw.githubusercontent.com/liwybloc/sonic-ws/refs/heads/main/release/version')
+                .then((res) => res.text())
+                .then((ver) => {
+                if (parseInt(ver) > version_1.VERSION) {
+                    console.warn(`SonicWS is currently running outdated! (current: ${version_1.VERSION}, latest: ${ver}) Update with "npm update sonic-ws"`);
+                }
+            })
+                .catch((err) => {
+                console.error(err);
+                console.warn(`Could not check SonicWS version.`);
+            });
+        }
+    }
+    generateSocketID() {
+        if (this.availableIds.length == 0)
+            this.availableIds.push(this.lastId + 1);
+        this.lastId = this.availableIds.shift();
+        return this.lastId;
+    }
+    /**
+     * Requires each client to send this packet upon initialization
+     *
+     * Recreates this:
+     * ```js
+     * let initiated = false;
+     * socket.on('init', () => {
+     *  if(initiated) return socket.close();
+     *  initiated = true;
+     *  // process
+     * });
+     *
+     * socket.on('otherPacket', () => {
+     *  if(!initiated) return socket.close();
+     *  // process
+     * })
+     * ```
+     *
+     * @param packet The tag of the packet to require as a handshake
+     */
+    requireHandshake(packet) {
+        if (!this.clientPackets.hasTag(packet))
+            throw new Error(`The client does not send "${packet}" and so it cannot use it as a handshake!`);
+        if (this.clientPackets.getPacket(packet).dataBatching != 0)
+            throw new Error(`The packet "${packet}" is a batched packet, and cannot be used as a handshake!`);
+        this.handshakePacket = packet;
+    }
+    /**
+     * Sets the rate limit for all client-side packets
+     * @param limit Amount of packets the sockets can send every second, or 0 for infinite
+     */
+    setClientRateLimit(limit) {
+        // so that i can store limits in 1 packet
+        if (limit > CompressionUtil_1.MAX_BYTE) {
+            limit = 0;
+            console.warn(`A rate limit above ${CompressionUtil_1.MAX_BYTE} is considered infinite.`);
+        }
+        this.clientRateLimit = limit;
+    }
+    /**
+     * Sets the rate limit for server-side packets per-socket
+     * @param limit Amount of packets the server can send every second, or 0 for infinite
+     */
+    setServerRateLimit(limit) {
+        // so that i can store limits in 1 packet
+        if (limit > CompressionUtil_1.MAX_BYTE) {
+            limit = 0;
+            console.warn(`A rate limit above ${CompressionUtil_1.MAX_BYTE} is considered infinite.`);
+        }
+        this.serverRateLimit = limit;
+    }
+    /**
+     * Enables a packet for all current & new clients.
+     * @param tag The tag of the packet
+     */
+    enablePacket(tag) {
+        this.clientPackets.getPacket(tag).defaultEnabled = true;
+        this.connections.forEach(socket => socket.enablePacket(tag));
+    }
+    /**
+     * Disables a packet for all current & new clients.
+     * @param tag The tag of the packet
+     */
+    disablePacket(tag) {
+        this.clientPackets.getPacket(tag).defaultEnabled = false;
+        this.connections.forEach(socket => socket.disablePacket(tag));
+    }
+    /**
+     * Listens for whenever a client connects
+     * @param runner Called when ready
+     */
+    on_connect(runner) {
+        this.connectListeners.push(runner);
+    }
+    /**
+     * Listens for whenever the server is ready
+     * @param runner Called when ready
+     */
+    on_ready(runner) {
+        this.wss.on('listening', runner);
+    }
+    /**
+     * Closes the server
+     * @param callback Called when server closes
+     */
+    shutdown(callback) {
+        this.wss.close(callback);
+    }
+    async broadcastInternal(packetTag, target, values) {
+        let recipients;
+        if (target.type === "all") {
+            recipients = this.connections;
+        }
+        else if (target.type === "tagged") {
+            if (!this.tagsInv.has(target.tag))
+                return;
+            recipients = Array.from(this.tagsInv.get(target.tag));
+        }
+        else {
+            recipients = this.connections.filter(target.filter);
+        }
+        if (await this.callMiddleware("onPacketBroadcast_pre", packetTag, { recipients, ...target }, values))
+            return;
+        if (recipients.length === 0)
+            return;
+        const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.serverPackets, packetTag, values, this.serverwideSendQueue, -1);
+        if (await this.callMiddleware("onPacketBroadcast_post", packetTag, { recipients, ...target }, data, data.length))
+            return;
+        recipients.forEach(conn => conn.send_processed(code, data, packet));
+    }
+    async broadcastTagged(tag, packetTag, ...values) {
+        await this.broadcastInternal(packetTag, { type: "tagged", tag }, values);
+    }
+    async broadcastFiltered(tag, filter, ...values) {
+        await this.broadcastInternal(tag, { type: "filter", filter }, values);
+    }
+    async broadcast(tag, ...values) {
+        await this.broadcastInternal(tag, { type: "all" }, values);
+    }
+    /**
+     * @returns All users connected to the socket
+     */
+    getConnected() {
+        return this.connections;
+    }
+    /**
+     * @param id The socket id
+     * @returns The socket
+     */
+    getSocket(id) {
+        return this.connectionMap[id];
+    }
+    /**
+     * Closes a socket by id
+     * @param id The socket id
+     */
+    closeSocket(id, code = 1000, reason) {
+        this.getSocket(id).close(code, reason);
+    }
+    /**
+     * Tags the socket with a key
+     * @param socket The socket to tag
+     * @param tag The tag to add
+     * @param replace If it should replace a previous tag; defaults to true. If using false, you can add multiple tags.
+     */
+    tag(socket, tag, replace = true) {
+        if (!this.tags.get(socket))
+            this.tags.set(socket, new Set());
+        if (!this.tagsInv.get(tag))
+            this.tagsInv.set(tag, new Set());
+        if (replace) {
+            this.tags.get(socket).forEach(v => this.tagsInv.get(v)?.delete(socket));
+        }
+        this.tags.get(socket).add(tag);
+        this.tagsInv.get(tag).add(socket);
+    }
+    debugServer = null;
+    /**
+     * Opens a debug menu; this launches the browser and starts a subserver
+     * @param port Port of the server/http, defaults to 0 which finds an open port
+     * @param password Toggles the requirement of a password to access the server. Defaults to empty, which doesn't ask for a password.
+     */
+    OpenDebug(data = {}) {
+        if (this.debugServer != null)
+            throw new Error("Attempted to open a debug server when one has already been opened.");
+        this.debugServer = new DebugServer_1.DebugServer(this, data);
+    }
+}
+exports.SonicWSServer = SonicWSServer;

package/dist/ws/util/BufferUtil.d.ts

@@ -1,7 +1,3 @@
-/**
- * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
- */
 type BuildTuple<T, L extends number, R extends unknown[] = []> = R['length'] extends L ? R : BuildTuple<T, L, [T, ...R]>;
 export declare function splitArray<T, N extends number>(arr: T[], size: N): Array<BuildTuple<T, N>>;
 export declare function toPacketBuffer(code: number, data: Uint8Array): Uint8Array;

package/dist/ws/util/BufferUtil.js

@@ -1,6 +1,42 @@
-/**
+"use strict";
+/*
  * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
-
-function r(r,t){const e=[];for(let n=0;n<r.length;n+=t){const o=r.slice(n,n+t);e.push(o)}return e}Object.defineProperty(exports,"__esModule",{value:!0}),exports.splitArray=r,exports.toPacketBuffer=function(r,t){const e=new Uint8Array(1+t.length);return e[0]=r,e.set(t,1),e},exports.splitBuffer=function(t,e){return r(Array.from(t),e)},exports.stringifyBuffer=function(r){return`<Buffer ${Array.from(r).map(r=>r.toString(16).padStart(2,"0")).join(" ")}>`};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitArray = splitArray;
+exports.toPacketBuffer = toPacketBuffer;
+exports.splitBuffer = splitBuffer;
+exports.stringifyBuffer = stringifyBuffer;
+function splitArray(arr, size) {
+    const result = [];
+    for (let i = 0; i < arr.length; i += size) {
+        const chunk = arr.slice(i, i + size);
+        result.push(chunk);
+    }
+    return result;
+}
+function toPacketBuffer(code, data) {
+    const buffer = new Uint8Array(1 + data.length);
+    buffer[0] = code;
+    buffer.set(data, 1);
+    return buffer;
+}
+function splitBuffer(arr, x) {
+    return splitArray(Array.from(arr), x);
+}
+function stringifyBuffer(data) {
+    const contents = Array.from(data).map(n => n.toString(16).padStart(2, "0")).join(" ");
+    return `<Buffer ${contents}>`;
+}

package/dist/ws/util/StringUtil.d.ts

@@ -1,7 +1,3 @@
-/**
- * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
- */
 export declare function processCharCodes(text: string): number[];
 export declare function convertCharCodes(codes: number[]): string;
 export declare function encodeHuffman(text: string): Uint8Array;

package/dist/ws/util/StringUtil.js

@@ -1,6 +1,51 @@
-/**
+"use strict";
+/*
  * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
-
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.processCharCodes=function(e){return Array.from(e,e=>e.codePointAt(0))},exports.convertCharCodes=r,exports.encodeHuffman=function(r){return(0,e.bitsToBytes)(Array.from(r).map(e=>t[e]).join(""))},exports.decodeHuffman=function(e){let r="",t="";for(const n of e)t+=n,o[t]&&(r+=o[t],t="");return r},exports.as8String=function(e){return r(Array.from(e))};const e=require("./packets/CompressionUtil");function r(e){return String.fromCodePoint(...e)}const o={1000001:"w",1000010:"m",1000100:"u",1000101:"c",1000110:"l",1000111:"d",1001001:"r",1001010:"h",1001100:"s",1001101:"n",1001110:"i",1001111:"o",1010001:"a",1010010:"t",1010100:"e",1010101:"",1e7:"ˆ",10000001:"‡",10000111:"†",1001e4:"…",10010001:"„",10010111:"ƒ",101e5:"‚",10100001:"",10100111:"€",10101100:"",10101101:"~",10101111:"}",1011e4:"|",10110001:"{",10110011:"`",10110100:"_",10110101:"^",10110111:"]",10111e3:"",10111001:"[",10111011:"@",10111100:"?",10111101:">",10111111:"=",11e6:"<",11000001:";",11000011:":",11000100:"9",11000101:"8",11000111:"7",11001e3:"6",11001001:"5",11001011:"4",11001100:"3",11001101:"2",11001111:"1",1101e4:"0",11010001:"/",11010011:".",11010100:"-",11010101:",",11010111:"+",11011e3:"*",11011001:")",11011011:"(",11011100:"'",11011101:"&",11011111:"$",11100001:"#",11100010:'"',11100100:"!",11100101:"",11100110:"",11100111:"",11101001:"",11101010:"",11101100:"",11101101:"",11101110:"",11101111:"",11110001:"",11110010:"",11110100:"",11110101:"",11110110:"",11110111:"",11111001:"",11111010:"",11111100:"",11111101:"",11111110:"",11111111:"",100001100:"Ã",100101100:"Â",100101101:"Á",101001100:"À",101011100:"¿",101011101:"¾",101100100:"½",101101100:"¼",101101101:"»",101110100:"º",101111100:"¹",101111101:"¸",110000100:"·",110001100:"¶",110001101:"µ",110010100:"´",110011100:"³",110011101:"²",110100100:"±",110101100:"°",110101101:"¯",110110100:"®",110111100:"­",110111101:"%",111e6:"¬",111000001:"«",111000111:"ª",11101e4:"©",111010001:"¨",111010111:"§",1111e5:"¦",111100001:"¥",111100111:"¤",11111e4:"£",111110001:"¢",111110111:"¡",1000011010:"á",1010011010:"à",1010011011:"ß",1011001010:"Þ",1011101010:"Ý",1011101011:"Ü",1100001010:"Û",1100101010:"Ú",1100101011:"Ù",1101001010:"Ø",1101101010:"×",1101101011:"Ö",1110001100:"Õ",1110101100:"Ô",1110101101:"Ó",1111001100:"Ò",1111101100:"Ñ",1111101101:"Ð","00000000":" ","00000001":"Ÿ","0000001":"\n","0000010":"","000001100":"Ï","0000011010":"ç","00000110110":"ó","000001101110":"ù","0000011011110":"ü","00000110111110":"þ","00000110111111":"ý","00000111":"ž","0000100":"\b","0000101":"","0000110":"","0000111":"","00010000":"","00010001":"œ","0001001":"","0001010":"","000101100":"Î","000101101":"Í","00010111":"›","0001100":"","0001101":"
","0001110":"","0001111":"Z","00100000":"š","00100001":"™","0010001":"Q","0010010":"X","001001100":"Ì","0010011010":"æ","0010011011":"å","00100111":"˜","0010100":"J","0010101":"K","0010110":"V","0010111":"B","00110000":"—","00110001":"–","0011001":"P","0011010":"Y","001101100":"Ë","001101101":"Ê","00110111":"•","0011100":"G","0011101":"F","0011110":"W","0011111":"M","01000000":"”","01000001":"“","0100001":"U","0100010":"C","010001100":"É","0100011010":"ä","01000110110":"ò","01000110111":"ñ","01000111":"’","0100100":"L","0100101":"D","0100110":"R","0100111":"H","01010000":"‘","01010001":"","0101001":"S","0101010":"N","010101100":"È","010101101":"Ç","01010111":"","0101100":"I","0101101":"O","0101110":"A","0101111":"T","01100000":"Ž","01100001":"","0110001":"E","0110010":"z","011001100":"Æ","0110011010":"ã","0110011011":"â","01100111":"Œ","0110100":"q","0110101":"x","0110110":"j","0110111":"k","01110000":"‹","01110001":"Š","0111001":"v","0111010":"b","011101100":"Å","011101101":"Ä","01110111":"‰","0111100":"p","0111101":"y","0111110":"g","0111111":"f",10000110110:"ð",100001101110:"ø",100001101111:"÷",10110010110:"ï",10110010111:"î",11000010110:"í",110000101110:"ö",1100001011110:"û",1100001011111:"ú",11010010110:"ì",11010010111:"ë",11100011010:"ê",111000110110:"õ",111000110111:"ô",11110011010:"é",11110011011:"è"},t=Object.fromEntries(Object.entries(o).map(([e,r])=>[r,e]));
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processCharCodes = processCharCodes;
+exports.convertCharCodes = convertCharCodes;
+exports.encodeHuffman = encodeHuffman;
+exports.decodeHuffman = decodeHuffman;
+exports.as8String = as8String;
+const CompressionUtil_1 = require("./packets/CompressionUtil");
+function processCharCodes(text) {
+    return Array.from(text, char => char.codePointAt(0));
+}
+function convertCharCodes(codes) {
+    return String.fromCodePoint(...codes);
+}
+const codeToChar = { "1000001": "w", "1000010": "m", "1000100": "u", "1000101": "c", "1000110": "l", "1000111": "d", "1001001": "r", "1001010": "h", "1001100": "s", "1001101": "n", "1001110": "i", "1001111": "o", "1010001": "a", "1010010": "t", "1010100": "e", "1010101": "", "10000000": "ˆ", "10000001": "‡", "10000111": "†", "10010000": "…", "10010001": "„", "10010111": "ƒ", "10100000": "‚", "10100001": "", "10100111": "€", "10101100": "", "10101101": "~", "10101111": "}", "10110000": "|", "10110001": "{", "10110011": "`", "10110100": "_", "10110101": "^", "10110111": "]", "10111000": "", "10111001": "[", "10111011": "@", "10111100": "?", "10111101": ">", "10111111": "=", "11000000": "<", "11000001": ";", "11000011": ":", "11000100": "9", "11000101": "8", "11000111": "7", "11001000": "6", "11001001": "5", "11001011": "4", "11001100": "3", "11001101": "2", "11001111": "1", "11010000": "0", "11010001": "/", "11010011": ".", "11010100": "-", "11010101": ",", "11010111": "+", "11011000": "*", "11011001": ")", "11011011": "(", "11011100": "'", "11011101": "&", "11011111": "$", "11100001": "#", "11100010": "\"", "11100100": "!", "11100101": "\u001f", "11100110": "\u001e", "11100111": "\u001d", "11101001": "\u001c", "11101010": "\u001b", "11101100": "\u001a", "11101101": "\u0019", "11101110": "\u0018", "11101111": "\u0017", "11110001": "\u0016", "11110010": "\u0015", "11110100": "\u0014", "11110101": "\u0013", "11110110": "\u0012", "11110111": "\u0011", "11111001": "\u0010", "11111010": "\u000f", "11111100": "\u000e", "11111101": "", "11111110": "", "11111111": "", "100001100": "Ã", "100101100": "Â", "100101101": "Á", "101001100": "À", "101011100": "¿", "101011101": "¾", "101100100": "½", "101101100": "¼", "101101101": "»", "101110100": "º", "101111100": "¹", "101111101": "¸", "110000100": "·", "110001100": "¶", "110001101": "µ", "110010100": "´", "110011100": "³", "110011101": "²", "110100100": "±", "110101100": "°", "110101101": "¯", "110110100": "®", "110111100": "­", "110111101": "%", "111000000": "¬", "111000001": "«", "111000111": "ª", "111010000": "©", "111010001": "¨", "111010111": "§", "111100000": "¦", "111100001": "¥", "111100111": "¤", "111110000": "£", "111110001": "¢", "111110111": "¡", "1000011010": "á", "1010011010": "à", "1010011011": "ß", "1011001010": "Þ", "1011101010": "Ý", "1011101011": "Ü", "1100001010": "Û", "1100101010": "Ú", "1100101011": "Ù", "1101001010": "Ø", "1101101010": "×", "1101101011": "Ö", "1110001100": "Õ", "1110101100": "Ô", "1110101101": "Ó", "1111001100": "Ò", "1111101100": "Ñ", "1111101101": "Ð", "00000000": " ", "00000001": "Ÿ", "0000001": "\n", "0000010": "", "000001100": "Ï", "0000011010": "ç", "00000110110": "ó", "000001101110": "ù", "0000011011110": "ü", "00000110111110": "þ", "00000110111111": "ý", "00000111": "ž", "0000100": "\b", "0000101": "\u0007", "0000110": "\u0006", "0000111": "\u0005", "00010000": "", "00010001": "œ", "0001001": "\u0004", "0001010": "\u0003", "000101100": "Î", "000101101": "Í", "00010111": "›", "0001100": "\u0002", "0001101": "\u0001", "0001110": "", "0001111": "Z", "00100000": "š", "00100001": "™", "0010001": "Q", "0010010": "X", "001001100": "Ì", "0010011010": "æ", "0010011011": "å", "00100111": "˜", "0010100": "J", "0010101": "K", "0010110": "V", "0010111": "B", "00110000": "—", "00110001": "–", "0011001": "P", "0011010": "Y", "001101100": "Ë", "001101101": "Ê", "00110111": "•", "0011100": "G", "0011101": "F", "0011110": "W", "0011111": "M", "01000000": "”", "01000001": "“", "0100001": "U", "0100010": "C", "010001100": "É", "0100011010": "ä", "01000110110": "ò", "01000110111": "ñ", "01000111": "’", "0100100": "L", "0100101": "D", "0100110": "R", "0100111": "H", "01010000": "‘", "01010001": "", "0101001": "S", "0101010": "N", "010101100": "È", "010101101": "Ç", "01010111": "", "0101100": "I", "0101101": "O", "0101110": "A", "0101111": "T", "01100000": "Ž", "01100001": "", "0110001": "E", "0110010": "z", "011001100": "Æ", "0110011010": "ã", "0110011011": "â", "01100111": "Œ", "0110100": "q", "0110101": "x", "0110110": "j", "0110111": "k", "01110000": "‹", "01110001": "Š", "0111001": "v", "0111010": "b", "011101100": "Å", "011101101": "Ä", "01110111": "‰", "0111100": "p", "0111101": "y", "0111110": "g", "0111111": "f", "10000110110": "ð", "100001101110": "ø", "100001101111": "÷", "10110010110": "ï", "10110010111": "î", "11000010110": "í", "110000101110": "ö", "1100001011110": "û", "1100001011111": "ú", "11010010110": "ì", "11010010111": "ë", "11100011010": "ê", "111000110110": "õ", "111000110111": "ô", "11110011010": "é", "11110011011": "è" };
+const charToCode = Object.fromEntries(Object.entries(codeToChar).map(([code, char]) => [char, code]));
+function encodeHuffman(text) {
+    return (0, CompressionUtil_1.bitsToBytes)(Array.from(text).map(char => charToCode[char]).join(""));
+}
+;
+function decodeHuffman(bits) {
+    let result = '';
+    let buffer = '';
+    for (const bit of bits) {
+        buffer += bit;
+        if (codeToChar[buffer]) {
+            result += codeToChar[buffer];
+            buffer = '';
+        }
+    }
+    return result;
+}
+;
+function as8String(data) {
+    return convertCharCodes(Array.from(data));
+}

package/dist/ws/util/enums/EnumHandler.d.ts

@@ -1,7 +1,3 @@
-/**
- * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
- */
 import { EnumPackage } from "./EnumType";
 export declare const MAX_ENUM_SIZE = 255;
 export declare const ENUM_TAG_TO_KEY: Record<string, Record<any, number>>;

package/dist/ws/util/enums/EnumHandler.js

@@ -1,6 +1,60 @@
-/**
+"use strict";
+/*
  * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SET_PACKAGES = exports.ENUM_KEY_TO_TAG = exports.ENUM_TAG_TO_KEY = exports.MAX_ENUM_SIZE = void 0;
+exports.DefineEnum = DefineEnum;
+exports.WrapEnum = WrapEnum;
+exports.DeWrapEnum = DeWrapEnum;
+const CompressionUtil_1 = require("../packets/CompressionUtil");
+const EnumType_1 = require("./EnumType");
+exports.MAX_ENUM_SIZE = CompressionUtil_1.MAX_BYTE;
+exports.ENUM_TAG_TO_KEY = {};
+exports.ENUM_KEY_TO_TAG = {};
+exports.SET_PACKAGES = {};
+/**
+ * Defines an enum with its tag and values
+ * @param tag The tag of the enum; used for WrapEnum(tag, ...)
+ * @param values The possible values of the enum
+ * @returns A packaged enum
+ */
+function DefineEnum(tag, values) {
+    const setPkg = exports.SET_PACKAGES[tag];
+    if (setPkg) {
+        if (setPkg.values.find((n, i) => values[i] != n))
+            throw new Error(`Pre-existing enum package of tag '${tag}' is set and different!`);
+        return setPkg;
+    }
+    if (values.length > exports.MAX_ENUM_SIZE)
+        throw new Error(`An enum can only hold ${exports.MAX_ENUM_SIZE} possible values.`);
+    exports.ENUM_TAG_TO_KEY[tag] = Object.fromEntries(values.map((v, i) => [v, i]));
+    exports.ENUM_KEY_TO_TAG[tag] = Object.fromEntries(values.map((v, i) => [i, v]));
+    return exports.SET_PACKAGES[tag] = new EnumType_1.EnumPackage(tag, values);
+}
+/**
+ * Wraps an enum into a transmittable format
+ * @param tag The tag of the enum
+ * @param value The value to send
+ * @returns A transmittable enum value
  */
-
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.SET_PACKAGES=exports.ENUM_KEY_TO_TAG=exports.ENUM_TAG_TO_KEY=exports.MAX_ENUM_SIZE=void 0,exports.DefineEnum=function(e,t){const o=exports.SET_PACKAGES[e];if(o){if(o.values.find((e,r)=>t[r]!=e))throw new Error(`Pre-existing enum package of tag '${e}' is set and different!`);return o}if(t.length>exports.MAX_ENUM_SIZE)throw new Error(`An enum can only hold ${exports.MAX_ENUM_SIZE} possible values.`);return exports.ENUM_TAG_TO_KEY[e]=Object.fromEntries(t.map((e,r)=>[e,r])),exports.ENUM_KEY_TO_TAG[e]=Object.fromEntries(t.map((e,r)=>[r,e])),exports.SET_PACKAGES[e]=new r.EnumPackage(e,t)},exports.WrapEnum=function(e,r){if(!(r in exports.ENUM_TAG_TO_KEY[e]))throw new Error(`Value "${r}" does not exist in enum "${e}"`);return exports.ENUM_TAG_TO_KEY[e][r]},exports.DeWrapEnum=function(e,r){return exports.ENUM_KEY_TO_TAG[e][r]};const e=require("../packets/CompressionUtil"),r=require("./EnumType");exports.MAX_ENUM_SIZE=e.MAX_BYTE,exports.ENUM_TAG_TO_KEY={},exports.ENUM_KEY_TO_TAG={},exports.SET_PACKAGES={};
+function WrapEnum(tag, value) {
+    if (!(value in exports.ENUM_TAG_TO_KEY[tag]))
+        throw new Error(`Value "${value}" does not exist in enum "${tag}"`);
+    return exports.ENUM_TAG_TO_KEY[tag][value];
+}
+function DeWrapEnum(tag, value) {
+    return exports.ENUM_KEY_TO_TAG[tag][value];
+}

package/dist/ws/util/enums/EnumType.d.ts

@@ -1,6 +1,2 @@
-/**
- * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
- */
 export declare const TYPE_CONVERSION_MAP: Record<number, (data: string) => string | number | boolean | undefined | null>;
 export type EnumValue = string | number | boolean | undefined | null;

package/dist/ws/util/enums/EnumType.js

@@ -1,6 +1,72 @@
-/**
+"use strict";
+/*
  * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
-
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.EnumPackage=exports.TYPE_CONVERSION_MAP=void 0;const e=require("../StringUtil"),t=require("./EnumHandler"),r={string:0,number:1,boolean:2,undefined:3,object:4};function n(e){const t=typeof e;if(!(t in r)&&null!=e)throw new Error(`Cannot serialize type "${t}" in an enum!`);return r[t]}exports.TYPE_CONVERSION_MAP={0:e=>e,1:e=>parseFloat(e),2:e=>"true"==e,3:()=>{},4:()=>null};exports.EnumPackage=class{tag;values;constructor(e,t){this.tag=e,this.values=t,this.wrap=this.wrap.bind(this)}serialize(){const t=(0,e.processCharCodes)(this.tag);return[this.tag.length,...t,this.values.length,...this.values.map(t=>[String(t).length,n(t),...(0,e.processCharCodes)(String(t))]).flat()]}wrap(e){return(0,t.WrapEnum)(this.tag,e)}};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumPackage = exports.TYPE_CONVERSION_MAP = void 0;
+const StringUtil_1 = require("../StringUtil");
+const EnumHandler_1 = require("./EnumHandler");
+const TYPE_INDEX_MAP = {
+    'string': 0,
+    'number': 1,
+    'boolean': 2,
+    'undefined': 3,
+    'object': 4, // to handle null bug
+};
+exports.TYPE_CONVERSION_MAP = {
+    0: (d) => d,
+    1: (d) => parseFloat(d),
+    2: (d) => d == 'true',
+    3: () => undefined,
+    4: () => null,
+};
+function getTypedIndex(data) {
+    const type = typeof data;
+    if (!(type in TYPE_INDEX_MAP) && data != null)
+        throw new Error(`Cannot serialize type "${type}" in an enum!`);
+    return TYPE_INDEX_MAP[type];
+}
+/** @internal */
+class EnumPackage {
+    tag;
+    values;
+    constructor(tag, values) {
+        this.tag = tag;
+        this.values = values;
+        this.wrap = this.wrap.bind(this);
+    }
+    serialize() {
+        const tag = (0, StringUtil_1.processCharCodes)(this.tag);
+        return [
+            this.tag.length, // tag length
+            ...tag, // tag
+            this.values.length, // value count
+            ...this.values.map(v => [
+                String(v).length, // value length
+                getTypedIndex(v), // value type
+                ...(0, StringUtil_1.processCharCodes)(String(v)) // value
+            ]).flat(),
+        ];
+    }
+    /**
+     * Wraps a value with this enum package
+     * @param value Value to wrap
+     * @returns Network encoded value
+     */
+    wrap(value) {
+        return (0, EnumHandler_1.WrapEnum)(this.tag, value);
+    }
+}
+exports.EnumPackage = EnumPackage;

package/dist/ws/util/packets/BatchHelper.d.ts

@@ -1,5 +1 @@
-/**
- * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
- */
 export {};