sonic-ws 1.0.0-rc.7 → 1.0.0

package/dist/ws/util/packets/BatchHelper.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.
@@ -16,42 +16,54 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BatchHelper = void 0;
+var BufferUtil_1 = require("../BufferUtil");
+var CompressionUtil_1 = require("./CompressionUtil");
 var BatchHelper = /** @class */ (function () {
     function BatchHelper() {
+        this.batchTimes = {};
+        this.batchTimeouts = {};
         this.batchedData = {};
     }
-    BatchHelper.prototype.registerSendPackets = function (packetHolder, clazz) {
+    BatchHelper.prototype.registerSendPackets = function (packetHolder, conn) {
         var _this = this;
+        this.conn = conn;
         packetHolder.getTags().forEach(function (tag) {
             var packet = packetHolder.getPacket(tag);
             if (packet.dataBatching == 0)
                 return;
-            var code = packetHolder.getChar(tag);
-            _this.initiateBatch(code, packet.dataBatching, clazz);
+            var code = packetHolder.getKey(tag);
+            _this.initiateBatch(code, packet.dataBatching);
         });
     };
-    BatchHelper.prototype.initiateBatch = function (code, time, clazz) {
-        var _this = this;
+    BatchHelper.prototype.initiateBatch = function (code, time) {
         this.batchedData[code] = [];
-        clazz.setInterval(function () {
-            if (_this.batchedData[code].length == 0)
-                return;
-            clazz.raw_send(code + _this.batchedData[code].join(""));
+        this.batchTimes[code] = time;
+    };
+    BatchHelper.prototype.startBatch = function (code) {
+        var _this = this;
+        this.batchTimeouts[code] = this.conn.setTimeout(function () {
+            _this.conn.raw_send((0, BufferUtil_1.toPacketBuffer)(code, _this.batchedData[code]));
             _this.batchedData[code] = [];
-        }, time);
+            delete _this.batchTimeouts[code];
+        }, this.batchTimes[code]);
     };
     BatchHelper.prototype.batchPacket = function (code, data) {
-        this.batchedData[code].push(String.fromCharCode(data.length) + data);
+        var batch = this.batchedData[code];
+        batch.push.apply(batch, (0, CompressionUtil_1.convertVarInt)(data.length, false));
+        data.forEach(function (val) { return batch.push(val); });
+        if (!this.batchTimeouts[code])
+            this.startBatch(code);
     };
     BatchHelper.unravelBatch = function (packet, data, socket) {
         var result = [];
         for (var i = 0; i < data.length;) {
-            if (result.length > packet.maxBatchSize)
+            if (packet.maxBatchSize != 0 && result.length > packet.maxBatchSize)
                 return "Too big of batch";
-            var len = data.charCodeAt(i++);
-            if (i + len > data.length)
+            var _a = (0, CompressionUtil_1.readVarInt)(data, i, false), off = _a[0], varint = _a[1];
+            i = off;
+            if (i + varint > data.length)
                 return "Tampered batch length";
-            var sect = data.substring(i, i += len);
+            var sect = data.slice(i, i += varint);
             var listen = packet.listen(sect, socket);
             if (typeof listen == 'string')
                 return "Batched packet: " + listen;

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

@@ -0,0 +1,44 @@
+export declare const MAX_BYTE = 255;
+export declare const NEGATIVE_BYTE: number;
+export declare const BYTE_OVERFLOW: number;
+export declare const MAX_SHORT = 65535;
+export declare const NEGATIVE_SHORT: number;
+export declare const SHORT_CC_OVERFLOW: number;
+export declare const SHORT_OVERFLOW: number;
+export declare const MAX_INT_D: number;
+export declare const UVARINT_OVERFLOW: number;
+export declare const VARINT_CHAIN_FLAG = 128;
+export declare const NEGATIVE_VARINT: number;
+export declare const VARINT_OVERFLOW: number;
+export declare const MAX_VSECT_SIZE = 7;
+export declare const MAX_UVARINT: number;
+export declare const MAX_VARINT: number;
+export declare const byteOverflowPow: (num: number) => number;
+export declare const uvarIntOverflowPow: (num: number) => number;
+export declare const varIntOverflowPow: (num: number) => number;
+export type SHORT_BITS = [high: number, low: number];
+export declare function fromShort(short: SHORT_BITS): number;
+export declare function toShort(n: number, signed: boolean): SHORT_BITS;
+export declare function fromSignedShort(short: SHORT_BITS): number;
+export declare function toSignedShort(number: number): SHORT_BITS;
+export declare function toByte(n: number, signed: boolean): number;
+export declare function fromSignedByte(point: number): number;
+export declare function toSignedByte(number: number): number;
+export declare function sectorSize(number: number, pow: any): number;
+export declare const MAX_DSECT_SIZE: number;
+export declare function convertBase(number: number, chars: number, single: any, neg: number, overflow: number, overflowFunc: any): number[];
+export declare function convertBytePows(number: number, chars: number): number[];
+export declare function deconvertBytePows(codes: any): any;
+export declare const compressBools: (array: boolean[]) => number;
+export declare const decompressBools: (byte: number) => boolean[];
+export declare function convertFloat(flt: number): number[];
+export declare function deconvertFloat(str: number[]): number;
+export declare function mapZigZag(n: number): number;
+export declare function demapZigZag(n: number): number;
+export declare function demapShort_ZZ(short: SHORT_BITS): number;
+export declare function mapShort_ZZ(short: number): SHORT_BITS;
+export declare function toSignedVarInt(n: number): number;
+export declare function fromSignedVarInt(n: number, signed: boolean): number;
+export declare function convertVarInt(num: number, signed: boolean): number[];
+export declare function readVarInt(arr: number[] | Uint8Array, off: number, signed: boolean): [offset: number, number: number];
+export declare function deconvertVarInts(arr: Uint8Array | number[], signed: boolean): number[];

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

@@ -0,0 +1,321 @@
+"use strict";
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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.decompressBools = exports.compressBools = exports.MAX_DSECT_SIZE = exports.varIntOverflowPow = exports.uvarIntOverflowPow = exports.byteOverflowPow = exports.MAX_VARINT = exports.MAX_UVARINT = exports.MAX_VSECT_SIZE = exports.VARINT_OVERFLOW = exports.NEGATIVE_VARINT = exports.VARINT_CHAIN_FLAG = exports.UVARINT_OVERFLOW = exports.MAX_INT_D = exports.SHORT_OVERFLOW = exports.SHORT_CC_OVERFLOW = exports.NEGATIVE_SHORT = exports.MAX_SHORT = exports.BYTE_OVERFLOW = exports.NEGATIVE_BYTE = exports.MAX_BYTE = void 0;
+exports.fromShort = fromShort;
+exports.toShort = toShort;
+exports.fromSignedShort = fromSignedShort;
+exports.toSignedShort = toSignedShort;
+exports.toByte = toByte;
+exports.fromSignedByte = fromSignedByte;
+exports.toSignedByte = toSignedByte;
+exports.sectorSize = sectorSize;
+exports.convertBase = convertBase;
+exports.convertBytePows = convertBytePows;
+exports.deconvertBytePows = deconvertBytePows;
+exports.convertFloat = convertFloat;
+exports.deconvertFloat = deconvertFloat;
+exports.mapZigZag = mapZigZag;
+exports.demapZigZag = demapZigZag;
+exports.demapShort_ZZ = demapShort_ZZ;
+exports.mapShort_ZZ = mapShort_ZZ;
+exports.toSignedVarInt = toSignedVarInt;
+exports.fromSignedVarInt = fromSignedVarInt;
+exports.convertVarInt = convertVarInt;
+exports.readVarInt = readVarInt;
+exports.deconvertVarInts = deconvertVarInts;
+var ArrayUtil_1 = require("../ArrayUtil");
+// this shit is so complex so i commented it...
+// the highest 8-bit
+exports.MAX_BYTE = 0xFF;
+// we split the usable range in half to separate positive and negative encodings
+exports.NEGATIVE_BYTE = Math.floor(exports.MAX_BYTE / 2);
+// overflow is used as our "base" in a positional number system (like base 10, but very large)
+// we use this to reduce the number of characters needed to represent large numbers
+exports.BYTE_OVERFLOW = exports.NEGATIVE_BYTE + 1;
+// the highest16-bit
+exports.MAX_SHORT = 0xFFFF;
+// we split the usable range in half to separate positive and negative encodings
+exports.NEGATIVE_SHORT = Math.floor(exports.MAX_SHORT / 2);
+// overflow for shorts in construction
+exports.SHORT_CC_OVERFLOW = exports.MAX_BYTE + 1;
+// overflow for shorts base
+exports.SHORT_OVERFLOW = exports.MAX_SHORT + 1;
+// highest number INT_D can optimally support
+exports.MAX_INT_D = Number.MAX_SAFE_INTEGER;
+// for varint to overflow; is 128
+exports.UVARINT_OVERFLOW = exports.NEGATIVE_BYTE + 1;
+// flag for chaining
+exports.VARINT_CHAIN_FLAG = 0x80;
+// splitting usable range in half for signed
+exports.NEGATIVE_VARINT = Math.floor(exports.NEGATIVE_BYTE / 2);
+// for varint to overflow with negative; is 64
+exports.VARINT_OVERFLOW = exports.NEGATIVE_VARINT + 1;
+// max continues
+exports.MAX_VSECT_SIZE = 7;
+// max value from this, subtract one for overflow
+exports.MAX_UVARINT = (Math.pow(exports.UVARINT_OVERFLOW, exports.MAX_VSECT_SIZE)) - 1;
+// max for negatives
+exports.MAX_VARINT = Math.floor(exports.MAX_UVARINT / 2);
+// precompute powers
+var BYTE_OVERFLOW_POWS = [];
+var byteOverflowPow = function (num) { var _a; return (_a = BYTE_OVERFLOW_POWS[num]) !== null && _a !== void 0 ? _a : (BYTE_OVERFLOW_POWS[num] = Math.pow(exports.BYTE_OVERFLOW, num)); };
+exports.byteOverflowPow = byteOverflowPow;
+var UVARINT_OVERFLOW_POWS = [];
+var uvarIntOverflowPow = function (num) { var _a; return (_a = UVARINT_OVERFLOW_POWS[num]) !== null && _a !== void 0 ? _a : (UVARINT_OVERFLOW_POWS[num] = Math.pow(exports.UVARINT_OVERFLOW, num)); };
+exports.uvarIntOverflowPow = uvarIntOverflowPow;
+var VARINT_OVERFLOW_POWS = [];
+var varIntOverflowPow = function (num) { var _a; return (_a = VARINT_OVERFLOW_POWS[num]) !== null && _a !== void 0 ? _a : (VARINT_OVERFLOW_POWS[num] = Math.pow(exports.VARINT_OVERFLOW, num)); };
+exports.varIntOverflowPow = varIntOverflowPow;
+var TWO_POWS = [];
+var twoPow = function (num) { var _a; return (_a = TWO_POWS[num]) !== null && _a !== void 0 ? _a : (TWO_POWS[num] = Math.pow(2, num)); };
+for (var i = 0; i <= 3; i++) {
+    (0, exports.byteOverflowPow)(i);
+    (0, exports.uvarIntOverflowPow)(i);
+    (0, exports.varIntOverflowPow)(i);
+    twoPow(i);
+}
+// reconstruction
+function fromShort(short) {
+    // convert to number
+    return short[0] * exports.SHORT_CC_OVERFLOW + short[1];
+}
+// checks, conversion
+function toShort(n, signed) {
+    // no nan/infinity
+    if (!isFinite(n))
+        throw new Error("Can only use real numbers in shorts: " + n);
+    // limit check
+    var lim = signed ? exports.NEGATIVE_SHORT : exports.MAX_SHORT;
+    var min = signed ? -exports.NEGATIVE_SHORT - 1 : 0;
+    if (n > lim || n < min)
+        throw new Error("".concat(signed ? "Signed " : " ", "Short Numbers must be within range ").concat(min, " and ").concat(lim));
+    // how many times it passes SHORT_OVERFLOW and the remainder
+    return [Math.floor(n / exports.SHORT_CC_OVERFLOW), n % exports.SHORT_CC_OVERFLOW];
+}
+// this converts an encoded code point back to a signed number
+function fromSignedShort(short) {
+    // convert to number
+    var point = fromShort(short);
+    // if the number is below NEGATIVE_SHORT, it's a positive number and can be returned directly
+    // if it's above or equal to NEGATIVE_SHORT, it was originally negative, so we reverse the offset
+    return point <= exports.NEGATIVE_SHORT ? point : -point + exports.NEGATIVE_SHORT;
+}
+// this converts a signed number into a non-negative integer that fits in a short
+function toSignedShort(number) {
+    // positive numbers are returned as-is
+    // negative numbers are made positive and offset above NEGATIVE_SHORT to mark them
+    // ugh fix this shit
+    return toShort(number < 0 ? -number + exports.NEGATIVE_SHORT : number, false);
+}
+// checks
+function toByte(n, signed) {
+    // no nan/infinity
+    if (!isFinite(n))
+        throw new Error("Can only use real numbers in bytes: " + n);
+    ;
+    // limit check
+    var lim = signed ? exports.NEGATIVE_BYTE : exports.MAX_BYTE;
+    if (n > lim || n < -lim - 1)
+        throw new Error("".concat(signed ? "Signed " : " ", "Byte Numbers must be within range -").concat(lim + 1, " and ").concat(lim, ": ").concat(n));
+    return n;
+}
+// this converts a byte back to a signed number
+function fromSignedByte(point) {
+    // if the number is below NEGATIVE_BYTE, it's a positive number and can be returned directly
+    // if it's above or equal to NEGATIVE_BYTE, it was originally negative, so we reverse the offset
+    return point <= exports.NEGATIVE_BYTE ? point : -point + exports.NEGATIVE_BYTE;
+}
+// this converts a signed number into a non-negative integer that fits in a byte
+function toSignedByte(number) {
+    // positive numbers are returned as-is
+    // negative numbers are made positive and offset above NEGATIVE_BYTE to mark them
+    number = toByte(number, true);
+    return number < 0 ? -number + exports.NEGATIVE_BYTE : number;
+}
+// calculate how many characters (digits) are needed to store this number in OVERFLOW base
+function sectorSize(number, pow) {
+    number = Math.abs(number);
+    // iterative system because it's faster than log
+    var count = 1;
+    // i like my code 𝑓𝑟𝑒𝑎𝑘𝑦
+    for (var num = pow(1); number >= num; num = pow(++count))
+        ;
+    return count;
+}
+exports.MAX_DSECT_SIZE = sectorSize(exports.MAX_INT_D, exports.byteOverflowPow);
+// encodes a number into a safe array using a large base (OVERFLOW)
+function convertBase(number, chars, single, neg, overflow, overflowFunc) {
+    // no nan/infinity
+    if (!isFinite(number))
+        throw new Error("Cannot use a non-finite number: " + number);
+    // zero is just null
+    if (number == 0)
+        return Array.from({ length: chars }).map(function () { return 0; });
+    // any 1 char will just be INT_C anyway
+    if (chars == 1)
+        return [single(number)];
+    // store the sign and work with the absolute value
+    var negative = number < 0;
+    number = Math.abs(number);
+    // limit range
+    if (number > exports.MAX_INT_D)
+        throw new Error("Non-float numbers must be within range -".concat(exports.MAX_INT_D.toLocaleString(), " and ").concat(exports.MAX_INT_D.toLocaleString(), ": ").concat(number));
+    var result = [];
+    // for each character except the last, extract the digit at that position
+    // this is similar to how base conversion works: divide by base^position
+    var posPowerAmt = chars - 1;
+    for (var i = 0; i < posPowerAmt; i++) {
+        var power = overflowFunc(posPowerAmt - i);
+        var based = Math.floor(number / power);
+        result.push(based);
+        // remove it from the number so it doesnt effect future iterations
+        number -= based * power;
+    }
+    // the last digit is just the remainder
+    result.push(number % overflow);
+    // if the number was negative, we offset each character to indicate the sign
+    // we only offset non-zero digits to avoid collisions with the null character
+    var bits = negative ? result.map(function (part) { return part > 0 ? part + neg : part; })
+        : result;
+    return bits;
+}
+// im sleepy go aways..
+function convertBytePows(number, chars) {
+    return convertBase(number, chars, toSignedByte, exports.NEGATIVE_BYTE, exports.BYTE_OVERFLOW, exports.byteOverflowPow);
+}
+// decodes a string created by convertINT_D back into the original signed integer
+function deconvertBytePows(codes) {
+    if (codes.length == 0)
+        return fromSignedByte(codes[0]);
+    // for each code point in the string, reverse the sign encoding if necessary,
+    // multiply by the positional weight based on its place (most-significant-digit first)
+    return codes.reduce(function (c, n, i, arr) { return c + fromSignedByte(n) * (0, exports.byteOverflowPow)(arr.length - i - 1); }, 0);
+}
+// boolean stuff
+var compressBools = function (array) { return array.reduce(function (byte, val, i) { return byte | (val << (7 - i)); }, 0); };
+exports.compressBools = compressBools;
+var decompressBools = function (byte) { return __spreadArray([], Array(8), true).map(function (_, i) { return (byte & (1 << (7 - i))) !== 0; }); };
+exports.decompressBools = decompressBools;
+// IEEE-754 single-precision float codec
+var MAN_BITS = 23;
+function parseBin(str) {
+    return Number("0b" + str);
+}
+function parseMan(bin, isNormal) {
+    var mantissaInt = parseBin(bin);
+    var fraction = 0;
+    for (var i = 0; i < MAN_BITS; i++) {
+        if (mantissaInt & (1 << (MAN_BITS - i - 1))) {
+            fraction += twoPow(-(i + 1));
+        }
+    }
+    return (isNormal ? 1 : 0) + fraction;
+}
+function assembleFloat(sign, exponent, mantissa) {
+    var bin = sign.toString(2) + exponent.toString(2).padStart(8, "0") + mantissa.toString(2).padStart(23, "0");
+    return (0, ArrayUtil_1.splitArray)(bin, 8).map(function (x) { return parseBin(x); });
+}
+// https://stackoverflow.com/questions/3096646/how-to-convert-a-floating-point-number-to-its-binary-representation-ieee-754-i
+// edited for clarity
+function convertFloat(flt) {
+    if (isNaN(flt)) // Special case: NaN
+        return assembleFloat(0, 0xFF, 0x1337); // Mantissa is nonzero for NaN
+    var sign = (flt < 0) ? 1 : 0;
+    flt = Math.abs(flt);
+    if (flt == 0.0) // Special case: +-0
+        return assembleFloat(sign, 0, 0);
+    var exponent = Math.floor(Math.log(flt) / Math.LN2);
+    if (exponent > 127 || exponent < -126) // Special case: +-Infinity (and huge numbers)
+        return assembleFloat(sign, 0xFF, 0); // Mantissa is zero for +-Infinity
+    var mantissa = flt / twoPow(exponent);
+    var roundMan = Math.round((mantissa - 1) * twoPow(23));
+    return assembleFloat(sign, exponent + 127, roundMan & 0x7FFFFF);
+}
+function deconvertFloat(str) {
+    var bin = str.map(function (x) { return x.toString(2).padStart(8, "0"); }).join("");
+    var sign = parseBin(bin[0]);
+    var rawExp = parseBin(bin.slice(1, 9));
+    var exp = rawExp === 0 ? -126 : rawExp - 127;
+    var man = parseMan(bin.slice(9, 32), rawExp !== 0); // whether to add the implicit 1
+    return (sign == 0 ? 1 : -1) * man * twoPow(exp);
+}
+// zig_zag
+function mapZigZag(n) {
+    return (n << 1) // shifts left (multiply by 2 to get into zigzag)
+        ^
+            (n >> 15); // then xor the sign away
+}
+function demapZigZag(n) {
+    return (n >>> 1) // shifts right unsigned to remove the sign & divide by 2
+        ^
+            -(n & 1); // flips bits to give negative back
+}
+function demapShort_ZZ(short) {
+    return demapZigZag(fromShort(short));
+}
+function mapShort_ZZ(short) {
+    return toShort(mapZigZag(short), false);
+}
+// yeah!
+function toSignedVarInt(n) {
+    return n < 0 ? n | exports.VARINT_OVERFLOW : n;
+}
+function fromSignedVarInt(n, signed) {
+    return signed && (n & exports.VARINT_OVERFLOW) != 0 ? -(n ^ exports.VARINT_OVERFLOW) : n;
+}
+function convertSVarInt(num, min, max, overflowFunc, overflow, signed) {
+    if (num > max || num < min)
+        throw new Error("".concat(signed ? "Signed " : "", "Variable Ints must be within range ").concat(min, " and ").concat(max, ": ").concat(num));
+    var chars = sectorSize(num, overflowFunc);
+    return convertBase(num, chars, toSignedVarInt, exports.VARINT_OVERFLOW, overflow, overflowFunc).map(function (x, i) { return i == 0 ? x : x | exports.VARINT_CHAIN_FLAG; }).reverse();
+}
+function convertVarInt(num, signed) {
+    return signed ? convertSVarInt(num, -exports.MAX_UVARINT - 1, exports.MAX_UVARINT, exports.varIntOverflowPow, exports.VARINT_OVERFLOW, true)
+        : convertSVarInt(num, 0, exports.MAX_UVARINT, exports.uvarIntOverflowPow, exports.UVARINT_OVERFLOW, false);
+}
+function readVarInt(arr, off, signed) {
+    var num = [];
+    var cont;
+    do {
+        var part = arr[off++];
+        cont = (part & exports.VARINT_CHAIN_FLAG) != 0;
+        num.push(cont ? part ^ exports.VARINT_CHAIN_FLAG : part);
+    } while (cont);
+    var func = signed ? exports.varIntOverflowPow : exports.uvarIntOverflowPow;
+    var number = num.reduce(function (p, c, i) { return p + fromSignedVarInt(c, signed) * func(i); }, 0);
+    return [off, number];
+}
+function deconvertVarInts(arr, signed) {
+    var res = [];
+    var i = 0;
+    while (i < arr.length) {
+        var _a = readVarInt(arr, i, signed), off = _a[0], varint = _a[1];
+        res.push(varint);
+        i = off;
+    }
+    return res;
+}

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

@@ -29,17 +29,12 @@ export declare class PacketHolder {
      * Returns the numeric key for a given tag
      * @param tag The packet tag
      */
-    get(tag: string): number;
-    /**
-     * Returns the character representation of a tag's key
-     * @param tag The packet tag
-     */
-    getChar(tag: string): string;
+    getKey(tag: string): number;
     /**
      * Returns the tag associated with a given character key
      * @param key A 1-character string key
      */
-    getTag(key: string): string;
+    getTag(key: number): string;
     /**
      * Returns the packet instance associated with a tag
      * @param tag The packet tag
@@ -47,9 +42,9 @@ export declare class PacketHolder {
     getPacket(tag: string): Packet;
     /**
      * Checks if a given character key exists
-     * @param key A 1-character string key
+     * @param key A string index
      */
-    has(key: string): boolean;
+    hasKey(key: number): boolean;
     /**
      * Checks if a tag has been assigned a key
      * @param tag The packet tag
@@ -64,5 +59,5 @@ export declare class PacketHolder {
     /** Returns the list of all registered packets */
     getPackets(): Packet[];
     /** Serializes all registered packets into a string */
-    serialize(): string;
+    serialize(): number[];
 }

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

@@ -1,4 +1,19 @@
 "use strict";
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PacketHolder = void 0;
 /**
@@ -39,36 +54,33 @@ var PacketHolder = /** @class */ (function () {
      * Returns the numeric key for a given tag
      * @param tag The packet tag
      */
-    PacketHolder.prototype.get = function (tag) {
+    PacketHolder.prototype.getKey = function (tag) {
+        if (!(tag in this.keys))
+            throw new Error("Not a valid tag: ".concat(tag));
         return this.keys[tag];
     };
-    /**
-     * Returns the character representation of a tag's key
-     * @param tag The packet tag
-     */
-    PacketHolder.prototype.getChar = function (tag) {
-        return String.fromCharCode(this.get(tag));
-    };
     /**
      * Returns the tag associated with a given character key
      * @param key A 1-character string key
      */
     PacketHolder.prototype.getTag = function (key) {
-        return this.tags[key.charCodeAt(0)];
+        return this.tags[key];
     };
     /**
      * Returns the packet instance associated with a tag
      * @param tag The packet tag
      */
     PacketHolder.prototype.getPacket = function (tag) {
+        if (!(tag in this.packetMap))
+            throw new Error("Unknown packet tag: " + tag);
         return this.packetMap[tag];
     };
     /**
      * Checks if a given character key exists
-     * @param key A 1-character string key
+     * @param key A string index
      */
-    PacketHolder.prototype.has = function (key) {
-        return key.charCodeAt(0) in this.tags;
+    PacketHolder.prototype.hasKey = function (key) {
+        return key in this.tags;
     };
     /**
      * Checks if a tag has been assigned a key
@@ -95,7 +107,7 @@ var PacketHolder = /** @class */ (function () {
     };
     /** Serializes all registered packets into a string */
     PacketHolder.prototype.serialize = function () {
-        return this.packets.map(function (p) { return p.serialize(); }).join("");
+        return this.packets.map(function (p) { return p.serialize(); }).flat();
     };
     return PacketHolder;
 }());

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

@@ -1,8 +1,7 @@
 import { PacketHolder } from "./PacketHolder";
-import { Packet } from "../../packets/Packets";
+import { Packet, ValidatorFunction } from "../../packets/Packets";
 import { PacketType } from "../../packets/PacketType";
 import { EnumPackage } from "../enums/EnumType";
-import { SonicWSConnection } from "../../server/SonicWSConnection";
 /**
  * Processes and verifies values into a sendable format
  * @param packets Packet holder
@@ -10,7 +9,7 @@ import { SonicWSConnection } from "../../server/SonicWSConnection";
  * @param values The values
  * @returns The indexed code, the data, and the packet schema
  */
-export declare function processPacket(packets: PacketHolder, tag: string, values: any[]): [code: string, data: string, packet: Packet];
+export declare function processPacket(packets: PacketHolder, tag: string, values: any[]): [code: number, data: number[], packet: Packet];
 /**
  * Calls the listener for a packet with error callback
  * @param listened The listened data
@@ -36,12 +35,18 @@ export type SharedPacketSettings = {
      * Each batched packet is counted towards the rate limit.
      */
     dataBatching?: number;
-    /** If data batching is on, this will limit the amount of packets that can be batched into one (only effects the client). Defaults to 10. */
+    /** If data batching is on, this will limit the amount of packets that can be batched into one (only effects the client). Defaults to 10. 0 for unlimited. */
     maxBatchSize?: number;
-    /** The amount of times this packet can be sent every second, or 0 for infinite */
+    /** The amount of times this packet can be sent every second, or 0 for infinite. */
     rateLimit?: number;
+    /**
+     * If the packet should be enabled by default. Defaults to true. Will kick the client if they send a disabled packet. Does not effect server.
+     *
+     * Changeable with socket.enablePacket("tag") | socket.disablePacket("tag") (you can also do wss.enablePacket/disablePacket).
+     */
+    enabled?: boolean;
     /** A validation function that is called whenever data is received. Return true for success, return false to kick socket. */
-    validator?: ((socket: SonicWSConnection, values: any[]) => boolean) | null;
+    validator?: ValidatorFunction;
 };
 /** Settings for single-typed packets */
 export type SinglePacketSettings = SharedPacketSettings & {
@@ -62,8 +67,6 @@ export type MultiPacketSettings = SharedPacketSettings & {
     dataMins?: number[] | number;
     /** Will automatically run FlattenData() and UnFlattenData() on values; this will optimize [[x,y,z],[x,y,z]...] for wire transfer */
     autoFlatten?: boolean;
-    /** If the packet will have values larger than 55,296 then this will allow up to 3,057,647,616 length for some minor bandwidth cost. */
-    largePacket?: boolean;
 };
 /** Settings for single-typed enum packets */
 export type EnumPacketSettings = SharedPacketSettings & {