sonic-ws 1.0.5 → 1.0.6

package/dist/version.d.ts

@@ -1,5 +1,5 @@
 /** Current protocol version */
-export declare const VERSION = 12;
+export declare const VERSION = 13;
 /** Server data suffix */
 export declare const SERVER_SUFFIX = "SWS";
 /** Server data suffix in array */

package/dist/version.js

@@ -18,7 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SERVER_SUFFIX_NUMS = exports.SERVER_SUFFIX = exports.VERSION = void 0;
 const StringUtil_1 = require("./ws/util/StringUtil");
 /** Current protocol version */
-exports.VERSION = 12;
+exports.VERSION = 13;
 /** Server data suffix */
 exports.SERVER_SUFFIX = "SWS";
 /** Server data suffix in array */

package/dist/ws/client/core/ClientCore.d.ts

@@ -14,8 +14,8 @@ export declare abstract class SonicWSCore implements Connection {
     protected preListen: {
         [key: string]: Array<(data: any[]) => void>;
     } | null;
-    protected clientPackets: PacketHolder<any>;
-    protected serverPackets: PacketHolder<any>;
+    protected clientPackets: PacketHolder;
+    protected serverPackets: PacketHolder;
     private pastKeys;
     private readyListeners;
     private batcher;

package/dist/ws/packets/PacketProcessors.js

@@ -37,7 +37,7 @@ function SHORT_LEN(cap, min) {
 function VARINT_VERIF(cap, min) {
     return (data) => {
         if (data.length == 0)
-            return false;
+            return min <= 0 ? [] : false;
         let sectors = 0, i = 0, computed = [];
         while (i < data.length) {
             const [off, varint] = (0, CompressionUtil_1.readVarInt)(data, i);
@@ -96,20 +96,22 @@ function createValidator(type, dataCap, dataMin, packet) {
             }
             ;
         case PacketType_1.PacketType.STRINGS_ASCII: return (data) => {
-            let sectors = 0, index = 0, computed = [];
-            while (index < data.length) {
-                sectors++;
-                if (sectors > dataCap)
-                    return false;
-                const [off, varint] = (0, CompressionUtil_1.readVarInt)(data, index);
-                computed.push([off - index, varint]);
-                index = off + varint;
-                if (index > data.length)
-                    return false;
+            let index = 0;
+            const [offCount, stringCount] = (0, CompressionUtil_1.readVarInt)(data, index);
+            index = offCount;
+            if (stringCount < dataMin || stringCount > dataCap)
+                return false;
+            const lengths = [];
+            let totalLength = 0;
+            for (let i = 0; i < stringCount; i++) {
+                const [offLen, strLen] = (0, CompressionUtil_1.readVarInt)(data, index);
+                index = offLen;
+                lengths.push(strLen);
+                totalLength += strLen;
             }
-            if (sectors < dataMin)
+            if (index + Math.ceil(totalLength / 8) > data.length)
                 return false;
-            return computed;
+            return [stringCount, lengths, index];
         };
         case PacketType_1.PacketType.STRINGS_UTF16: return (data) => {
             let sectors = 0, index = 0, computed = [];
@@ -154,14 +156,17 @@ function createReceiveProcessor(type, enumData, cap) {
             const pkg = enumData[index];
             return Array.from(data).map(code => pkg.values[code]);
         };
-        case PacketType_1.PacketType.STRINGS_ASCII: return (data, computed) => {
+        case PacketType_1.PacketType.STRINGS_ASCII: return (data, validationResult) => {
+            const [stringCount, lengths, dataStart] = validationResult;
+            const bitString = (0, CompressionUtil_1.bytesToBits)(data.subarray(dataStart));
+            const decoded = (0, CompressionUtil_1.decodeHuffman)(bitString);
+            if (!decoded)
+                return [];
             const strings = [];
-            let index = 0;
-            for (let i = 0; i < computed.length; i++) {
-                const [strLenLen, strLen] = computed[i];
-                index += strLenLen;
-                const str = (0, BufferUtil_1.as8String)(data.subarray(index, index += strLen));
-                strings.push(str);
+            let offset = 0;
+            for (let i = 0; i < stringCount; i++) {
+                strings.push(decoded.slice(offset, offset + lengths[i]));
+                offset += lengths[i];
             }
             return strings;
         };
@@ -188,18 +193,11 @@ function createSendProcessor(type) {
         case PacketType_1.PacketType.DOUBLES: return (doubles) => doubles.map(CompressionUtil_1.convertDouble).flat();
         case PacketType_1.PacketType.BOOLEANS: return (bools) => (0, ArrayUtil_1.splitArray)(bools, 8).map((bools) => (0, CompressionUtil_1.compressBools)(bools)).flat();
         case PacketType_1.PacketType.STRINGS_ASCII: return (strings) => {
-            const res = [];
-            for (const v of strings) {
-                const string = String(v);
-                const lenVI = (0, CompressionUtil_1.convertVarInt)(string.length);
-                res.push(...lenVI);
-                const codes = (0, StringUtil_1.processCharCodes)(string);
-                const highCode = codes.find(x => x > CompressionUtil_1.MAX_BYTE);
-                if (highCode)
-                    throw new Error(`Cannot store code ${highCode} (${String.fromCharCode(highCode)}) in a UTF-8 String! Use STRINGS_UTF16.`);
-                res.push(...codes);
-            }
-            return res;
+            return [
+                ...(0, CompressionUtil_1.convertVarInt)(strings.length),
+                ...strings.map(str => (0, CompressionUtil_1.convertVarInt)(str.length)).flat(),
+                ...(0, CompressionUtil_1.encodeHuffman)(strings.reduce((a, b) => a + String(b), "")),
+            ];
         };
         case PacketType_1.PacketType.STRINGS_UTF16: return (strings) => {
             const res = [];

package/dist/ws/packets/Packets.d.ts

@@ -1,7 +1,7 @@
 import { EnumPackage } from "../util/enums/EnumType";
 import { SonicWSConnection } from "../server/SonicWSConnection";
 import { PacketType } from "./PacketType";
-export type ValidatorFunction = ((socket: SonicWSConnection<any, any>, values: any[]) => boolean) | null;
+export type ValidatorFunction = ((socket: SonicWSConnection, values: any) => boolean) | null;
 export type ConvertType<T> = T extends EnumPackage ? PacketType.ENUMS : T;
 type ImpactType<T extends (PacketType | readonly PacketType[]), K> = T extends PacketType[] ? K[] : K;
 export declare class Packet<T extends (PacketType | readonly PacketType[])> {
@@ -26,9 +26,9 @@ export declare class Packet<T extends (PacketType | readonly PacketType[])> {
     processReceive: (data: Uint8Array, validationResult: any) => any;
     processSend: (data: any[]) => number[];
     validate: (data: Uint8Array) => boolean;
-    customValidator: ((socket: SonicWSConnection<any, any>, ...values: any[]) => boolean) | null;
+    customValidator: ((socket: SonicWSConnection, ...values: any[]) => boolean) | null;
     constructor(tag: string, schema: PacketSchema<T>, customValidator: ValidatorFunction, enabled: boolean, client: boolean);
-    listen(value: Uint8Array, socket: SonicWSConnection<any, any> | null): [processed: any, flatten: boolean] | string;
+    listen(value: Uint8Array, socket: SonicWSConnection | null): [processed: any, flatten: boolean] | string;
     serialize(): number[];
     private static readVarInts;
     static deserialize(data: Uint8Array, offset: number, client: boolean): [packet: Packet<any>, offset: number];

package/dist/ws/packets/Packets.js

@@ -92,7 +92,8 @@ class Packet {
     listen(value, socket) {
         try {
             const validationResult = this.validate(value);
-            if (!this.client && validationResult == false)
+            // holy shit i used === to fix another bug
+            if (!this.client && validationResult === false)
                 return "Invalid packet";
             const processed = this.processReceive(value, validationResult);
             const useableData = this.autoFlatten ? (0, PacketUtils_1.UnFlattenData)(processed) : processed;

package/dist/ws/server/SonicWSConnection.d.ts

@@ -1,9 +1,8 @@
 import * as WS from 'ws';
-import { PacketTypings, SonicWSServer } from './SonicWSServer';
+import { SonicWSServer } from './SonicWSServer';
 import { Packet } from '../packets/Packets';
 import { Connection } from '../Connection';
-import { PacketResponse } from '../packets/PacketProcessors';
-export declare class SonicWSConnection<ClientTypes extends PacketTypings, ServerTypes extends PacketTypings> implements Connection {
+export declare class SonicWSConnection implements Connection {
     /** Raw 'ws' library socket */
     socket: WS.WebSocket;
     private host;
@@ -21,7 +20,7 @@ export declare class SonicWSConnection<ClientTypes extends PacketTypings, Server
     /** The index of the connection; unique for all connected, recycles old disconnected ids. Should be safe for INTS_C unless you have more than 27,647 connected at once. */
     id: number;
     _timers: Record<number, number>;
-    constructor(socket: WS.WebSocket, host: SonicWSServer<ClientTypes, ServerTypes>, id: number, handshakePacket: string | null, clientRateLimit: number, serverRateLimit: number);
+    constructor(socket: WS.WebSocket, host: SonicWSServer, id: number, handshakePacket: string | null, clientRateLimit: number, serverRateLimit: number);
     private parseData;
     private handshakeHandler;
     private invalidPacket;
@@ -46,17 +45,17 @@ export declare class SonicWSConnection<ClientTypes extends PacketTypings, Server
      * Listens for when the connection closes
      * @param listener Called when it closes
      */
-    on_close(listener: (code: number, reason: Buffer) => void): void;
+    on_close(listener: (code: number, reason: string) => void): void;
     /**
      * Listens for a packet
      * @param tag The tag of the key to listen for
      * @param listener A function to listen for it
      */
-    on<K extends number, T extends ClientTypes[K], Tag extends T['tag'] = T['tag'], Type extends T['type'] = T['type'], DataMax extends T['dataMax'] = T['dataMax']>(tag: Tag, listener: T['dontSpread'] extends true ? (packet: PacketResponse<Type, DataMax>) => void : (...packet: PacketResponse<Type, DataMax>) => void): void;
+    on(tag: string, listener: (...values: any) => void): void;
     /**
      * For internal use.
      */
-    send_processed(code: number, data: number[], packet: Packet<ClientTypes[number]['type']>): void;
+    send_processed(code: number, data: number[], packet: Packet<any>): void;
     /**
      * Sends a packet with the tag and values
      * @param tag The tag to send
@@ -68,7 +67,7 @@ export declare class SonicWSConnection<ClientTypes extends PacketTypings, Server
      * @param tag The tag to send
      * @param values The values to send
      */
-    broadcastFiltered(tag: string, filter: (socket: SonicWSConnection<ClientTypes, ServerTypes>) => boolean, ...values: any[]): void;
+    broadcastFiltered(tag: string, filter: (socket: SonicWSConnection) => boolean, ...values: any[]): void;
     /**
      * Broadcasts a packet to all other users connected
      * @param tag The tag to send
@@ -85,4 +84,10 @@ export declare class SonicWSConnection<ClientTypes extends PacketTypings, Server
     setInterval(call: () => void, time: number): number;
     clearTimeout(id: number): void;
     clearInterval(id: number): void;
+    /**
+     * Tags the socket with a key
+     * @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(tag: string, replace?: boolean): void;
 }

package/dist/ws/server/SonicWSConnection.js

@@ -67,7 +67,7 @@ class SonicWSConnection {
     handshakedMessageLambda = (data) => {
         const parsed = this.parseData(data);
         if (parsed == null)
-            return;
+            return this.socket.close(4004);
         if (parsed[0] == this.handshakePacket)
             return this.socket.close(4005);
         this.messageHandler(parsed);
@@ -143,7 +143,7 @@ class SonicWSConnection {
     handshakeHandler(data) {
         const parsed = this.parseData(data);
         if (parsed == null)
-            return;
+            return this.socket.close(4004);
         if (parsed[0] != this.handshakePacket) {
             this.socket.close(4004);
             return;
@@ -154,6 +154,7 @@ class SonicWSConnection {
         this.handshakeComplete = true;
     }
     invalidPacket(listened) {
+        console.log("Closure cause", listened);
         this.socket.close(4003, listened);
     }
     listenPacket(data, tag) {
@@ -202,7 +203,7 @@ class SonicWSConnection {
      * @param listener Called when it closes
      */
     on_close(listener) {
-        this.socket.on('close', listener);
+        this.socket.on('close', (code, reason) => listener(code, String(reason)));
     }
     /**
      * Listens for a packet
@@ -258,8 +259,10 @@ class SonicWSConnection {
     }
     /* JSDocs in Connection.ts class */
     raw_send(data) {
-        if (this.isClosed())
-            throw new Error("Connection is already closed!");
+        if (this.isClosed()) {
+            console.warn("WARN! Connection already closed when trying to send message!", this.id, (0, BufferUtil_1.stringifyBuffer)(data));
+            return;
+        }
         if (this.rater.trigger(SERVER_RATELIMIT_TAG))
             return;
         if (this.print)
@@ -289,5 +292,13 @@ class SonicWSConnection {
     clearInterval(id) {
         this.clearTimeout(id);
     }
+    /**
+     * Tags the socket with a key
+     * @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(tag, replace = true) {
+        this.host.tag(this, tag, replace);
+    }
 }
 exports.SonicWSConnection = SonicWSConnection;

package/dist/ws/server/SonicWSServer.d.ts

@@ -6,33 +6,35 @@ import { PacketType } from '../packets/PacketType';
 /**
  * Sonic WS Server Options
  */
-export type SonicServerOptions<ClientTypes extends PacketTypings, ServerTypes extends PacketTypings> = {
+export type SonicServerOptions = {
     /** An array of packets the client can send and server can listen for; using CreatePacket(), CreateObjPacket(), and CreateEnumPacket() */
-    readonly clientPackets?: ClientTypes;
+    readonly clientPackets?: PacketTypings;
     /** An array of packets the server can send and client can listen for; using CreatePacket(), CreateObjPacket(), and CreateEnumPacket() */
-    readonly serverPackets?: ServerTypes;
+    readonly serverPackets?: PacketTypings;
     /** Default WS Options */
     readonly websocketOptions?: WS.ServerOptions;
 };
 export type PacketTypings = readonly Packet<PacketType | readonly PacketType[]>[];
-export declare class SonicWSServer<ClientTypes extends PacketTypings, ServerTypes extends PacketTypings> {
+export declare class SonicWSServer {
     private wss;
     private availableIds;
     private lastId;
     private connectListeners;
-    clientPackets: PacketHolder<ClientTypes>;
-    serverPackets: PacketHolder<ServerTypes>;
-    connections: SonicWSServer.Connection[];
+    clientPackets: PacketHolder;
+    serverPackets: PacketHolder;
+    connections: SonicWSConnection[];
     private connectionMap;
     private clientRateLimit;
     private serverRateLimit;
     private handshakePacket;
+    tags: Map<SonicWSConnection, Set<String>>;
+    tagsInv: Map<String, Set<SonicWSConnection>>;
     /**
      * 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: SonicServerOptions<ClientTypes, ServerTypes>);
+    constructor(settings: SonicServerOptions);
     private generateSocketID;
     /**
      * Requires each client to send this packet upon initialization
@@ -79,7 +81,7 @@ export declare class SonicWSServer<ClientTypes extends PacketTypings, ServerType
      * Listens for whenever a client connects
      * @param runner Called when ready
      */
-    on_connect(runner: (client: SonicWSConnection<ClientTypes, ServerTypes>) => void): void;
+    on_connect(runner: (client: SonicWSConnection) => void): void;
     /**
      * Listens for whenever the server is ready
      * @param runner Called when ready
@@ -90,13 +92,20 @@ export declare class SonicWSServer<ClientTypes extends PacketTypings, ServerType
      * @param callback Called when server closes
      */
     shutdown(callback: (err?: Error) => void): void;
+    /**
+     * Broadcasts a packet to tagged users; this is fast as it is a record rather than looping and filtering
+     * @param tag The tag to send packets to
+     * @param packetTag Packet tag to send
+     * @param values Values to send
+     */
+    broadcastTagged(tag: string, packetTag: string, ...values: any): void;
     /**
      * Broadcasts a packet to all users connected, but with a filter
      * @param tag The tag to send
      * @param filter The filter for who to send to
      * @param values The values to send
      */
-    broadcastFiltered(tag: string, filter: (socket: SonicWSConnection<ClientTypes, ServerTypes>) => boolean, ...values: any): void;
+    broadcastFiltered(tag: string, filter: (socket: SonicWSConnection) => boolean, ...values: any): void;
     /**
      * Broadcasts a packet to all users connected
      * @param tag The tag to send
@@ -106,18 +115,22 @@ export declare class SonicWSServer<ClientTypes extends PacketTypings, ServerType
     /**
      * @returns All users connected to the socket
      */
-    getConnected(): SonicWSServer.Connection[];
+    getConnected(): SonicWSConnection[];
     /**
      * @param id The socket id
      * @returns The socket
      */
-    getSocket(id: number): SonicWSConnection<ClientTypes, ServerTypes>;
+    getSocket(id: number): SonicWSConnection;
     /**
      * Closes a socket by id
      * @param id The socket id
      */
     closeSocket(id: number, code?: number, reason?: string | Buffer): void;
-}
-export declare namespace SonicWSServer {
-    type Connection<ClientTypes extends PacketTypings = any, ServerTypes extends PacketTypings = any> = import('./SonicWSConnection').SonicWSConnection<ClientTypes, ServerTypes>;
+    /**
+     * 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: SonicWSConnection, tag: string, replace?: boolean): void;
 }

package/dist/ws/server/SonicWSServer.js

@@ -67,6 +67,8 @@ class SonicWSServer {
     clientRateLimit = 500;
     serverRateLimit = 500;
     handshakePacket = null;
+    tags = new Map();
+    tagsInv = new Map();
     /**
      * 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
@@ -200,6 +202,18 @@ class SonicWSServer {
     shutdown(callback) {
         this.wss.close(callback);
     }
+    /**
+     * Broadcasts a packet to tagged users; this is fast as it is a record rather than looping and filtering
+     * @param tag The tag to send packets to
+     * @param packetTag Packet tag to send
+     * @param values Values to send
+     */
+    broadcastTagged(tag, packetTag, ...values) {
+        if (!this.tagsInv.has(tag))
+            return;
+        const data = (0, PacketUtils_1.processPacket)(this.serverPackets, packetTag, values);
+        this.tagsInv.get(tag).forEach(conn => conn.send_processed(...data));
+    }
     /**
      * Broadcasts a packet to all users connected, but with a filter
      * @param tag The tag to send
@@ -208,7 +222,6 @@ class SonicWSServer {
      */
     broadcastFiltered(tag, filter, ...values) {
         const data = (0, PacketUtils_1.processPacket)(this.serverPackets, tag, values);
-        // weird type bug here so i make it as any
         this.connections.filter(filter).forEach(conn => conn.send_processed(...data));
     }
     /**
@@ -239,5 +252,22 @@ class SonicWSServer {
     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);
+    }
 }
 exports.SonicWSServer = SonicWSServer;

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

@@ -9,7 +9,7 @@ export declare const SET_PACKAGES: Record<string, EnumPackage>;
  * @param values The possible values of the enum
  * @returns A packaged enum
  */
-export declare function DefineEnum(tag: string, values: any[]): EnumPackage;
+export declare function DefineEnum(tag: string, values: any[] | readonly any[]): EnumPackage;
 /**
  * Wraps an enum into a transmittable format
  * @param tag The tag of the enum
@@ -17,3 +17,4 @@ export declare function DefineEnum(tag: string, values: any[]): EnumPackage;
  * @returns A transmittable enum value
  */
 export declare function WrapEnum(tag: string, value: any): number;
+export declare function DeWrapEnum(tag: string, value: number): any;

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

@@ -18,6 +18,7 @@ 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;
@@ -54,3 +55,6 @@ function WrapEnum(tag, value) {
         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

@@ -2,7 +2,13 @@ export declare const TYPE_CONVERSION_MAP: Record<number, (data: string) => strin
 export type EnumValue = string | number | boolean | undefined | null;
 export declare class EnumPackage {
     tag: string;
-    values: EnumValue[];
-    constructor(tag: string, values: any[]);
+    values: EnumValue[] | readonly EnumValue[];
+    constructor(tag: string, values: any[] | readonly any[]);
     serialize(): number[];
+    /**
+     * Wraps a value with this enum package
+     * @param value Value to wrap
+     * @returns Network encoded value
+     */
+    wrap(value: any): number;
 }

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

@@ -17,6 +17,7 @@
 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,
@@ -43,6 +44,7 @@ class EnumPackage {
     constructor(tag, values) {
         this.tag = tag;
         this.values = values;
+        this.wrap = this.wrap.bind(this);
     }
     serialize() {
         const tag = (0, StringUtil_1.processCharCodes)(this.tag);
@@ -57,5 +59,13 @@ class EnumPackage {
             ]).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,15 +1,15 @@
 import { Connection } from "../../Connection";
 import { Packet } from "../../packets/Packets";
-import { SonicWSServer } from "../../server/SonicWSServer";
+import { SonicWSConnection } from "../../server/SonicWSConnection";
 import { PacketHolder } from "./PacketHolder";
 export declare class BatchHelper {
     private batchTimes;
     private batchTimeouts;
     private batchedData;
     private conn;
-    registerSendPackets(packetHolder: PacketHolder<any>, conn: Connection): void;
+    registerSendPackets(packetHolder: PacketHolder, conn: Connection): void;
     private initiateBatch;
     private startBatch;
     batchPacket(code: number, data: number[]): void;
-    static unravelBatch(packet: Packet<any>, data: Uint8Array, socket: SonicWSServer.Connection | null): any[] | string;
+    static unravelBatch(packet: Packet<any>, data: Uint8Array, socket: SonicWSConnection | null): any[] | string;
 }

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

@@ -35,3 +35,7 @@ export declare function mapShort_ZZ(short: number): SHORT_BITS;
 export declare function convertVarInt(num: number): number[];
 export declare function readVarInt(arr: number[] | Uint8Array, off: number): [offset: number, number: number];
 export declare function deconvertVarInts(arr: Uint8Array | number[]): number[];
+export declare function bytesToBits(bytes: ArrayLike<number>): string;
+export declare function bitsToBytes(bitString: string): Uint8Array;
+export declare function encodeHuffman(text: string): Uint8Array;
+export declare function decodeHuffman(bits: string): string;

package/dist/ws/util/packets/CompressionUtil.js

@@ -32,6 +32,10 @@ exports.mapShort_ZZ = mapShort_ZZ;
 exports.convertVarInt = convertVarInt;
 exports.readVarInt = readVarInt;
 exports.deconvertVarInts = deconvertVarInts;
+exports.bytesToBits = bytesToBits;
+exports.bitsToBytes = bitsToBytes;
+exports.encodeHuffman = encodeHuffman;
+exports.decodeHuffman = decodeHuffman;
 const ArrayUtil_1 = require("../ArrayUtil");
 // this shit is so complex so i commented it...
 // the highest 8-bit
@@ -259,14 +263,10 @@ function deconvertDouble(bytes) {
 }
 // zig_zag
 function mapZigZag(n) {
-    return (n << 1) // shifts left (multiply by 2 to get into zigzag)
-        ^
-            (n >> 15); // then xor the sign away
+    return ((n << 1) ^ (n >> 31));
 }
 function demapZigZag(n) {
-    return (n >>> 1) // shifts right unsigned to remove the sign & divide by 2
-        ^
-            -(n & 1); // flips bits to give negative back
+    return (n >>> 1) ^ -((n & 1));
 }
 function demapShort_ZZ(short) {
     return demapZigZag(fromShort(short));
@@ -302,3 +302,33 @@ function deconvertVarInts(arr) {
     }
     return res;
 }
+function bytesToBits(bytes) {
+    return Array.from(bytes).map(b => b.toString(2).padStart(8, '0')).join('');
+}
+function bitsToBytes(bitString) {
+    const bytes = [];
+    for (let i = 0; i < bitString.length; i += 8) {
+        const byte = bitString.slice(i, i + 8).padEnd(8, '0');
+        bytes.push(parseInt(byte, 2));
+    }
+    return new Uint8Array(bytes);
+}
+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 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;
+}
+;

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

@@ -1,8 +1,9 @@
 import { Packet } from "../../packets/Packets";
+import { PacketTypings } from "../../server/SonicWSServer";
 /**
  * Holds and maps packets to indexed keys and tags for serialization and lookup
  */
-export declare class PacketHolder<Typings extends readonly Packet<any>[], K extends Typings[number] = Typings[number], Type extends K['type'] = K['type'], Tag extends K['tag'] = K['tag']> {
+export declare class PacketHolder {
     /** Current key index for packet tags */
     private key;
     /** Maps tags to keys */
@@ -17,19 +18,19 @@ export declare class PacketHolder<Typings extends readonly Packet<any>[], K exte
      * Creates a new PacketHolder with an array of packets
      * @param packets Array of packets to register
      */
-    constructor(packets?: Typings);
+    constructor(packets?: PacketTypings);
     /** Assigns a new unique key to a tag */
-    createKey(tag: Tag): void;
+    createKey(tag: string): void;
     /**
      * Registers an array of packets and assigns them keys
      * @param packets Array of packets to register
      */
-    holdPackets(packets: Typings): void;
+    holdPackets(packets: PacketTypings): void;
     /**
      * Returns the numeric key for a given tag
      * @param tag The packet tag
      */
-    getKey(tag: Tag): number;
+    getKey(tag: string): number;
     /**
      * Returns the tag associated with a given character key
      * @param key A 1-character string key
@@ -39,7 +40,7 @@ export declare class PacketHolder<Typings extends readonly Packet<any>[], K exte
      * Returns the packet instance associated with a tag
      * @param tag The packet tag
      */
-    getPacket(tag: string): Packet<Type>;
+    getPacket(tag: string): Packet<any>;
     /**
      * Checks if a given character key exists
      * @param key A string index
@@ -57,7 +58,7 @@ export declare class PacketHolder<Typings extends readonly Packet<any>[], K exte
     /** Returns an array of all registered tags */
     getTags(): string[];
     /** Returns the list of all registered packets */
-    getPackets(): Typings;
+    getPackets(): PacketTypings;
     /** Serializes all registered packets into a string */
     serialize(): number[];
 }

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

@@ -2,7 +2,6 @@ import { PacketHolder } from "./PacketHolder";
 import { ConvertType, Packet, ValidatorFunction } from "../../packets/Packets";
 import { PacketType } from "../../packets/PacketType";
 import { EnumPackage } from "../enums/EnumType";
-import { PacketTypings } from "../../server/SonicWSServer";
 /**
  * Processes and verifies values into a sendable format
  * @param packets Packet holder
@@ -10,7 +9,7 @@ import { PacketTypings } from "../../server/SonicWSServer";
  * @param values The values
  * @returns The indexed code, the data, and the packet schema
  */
-export declare function processPacket<T extends PacketTypings, K extends T[number]>(packets: PacketHolder<T>, tag: K['tag'], values: any[]): [code: number, data: number[], packet: Packet<K['type']>];
+export declare function processPacket(packets: PacketHolder, tag: string, values: any[]): [code: number, data: number[], packet: Packet<any>];
 /**
  * Calls the listener for a packet with error callback
  * @param listened The listened data
@@ -95,9 +94,11 @@ export declare function CreatePacket<T extends ArguableType>(settings: SinglePac
  * @returns The constructed packet structure data.
  * @throws {Error} If any type in `types` is invalid.
  */
-export declare function CreateObjPacket<T extends readonly PacketType[]>(settings: MultiPacketSettings & {
+export declare function CreateObjPacket<T extends readonly ArguableType[], V extends readonly PacketType[] = {
+    [K in keyof T]: ConvertType<T[K]>;
+}>(settings: MultiPacketSettings & {
     readonly types: T;
-}): Packet<T>;
+}): Packet<V>;
 /**
  * Creates and defines an enum packet. This can be used to create an enum-based packet
  * with a specific tag and possible values.

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

@@ -1,14 +1,14 @@
-import { SonicWSServer } from "../../server/SonicWSServer";
+import { SonicWSConnection } from "../../server/SonicWSConnection";
 import { PacketHolder } from "./PacketHolder";
 export declare class RateHandler {
     private rates;
     private limits;
     private setInterval;
     private socket;
-    constructor(host: SonicWSServer.Connection);
+    constructor(host: SonicWSConnection);
     start(): void;
     registerRate(tag: string, limit: number): void;
-    registerAll(packetHolder: PacketHolder<any>, prefix: string): void;
+    registerAll(packetHolder: PacketHolder, prefix: string): void;
     trigger(tag: string | number): boolean;
     subtract(tag: string | number): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonic-ws",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Ultra-lightweight, high-performance, and bandwidth efficient websocket library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",