sonic-ws 1.0.0-rc.7 → 1.0.0

package/dist/ws/packets/PacketProcessors.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,207 +14,265 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PacketSendProcessors = exports.PacketReceiveProcessors = exports.PacketValidityProcessors = void 0;
+exports.createValidator = createValidator;
+exports.createReceiveProcessor = createReceiveProcessor;
+exports.createSendProcessor = createSendProcessor;
 exports.createObjSendProcessor = createObjSendProcessor;
 exports.createObjReceiveProcessor = createObjReceiveProcessor;
 exports.createObjValidator = createObjValidator;
 var ArrayUtil_1 = require("../util/ArrayUtil");
-var CodePointUtil_1 = require("../util/packets/CodePointUtil");
+var CompressionUtil_1 = require("../util/packets/CompressionUtil");
 var PacketType_1 = require("./PacketType");
-var LEN_DELIMIT = function (data, cap, min) {
-    var sectors = 0;
-    for (var index = 0; index < data.length; index++) {
-        sectors++;
-        if (sectors > cap)
-            return false;
-        index += data.charCodeAt(index);
-        if (index + 1 > data.length)
-            return false;
-    }
-    if (sectors < min)
-        return false;
-    return true;
-};
-var INT_C_LEN = function (data, cap, min) { return data.length >= min && data.length <= cap && (0, CodePointUtil_1.processCharCodes)(data).find(function (v) { return v > CodePointUtil_1.MAX_C; }) == null; };
-var INT_D_LIKE = function (raw, cap, min, off) {
-    if (raw.length == 0)
-        return false;
-    var dataLength = raw.length - 1, sectSize = raw.charCodeAt(0) + off;
-    if (dataLength % sectSize != 0)
-        return false;
-    var valueAmount = dataLength / sectSize;
-    if (valueAmount < min || valueAmount > cap)
-        return false;
-    return true;
-};
-// todo, instead of big array make this a function that creates functions, then i can include pre-defined data like Math.floor(min/8) and stuff
-exports.PacketValidityProcessors = (_a = {},
-    _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, min, packet, index) {
-        if (data.length < min || data.length > cap || index >= packet.enumData.length)
+var BufferUtil_1 = require("../util/BufferUtil");
+var StringUtil_1 = require("../util/StringUtil");
+function BYTE_LEN(cap, min) {
+    return function (data) { return data.length >= min && data.length <= cap; };
+}
+function SHORT_LEN(cap, min) {
+    min *= 2;
+    cap *= 2;
+    return function (data) { return data.length >= min && data.length <= cap && data.length % 2 == 0; };
+}
+function VARINT_VERIF(cap, min, signed) {
+    return function (data) {
+        if (data.length == 0)
             return false;
-        var pkg = packet.enumData[index];
-        for (var i = 0; i < data.length; i++) {
-            if (pkg.values.length <= data.charCodeAt(i))
+        var sectors = 0, i = 0, computed = [];
+        while (i < data.length) {
+            var _a = (0, CompressionUtil_1.readVarInt)(data, i, signed), off = _a[0], varint = _a[1];
+            i = off;
+            computed.push(varint);
+            if (++sectors > cap)
                 return false;
         }
-        return true;
-    },
-    _a[PacketType_1.PacketType.INTS_C] = INT_C_LEN,
-    _a[PacketType_1.PacketType.UINTS_C] = INT_C_LEN,
-    _a[PacketType_1.PacketType.ZIG_ZAG] = INT_C_LEN,
-    _a[PacketType_1.PacketType.INTS_D] = function (raw, cap, min) { return INT_D_LIKE(raw, cap, min, 0); },
-    _a[PacketType_1.PacketType.INTS_A] = LEN_DELIMIT,
-    _a[PacketType_1.PacketType.EXPONENTIAL] = function (raw, cap, min) { return INT_D_LIKE(raw, cap, min, 1); },
-    _a[PacketType_1.PacketType.DECIMALS] = function (data, cap, min) {
-        var sectors = 0;
-        for (var i = 0; i < data.length;) {
-            sectors++;
-            if (sectors > cap)
+        if (sectors < min)
+            return false;
+        return computed;
+    };
+}
+;
+function createValidator(type, dataCap, dataMin, enumData) {
+    switch (type) {
+        case PacketType_1.PacketType.NONE: return function (data) { return data.length == 0; };
+        case PacketType_1.PacketType.RAW: return function () { return undefined; };
+        case PacketType_1.PacketType.ENUMS: return function (data, index) {
+            if (data.length < dataMin || data.length > dataCap || index >= enumData.length)
                 return false;
-            var sectorBits = data.charCodeAt(i++);
-            var len = sectorBits >> 7;
-            var len2 = sectorBits & 0x7F;
-            i += len;
-            if (i > data.length)
+            var pkg = enumData[index];
+            for (var i = 0; i < data.length; i++) {
+                if (pkg.values.length <= data[i])
+                    return false;
+            }
+            return undefined;
+        };
+        case PacketType_1.PacketType.BYTES: return BYTE_LEN(dataCap, dataMin);
+        case PacketType_1.PacketType.UBYTES: return BYTE_LEN(dataCap, dataMin);
+        case PacketType_1.PacketType.BYTES_ZZ: 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.SHORTS_ZZ: return SHORT_LEN(dataCap, dataMin);
+        case PacketType_1.PacketType.NUMBERS: return function (raw) {
+            if (raw.length == 0)
                 return false;
-            i += len2;
-            if (i > data.length)
+            var sectSize = raw[0];
+            if (sectSize > CompressionUtil_1.MAX_DSECT_SIZE)
                 return false;
-        }
-        if (sectors < min)
-            return false;
-        return true;
-    },
-    _a[PacketType_1.PacketType.BOOLEANS] = function (data, cap, min) {
-        var codes = (0, CodePointUtil_1.processCharCodes)(data);
-        return codes.length >= Math.floor(min / 8) + 1 && codes.length <= Math.floor(cap / 8) + 1 && codes.find(function (d) { return d > 255; }) == undefined;
-    },
-    _a);
-exports.PacketReceiveProcessors = (_b = {},
-    _b[PacketType_1.PacketType.NONE] = function (_) { return ""; },
-    _b[PacketType_1.PacketType.RAW] = function (data) { return data; },
-    _b[PacketType_1.PacketType.STRINGS] = function (data) {
-        var strings = [];
-        for (var i = 0; i < data.length; i++) {
-            var stringSize = data.charCodeAt(i);
-            strings.push(data.substring(i + 1, i + 1 + stringSize));
-            i += stringSize;
-        }
-        return strings;
-    },
-    _b[PacketType_1.PacketType.ENUMS] = function (data, _, packet, index) {
-        var pkg = packet.enumData[index];
-        return (0, CodePointUtil_1.processCharCodes)(data).map(function (code) { return pkg.values[code]; });
-    },
-    _b[PacketType_1.PacketType.INTS_C] = function (data) { return (0, CodePointUtil_1.processCharCodes)(data).map(CodePointUtil_1.fromSignedINT_C); },
-    _b[PacketType_1.PacketType.UINTS_C] = function (data) { return (0, CodePointUtil_1.processCharCodes)(data); },
-    _b[PacketType_1.PacketType.ZIG_ZAG] = function (data) { return (0, CodePointUtil_1.processCharCodes)(data).map(CodePointUtil_1.demapZIG_ZAG); },
-    _b[PacketType_1.PacketType.INTS_D] = function (data) { return (0, ArrayUtil_1.splitArray)(data.substring(1), data.charCodeAt(0)).map(CodePointUtil_1.deconvertINT_D); },
-    _b[PacketType_1.PacketType.INTS_A] = function (data) {
-        var numbers = [];
-        for (var i = 0; i < data.length; i++) {
-            var sectSize = data.charCodeAt(i);
-            numbers.push((0, CodePointUtil_1.deconvertINT_D)(data.substring(i + 1, i + 1 + sectSize)));
-            i += sectSize;
-        }
-        return numbers;
-    },
-    _b[PacketType_1.PacketType.EXPONENTIAL] = function (data) { return (0, ArrayUtil_1.splitArray)(data.substring(1), data.charCodeAt(0) + 1).map(CodePointUtil_1.deconvertINT_E); },
-    _b[PacketType_1.PacketType.DECIMALS] = function (data) {
-        var points = (0, CodePointUtil_1.processCharCodes)(data);
-        var numbers = [];
-        for (var i = 0; i < points.length;) {
-            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 decimal = (0, CodePointUtil_1.deconvertINT_DCodes)(points.slice(i, i + decimalSS));
-            i += decimalSS;
-            numbers.push(parseFloat(whole + "." + decimal));
-        }
-        return numbers;
-    },
-    _b[PacketType_1.PacketType.BOOLEANS] = function (data, cap) { return (0, CodePointUtil_1.processCharCodes)(data).map(function (d) { return (0, CodePointUtil_1.decompressBools)(d); }).flat().splice(0, cap); },
-    _b);
-exports.PacketSendProcessors = (_c = {},
-    _c[PacketType_1.PacketType.NONE] = function () { return ""; },
-    _c[PacketType_1.PacketType.RAW] = function (data) { return data.map(String).join(""); },
-    // todo: try some kind of string compression ig :p
-    _c[PacketType_1.PacketType.STRINGS] = function (strings) { return strings.map(function (string) { return String.fromCharCode(string.toString().length) + string; }).join(""); },
-    _c[PacketType_1.PacketType.ENUMS] = function (enums) { return enums.join(""); },
-    _c[PacketType_1.PacketType.INTS_C] = function (numbers) { return numbers.map(CodePointUtil_1.stringedINT_C).join(""); },
-    _c[PacketType_1.PacketType.UINTS_C] = function (numbers) { return String.fromCharCode.apply(String, numbers); },
-    _c[PacketType_1.PacketType.ZIG_ZAG] = function (numbers) { return String.fromCharCode.apply(String, numbers.map(CodePointUtil_1.mapZIG_ZAG)); },
-    _c[PacketType_1.PacketType.INTS_D] = function (numbers) {
-        var sectSize = numbers.reduce(function (c, n) { return Math.max(c, (0, CodePointUtil_1.sectorSize)(n)); }, 1);
-        var sects = numbers.map(function (n) { return (0, CodePointUtil_1.convertINT_D)(n, sectSize); });
-        return String.fromCharCode(sectSize) + sects.join("");
-    },
-    _c[PacketType_1.PacketType.INTS_A] = function (numbers) { return numbers.map(function (v) {
-        var sectSize = (0, CodePointUtil_1.sectorSize)(v);
-        return String.fromCharCode(sectSize) + (0, CodePointUtil_1.convertINT_D)(v, sectSize);
-    }).join(""); },
-    _c[PacketType_1.PacketType.EXPONENTIAL] = function (numbers) { return (0, CodePointUtil_1.convertINT_Es)(numbers); },
-    _c[PacketType_1.PacketType.DECIMALS] = function (numbers) { return numbers.map(function (n) {
-        var split = n.toString().split(".");
-        var whole = parseFloat(split[0]) || 0;
-        var decimal = split.length > 1 ? parseFloat(split[1]) || 0 : 0;
-        var wholeSS = (0, CodePointUtil_1.sectorSize)(whole);
-        var decimalSS = (0, CodePointUtil_1.sectorSize)(decimal);
-        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 (bools) { return (0, ArrayUtil_1.splitArray)(bools, 7).map(function (bools) { return String.fromCharCode((0, CodePointUtil_1.compressBools)(bools)); }).join(""); },
-    _c);
-// so uhm. it work. sorry-
-function createObjSendProcessor(types, packetDelimitSize) {
+            var dataLength = raw.length - 1;
+            if (dataLength % sectSize != 0)
+                return false;
+            var valueAmount = dataLength / sectSize;
+            if (valueAmount < dataMin || valueAmount > dataCap)
+                return false;
+            return undefined;
+        };
+        case PacketType_1.PacketType.VARINT: return VARINT_VERIF(dataCap, dataMin, true);
+        case PacketType_1.PacketType.UVARINT: return VARINT_VERIF(dataCap, dataMin, false);
+        case PacketType_1.PacketType.VARINT_ZZ: return VARINT_VERIF(dataCap, dataMin, false);
+        case PacketType_1.PacketType.DELTAS: return VARINT_VERIF(dataCap, dataMin, false);
+        case PacketType_1.PacketType.FLOAT: return function (data) {
+            if (data.length % 4 !== 0)
+                return false;
+            var sectors = data.length / 4;
+            if (sectors > dataCap || sectors < dataMin)
+                return false;
+            return undefined;
+        };
+        case PacketType_1.PacketType.BOOLEANS:
+            {
+                var min_1 = Math.floor(dataMin / 8);
+                var cap_1 = Math.floor(dataCap / 8);
+                return function (data) { return data.length >= min_1 && data.length <= cap_1; };
+            }
+            ;
+        case PacketType_1.PacketType.STRINGS_ASCII: return function (data) {
+            var sectors = 0, index = 0, computed = [];
+            while (index < data.length) {
+                sectors++;
+                if (sectors > dataCap)
+                    return false;
+                var _a = (0, CompressionUtil_1.readVarInt)(data, index, false), off = _a[0], varint = _a[1];
+                index = off + varint;
+                computed.push(varint);
+                if (index > data.length)
+                    return false;
+            }
+            if (sectors < dataMin)
+                return false;
+            return computed; // todo
+        };
+        case PacketType_1.PacketType.STRINGS_UTF16: return function (data) {
+            var sectors = 0, index = 0, computed = [];
+            while (index < data.length) {
+                sectors++;
+                if (sectors > dataCap)
+                    return false;
+                var _a = (0, CompressionUtil_1.readVarInt)(data, index, false), off = _a[0], varint = _a[1];
+                index = off + varint * 2;
+                computed.push(varint);
+                if (index > data.length)
+                    return false;
+            }
+            if (sectors < dataMin)
+                return false;
+            return computed; // todo
+        };
+        default: throw new Error("Unknown type: " + type);
+    }
+}
+function createReceiveProcessor(type, enumData, cap) {
+    switch (type) {
+        case PacketType_1.PacketType.NONE: return function () { return undefined; };
+        case PacketType_1.PacketType.RAW: return function (data) { return data; };
+        case PacketType_1.PacketType.BYTES: return function (data) { return Array.from(data).map(CompressionUtil_1.fromSignedByte); };
+        case PacketType_1.PacketType.UBYTES: return function (data) { return Array.from(data); };
+        case PacketType_1.PacketType.BYTES_ZZ: return function (data) { return Array.from(data).map(CompressionUtil_1.demapZigZag); };
+        case PacketType_1.PacketType.SHORTS: return function (data) { return (0, BufferUtil_1.splitBuffer)(data, 2).map(function (v) { return (0, CompressionUtil_1.fromSignedShort)(v); }); };
+        case PacketType_1.PacketType.USHORTS: return function (data) { return (0, BufferUtil_1.splitBuffer)(data, 2).map(function (v) { return (0, CompressionUtil_1.fromShort)(v); }); };
+        case PacketType_1.PacketType.SHORTS_ZZ: return function (data) { return (0, BufferUtil_1.splitBuffer)(data, 2).map(function (v) { return (0, CompressionUtil_1.demapShort_ZZ)(v); }); };
+        case PacketType_1.PacketType.VARINT: return function (_, computed) { return computed; };
+        case PacketType_1.PacketType.UVARINT: return function (_, computed) { return computed; };
+        case PacketType_1.PacketType.VARINT_ZZ: return function (_, computed) { return computed.map(CompressionUtil_1.demapZigZag); };
+        case PacketType_1.PacketType.DELTAS: return function (_, computed) { return computed.map(function (x, i) { return computed[i] = (computed[i - 1] || 0) + (0, CompressionUtil_1.demapZigZag)(x); }); };
+        case PacketType_1.PacketType.FLOAT: return function (data) { return (0, BufferUtil_1.splitBuffer)(data, 4).map(CompressionUtil_1.deconvertFloat); };
+        case PacketType_1.PacketType.BOOLEANS: return function (data) { return Array.from(data).map(function (d) { return (0, CompressionUtil_1.decompressBools)(d); }).flat().splice(0, cap); };
+        case PacketType_1.PacketType.NUMBERS: return function (data) { return (0, ArrayUtil_1.splitArray)(data.subarray(1), data[0]).map(CompressionUtil_1.deconvertBytePows); };
+        case PacketType_1.PacketType.ENUMS: return function (data, _, index) {
+            var pkg = enumData[index];
+            return Array.from(data).map(function (code) { return pkg.values[code]; });
+        };
+        case PacketType_1.PacketType.STRINGS_ASCII: return function (data, computed) {
+            var off = 0;
+            return computed.map(function (len) { return (0, BufferUtil_1.as8String)(data.subarray(++off, off += len)); });
+        };
+        case PacketType_1.PacketType.STRINGS_UTF16: return function (data, computed) {
+            var off = 0;
+            return computed.map(function (len) { return (0, BufferUtil_1.as16String)(data.subarray(++off, off += len * 2)); });
+        };
+        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 function () { return []; };
+        case PacketType_1.PacketType.RAW: return function (data) { return Array.from(data); };
+        case PacketType_1.PacketType.ENUMS: return function (enums) { return enums; };
+        case PacketType_1.PacketType.BYTES: return function (numbers) { return numbers.map(CompressionUtil_1.toSignedByte); };
+        case PacketType_1.PacketType.UBYTES: return function (numbers) { return numbers.map(function (n) { return (0, CompressionUtil_1.toByte)(n, false); }); };
+        case PacketType_1.PacketType.BYTES_ZZ: return function (numbers) { return numbers.map(CompressionUtil_1.mapZigZag); };
+        case PacketType_1.PacketType.SHORTS: return function (numbers) { return numbers.map(CompressionUtil_1.toSignedShort).flat(); };
+        case PacketType_1.PacketType.USHORTS: return function (numbers) { return numbers.map(function (n) { return (0, CompressionUtil_1.toShort)(n, false); }).flat(); };
+        case PacketType_1.PacketType.SHORTS_ZZ: return function (numbers) { return numbers.map(CompressionUtil_1.mapShort_ZZ).flat(); };
+        case PacketType_1.PacketType.VARINT: return function (numbers) { return numbers.map(function (n) { return (0, CompressionUtil_1.convertVarInt)(n, true); }).flat(); };
+        case PacketType_1.PacketType.UVARINT: return function (numbers) { return numbers.map(function (n) { return (0, CompressionUtil_1.convertVarInt)(n, false); }).flat(); };
+        case PacketType_1.PacketType.VARINT_ZZ: return function (numbers) { return numbers.map(function (n) { return (0, CompressionUtil_1.convertVarInt)((0, CompressionUtil_1.mapZigZag)(n), false); }).flat(); };
+        case PacketType_1.PacketType.DELTAS: return function (numbers) { return numbers.map(function (n, i) { return (0, CompressionUtil_1.convertVarInt)((0, CompressionUtil_1.mapZigZag)(n - (numbers[i - 1] || 0)), false); }).flat(); };
+        case PacketType_1.PacketType.FLOAT: return function (floats) { return floats.map(CompressionUtil_1.convertFloat).flat(); };
+        case PacketType_1.PacketType.BOOLEANS: return function (bools) { return (0, ArrayUtil_1.splitArray)(bools, 8).map(function (bools) { return (0, CompressionUtil_1.compressBools)(bools); }).flat(); };
+        case PacketType_1.PacketType.NUMBERS: return function (numbers) {
+            var res = [];
+            var sectSize = numbers.reduce(function (c, n) { return Math.max(c, (0, CompressionUtil_1.sectorSize)(n, CompressionUtil_1.byteOverflowPow)); }, 1);
+            res.push(sectSize);
+            numbers.forEach(function (n) { return (0, CompressionUtil_1.convertBytePows)(n, sectSize).forEach(function (c) { return res.push(c); }); });
+            return res;
+        };
+        case PacketType_1.PacketType.STRINGS_ASCII: return function (strings) {
+            var res = [];
+            for (var _i = 0, strings_1 = strings; _i < strings_1.length; _i++) {
+                var v = strings_1[_i];
+                var string = String(v);
+                res.push.apply(res, (0, CompressionUtil_1.convertVarInt)(string.length, false));
+                var codes = (0, StringUtil_1.processCharCodes)(string);
+                var highCode = codes.find(function (x) { return x > CompressionUtil_1.MAX_BYTE; });
+                if (highCode)
+                    throw new Error("Cannot store code ".concat(highCode, " (").concat(String.fromCharCode(highCode), ") in a UTF-8 String! Use STRINGS_UTF16."));
+                codes.map(function (c) { return res.push(c); });
+            }
+            return res;
+        };
+        case PacketType_1.PacketType.STRINGS_UTF16: return function (strings) {
+            var res = [];
+            for (var _i = 0, strings_2 = strings; _i < strings_2.length; _i++) {
+                var v = strings_2[_i];
+                var string = String(v);
+                res.push.apply(res, (0, CompressionUtil_1.convertVarInt)(string.length, false));
+                (0, StringUtil_1.processCharCodes)(string).map(function (c) { return res.push.apply(res, (0, StringUtil_1.splitCodePoint)(c).map(function (p) { return (0, CompressionUtil_1.toShort)(p, false); }).flat()); });
+            }
+            return res;
+        };
+        default: throw new Error("Unknown type: " + type);
+    }
+}
+function createObjSendProcessor(packet) {
+    var types = packet.type;
     var size = types.length;
-    var processors = types.map(function (t) { return exports.PacketSendProcessors[t]; });
+    var processors = types.map(function (t) { return createSendProcessor(t); });
     return function (data) {
-        var result = "";
+        var result = [];
         for (var i = 0; i < size; i++) {
             var sectorData = data[i];
             var d = processors[i](Array.isArray(sectorData) ? sectorData : [sectorData]);
-            if (d.length > (0, CodePointUtil_1.overflowPow)(packetDelimitSize))
-                throw new Error("Cannot store ".concat(d.length, " bytes of data! Set largePacket: true on the object!"));
-            result += (0, CodePointUtil_1.convertINT_D)(d.length, packetDelimitSize) + d;
+            if (d.length > CompressionUtil_1.MAX_UVARINT)
+                throw new Error("Cannot send ".concat(d.length, "/").concat(CompressionUtil_1.MAX_UVARINT, " bytes of data!"));
+            result.push.apply(result, (0, CompressionUtil_1.convertVarInt)(d.length, false));
+            d.forEach(function (val) { return result.push(val); });
         }
         return result;
     };
 }
-function createObjReceiveProcessor(types, packetDelimitSize) {
-    var processors = types.map(function (t) { return exports.PacketReceiveProcessors[t]; });
-    return function (data, dataCaps, packet) {
-        var result = [];
-        var enums = 0;
-        for (var i = 0; i < data.length;) {
-            var sectorLength = (0, CodePointUtil_1.deconvertINT_D)(data.slice(i, i += packetDelimitSize));
-            var sector = data.slice(i, i += sectorLength);
-            result.push(processors[result.length](sector, dataCaps[result.length], packet, types[result.length] == PacketType_1.PacketType.ENUMS ? enums++ : 0));
+function createObjReceiveProcessor(packet) {
+    var types = packet.type, dataMaxes = packet.dataMax;
+    var processors = types.map(function (t, i) { return createReceiveProcessor(t, packet.enumData, dataMaxes[i]); });
+    return function (data, validationResult) {
+        var index = 0, enums = 0, result = [];
+        while (index < data.length) {
+            var _a = (0, CompressionUtil_1.readVarInt)(data, index, false), off = _a[0], sectorLength = _a[1];
+            index = off;
+            var sector = data.subarray(index, index += sectorLength);
+            result.push(processors[result.length](sector, validationResult[result.length], types[result.length] == PacketType_1.PacketType.ENUMS ? enums++ : 0));
         }
         return result;
     };
 }
-function createObjValidator(types, packetDelimitSize) {
-    var validators = types.map(function (t) { return exports.PacketValidityProcessors[t]; });
-    return function (data, dataCaps, dataMins, packet) {
-        var sectors = 0, enums = 0;
-        for (var i = 0; i < data.length;) {
-            var sectorLength = (0, CodePointUtil_1.deconvertINT_D)(data.slice(i, i += packetDelimitSize));
-            if (sectorLength + i > data.length)
+function createObjValidator(packet) {
+    var types = packet.type, dataMaxes = packet.dataMax, dataMins = packet.dataMin;
+    var validators = types.map(function (t, i) { return createValidator(t, dataMaxes[i], dataMins[i], packet.enumData); });
+    return function (data) {
+        var index = 0, enums = 0, computedData = [];
+        while (index < data.length) {
+            if (computedData.length > types.length)
+                return false; // only types amount of values
+            var _a = (0, CompressionUtil_1.readVarInt)(data, index, false), off = _a[0], sectorLength = _a[1];
+            index = off;
+            if (sectorLength + index > data.length)
                 return false;
-            var sector = data.slice(i, i += sectorLength);
-            if (!validators[sectors](sector, dataCaps[sectors], dataMins[sectors], packet, types[sectors] == PacketType_1.PacketType.ENUMS ? enums++ : 0))
+            var sector = data.subarray(index, index += sectorLength);
+            var result = validators[computedData.length](sector, types[computedData.length] == PacketType_1.PacketType.ENUMS ? enums++ : 0);
+            if (result == false)
                 return false;
-            if (++sectors > dataCaps.length)
-                return false; // caps length is also the amount of values there are
+            computedData.push(result);
         }
-        return true;
+        return computedData;
     };
 }

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

@@ -4,24 +4,38 @@ export declare enum PacketType {
     NONE = 0,
     /** Raw data */
     RAW = 1,
-    /** String data; use ENUMS if the values are constant  */
+    /** 8 byte string data (0-255 codes) */
+    STRINGS_ASCII = 2,
+    /** 16 byte string data (0-65535 codes) */
+    STRINGS_UTF16 = 3,
+    /** Strings; defaults to UTF8 (0-255 codes) */
     STRINGS = 2,
     /** Constant primitive data; strings, numbers, booleans, null, undefined */
-    ENUMS = 3,
-    /** One or more integers from -27,648 to 27,647 */
-    INTS_C = 4,
-    /** One or more positive integers from 0 to 55,295 */
-    UINTS_C = 5,
-    /** One or more integers from -27,648 to 27,647, but zig-zag encoded for small negatives (good for deltas; maps like -1->1, 1->2, -2->3, 2->4, etc.) */
-    ZIG_ZAG = 6,
+    ENUMS = 4,
+    /** One or more bytes; -128 to 127 */
+    BYTES = 5,
+    /** One or more bytes; 0 to 255 */
+    UBYTES = 6,
+    /** One or more bytes; -128 to 127 | zig-zag encoded for small negatives (good for deltas; maps like -1->1, 1->2, -2->3, 2->4, etc.) */
+    BYTES_ZZ = 7,
+    /** One or more shorts; -32,768 to 32,767 */
+    SHORTS = 8,
+    /** One or more shorts; 0 to 65,535 */
+    USHORTS = 9,
+    /** One or more shorts; -32,768 to 32,767 | zig-zag encoded for small negatives (good for deltas; maps like -1->1, 1->2, -2->3, 2->4, etc.) */
+    SHORTS_ZZ = 10,
     /** One or more integers up to MAX_SAFE_INTEGER | 9,007,199,254,740,991 (or negative). Similar maximum size will produce maximum efficiency */
-    INTS_D = 7,
-    /** One or more integers up to MAX_SAFE_INTEGER | 9,007,199,2554,740,991 (or negative). More efficient for differently sized numbers, but worse than INTS_D for similar sized numbers. */
-    INTS_A = 8,
-    /** One or more numbers up to MAX_VALUE or 1.7976931348623157e+308. */
-    EXPONENTIAL = 9,
-    /** One or more numbers of any size */
-    DECIMALS = 10,
+    NUMBERS = 11,
+    /** One or more integers between -281,474,976,710,656 and 281,474,976,710,655. */
+    VARINT = 12,
+    /** One or more integers up to 562,949,953,421,311. */
+    UVARINT = 13,
+    /** One or more integers between -281,474,976,710,656 and 281,474,976,710,655 | zig-zag encoded (good for deltas; maps like -1->1, 1->2, -2->3, 2->4, etc.)  */
+    VARINT_ZZ = 14,
+    /** Var ints that use deltas; each value will show the difference from the last value. Good for close numbers */
+    DELTAS = 15,
+    /** One or more single precision floating point numbers. Only up to 7 digits of accuracy. */
+    FLOAT = 16,
     /** One or more true/false */
-    BOOLEANS = 11
+    BOOLEANS = 17
 }

package/dist/ws/packets/PacketType.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,24 +24,38 @@ var PacketType;
     PacketType[PacketType["NONE"] = 0] = "NONE";
     /** Raw data */
     PacketType[PacketType["RAW"] = 1] = "RAW";
-    /** String data; use ENUMS if the values are constant  */
+    /** 8 byte string data (0-255 codes) */
+    PacketType[PacketType["STRINGS_ASCII"] = 2] = "STRINGS_ASCII";
+    /** 16 byte string data (0-65535 codes) */
+    PacketType[PacketType["STRINGS_UTF16"] = 3] = "STRINGS_UTF16";
+    /** Strings; defaults to UTF8 (0-255 codes) */
     PacketType[PacketType["STRINGS"] = 2] = "STRINGS";
     /** Constant primitive data; strings, numbers, booleans, null, undefined */
-    PacketType[PacketType["ENUMS"] = 3] = "ENUMS";
-    /** One or more integers from -27,648 to 27,647 */
-    PacketType[PacketType["INTS_C"] = 4] = "INTS_C";
-    /** One or more positive integers from 0 to 55,295 */
-    PacketType[PacketType["UINTS_C"] = 5] = "UINTS_C";
-    /** One or more integers from -27,648 to 27,647, but zig-zag encoded for small negatives (good for deltas; maps like -1->1, 1->2, -2->3, 2->4, etc.) */
-    PacketType[PacketType["ZIG_ZAG"] = 6] = "ZIG_ZAG";
+    PacketType[PacketType["ENUMS"] = 4] = "ENUMS";
+    /** One or more bytes; -128 to 127 */
+    PacketType[PacketType["BYTES"] = 5] = "BYTES";
+    /** One or more bytes; 0 to 255 */
+    PacketType[PacketType["UBYTES"] = 6] = "UBYTES";
+    /** One or more bytes; -128 to 127 | zig-zag encoded for small negatives (good for deltas; maps like -1->1, 1->2, -2->3, 2->4, etc.) */
+    PacketType[PacketType["BYTES_ZZ"] = 7] = "BYTES_ZZ";
+    /** One or more shorts; -32,768 to 32,767 */
+    PacketType[PacketType["SHORTS"] = 8] = "SHORTS";
+    /** One or more shorts; 0 to 65,535 */
+    PacketType[PacketType["USHORTS"] = 9] = "USHORTS";
+    /** One or more shorts; -32,768 to 32,767 | zig-zag encoded for small negatives (good for deltas; maps like -1->1, 1->2, -2->3, 2->4, etc.) */
+    PacketType[PacketType["SHORTS_ZZ"] = 10] = "SHORTS_ZZ";
     /** One or more integers up to MAX_SAFE_INTEGER | 9,007,199,254,740,991 (or negative). Similar maximum size will produce maximum efficiency */
-    PacketType[PacketType["INTS_D"] = 7] = "INTS_D";
-    /** One or more integers up to MAX_SAFE_INTEGER | 9,007,199,2554,740,991 (or negative). More efficient for differently sized numbers, but worse than INTS_D for similar sized numbers. */
-    PacketType[PacketType["INTS_A"] = 8] = "INTS_A";
-    /** One or more numbers up to MAX_VALUE or 1.7976931348623157e+308. */
-    PacketType[PacketType["EXPONENTIAL"] = 9] = "EXPONENTIAL";
-    /** One or more numbers of any size */
-    PacketType[PacketType["DECIMALS"] = 10] = "DECIMALS";
+    PacketType[PacketType["NUMBERS"] = 11] = "NUMBERS";
+    /** One or more integers between -281,474,976,710,656 and 281,474,976,710,655. */
+    PacketType[PacketType["VARINT"] = 12] = "VARINT";
+    /** One or more integers up to 562,949,953,421,311. */
+    PacketType[PacketType["UVARINT"] = 13] = "UVARINT";
+    /** One or more integers between -281,474,976,710,656 and 281,474,976,710,655 | zig-zag encoded (good for deltas; maps like -1->1, 1->2, -2->3, 2->4, etc.)  */
+    PacketType[PacketType["VARINT_ZZ"] = 14] = "VARINT_ZZ";
+    /** Var ints that use deltas; each value will show the difference from the last value. Good for close numbers */
+    PacketType[PacketType["DELTAS"] = 15] = "DELTAS";
+    /** One or more single precision floating point numbers. Only up to 7 digits of accuracy. */
+    PacketType[PacketType["FLOAT"] = 16] = "FLOAT";
     /** One or more true/false */
-    PacketType[PacketType["BOOLEANS"] = 11] = "BOOLEANS";
+    PacketType[PacketType["BOOLEANS"] = 17] = "BOOLEANS";
 })(PacketType || (exports.PacketType = PacketType = {}));