sonic-ws 1.0.0-beta.9 → 1.0.0-rc.0-patch

package/README.md

@@ -4,11 +4,11 @@
 
 WebSocket library focused on bandwidth efficiency and security.
 
-It can reduce packet size by up to 70% or more and process large packets in microseconds.
+It can reduce packet size by up to 70% or more and validate and process large packets in microseconds.
 
 It has low latency and optimized data transfer.
 
-While still simple and efficient, SonicWS provides efficient packet transfers.
+Helper functions for frequent cases are included to reduce dev boilerplate.
 
 ## SAMPLES
 
@@ -26,8 +26,8 @@ Browser (Client):
 ### Server:
 ```js
 const wss = new SonicWSServer(
-    [CreatePacket("pong", PacketType.INTS_D, 1)], // client-sent packets
-    [CreatePacket("ping", PacketType.INTS_D, 1), CreateObjPacket("data", [PacketType.INTS_A, PacketTypes.STRING], [2, 3])], // server-sent packets
+    [CreatePacket({tag: "pong", type: PacketType.INTS_D, dataMax: 1})], // client-sent packets
+    [CreatePacket({tag: "ping", type: PacketType.INTS_D, dataMax: 1}), CreateObjPacket({tag: "data", types: [PacketType.INTS_A, PacketTypes.STRING], dataMaxes: [2, 3]})], // server-sent packets
     { port: 1234 }
 );
 

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

@@ -11,12 +11,16 @@ export declare abstract class SonicWSCore {
     };
     protected preListen: {
         [key: string]: Array<(value: string) => void>;
-    };
+    } | null;
     protected clientPackets: PacketHolder;
     protected serverPackets: PacketHolder;
     private pastKeys;
     private readyListeners;
     private keyHandler;
+    private rateLimitTimeout;
+    private rateLimit;
+    private sentPackets;
+    private sendQueue;
     constructor(ws: WebSocket);
     private serverKeyHandler;
     private messageHandler;

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

@@ -1,4 +1,13 @@
 "use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SonicWSCore = void 0;
 var PacketHolder_1 = require("../../util/PacketHolder");
@@ -14,6 +23,10 @@ var SonicWSCore = /** @class */ (function () {
         this.serverPackets = PacketHolder_1.PacketHolder.empty();
         this.pastKeys = false;
         this.readyListeners = [];
+        this.rateLimitTimeout = -1;
+        this.rateLimit = -1;
+        this.sentPackets = 0;
+        this.sendQueue = [];
         this.ws = ws;
         this.listeners = {
             message: [],
@@ -25,6 +38,8 @@ var SonicWSCore = /** @class */ (function () {
         this.ws.addEventListener('message', this.keyHandler); // lambda to persist 'this'
         this.ws.addEventListener('close', function (event) {
             _this.listeners.close.forEach(function (listener) { return listener(event); });
+            if (_this.rateLimit != 0 && _this.rateLimitTimeout != -1)
+                clearInterval(_this.rateLimitTimeout);
         });
     }
     SonicWSCore.prototype.serverKeyHandler = function (event) {
@@ -39,9 +54,18 @@ var SonicWSCore = /** @class */ (function () {
             this.ws.close(1003);
             throw new Error("Version mismatch: ".concat(version > version_1.VERSION ? "client" : "server", " is outdated (server: ").concat(version, ", client: ").concat(version_1.VERSION, ")"));
         }
-        var _a = data.substring(4).split(CodePointUtil_1.NULL), ckData = _a[0], skData = _a[1];
-        this.clientPackets.createPackets(Packets_1.Packet.deserializeAll(ckData));
-        this.serverPackets.createPackets(Packets_1.Packet.deserializeAll(skData));
+        var _a = data.substring(4).split(CodePointUtil_1.NULL), ckData = _a[0], skData = _a[1], rateLimit = _a[2];
+        this.clientPackets.createPackets(Packets_1.Packet.deserializeAll(ckData, true));
+        this.serverPackets.createPackets(Packets_1.Packet.deserializeAll(skData, true));
+        this.rateLimit = rateLimit.charCodeAt(0);
+        if (this.rateLimit != 0) {
+            this.rateLimitTimeout = setInterval(function () {
+                _this.sentPackets = 0;
+                var toSend = __spreadArray([], _this.sendQueue, true);
+                _this.sendQueue = [];
+                toSend.forEach(function (p) { return _this.raw_send(p); });
+            }, 1000);
+        }
         Object.keys(this.preListen).forEach(function (tag) { return _this.preListen[tag].forEach(function (listener) {
             var key = _this.serverPackets.get(tag);
             // print the error to console without halting execution
@@ -51,10 +75,13 @@ var SonicWSCore = /** @class */ (function () {
             var packetListener = new PacketListener_1.PacketListener(packet, listener);
             _this.listen(tag, packetListener);
         }); });
+        this.preListen = null; // clear
         this.pastKeys = true;
         this.readyListeners.forEach(function (l) { return l(); });
+        this.readyListeners = null; // clear
         this.ws.removeEventListener('message', this.keyHandler);
         this.ws.addEventListener('message', function (event) { return _this.messageHandler(event); }); // lambda to persist 'this'
+        this.keyHandler = null;
     };
     SonicWSCore.prototype.messageHandler = function (event) {
         var _a;
@@ -65,14 +92,14 @@ var SonicWSCore = /** @class */ (function () {
         var key = data.substring(0, 1);
         var value = data.substring(1);
         var code = key.charCodeAt(0);
-        if (code != null) {
-            (_a = this.listeners.event[code]) === null || _a === void 0 ? void 0 : _a.forEach(function (l) {
-                var result = l.listen(value);
-                if (!result) {
-                    throw new Error("An error occured with data from the server!! This is probably my fault.. make an issue at https://github.com/cutelittlelily/sonic-ws");
-                }
-            });
+        if (code == null)
+            return;
+        var result = this.serverPackets.getPacket(this.serverPackets.getTag(key)).listen(value);
+        if (result == null) {
+            throw new Error("An error occured with data from the server!! This is probably my fault.. make an issue at https://github.com/cutelittlelily/sonic-ws");
         }
+        var processed = result[0], isArray = result[1];
+        (_a = this.listeners.event[code]) === null || _a === void 0 ? void 0 : _a.forEach(function (l) { return l.listen(processed, isArray); });
     };
     SonicWSCore.prototype.listen = function (key, listener) {
         var skey = this.serverPackets.get(key);
@@ -88,6 +115,12 @@ var SonicWSCore = /** @class */ (function () {
         this.listeners.message.push(listener);
     };
     SonicWSCore.prototype.raw_send = function (data) {
+        if (this.rateLimit == -1)
+            return console.error("A rate limit has not been received by the server!");
+        if (this.rateLimit != 0 && ++this.sentPackets > this.rateLimit) {
+            this.sendQueue.push(data);
+            return console.warn("Client is emitting more packets than the rate limit! Current queue size: ".concat(this.sendQueue.length));
+        }
         this.ws.send(data);
     };
     SonicWSCore.prototype.send = function (tag) {

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

@@ -1,20 +1,20 @@
-import { EnumPackage, EnumValue } from "./EnumType";
+import { EnumPackage } from "./EnumType";
 export declare const MAX_ENUM_SIZE = 128;
-export declare const ENUM_TAG_TO_KEY: Record<string, Record<string, number>>;
-export declare const ENUM_KEY_TO_TAG: Record<string, Record<number, string>>;
+export declare const ENUM_TAG_TO_KEY: Record<string, Record<any, number>>;
+export declare const ENUM_KEY_TO_TAG: Record<string, Record<number, any>>;
 /**
  * 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
  */
-export declare function DefineEnum(tag: string, values: string[]): EnumPackage;
+export declare function DefineEnum(tag: string, values: any[]): EnumPackage;
 /**
  * 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
  */
-export declare function WrapEnum(tag: string, value: string): EnumValue;
+export declare function WrapEnum(tag: string, value: any): string;
 export declare function fromIndex(tag: string, index: number): string;
 export declare function fromEncoded(tag: string, encoded: string): string;

package/dist/ws/enums/EnumHandler.js

@@ -31,7 +31,7 @@ function DefineEnum(tag, values) {
 function WrapEnum(tag, value) {
     if (!(value in exports.ENUM_TAG_TO_KEY[tag]))
         throw new Error("Value \"".concat(value, "\" does not exist in enum \"").concat(tag, "\""));
-    return new EnumType_1.EnumValue(tag, exports.ENUM_TAG_TO_KEY[tag][value]);
+    return String.fromCharCode(exports.ENUM_TAG_TO_KEY[tag][value]);
 }
 function fromIndex(tag, index) {
     return exports.ENUM_KEY_TO_TAG[tag][index];

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

@@ -1,12 +1,7 @@
-export declare class EnumValue {
-    tag: string;
-    index: number;
-    encoded: string;
-    constructor(tag: string, index: number);
-}
+export declare const TYPE_CONVERSION_MAP: Record<number, (data: string) => string | number | boolean | undefined | null>;
 export declare class EnumPackage {
     tag: string;
-    values: string[];
-    constructor(tag: string, values: string[]);
+    values: any[];
+    constructor(tag: string, values: any[]);
     serialize(): string;
 }

package/dist/ws/enums/EnumType.js

@@ -1,22 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumPackage = exports.EnumValue = void 0;
-var EnumValue = /** @class */ (function () {
-    function EnumValue(tag, index) {
-        this.tag = tag;
-        this.index = index;
-        this.encoded = String.fromCharCode(index);
-    }
-    return EnumValue;
-}());
-exports.EnumValue = EnumValue;
+exports.EnumPackage = exports.TYPE_CONVERSION_MAP = void 0;
+var TYPE_INDEX_MAP = {
+    'string': 0,
+    'number': 1,
+    'boolean': 2,
+    'undefined': 3,
+    'object': 4, // to handle null bug
+};
+exports.TYPE_CONVERSION_MAP = {
+    0: function (d) { return d; },
+    1: function (d) { return parseFloat(d); },
+    2: function (d) { return d == 'true'; },
+    3: function () { return undefined; },
+    4: function () { return null; },
+};
+function getTypedIndex(data) {
+    var type = typeof data;
+    if (!(type in TYPE_INDEX_MAP) && data != null)
+        throw new Error("Cannot serialize type \"".concat(type, "\" in an enum!"));
+    return TYPE_INDEX_MAP[type];
+}
 var EnumPackage = /** @class */ (function () {
     function EnumPackage(tag, values) {
         this.tag = tag;
         this.values = values;
     }
     EnumPackage.prototype.serialize = function () {
-        return String.fromCharCode(this.tag.length + 1) + this.tag + String.fromCharCode(this.values.length + 1) + this.values.map(function (v) { return String.fromCharCode(v.length + 1) + v; }).join("");
+        return String.fromCharCode(this.tag.length + 1) + // tag length
+            this.tag + // tag
+            String.fromCharCode(this.values.length + 1) + // value count
+            this.values.map(function (v) {
+                return String.fromCharCode(String(v).length + 1) + // value length
+                    String.fromCharCode(getTypedIndex(v) + 1) + // value type
+                    v;
+            } // value
+            ).join("");
     };
     return EnumPackage;
 }());

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

@@ -3,5 +3,5 @@ export declare class PacketListener {
     private listener;
     private packet;
     constructor(packet: Packet, listener: (...data: any[]) => void);
-    listen(value: string): boolean;
+    listen(processed: any, isArray: boolean): boolean;
 }

package/dist/ws/packets/PacketListener.js

@@ -6,18 +6,8 @@ var PacketListener = /** @class */ (function () {
         this.listener = listener;
         this.packet = packet;
     }
-    PacketListener.prototype.listen = function (value) {
-        var processed;
-        try {
-            if (!this.packet.validate(value))
-                return false;
-            processed = this.packet.processReceive(value);
-        }
-        catch (err) {
-            console.error("There was an error processing the packet! This is probably my fault... report at https://github.com/cutelittlelily/sonic-ws", err);
-            return false;
-        }
-        if (Array.isArray(processed) && !this.packet.dontSpread)
+    PacketListener.prototype.listen = function (processed, isArray) {
+        if (isArray && !this.packet.dontSpread)
             this.listener.apply(this, processed);
         else
             this.listener(processed);

package/dist/ws/packets/PacketProcessors.js

@@ -22,7 +22,7 @@ var LEN_DELIMIT = function (data, cap) {
     return true;
 };
 exports.PacketValidityProcessors = (_a = {},
-    _a[PacketType_1.PacketType.NONE] = function (data) { return data == ""; },
+    _a[PacketType_1.PacketType.NONE] = function (data) { return data.length == 0; },
     _a[PacketType_1.PacketType.RAW] = function () { return true; },
     _a[PacketType_1.PacketType.STRINGS] = LEN_DELIMIT,
     _a[PacketType_1.PacketType.ENUMS] = function (data, cap, packet, index) {
@@ -40,15 +40,16 @@ exports.PacketValidityProcessors = (_a = {},
     _a[PacketType_1.PacketType.INTS_A] = LEN_DELIMIT,
     _a[PacketType_1.PacketType.DECIMALS] = function (data, cap) {
         var sectors = 0;
-        for (var i = 0; i < data.length; i++) {
+        for (var i = 0; i < data.length;) {
             sectors++;
             if (sectors > cap)
                 return false;
-            var len = data.charCodeAt(i);
-            i += len + 1;
+            var sectorBits = data.charCodeAt(i++);
+            var len = sectorBits >> 7;
+            var len2 = sectorBits & 0x7F;
+            i += len;
             if (i > data.length)
                 return false;
-            var len2 = data.charCodeAt(i);
             i += len2;
             if (i > data.length)
                 return false;
@@ -91,10 +92,11 @@ exports.PacketReceiveProcessors = (_b = {},
         var points = (0, CodePointUtil_1.processCharCodes)(data);
         var numbers = [];
         for (var i = 0; i < points.length;) {
-            var wholeSS = points[i++];
+            var sectorBits = points[i++];
+            var wholeSS = sectorBits >> 7;
+            var decimalSS = sectorBits & 0x7F;
             var whole = (0, CodePointUtil_1.deconvertINT_DCodes)(points.slice(i, i + wholeSS));
             i += wholeSS;
-            var decimalSS = points[i++];
             var decimal = (0, CodePointUtil_1.deconvertINT_DCodes)(points.slice(i, i + decimalSS));
             i += decimalSS;
             numbers.push(parseFloat(whole + "." + decimal));
@@ -119,7 +121,7 @@ exports.PacketSendProcessors = (_c = {},
         for (var _i = 0; _i < arguments.length; _i++) {
             enums[_i] = arguments[_i];
         }
-        return enums.map(function (v) { return v.encoded; }).join("");
+        return enums.join("");
     },
     _c[PacketType_1.PacketType.INTS_C] = function () {
         var numbers = [];
@@ -158,7 +160,8 @@ exports.PacketSendProcessors = (_c = {},
             var decimal = split.length > 1 ? parseFloat(split[1]) || 0 : 0;
             var wholeSS = (0, CodePointUtil_1.sectorSize)(whole);
             var decimalSS = (0, CodePointUtil_1.sectorSize)(decimal);
-            return String.fromCharCode(wholeSS) + (0, CodePointUtil_1.convertINT_D)(whole, wholeSS) + String.fromCharCode(decimalSS) + (0, CodePointUtil_1.convertINT_D)(decimal, decimalSS);
+            var num = (wholeSS << 7) | decimalSS;
+            return String.fromCharCode(num) + (0, CodePointUtil_1.convertINT_D)(whole, wholeSS) + (0, CodePointUtil_1.convertINT_D)(decimal, decimalSS);
         }).join("");
     },
     _c[PacketType_1.PacketType.BOOLEANS] = function () {

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

@@ -1,3 +1,4 @@
+/** All different packet types. Use ENUMS for any constant primitive data */
 export declare enum PacketType {
     /** No data */
     NONE = 0,
@@ -5,7 +6,7 @@ export declare enum PacketType {
     RAW = 1,
     /** String data; use ENUMS if the values are constant  */
     STRINGS = 2,
-    /** Constant strings */
+    /** Constant primitive data; strings, numbers, booleans, null, undefined */
     ENUMS = 3,
     /** One or more numbers from -27,648 to 27,647 */
     INTS_C = 4,

package/dist/ws/packets/PacketType.js

@@ -1,7 +1,8 @@
 "use strict";
+// separated file to allow imports
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PacketType = void 0;
-// separated file to allow imports
+/** All different packet types. Use ENUMS for any constant primitive data */
 var PacketType;
 (function (PacketType) {
     /** No data */
@@ -10,7 +11,7 @@ var PacketType;
     PacketType[PacketType["RAW"] = 1] = "RAW";
     /** String data; use ENUMS if the values are constant  */
     PacketType[PacketType["STRINGS"] = 2] = "STRINGS";
-    /** Constant strings */
+    /** Constant primitive data; strings, numbers, booleans, null, undefined */
     PacketType[PacketType["ENUMS"] = 3] = "ENUMS";
     /** One or more numbers from -27,648 to 27,647 */
     PacketType[PacketType["INTS_C"] = 4] = "INTS_C";

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

@@ -2,11 +2,13 @@ import { EnumPackage } from "../enums/EnumType";
 import { PacketType } from "./PacketType";
 export declare class Packet {
     tag: string;
-    size: number;
+    maxSize: number;
+    minSize: number;
     type: PacketType | PacketType[];
-    dataCap: number | number[];
-    dontSpread: boolean;
     enumData: EnumPackage[];
+    dataMax: number | number[];
+    dataMin: number | number[];
+    dontSpread: boolean;
     object: boolean;
     private receiveProcessor;
     private sendProcessor;
@@ -14,20 +16,23 @@ export declare class Packet {
     processReceive: (data: string) => any;
     processSend: (data: any[]) => string;
     validate: (data: string) => boolean;
-    constructor(tag: string, schema: PacketSchema);
+    constructor(tag: string, schema: PacketSchema, client: boolean);
+    listen(value: string): [processed: any, isArray: boolean] | null;
     serialize(): string;
-    static deserialize(text: string, offset: number): [packet: Packet, offset: number];
-    static deserializeAll(text: string): Packet[];
+    static deserialize(text: string, offset: number, client: boolean): [packet: Packet, offset: number];
+    static deserializeAll(text: string, client: boolean): Packet[];
 }
 export declare class PacketSchema {
     types: PacketType[];
-    dataCaps: number[];
-    enumData: EnumPackage[];
+    dataMaxes: number[];
+    dataMins: number[];
     type: PacketType;
-    dataCap: number;
+    dataMax: number;
+    dataMin: number;
+    enumData: EnumPackage[];
     dontSpread: boolean;
     object: boolean;
     constructor(object: boolean);
-    static single(type: PacketType | EnumPackage, dataCap: number, dontSpread: boolean): PacketSchema;
-    static object(types: (PacketType | EnumPackage)[], dataCaps: number[], dontSpread: boolean): PacketSchema;
+    static single(type: PacketType | EnumPackage, dataMax: number, dataMin: number, dontSpread: boolean): PacketSchema;
+    static object(types: (PacketType | EnumPackage)[], dataMaxes: number[], dataMins: number[], dontSpread: boolean): PacketSchema;
 }

package/dist/ws/packets/Packets.js

@@ -2,17 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PacketSchema = exports.Packet = void 0;
 var EnumHandler_1 = require("../enums/EnumHandler");
+var EnumType_1 = require("../enums/EnumType");
 var CodePointUtil_1 = require("../util/CodePointUtil");
 var PacketProcessors_1 = require("./PacketProcessors");
 var PacketType_1 = require("./PacketType");
 var Packet = /** @class */ (function () {
-    function Packet(tag, schema) {
+    function Packet(tag, schema, client) {
         var _this = this;
         this.tag = tag;
         if (schema.object) {
             this.type = schema.types;
-            this.dataCap = schema.dataCaps;
-            this.size = this.type.length;
+            this.dataMax = schema.dataMaxes;
+            this.dataMin = schema.dataMins;
+            this.maxSize = this.type.length;
+            this.minSize = this.type.length;
             this.object = true;
             this.receiveProcessor = (0, PacketProcessors_1.createObjReceiveProcesor)(this.type);
             this.validifier = (0, PacketProcessors_1.createObjValidator)(this.type);
@@ -27,8 +30,10 @@ var Packet = /** @class */ (function () {
         }
         else {
             this.type = schema.type;
-            this.dataCap = schema.dataCap;
-            this.size = this.dataCap;
+            this.dataMax = schema.dataMax;
+            this.dataMin = schema.dataMin;
+            this.maxSize = this.dataMax;
+            this.minSize = this.dataMin;
             this.object = false;
             this.receiveProcessor = PacketProcessors_1.PacketReceiveProcessors[this.type];
             this.validifier = PacketProcessors_1.PacketValidityProcessors[this.type];
@@ -41,11 +46,27 @@ var Packet = /** @class */ (function () {
                 return _this.sendProcessor.apply(_this, data.flat());
             };
         }
-        this.processReceive = function (data) { return _this.receiveProcessor(data, _this.dataCap, _this, 0); };
-        this.validate = function (data) { return _this.validifier(data, _this.dataCap, _this, 0); };
+        this.processReceive = function (data) { return _this.receiveProcessor(data, _this.dataMax, _this, 0); };
+        this.validate = client ? function () { return true; } : function (data) { return _this.validifier(data, _this.dataMax, _this, 0); };
         this.enumData = schema.enumData;
         this.dontSpread = schema.dontSpread;
     }
+    Packet.prototype.listen = function (value) {
+        var processed, isArray;
+        try {
+            if (!this.validate(value))
+                return null;
+            processed = this.processReceive(value);
+            isArray = Array.isArray(processed);
+            if (isArray && processed.length < this.dataMin)
+                return null;
+        }
+        catch (err) {
+            console.error("There was an error processing the packet! This is probably my fault... report at https://github.com/cutelittlelily/sonic-ws", err);
+            return null;
+        }
+        return [processed, isArray];
+    };
     Packet.prototype.serialize = function () {
         // spread flag; ETX for "2", STX for "1", avoid NULL for delimiting
         var spreadFlag = this.dontSpread ? CodePointUtil_1.ETX : CodePointUtil_1.STX;
@@ -55,23 +76,26 @@ var Packet = /** @class */ (function () {
         if (!this.object) {
             return spreadFlag + enumData +
                 CodePointUtil_1.STX + // dummy byte flag for consistent deserialization; becomes -1 to indicate single
-                String.fromCharCode(this.dataCap + 1) + // the data cap, offset by 1 for NULL
+                String.fromCharCode(this.dataMax + 1) + // the data max, offset by 1 for NULL
+                String.fromCharCode(this.dataMin + 1) + // the data min, offset by 1 for NULL
                 String.fromCharCode(this.type + 1) + // the type, offset by 1 for NULL
                 String.fromCharCode(this.tag.length + 1) + // tag length, offset by 1 for NULL
                 this.tag; // the tag
         }
         // object packet
         return spreadFlag + enumData +
-            String.fromCharCode(this.size + 2) + // size, and +2 because of NULL and STX (STX is for single)
+            String.fromCharCode(this.maxSize + 2) + // size, and +2 because of NULL and STX (STX is for single)
          String.fromCharCode.apply(// size, and +2 because of NULL and STX (STX is for single)
-        String, this.dataCap.map(function (x) { return x + 1; })) + // all data caps, offset by 1 for NULL
-         String.fromCharCode.apply(// all data caps, offset by 1 for NULL
+        String, this.dataMax.map(function (x) { return x + 1; })) + // all data maxes, offset by 1 for NULL
+         String.fromCharCode.apply(// all data maxes, offset by 1 for NULL
+        String, this.dataMin.map(function (x) { return x + 1; })) + // all data mins, offset by 1 for NULL
+         String.fromCharCode.apply(// all data mins, offset by 1 for NULL
         String, this.type.map(function (x) { return x + 1; })) + // all types, offset by 1 for NULL
             String.fromCharCode(this.tag.length + 1) + // tag length, offset by 1 for NULL
             this.tag; // the tag
     };
     // i think i was high when i made these
-    Packet.deserialize = function (text, offset) {
+    Packet.deserialize = function (text, offset, client) {
         var beginningOffset = offset;
         var dontSpread = text[offset] == CodePointUtil_1.ETX;
         var enumLength = text.charCodeAt(++offset) - 1;
@@ -84,9 +108,10 @@ var Packet = /** @class */ (function () {
             var values = [];
             for (var j = 0; j < valueCount; j++) {
                 var valueLength = text.charCodeAt(++offset) - 1;
+                var valueType = text.charCodeAt(++offset) - 1;
                 var value = text.slice(++offset, offset += valueLength);
                 offset--;
-                values.push(value);
+                values.push(EnumType_1.TYPE_CONVERSION_MAP[valueType](value));
             }
             enums.push((0, EnumHandler_1.DefineEnum)(enumTag, values));
         }
@@ -94,39 +119,43 @@ var Packet = /** @class */ (function () {
         // objects
         // the single packet is STX so STX - 2 = -1
         if (size != -1) {
-            var dcStart = ++offset; // data caps section start
-            var dcEnd = dcStart + size; // data caps section end
-            var tStart = dcEnd; // types section start
+            var dcStart = ++offset; // data maxes section start
+            var dcEnd = dcStart + size; // data maxes section end
+            var dmStart = dcEnd; // data mins section start
+            var dmEnd = dmStart + size; // data mins section end
+            var tStart = dmEnd; // types section start
             var tEnd = tStart + size; // types section end
             var tagStart_1 = tEnd + 1; // tag string starts after tag length byte
-            var dataCaps = (0, CodePointUtil_1.processCharCodes)(text.substring(dcStart, dcEnd)).map(function (x) { return x - 1; }); // subtract 1 to reverse
+            var dataMaxes = (0, CodePointUtil_1.processCharCodes)(text.substring(dcStart, dcEnd)).map(function (x) { return x - 1; }); // subtract 1 to reverse
+            var dataMins = (0, CodePointUtil_1.processCharCodes)(text.substring(dmStart, dmEnd)).map(function (x) { return x - 1; }); // subtract 1 to reverse
             var types = (0, CodePointUtil_1.processCharCodes)(text.substring(tStart, tEnd)).map(function (x) { return x - 1; }); // subtract 1 to reverse
             var index_1 = 0;
             var finalTypes = types.map(function (x) { return x == PacketType_1.PacketType.ENUMS ? enums[index_1++] : x; }); // convert enums to their enum packages
             var tagLength_1 = text.charCodeAt(tagStart_1 - 1) - 1; // tag length is right behind tag, subtracting 1 to reverse
             var tag_1 = text.substring(tagStart_1, tagStart_1 + tagLength_1); // tag is tag length long. yeah
             return [
-                new Packet(tag_1, PacketSchema.object(finalTypes, dataCaps, dontSpread)),
-                (offset - beginningOffset) + 1 + size + size + tagLength_1
+                new Packet(tag_1, PacketSchema.object(finalTypes, dataMaxes, dataMins, dontSpread), client),
+                (offset - beginningOffset) + 1 + size + size + size + tagLength_1
             ];
         }
         // single packet; subtracting 1 to revere.
-        var dataCap = text.charCodeAt(++offset) - 1;
+        var dataMax = text.charCodeAt(++offset) - 1;
+        var dataMin = text.charCodeAt(++offset) - 1;
         var type = (text.charCodeAt(++offset) - 1);
         var finalType = type == PacketType_1.PacketType.ENUMS ? enums[0] : type; // convert enum to enum package
         var tagStart = ++offset;
         var tagLength = text.charCodeAt(tagStart) - 1;
         var tag = text.substring(tagStart + 1, tagStart + 1 + tagLength);
         return [
-            new Packet(tag, PacketSchema.single(finalType, dataCap, dontSpread)),
+            new Packet(tag, PacketSchema.single(finalType, dataMax, dataMin, dontSpread), client),
             (offset - beginningOffset) + 1 + tagLength
         ];
     };
-    Packet.deserializeAll = function (text) {
+    Packet.deserializeAll = function (text, client) {
         var arr = [];
         var offset = 0;
         while (offset < text.length) {
-            var _a = this.deserialize(text, offset), packet = _a[0], len = _a[1];
+            var _a = this.deserialize(text, offset, client), packet = _a[0], len = _a[1];
             arr.push(packet);
             offset += len;
         }
@@ -138,14 +167,16 @@ exports.Packet = Packet;
 var PacketSchema = /** @class */ (function () {
     function PacketSchema(object) {
         this.types = [];
-        this.dataCaps = [];
-        this.enumData = [];
+        this.dataMaxes = [];
+        this.dataMins = [];
         this.type = PacketType_1.PacketType.NONE;
-        this.dataCap = -1;
+        this.dataMax = -1;
+        this.dataMin = -1;
+        this.enumData = [];
         this.dontSpread = false;
         this.object = object;
     }
-    PacketSchema.single = function (type, dataCap, dontSpread) {
+    PacketSchema.single = function (type, dataMax, dataMin, dontSpread) {
         var schema = new PacketSchema(false);
         if (typeof type == 'number') {
             schema.type = type;
@@ -154,13 +185,14 @@ var PacketSchema = /** @class */ (function () {
             schema.type = PacketType_1.PacketType.ENUMS;
             schema.enumData = [type];
         }
-        schema.dataCap = dataCap;
+        schema.dataMax = dataMax;
+        schema.dataMin = dataMin;
         schema.dontSpread = dontSpread;
         return schema;
     };
-    PacketSchema.object = function (types, dataCaps, dontSpread) {
-        if (types.length != dataCaps.length)
-            throw new Error("There is an inbalance between types and datacaps!");
+    PacketSchema.object = function (types, dataMaxes, dataMins, dontSpread) {
+        if (types.length != dataMaxes.length || types.length != dataMins.length)
+            throw new Error("There is an inbalance between the amount of types, data maxes, and data mins!");
         var schema = new PacketSchema(true);
         types.forEach(function (type) {
             if (typeof type == 'number') {
@@ -171,7 +203,8 @@ var PacketSchema = /** @class */ (function () {
                 schema.enumData.push(type);
             }
         });
-        schema.dataCaps = dataCaps;
+        schema.dataMaxes = dataMaxes;
+        schema.dataMins = dataMins;
         schema.dontSpread = dontSpread;
         return schema;
     };