sonic-ws 1.0.0-rc.8 → 1.0.3

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,201 +14,242 @@
  * 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 CompressionUtil_1 = require("../util/packets/CompressionUtil");
-var PacketType_1 = require("./PacketType");
-var BufferUtil_1 = require("../util/BufferUtil");
-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[index];
-        if (index + 1 > data.length)
-            return false;
-    }
-    if (sectors < min)
-        return false;
-    return true;
-};
-var BYTE_LEN = function (data, cap, min) { return data.length >= min && data.length <= cap; };
-var SHORT_LEN = function (data, cap, min) { return data.length >= min * 2 && data.length <= cap * 2 && data.length % 2 == 0; };
-// 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)
+const ArrayUtil_1 = require("../util/ArrayUtil");
+const CompressionUtil_1 = require("../util/packets/CompressionUtil");
+const PacketType_1 = require("./PacketType");
+const BufferUtil_1 = require("../util/BufferUtil");
+const StringUtil_1 = require("../util/StringUtil");
+function BYTE_LEN(cap, min) {
+    return (data) => data.length >= min && data.length <= cap;
+}
+function SHORT_LEN(cap, min) {
+    min *= 2;
+    cap *= 2;
+    return (data) => data.length >= min && data.length <= cap && data.length % 2 == 0;
+}
+function VARINT_VERIF(cap, min) {
+    return (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[i])
+        let sectors = 0, i = 0, computed = [];
+        while (i < data.length) {
+            const [off, varint] = (0, CompressionUtil_1.readVarInt)(data, i);
+            i = off;
+            computed.push(varint);
+            if (++sectors > cap)
                 return false;
         }
-        return true;
-    },
-    _a[PacketType_1.PacketType.BYTES] = BYTE_LEN,
-    _a[PacketType_1.PacketType.UBYTES] = BYTE_LEN,
-    _a[PacketType_1.PacketType.BYTES_ZZ] = BYTE_LEN,
-    _a[PacketType_1.PacketType.SHORTS] = SHORT_LEN,
-    _a[PacketType_1.PacketType.USHORTS] = SHORT_LEN,
-    _a[PacketType_1.PacketType.SHORTS_ZZ] = SHORT_LEN,
-    _a[PacketType_1.PacketType.INTEGERS_D] = function (raw, cap, min) {
-        if (raw.length == 0)
-            return false;
-        var dataLength = raw.length - 1, sectSize = raw[0];
-        if (dataLength % sectSize != 0)
-            return false;
-        var valueAmount = dataLength / sectSize;
-        if (valueAmount < min || valueAmount > cap)
+        if (sectors < min)
             return false;
-        return true;
-    },
-    _a[PacketType_1.PacketType.INTEGERS_A] = LEN_DELIMIT,
-    _a[PacketType_1.PacketType.FLOAT] = function (data, cap, min) {
-        var sectors = 0;
-        for (var i = 0; i < data.length; i += 4) {
-            if (i + 4 > data.length)
+        return computed;
+    };
+}
+;
+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;
-            sectors++;
-            if (sectors > cap)
+            console.log("~~ENUM~~", packet, packet.enumData, index);
+            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.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;
-        }
-        if (sectors < min)
-            return false;
-        return true;
-    },
-    _a[PacketType_1.PacketType.BOOLEANS] = function (data, cap, min) {
-        return data.length >= Math.floor(min / 8) && data.length <= Math.floor(cap / 8) && data.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[i];
-            strings.push(Array.from(data.slice(i + 1, i + 1 + stringSize)).map(function (x) { return String.fromCharCode(x); }).join(""));
-            i += stringSize;
-        }
-        return strings;
-    },
-    _b[PacketType_1.PacketType.ENUMS] = function (data, _, packet, index) {
-        var pkg = packet.enumData[index];
-        return Array.from(data).map(function (code) { return pkg.values[code]; });
-    },
-    _b[PacketType_1.PacketType.BYTES] = function (data) { return Array.from(data).map(CompressionUtil_1.fromSignedByte); },
-    _b[PacketType_1.PacketType.UBYTES] = function (data) { return Array.from(data); },
-    _b[PacketType_1.PacketType.BYTES_ZZ] = function (data) { return Array.from(data).map(CompressionUtil_1.demapZigZag); },
-    _b[PacketType_1.PacketType.SHORTS] = function (data) { return (0, BufferUtil_1.splitBuffer)(data, 2).map(function (v) { return (0, CompressionUtil_1.fromSignedShort)(v); }); },
-    _b[PacketType_1.PacketType.USHORTS] = function (data) { return (0, BufferUtil_1.splitBuffer)(data, 2).map(function (v) { return (0, CompressionUtil_1.fromShort)(v); }); },
-    _b[PacketType_1.PacketType.SHORTS_ZZ] = function (data) { return (0, BufferUtil_1.splitBuffer)(data, 2).map(function (v) { return (0, CompressionUtil_1.demapShort_ZZ)(v); }); },
-    _b[PacketType_1.PacketType.INTEGERS_D] = function (data) { return (0, ArrayUtil_1.splitArray)(data.slice(1), data[0]).map(CompressionUtil_1.deconvertINT_DCodes); },
-    _b[PacketType_1.PacketType.INTEGERS_A] = function (data) {
-        var numbers = [];
-        for (var i = 0; i < data.length; i++) {
-            var sectSize = data[i];
-            numbers.push((0, CompressionUtil_1.deconvertINT_DCodes)(data.slice(i + 1, i + 1 + sectSize)));
-            i += sectSize;
-        }
-        return numbers;
-    },
-    _b[PacketType_1.PacketType.FLOAT] = function (data) { return (0, BufferUtil_1.splitBuffer)(data, 4).map(CompressionUtil_1.deconvertFloat); },
-    _b[PacketType_1.PacketType.BOOLEANS] = function (data, cap) { return Array.from(data).map(function (d) { return (0, CompressionUtil_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(function (s) { return (0, CompressionUtil_1.processCharCodes)(String(s)); }).flat(); },
-    _c[PacketType_1.PacketType.STRINGS] = 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(string.length);
-            (0, CompressionUtil_1.processCharCodes)(string).map(function (c) { return res.push(c); });
-        }
-        return res;
-    },
-    _c[PacketType_1.PacketType.ENUMS] = function (enums) { return enums; },
-    _c[PacketType_1.PacketType.BYTES] = function (numbers) { return numbers.map(CompressionUtil_1.toSignedByte); },
-    _c[PacketType_1.PacketType.UBYTES] = function (numbers) { return numbers.map(function (n) { return (0, CompressionUtil_1.toByte)(n, false); }); },
-    _c[PacketType_1.PacketType.BYTES_ZZ] = function (numbers) { return numbers.map(CompressionUtil_1.mapZigZag); },
-    _c[PacketType_1.PacketType.SHORTS] = function (numbers) { return numbers.map(CompressionUtil_1.toSignedShort).flat(); },
-    _c[PacketType_1.PacketType.USHORTS] = function (numbers) { return numbers.map(function (n) { return (0, CompressionUtil_1.toShort)(n, false); }).flat(); },
-    _c[PacketType_1.PacketType.SHORTS_ZZ] = function (numbers) { return numbers.map(CompressionUtil_1.mapShort_ZZ).flat(); },
-    _c[PacketType_1.PacketType.INTEGERS_D] = function (numbers) {
-        var res = [];
-        var sectSize = numbers.reduce(function (c, n) { return Math.max(c, (0, CompressionUtil_1.sectorSize)(n)); }, 1);
-        res.push(sectSize);
-        numbers.forEach(function (n) { return (0, CompressionUtil_1.convertINT_DCodes)(n, sectSize).forEach(function (c) { return res.push(c); }); });
-        return res;
-    },
-    _c[PacketType_1.PacketType.INTEGERS_A] = function (numbers) {
-        var res = [];
-        for (var _i = 0, numbers_1 = numbers; _i < numbers_1.length; _i++) {
-            var number = numbers_1[_i];
-            var sectSize = (0, CompressionUtil_1.sectorSize)(number);
-            res.push(sectSize);
-            (0, CompressionUtil_1.convertINT_DCodes)(number, sectSize).forEach(function (n) { return res.push(n); });
-        }
-        return res;
-    },
-    _c[PacketType_1.PacketType.FLOAT] = function (floats) { return floats.map(CompressionUtil_1.convertFloat).flat(); },
-    _c[PacketType_1.PacketType.BOOLEANS] = function (bools) { return (0, ArrayUtil_1.splitArray)(bools, 8).map(function (bools) { return (0, CompressionUtil_1.compressBools)(bools); }).flat(); },
-    _c);
-// so uhm. it work. sorry-
-function createObjSendProcessor(types, packetDelimitSize) {
-    var size = types.length;
-    var processors = types.map(function (t) { return exports.PacketSendProcessors[t]; });
-    return function (data) {
-        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, CompressionUtil_1.overflowPow)(packetDelimitSize))
-                throw new Error("Cannot store ".concat(d.length, " bytes of data! Set largePacket: true on the object!"));
-            result.push.apply(result, (0, CompressionUtil_1.convertINT_DCodes)(d.length, packetDelimitSize));
-            d.forEach(function (val) { return result.push(val); });
+            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.floor(dataMin * CompressionUtil_1.ONE_EIGHT);
+                const cap = Math.floor(dataCap * CompressionUtil_1.ONE_EIGHT);
+                return (data) => data.length >= min && data.length <= cap;
+            }
+            ;
+        case PacketType_1.PacketType.STRINGS_ASCII: return (data) => {
+            let sectors = 0, index = 0, computed = [];
+            while (index < data.length) {
+                sectors++;
+                if (sectors > dataCap)
+                    return false;
+                const [off, varint] = (0, CompressionUtil_1.readVarInt)(data, index);
+                index = off + varint;
+                computed.push(varint);
+                if (index > data.length)
+                    return false;
+            }
+            if (sectors < dataMin)
+                return false;
+            return computed;
+        };
+        case PacketType_1.PacketType.STRINGS_UTF16: return (data) => {
+            let sectors = 0, index = 0, computed = [];
+            while (index < data.length) {
+                sectors++;
+                if (sectors > dataCap)
+                    return false;
+                const [off, varint] = (0, CompressionUtil_1.readVarInt)(data, index);
+                index = off + varint * 2;
+                computed.push(varint);
+                if (index > data.length)
+                    return false;
+            }
+            if (sectors < dataMin)
+                return false;
+            return computed;
+        };
+        default: throw new Error("Unknown type: " + type);
+    }
+}
+function createReceiveProcessor(type, enumData, cap) {
+    switch (type) {
+        case PacketType_1.PacketType.NONE: return () => undefined;
+        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.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);
+        case PacketType_1.PacketType.UVARINT: return (_, computed) => computed;
+        case PacketType_1.PacketType.DELTAS: return (_, computed) => computed.map((x, i) => computed[i] = (computed[i - 1] || 0) + (0, CompressionUtil_1.demapZigZag)(x));
+        case PacketType_1.PacketType.FLOATS: return (data) => (0, BufferUtil_1.splitBuffer)(data, 4).map(CompressionUtil_1.deconvertFloat);
+        case PacketType_1.PacketType.DOUBLES: return (data) => (0, BufferUtil_1.splitBuffer)(data, 8).map(CompressionUtil_1.deconvertDouble);
+        case PacketType_1.PacketType.BOOLEANS: return (data) => Array.from(data).map(d => (0, CompressionUtil_1.decompressBools)(d)).flat().splice(0, cap);
+        case PacketType_1.PacketType.ENUMS: return (data, _, index) => {
+            const pkg = enumData[index];
+            return Array.from(data).map(code => pkg.values[code]);
+        };
+        case PacketType_1.PacketType.STRINGS_ASCII: return (data, computed) => {
+            let off = 0;
+            return computed.map(len => (0, BufferUtil_1.as8String)(data.subarray(++off, off += len)));
+        };
+        case PacketType_1.PacketType.STRINGS_UTF16: return (data, computed) => {
+            let off = 0;
+            return computed.map(len => (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 () => [];
+        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) => {
+            const res = [];
+            for (const v of strings) {
+                const string = String(v);
+                res.push(...(0, CompressionUtil_1.convertVarInt)(string.length));
+                const codes = (0, StringUtil_1.processCharCodes)(string);
+                const highCode = codes.find(x => x > CompressionUtil_1.MAX_BYTE);
+                if (highCode)
+                    throw new Error(`Cannot store code ${highCode} (${String.fromCharCode(highCode)}) in a UTF-8 String! Use STRINGS_UTF16.`);
+                codes.map(c => res.push(c));
+            }
+            return res;
+        };
+        case PacketType_1.PacketType.STRINGS_UTF16: return (strings) => {
+            const res = [];
+            for (const v of strings) {
+                const string = String(v);
+                res.push(...(0, CompressionUtil_1.convertVarInt)(string.length));
+                (0, StringUtil_1.processCharCodes)(string).map(c => res.push(...(0, StringUtil_1.splitCodePoint)(c).map(p => (0, CompressionUtil_1.toShort)(p)).flat()));
+            }
+            return res;
+        };
+        default: throw new Error("Unknown type: " + type);
+    }
+}
+function createObjSendProcessor(packet) {
+    const types = packet.type;
+    const size = types.length;
+    const processors = types.map(t => createSendProcessor(t));
+    return (data) => {
+        let result = [];
+        for (let i = 0; i < size; i++) {
+            const sectorData = data[i];
+            const d = processors[i](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;
     };
 }
-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, CompressionUtil_1.deconvertINT_DCodes)(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) {
+    const types = packet.type, dataMaxes = packet.dataMax;
+    const processors = types.map((t, i) => createReceiveProcessor(t, packet.enumData, dataMaxes[i]));
+    return (data, validationResult) => {
+        let index = 0, enums = 0, result = [];
+        while (index < data.length) {
+            const [off, sectorLength] = (0, CompressionUtil_1.readVarInt)(data, index);
+            index = off;
+            const 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, CompressionUtil_1.deconvertINT_DCodes)(data.slice(i, i += packetDelimitSize));
-            if (sectorLength + i > 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))
+function createObjValidator(packet) {
+    const types = packet.type, dataMaxes = packet.dataMax, dataMins = packet.dataMin;
+    const validators = types.map((t, i) => createValidator(t, dataMaxes[i], dataMins[i], packet));
+    return (data) => {
+        let index = 0, enums = 0, computedData = [];
+        while (index < data.length) {
+            if (computedData.length > types.length)
+                return false; // only types amount of values
+            const [off, sectorLength] = (0, CompressionUtil_1.readVarInt)(data, index);
+            index = off;
+            if (sectorLength + index > data.length)
                 return false;
-            if (++sectors > dataCaps.length)
-                return false; // caps length is also the amount of values there are
+            const sector = data.subarray(index, index += sectorLength);
+            const result = validators[computedData.length](sector, types[computedData.length] == PacketType_1.PacketType.ENUMS ? enums++ : 0);
+            if (result === false)
+                return false; // chat i used === to fix a bug !!!!
+            computedData.push(result);
         }
-        return true;
+        return computedData;
     };
 }

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

@@ -4,28 +4,32 @@ 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,
+    /** Code point UTF16 data; up to 0x10FFFF */
+    STRINGS_UTF16 = 3,
+    /** Strings; defaults to ASCII (0-255 codes). Use STRINGS_UTF16 for more codes. */
     STRINGS = 2,
     /** Constant primitive data; strings, numbers, booleans, null, undefined */
-    ENUMS = 3,
-    /** One or more bytes; -128 to 127 */
-    BYTES = 4,
+    ENUMS = 4,
+    /** One or more bytes; -128 to 127 | zig-zag encoded */
+    BYTES = 5,
     /** One or more bytes; 0 to 255 */
-    UBYTES = 5,
-    /** 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 = 6,
-    /** One or more shorts; -32,768 to 32,767 */
+    UBYTES = 6,
+    /** One or more shorts; -32,768 to 32,767 | zig-zag encoded */
     SHORTS = 7,
     /** One or more shorts; 0 to 65,535 */
     USHORTS = 8,
-    /** 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 = 9,
-    /** One or more integers up to MAX_SAFE_INTEGER | 9,007,199,254,740,991 (or negative). Similar maximum size will produce maximum efficiency */
-    INTEGERS_D = 10,
-    /** 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. */
-    INTEGERS_A = 11,
+    /** One or more integers between -281,474,976,710,656 and 281,474,976,710,655 | zig-zag encoded */
+    VARINT = 9,
+    /** One or more integers up to 562,949,953,421,311. */
+    UVARINT = 10,
+    /** Var ints that use deltas; each value will show the difference from the last value. Good for close numbers */
+    DELTAS = 11,
     /** One or more single precision floating point numbers. Only up to 7 digits of accuracy. */
-    FLOAT = 12,
+    FLOATS = 12,
+    /** One or more double precision floating point numbers. */
+    DOUBLES = 13,
     /** One or more true/false */
-    BOOLEANS = 13
+    BOOLEANS = 14
 }

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,28 +24,32 @@ 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";
+    /** Code point UTF16 data; up to 0x10FFFF */
+    PacketType[PacketType["STRINGS_UTF16"] = 3] = "STRINGS_UTF16";
+    /** Strings; defaults to ASCII (0-255 codes). Use STRINGS_UTF16 for more codes. */
     PacketType[PacketType["STRINGS"] = 2] = "STRINGS";
     /** Constant primitive data; strings, numbers, booleans, null, undefined */
-    PacketType[PacketType["ENUMS"] = 3] = "ENUMS";
-    /** One or more bytes; -128 to 127 */
-    PacketType[PacketType["BYTES"] = 4] = "BYTES";
+    PacketType[PacketType["ENUMS"] = 4] = "ENUMS";
+    /** One or more bytes; -128 to 127 | zig-zag encoded */
+    PacketType[PacketType["BYTES"] = 5] = "BYTES";
     /** One or more bytes; 0 to 255 */
-    PacketType[PacketType["UBYTES"] = 5] = "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"] = 6] = "BYTES_ZZ";
-    /** One or more shorts; -32,768 to 32,767 */
+    PacketType[PacketType["UBYTES"] = 6] = "UBYTES";
+    /** One or more shorts; -32,768 to 32,767 | zig-zag encoded */
     PacketType[PacketType["SHORTS"] = 7] = "SHORTS";
     /** One or more shorts; 0 to 65,535 */
     PacketType[PacketType["USHORTS"] = 8] = "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"] = 9] = "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["INTEGERS_D"] = 10] = "INTEGERS_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["INTEGERS_A"] = 11] = "INTEGERS_A";
