sonic-ws 1.1.1 → 1.2.0

package/README.md

@@ -7,8 +7,9 @@ SonicWS is an ultra-lightweight, high-performance WebSocket library focused on m
 Compression:
 - Lossless compression up to 70% or more (for example, 38kb -> 14kb)
 - Optimized bandwidth for many different types to fit special constraints
-- Automatic helpers to flatten typed nested arrays for maximum wire efficiency (for example, [[1,2,3],[4,5,6]] to [[1,4],[2,5],[3,6]])
+- Automatic helpers to flatten typed nested arrays for maximum wire efficiency (for example, [[1,false,"text"],[4,true,"other"]] to [[1,4],[false,true],["text,"other"]])
 - Uses raw binary bytes to transmit data as efficiently as possible while still using high level readable code
+- Built-in ability to use compression libraries
 
 Developer Friendly:
 - Predefined data types of various sized integers, single and double precision floating point numbers, strings, enums, etc. and RAW to allow for developers to do anything they want
@@ -38,8 +39,9 @@ Developer Experience:
 - Debug tools for socket ids, byte size, data logging, etc. for troubleshooting
 - Very minimal learning curve, easy to work in
 - JSDoc's for understanding; immensely intuitive (personally, I took a break for half a year and came back and snapped right back in)
+- Almost every case has a pre-made wire optimization and boilerplate removal.
 
-Whether you're making a real-time game, a dashboard, a distributed system, or anything else, SonicWS gets you safe, structured packets, fast.
+Whether you're making a real-time game, a dashboard, a distributed system, or anything else, SonicWS gets you safe, structured packets; fast.
 
 ## SAMPLES
 
@@ -117,4 +119,4 @@ Some weird error messages when invalid inputs are in like CreatePacket() and stu
 
 Better error handling
 
-ZLib/gzip compression
+Some middleware support

package/dist/version.d.ts

@@ -1,5 +1,5 @@
 /** Current protocol version */
-export declare const VERSION = 14;
+export declare const VERSION = 16;
 /** 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 = 14;
+exports.VERSION = 16;
 /** Server data suffix */
 exports.SERVER_SUFFIX = "SWS";
 /** Server data suffix in array */

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

@@ -26,6 +26,7 @@ export declare abstract class SonicWSCore implements Connection {
     private asyncMap;
     constructor(ws: WebSocket, bufferHandler: (val: MessageEvent) => Promise<Uint8Array>);
     private reading;
+    private readQueue;
     private serverKeyHandler;
     private invalidPacket;
     private listenLock;
@@ -50,7 +51,7 @@ export declare abstract class SonicWSCore implements Connection {
      * @param tag The tag of the packet
      * @param values The values to send
      */
-    send(tag: string, ...values: any[]): void;
+    send(tag: string, ...values: any[]): Promise<void>;
     /**
      * Listens for when the client connects
      * @param listener Callback on connection

package/dist/ws/client/core/ClientCore.js

@@ -63,27 +63,28 @@ class SonicWSCore {
         this.bufferHandler = bufferHandler;
     }
     reading = false;
+    readQueue = [];
     async serverKeyHandler(event) {
-        // stupid asynchronous bullshit
         if (this.reading)
-            return this.messageHandler(event);
+            return this.readQueue.push(event);
         this.reading = true;
-        const data = await this.bufferHandler(event);
-        if (data.length < 3 || (0, BufferUtil_1.as8String)(data.slice(0, 3)) != version_1.SERVER_SUFFIX) {
+        const cdata = await this.bufferHandler(event);
+        if (cdata.length < 3 || (0, BufferUtil_1.as8String)(cdata.slice(0, 3)) != version_1.SERVER_SUFFIX) {
             this.socket.close(1000);
             throw new Error("The server requested is not a Sonic WS server.");
         }
-        const version = data[3];
+        const version = cdata[3];
         if (version != version_1.VERSION) {
             this.socket.close(1000);
             throw new Error(`Version mismatch: ${version > version_1.VERSION ? "client" : "server"} is outdated (server: ${version}, client: ${version_1.VERSION})`);
         }
-        const [ckOff, id] = (0, CompressionUtil_1.readVarInt)(data, 4);
+        const data = await (0, CompressionUtil_1.decompressGzip)(cdata.subarray(4, cdata.length));
+        const [ckOff, id] = (0, CompressionUtil_1.readVarInt)(data, 0);
         this.id = id;
         const [valuesOff, ckLength] = (0, CompressionUtil_1.readVarInt)(data, ckOff);
-        const ckData = data.slice(valuesOff, valuesOff + ckLength);
+        const ckData = data.subarray(valuesOff, valuesOff + ckLength);
         this.clientPackets.holdPackets(Packets_1.Packet.deserializeAll(ckData, true));
-        const skData = data.slice(valuesOff + ckLength, data.length);
+        const skData = data.subarray(valuesOff + ckLength, data.length);
         this.serverPackets.holdPackets(Packets_1.Packet.deserializeAll(skData, true));
         this.batcher.registerSendPackets(this.clientPackets, this);
         for (const p of this.serverPackets.getPackets()) {
@@ -105,6 +106,8 @@ class SonicWSCore {
         this.readyListeners = null; // clear
         this.socket.removeEventListener('message', this.serverKeyHandler);
         this.socket.addEventListener('message', this.messageHandler);
+        this.readQueue.forEach(e => this.messageHandler(e));
+        this.readQueue = [];
     }
     invalidPacket(listened) {
         console.error(listened);
@@ -136,7 +139,7 @@ class SonicWSCore {
             packetQueue = this.packetQueue;
         }
         if (locked) {
-            packetQueue.push([data, code]);
+            packetQueue.push(data);
             return;
         }
         if (isAsync)
@@ -144,12 +147,11 @@ class SonicWSCore {
         else
             this.listenLock = true;
         let currentData = data;
-        let currentCode = code;
         while (true) {
             await (0, PacketUtils_1.listenPacket)(currentData, listeners, this.invalidPacket);
             if (packetQueue.length === 0)
                 break;
-            [currentData, currentCode] = packetQueue.shift();
+            currentData = packetQueue.shift();
         }
         if (isAsync)
             asyncData[0] = false;
@@ -165,10 +167,10 @@ class SonicWSCore {
         const value = data.slice(1);
         const packet = this.serverPackets.getPacket(this.serverPackets.getTag(key));
         if (packet.dataBatching == 0) {
-            this.listenPacket(packet.listen(value, null), key);
+            this.listenPacket(await packet.listen(value, null), key);
             return;
         }
-        const batchData = BatchHelper_1.BatchHelper.unravelBatch(packet, value, null);
+        const batchData = await BatchHelper_1.BatchHelper.unravelBatch(packet, value, null);
         if (typeof batchData == 'string')
             return this.invalidPacket(batchData);
         batchData.forEach(data => this.listenPacket(data, key));
@@ -202,8 +204,8 @@ class SonicWSCore {
      * @param tag The tag of the packet
      * @param values The values to send
      */
-    send(tag, ...values) {
-        const [code, data, packet] = (0, PacketUtils_1.processPacket)(this.clientPackets, tag, values);
+    async send(tag, ...values) {
+        const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.clientPackets, tag, values);
         if (packet.dataBatching == 0)
             this.raw_send((0, BufferUtil_1.toPacketBuffer)(code, data));
         else

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

@@ -1,19 +1,13 @@
 import { EnumPackage } from "../util/enums/EnumType";
 import { Packet } from "./Packets";
 import { PacketType } from "./PacketType";
-export type PacketTypeValidator = (data: Uint8Array, index: number) => false | any;
+export type PacketTypeValidator = (data: Uint8Array, index: number) => Promise<[Uint8Array, false | any]>;
 export type PacketReceiveProcessor = (data: Uint8Array, validationResult: any, index: number) => any;
-export type PacketSendProcessor = (...data: any) => number[];
-export declare function createValidator<T extends PacketType>(type: T, dataCap: number, dataMin: number, packet: Packet<T | T[]>): PacketTypeValidator;
+export type PacketSendProcessor = (ident: string, ...data: any[]) => Promise<Uint8Array>;
+export declare function createValidator<T extends PacketType>(type: T, dataCap: number, dataMin: number, packet: Packet<T | T[]>, gzipCompression: boolean, rereference: boolean): PacketTypeValidator;
 export declare function createReceiveProcessor(type: PacketType, enumData: EnumPackage[], cap: number): PacketReceiveProcessor;
 /** Creates a function that processes a packet type */
-export declare function createSendProcessor(type: PacketType): PacketSendProcessor;
+export declare function createSendProcessor(type: PacketType, gzipCompression: boolean, rereference: boolean): PacketSendProcessor;
 export declare function createObjSendProcessor(packet: Packet<PacketType[]>): PacketSendProcessor;
 export declare function createObjReceiveProcessor(packet: Packet<PacketType[]>): PacketReceiveProcessor;
 export declare function createObjValidator(packet: Packet<PacketType[]>): PacketTypeValidator;
-type BuildTuple<T, N extends number, R extends unknown[] = []> = R['length'] extends N ? R : BuildTuple<T, N, [T, ...R]>;
-export type PacketResponse<T extends PacketType | readonly PacketType[], N extends number | readonly number[]> = T extends PacketType[] ? N extends number[] ? PacketResponseArray<T, N> : never : BuildTuple<T extends PacketType.NONE ? undefined : T extends PacketType.RAW ? Uint8Array : T extends PacketType.BYTES | PacketType.UBYTES ? number : T extends PacketType.SHORTS | PacketType.USHORTS ? number : T extends PacketType.VARINT | PacketType.UVARINT | PacketType.DELTAS ? number : T extends PacketType.FLOATS | PacketType.DOUBLES ? number : T extends PacketType.BOOLEANS ? boolean : T extends PacketType.STRINGS_ASCII | PacketType.STRINGS_UTF16 ? string : T extends PacketType.ENUMS ? any : never, N extends number ? N : never>;
-type PacketResponseArray<T extends PacketType[], N extends number[]> = {
-    [K in keyof T]: K extends number ? PacketResponse<T[K], N[K] & number> : never;
-};
-export {};

package/dist/ws/packets/PacketProcessors.js

@@ -52,91 +52,127 @@ function VARINT_VERIF(cap, min) {
     };
 }
 ;
-function createValidator(type, dataCap, dataMin, packet) {
-    switch (type) {
-        case PacketType_1.PacketType.NONE: return (data) => data.length == 0;
-        case PacketType_1.PacketType.RAW: return () => undefined;
-        case PacketType_1.PacketType.ENUMS: return (data, index) => {
-            if (data.length < dataMin || data.length > dataCap || index >= packet.enumData.length)
-                return false;
-            const pkg = packet.enumData[index];
-            for (let i = 0; i < data.length; i++) {
-                if (pkg.values.length <= data[i])
+function createValidator(type, dataCap, dataMin, packet, gzipCompression, rereference) {
+    function genFunc() {
+        switch (type) {
+            case PacketType_1.PacketType.NONE: return (data) => data.length == 0;
+            case PacketType_1.PacketType.RAW: return () => undefined;
+            case PacketType_1.PacketType.ENUMS: return (data, index) => {
+                if (data.length < dataMin || data.length > dataCap || index >= packet.enumData.length)
                     return false;
-            }
-        };
-        case PacketType_1.PacketType.BYTES: return BYTE_LEN(dataCap, dataMin);
-        case PacketType_1.PacketType.UBYTES: return BYTE_LEN(dataCap, dataMin);
-        case PacketType_1.PacketType.SHORTS: return SHORT_LEN(dataCap, dataMin);
-        case PacketType_1.PacketType.USHORTS: return SHORT_LEN(dataCap, dataMin);
-        case PacketType_1.PacketType.VARINT: return VARINT_VERIF(dataCap, dataMin);
-        case PacketType_1.PacketType.UVARINT: return VARINT_VERIF(dataCap, dataMin);
-        case PacketType_1.PacketType.DELTAS: return VARINT_VERIF(dataCap, dataMin);
-        case PacketType_1.PacketType.FLOATS: return (data) => {
-            if (data.length % 4 !== 0)
-                return false;
-            const sectors = data.length * CompressionUtil_1.ONE_FOURTH;
-            if (sectors > dataCap || sectors < dataMin)
-                return false;
-            return undefined;
-        };
-        case PacketType_1.PacketType.DOUBLES: return (data) => {
-            if (data.length % 8 !== 0)
-                return false;
-            const sectors = data.length * CompressionUtil_1.ONE_EIGHT;
-            if (sectors > dataCap || sectors < dataMin)
-                return false;
-            return undefined;
-        };
-        case PacketType_1.PacketType.BOOLEANS:
-            {
-                const min = Math.ceil(dataMin * CompressionUtil_1.ONE_EIGHT);
-                const cap = Math.ceil(dataCap * CompressionUtil_1.ONE_EIGHT);
-                return (data) => data.length >= min && data.length <= cap;
-            }
-            ;
-        case PacketType_1.PacketType.STRINGS_ASCII: return (data) => {
-            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 (index + Math.ceil(totalLength / 8) > data.length)
-                return false;
-            return [stringCount, lengths, index];
-        };
-        case PacketType_1.PacketType.STRINGS_UTF16: return (data) => {
-            let sectors = 0, index = 0, computed = [];
-            while (index < data.length) {
-                sectors++;
-                if (sectors > dataCap)
+                const pkg = packet.enumData[index];
+                for (let i = 0; i < data.length; i++) {
+                    if (pkg.values.length <= data[i])
+                        return false;
+                }
+            };
+            case PacketType_1.PacketType.BYTES: return BYTE_LEN(dataCap, dataMin);
+            case PacketType_1.PacketType.UBYTES: return BYTE_LEN(dataCap, dataMin);
+            case PacketType_1.PacketType.HEX: return BYTE_LEN(dataCap, dataMin);
+            case PacketType_1.PacketType.SHORTS: return SHORT_LEN(dataCap, dataMin);
+            case PacketType_1.PacketType.USHORTS: return SHORT_LEN(dataCap, dataMin);
+            case PacketType_1.PacketType.VARINT: return VARINT_VERIF(dataCap, dataMin);
+            case PacketType_1.PacketType.UVARINT: return VARINT_VERIF(dataCap, dataMin);
+            case PacketType_1.PacketType.DELTAS: return VARINT_VERIF(dataCap, dataMin);
+            case PacketType_1.PacketType.FLOATS: return (data) => {
+                if (data.length % 4 !== 0)
+                    return false;
+                const sectors = data.length * CompressionUtil_1.ONE_FOURTH;
+                if (sectors > dataCap || sectors < dataMin)
+                    return false;
+                return undefined;
+            };
+            case PacketType_1.PacketType.DOUBLES: return (data) => {
+                if (data.length % 8 !== 0)
+                    return false;
+                const sectors = data.length * CompressionUtil_1.ONE_EIGHT;
+                if (sectors > dataCap || sectors < dataMin)
                     return false;
-                const [off, strLength] = (0, CompressionUtil_1.readVarInt)(data, index);
-                index = off;
-                let string = [];
-                for (let i = 0; i < strLength; i++) {
-                    const [newOff, char] = (0, CompressionUtil_1.readVarInt)(data, index);
-                    index = newOff;
-                    if (index > data.length)
+                return undefined;
+            };
+            case PacketType_1.PacketType.BOOLEANS:
+                {
+                    const min = Math.ceil(dataMin * CompressionUtil_1.ONE_EIGHT);
+                    const cap = Math.ceil(dataCap * CompressionUtil_1.ONE_EIGHT);
+                    return (data) => data.length >= min && data.length <= cap;
+                }
+                ;
+            case PacketType_1.PacketType.STRINGS_ASCII: return (data) => {
+                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 (index + Math.ceil(totalLength / 8) > data.length)
+                    return false;
+                return [stringCount, lengths, index];
+            };
+            case PacketType_1.PacketType.STRINGS_UTF16: return (data) => {
+                let sectors = 0, index = 0, computed = [];
+                while (index < data.length) {
+                    sectors++;
+                    if (sectors > dataCap)
                         return false;
-                    string.push(char);
+                    const [off, strLength] = (0, CompressionUtil_1.readVarInt)(data, index);
+                    index = off;
+                    let string = [];
+                    for (let i = 0; i < strLength; i++) {
+                        const [newOff, char] = (0, CompressionUtil_1.readVarInt)(data, index);
+                        index = newOff;
+                        if (index > data.length)
+                            return false;
+                        string.push(char);
+                    }
+                    computed.push(string);
+                }
+                if (sectors < dataMin)
+                    return false;
+                return computed;
+            };
+            case PacketType_1.PacketType.JSON: return (data) => {
+                try {
+                    return (0, CompressionUtil_1.decompressJSON)(data);
                 }
-                computed.push(string);
+                catch {
+                    return false;
+                }
+            };
+            default: throw new Error("Unknown type: " + type);
+        }
+    }
+    const fn = genFunc();
+    let parsed = null;
+    return gzipCompression
+        ? async (data, index) => {
+            if (rereference && data.length == 0) {
+                if (parsed == null)
+                    return [data, false];
+                return parsed;
             }
-            if (sectors < dataMin)
-                return false;
-            return computed;
+            try {
+                const dec = await (0, CompressionUtil_1.decompressGzip)(data);
+                return parsed = [dec, fn(dec, index)];
+            }
+            catch {
+                return [data, false];
+            }
+        }
+        : async (data, index) => {
+            if (rereference && data.length == 0) {
+                if (parsed == null)
+                    return [data, false];
+                return parsed;
+            }
+            return parsed = [data, fn(data, index)];
         };
-        default: throw new Error("Unknown type: " + type);
-    }
 }
 function createReceiveProcessor(type, enumData, cap) {
     switch (type) {
@@ -144,6 +180,7 @@ function createReceiveProcessor(type, enumData, cap) {
         case PacketType_1.PacketType.RAW: return (data) => data;
         case PacketType_1.PacketType.BYTES: return (data) => Array.from(data).map(CompressionUtil_1.demapZigZag);
         case PacketType_1.PacketType.UBYTES: return (data) => Array.from(data);
+        case PacketType_1.PacketType.HEX: return (data) => (0, CompressionUtil_1.bytesToHex)(data);
         case PacketType_1.PacketType.SHORTS: return (data) => (0, BufferUtil_1.splitBuffer)(data, 2).map(v => (0, CompressionUtil_1.demapShort_ZZ)(v));
         case PacketType_1.PacketType.USHORTS: return (data) => (0, BufferUtil_1.splitBuffer)(data, 2).map(v => (0, CompressionUtil_1.fromShort)(v));
         case PacketType_1.PacketType.VARINT: return (_, computed) => computed.map(CompressionUtil_1.demapZigZag);
@@ -170,64 +207,101 @@ function createReceiveProcessor(type, enumData, cap) {
             }
             return strings;
         };
-        case PacketType_1.PacketType.STRINGS_UTF16: return (data, computed) => {
+        case PacketType_1.PacketType.STRINGS_UTF16: return (_, computed) => {
             return computed.map(codes => String.fromCodePoint(...codes));
         };
+        case PacketType_1.PacketType.JSON: return (_, computed) => computed;
         default: throw new Error("Unknown type: " + type);
     }
 }
 /** Creates a function that processes a packet type */
-function createSendProcessor(type) {
-    switch (type) {
-        case PacketType_1.PacketType.NONE: return () => [];
-        case PacketType_1.PacketType.RAW: return (data) => Array.from(data);
-        case PacketType_1.PacketType.ENUMS: return (enums) => enums;
-        case PacketType_1.PacketType.BYTES: return (numbers) => numbers.map(CompressionUtil_1.mapZigZag);
-        case PacketType_1.PacketType.UBYTES: return (numbers) => numbers.map(CompressionUtil_1.toByte);
-        case PacketType_1.PacketType.SHORTS: return (numbers) => numbers.map(CompressionUtil_1.mapShort_ZZ).flat();
-        case PacketType_1.PacketType.USHORTS: return (numbers) => numbers.map(CompressionUtil_1.toShort).flat();
-        case PacketType_1.PacketType.VARINT: return (numbers) => numbers.map(n => (0, CompressionUtil_1.convertVarInt)((0, CompressionUtil_1.mapZigZag)(n))).flat();
-        case PacketType_1.PacketType.UVARINT: return (numbers) => numbers.map(CompressionUtil_1.convertVarInt).flat();
-        case PacketType_1.PacketType.DELTAS: return (numbers) => numbers.map((n, i) => (0, CompressionUtil_1.convertVarInt)((0, CompressionUtil_1.mapZigZag)(n - (numbers[i - 1] || 0)))).flat();
-        case PacketType_1.PacketType.FLOATS: return (singles) => singles.map(CompressionUtil_1.convertFloat).flat();
-        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) => {
-            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 = [];
-            for (const v of strings) {
-                const string = String(v);
-                const charCodes = (0, StringUtil_1.processCharCodes)(string);
-                // hate js man
-                const length = charCodes.length;
-                res.push(...(0, CompressionUtil_1.convertVarInt)(length));
-                res.push(...charCodes.map(CompressionUtil_1.convertVarInt).flat());
+function createSendProcessor(type, gzipCompression, rereference) {
+    function genFunc() {
+        switch (type) {
+            case PacketType_1.PacketType.NONE: return () => [];
+            case PacketType_1.PacketType.RAW: return (data) => Array.from(data);
+            case PacketType_1.PacketType.ENUMS: return (enums) => enums;
+            case PacketType_1.PacketType.BYTES: return (numbers) => numbers.map(CompressionUtil_1.mapZigZag);
+            case PacketType_1.PacketType.UBYTES: return (numbers) => numbers.map(CompressionUtil_1.toByte);
+            case PacketType_1.PacketType.HEX: return (hex) => {
+                if (typeof hex != "string") {
+                    if (hex instanceof Array && hex.length == 1)
+                        return (0, CompressionUtil_1.hexToBytes)(hex[0]);
+                    throw new Error("Cannot send more than 1 hex string; this packet is equivalent to UBYTES: " + JSON.stringify(hex));
+                }
+                return (0, CompressionUtil_1.hexToBytes)(hex);
+            };
+            case PacketType_1.PacketType.SHORTS: return (numbers) => numbers.map(CompressionUtil_1.mapShort_ZZ).flat();
+            case PacketType_1.PacketType.USHORTS: return (numbers) => numbers.map(CompressionUtil_1.toShort).flat();
+            case PacketType_1.PacketType.VARINT: return (numbers) => numbers.map(n => (0, CompressionUtil_1.convertVarInt)((0, CompressionUtil_1.mapZigZag)(n))).flat();
+            case PacketType_1.PacketType.UVARINT: return (numbers) => numbers.map(CompressionUtil_1.convertVarInt).flat();
+            case PacketType_1.PacketType.DELTAS: return (numbers) => numbers.map((n, i) => (0, CompressionUtil_1.convertVarInt)((0, CompressionUtil_1.mapZigZag)(n - (numbers[i - 1] || 0)))).flat();
+            case PacketType_1.PacketType.FLOATS: return (singles) => singles.map(CompressionUtil_1.convertFloat).flat();
+            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) => {
+                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 = [];
+                for (const v of strings) {
+                    const string = String(v);
+                    const charCodes = (0, StringUtil_1.processCharCodes)(string);
+                    // hate js man
+                    const length = charCodes.length;
+                    res.push(...(0, CompressionUtil_1.convertVarInt)(length));
+                    res.push(...charCodes.map(CompressionUtil_1.convertVarInt).flat());
+                }
+                return res;
+            };
+            case PacketType_1.PacketType.JSON: return (value) => Array.from((0, CompressionUtil_1.compressJSON)(value));
+            default: throw new Error("Unknown type: " + type);
+        }
+    }
+    const fn = genFunc();
+    let lastSent;
+    if (!gzipCompression) {
+        return async (_, data) => {
+            if (rereference) {
+                const jstr = JSON.stringify(data);
+                if (jstr == lastSent) {
+                    return CompressionUtil_1.EMPTY_UINT8;
+                }
+                lastSent = jstr;
             }
-            return res;
+            return new Uint8Array(fn(data));
         };
-        default: throw new Error("Unknown type: " + type);
     }
+    return async (ident, data) => {
+        if (rereference) {
+            const jstr = JSON.stringify(data);
+            if (jstr == lastSent) {
+                return CompressionUtil_1.EMPTY_UINT8;
+            }
+            lastSent = jstr;
+        }
+        return (0, CompressionUtil_1.compressGzip)(new Uint8Array(fn(data)), ident);
+    };
 }
 function createObjSendProcessor(packet) {
     const size = packet.type.length;
-    const processors = packet.type.map(t => createSendProcessor(t));
-    return (data) => {
+    // TODO: Add compression and add rereferences[]
+    const processors = packet.type.map(t => createSendProcessor(t, false, false));
+    return async (ident, data) => {
         let result = [];
         for (let i = 0; i < size; i++) {
             const sectorData = data[i];
-            const d = processors[i](Array.isArray(sectorData) ? sectorData : [sectorData]);
+            const d = await processors[i](ident, Array.isArray(sectorData) ? sectorData : [sectorData]);
             if (d.length > CompressionUtil_1.MAX_UVARINT)
                 throw new Error(`Cannot send ${d.length}/${CompressionUtil_1.MAX_UVARINT} bytes of data!`);
             result.push(...(0, CompressionUtil_1.convertVarInt)(d.length));
             d.forEach(val => result.push(val));
         }
-        return result;
+        return new Uint8Array(result);
     };
 }
 function createObjReceiveProcessor(packet) {
@@ -247,22 +321,22 @@ function createObjReceiveProcessor(packet) {
     };
 }
 function createObjValidator(packet) {
-    const validators = packet.type.map((t, i) => createValidator(t, packet.dataMax[i], packet.dataMin[i], packet));
-    return (data) => {
+    const validators = packet.type.map((t, i) => createValidator(t, packet.dataMax[i], packet.dataMin[i], packet, false, false));
+    return async (data) => {
         let index = 0, enums = 0, computedData = [];
         while (index < data.length) {
             if (computedData.length > packet.type.length)
-                return false; // only types amount of values
+                return [data, false]; // only types amount of values
             const [off, sectorLength] = (0, CompressionUtil_1.readVarInt)(data, index);
             index = off;
             if (sectorLength + index > data.length)
-                return false;
+                return [data, false];
             const sector = data.subarray(index, index += sectorLength);
-            const result = validators[computedData.length](sector, packet.type[computedData.length] == PacketType_1.PacketType.ENUMS ? enums++ : 0);
+            const [, result] = await validators[computedData.length](sector, packet.type[computedData.length] == PacketType_1.PacketType.ENUMS ? enums++ : 0);
             if (result === false)
-                return false; // chat i used === to fix a bug !!!!
+                return [data, false]; // chat i used === to fix a bug !!!!
             computedData.push(result);
         }
-        return computedData;
+        return [data, computedData];
     };
 }

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

@@ -31,5 +31,11 @@ export declare enum PacketType {
     /** One or more double precision floating point numbers. */
     DOUBLES = 13,
     /** One or more true/false */
-    BOOLEANS = 14
+    BOOLEANS = 14,
+    /** Consumes multiple keys to describe the value. E.g. if you want to send a boolean, this could take up 2 keys instead of sending 2 bytes. Currently W.I.P. */
+    KEY_EFFECTIVE = 15,
+    /** A more optimized version of JSON for when it's a necessity. However, please try to avoid this; the other types are usually better. */
+    JSON = 16,
+    /** Hex bytes, e.g. 0xFFFFFF - the result will always be returned in lowercase. This can only hold 1 hex string, since it's the same as UBYTES but auto-parses. */
+    HEX = 17
 }

package/dist/ws/packets/PacketType.js

@@ -52,4 +52,10 @@ var PacketType;
     PacketType[PacketType["DOUBLES"] = 13] = "DOUBLES";
     /** One or more true/false */
     PacketType[PacketType["BOOLEANS"] = 14] = "BOOLEANS";
+    /** Consumes multiple keys to describe the value. E.g. if you want to send a boolean, this could take up 2 keys instead of sending 2 bytes. Currently W.I.P. */
+    PacketType[PacketType["KEY_EFFECTIVE"] = 15] = "KEY_EFFECTIVE";
+    /** A more optimized version of JSON for when it's a necessity. However, please try to avoid this; the other types are usually better. */
+    PacketType[PacketType["JSON"] = 16] = "JSON";
+    /** Hex bytes, e.g. 0xFFFFFF - the result will always be returned in lowercase. This can only hold 1 hex string, since it's the same as UBYTES but auto-parses. */
+    PacketType[PacketType["HEX"] = 17] = "HEX";
 })(PacketType || (exports.PacketType = PacketType = {}));