+    /** One or more integers between -281,474,976,710,656 and 281,474,976,710,655 | zig-zag encoded */
+    PacketType[PacketType["VARINT"] = 9] = "VARINT";
+    /** One or more integers up to 562,949,953,421,311. */
+    PacketType[PacketType["UVARINT"] = 10] = "UVARINT";
+    /** Var ints that use deltas; each value will show the difference from the last value. Good for close numbers */
+    PacketType[PacketType["DELTAS"] = 11] = "DELTAS";
     /** One or more single precision floating point numbers. Only up to 7 digits of accuracy. */
-    PacketType[PacketType["FLOAT"] = 12] = "FLOAT";
+    PacketType[PacketType["FLOATS"] = 12] = "FLOATS";
+    /** One or more double precision floating point numbers. */
+    PacketType[PacketType["DOUBLES"] = 13] = "DOUBLES";
     /** One or more true/false */
-    PacketType[PacketType["BOOLEANS"] = 13] = "BOOLEANS";
+    PacketType[PacketType["BOOLEANS"] = 14] = "BOOLEANS";
 })(PacketType || (exports.PacketType = PacketType = {}));

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

@@ -11,27 +11,26 @@ export declare class Packet {
     enumData: EnumPackage[];
     dataMax: number | number[];
     dataMin: number | number[];
-    packetDelimitSize: number;
     dataBatching: number;
     maxBatchSize: number;
     dontSpread: boolean;
     autoFlatten: boolean;
     rateLimit: number;
     object: boolean;
+    client: boolean;
     private receiveProcessor;
     private sendProcessor;
-    private validifier;
-    processReceive: (data: Uint8Array) => any;
+    private validator;
+    processReceive: (data: Uint8Array, validationResult: any) => any;
     processSend: (data: any[]) => number[];
     validate: (data: Uint8Array) => boolean;
     customValidator: ((socket: SonicWSConnection, ...values: any[]) => boolean) | null;
     constructor(tag: string, schema: PacketSchema, customValidator: ValidatorFunction, enabled: boolean, client: boolean);
     listen(value: Uint8Array, socket: SonicWSConnection | null): [processed: any, flatten: boolean] | string;
-    private serializeINT_D;
-    serialize(): string;
-    private static processINT_Ds;
-    static deserialize(text: string, offset: number, client: boolean): [packet: Packet, offset: number];
-    static deserializeAll(text: string, client: boolean): Packet[];
+    serialize(): number[];
+    private static readVarInts;
+    static deserialize(data: Uint8Array, offset: number, client: boolean): [packet: Packet, offset: number];
+    static deserializeAll(data: Uint8Array, client: boolean): Packet[];
 }
 export declare class PacketSchema {
     types: PacketType[];
@@ -40,7 +39,6 @@ export declare class PacketSchema {
     type: PacketType;
     dataMax: number;
     dataMin: number;
-    packetDelimitSize: number;
     dataBatching: number;
     maxBatchSize: number;
     rateLimit: number;
@@ -50,5 +48,5 @@ export declare class PacketSchema {
     object: boolean;
     constructor(object: boolean);
     static single(type: PacketType | EnumPackage, dataMax: number, dataMin: number, dontSpread: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number): PacketSchema;
-    static object(types: (PacketType | EnumPackage)[], dataMaxes: number[], dataMins: number[], dontSpread: boolean, autoFlatten: boolean, packetDelimitSize: number, dataBatching: number, maxBatchSize: number, rateLimit: number): PacketSchema;
+    static object(types: (PacketType | EnumPackage)[], dataMaxes: number[], dataMins: number[], dontSpread: boolean, autoFlatten: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number): PacketSchema;
 }