sonic-ws 1.3.2 → 1.3.3

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

@@ -1,6 +1,179 @@
-/**
+"use strict";
+/*
  * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
+ *
+ * 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:!0}),exports.decompressJSON=exports.compressJSON=void 0;const e=require("../BufferUtil"),r=require("./CompressionUtil");var t;!function(e){e[e.NULL=0]="NULL",e[e.BOOL=1]="BOOL",e[e.INT=2]="INT",e[e.FLOAT=3]="FLOAT",e[e.STRING=4]="STRING",e[e.ARRAY=5]="ARRAY",e[e.OBJECT=6]="OBJECT"}(t||(t={}));const s=e=>{const t=(new TextEncoder).encode(e);return[...(0,r.convertVarInt)(t.length),...t]},n=(e,t)=>{const[s,n]=(0,r.readVarInt)(e,t);return{value:(new TextDecoder).decode(e.subarray(s,s+n)),length:s+n-t}};exports.compressJSON=n=>{const o=[],c=[],a=[],u=e=>{if(null===e)a.push(t.NULL);else if("boolean"==typeof e)a.push(t.BOOL),o.push(e);else if(Number.isInteger(e))a.push(t.INT),c.push(...(0,r.convertVarInt)((0,r.mapZigZag)(e)));else if("number"==typeof e)a.push(t.FLOAT),c.push(...(0,r.convertFloat)(e));else if("string"==typeof e)a.push(t.STRING),c.push(...s(e));else if(Array.isArray(e)){a.push(t.ARRAY),c.push(...(0,r.convertVarInt)(e.length));for(const r of e)u(r)}else{if("object"!=typeof e)throw new Error("Unsupported type");{a.push(t.OBJECT);const n=Object.keys(e);c.push(...(0,r.convertVarInt)(n.length));for(const r of n)c.push(...s(r)),u(e[r])}}};u(n);const p=o.length?(0,e.splitArray)(o,8).map(e=>(0,r.compressBools)(e)):[],l=(e=>{let t="";for(const r of e)t+=r.toString(2).padStart(3,"0");return(0,r.bitsToBytes)(t)})(a),h=[...(0,r.convertVarInt)(p.length),...(0,r.convertVarInt)(l.length)];return Uint8Array.from([...h,...p.flat(),...l,...c])};exports.decompressJSON=e=>{let s=0;const[o,c]=(0,r.readVarInt)(e,s);s=o;const[a,u]=(0,r.readVarInt)(e,s);s=a;const p=[];for(let t=0;t<c;t++)p.push(...(0,r.decompressBools)(e[s++]));let l=0;const h=e.subarray(s,s+u);s+=u;const f=((e,t)=>{const s=(0,r.bytesToBits)(e),n=[];for(let e=0;e<t;e++)n.push(parseInt(s.slice(3*e,3*e+3),2));return n})(h,8*h.length/3);let i=0;const d=o=>{if(o>500)throw new Error("JSON array too deep.");const c=f[i++];switch(c){case t.NULL:return null;case t.BOOL:return p[l++];case t.INT:{const[t,n]=(0,r.readVarInt)(e,s);return s=t,(0,r.demapZigZag)(n)}case t.FLOAT:{const t=(0,r.deconvertFloat)(Array.from(e.subarray(s,s+4)));return s+=4,t}case t.STRING:{const{value:r,length:t}=n(e,s);return s+=t,r}case t.ARRAY:{const[t,n]=(0,r.readVarInt)(e,s);s=t;const c=[];for(let e=0;e<n;e++)c.push(d(o+1));return c}case t.OBJECT:{const[t,c]=(0,r.readVarInt)(e,s);s=t;const a={};for(let r=0;r<c;r++){const{value:r,length:t}=n(e,s);s+=t,a[r]=d(o+1)}return a}default:throw new Error(`Unknown type ${c}`)}};return d(0)};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decompressJSON = exports.compressJSON = void 0;
+const BufferUtil_1 = require("../BufferUtil");
+const CompressionUtil_1 = require("./CompressionUtil");
+var JSONType;
+(function (JSONType) {
+    JSONType[JSONType["NULL"] = 0] = "NULL";
+    JSONType[JSONType["BOOL"] = 1] = "BOOL";
+    JSONType[JSONType["INT"] = 2] = "INT";
+    JSONType[JSONType["FLOAT"] = 3] = "FLOAT";
+    JSONType[JSONType["STRING"] = 4] = "STRING";
+    JSONType[JSONType["ARRAY"] = 5] = "ARRAY";
+    JSONType[JSONType["OBJECT"] = 6] = "OBJECT";
+})(JSONType || (JSONType = {}));
+const encodeString = (str) => {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(str);
+    return [...(0, CompressionUtil_1.convertVarInt)(data.length), ...data];
+};
+const decodeString = (bytes, offset) => {
+    const [off, len] = (0, CompressionUtil_1.readVarInt)(bytes, offset);
+    const decoder = new TextDecoder();
+    return { value: decoder.decode(bytes.subarray(off, off + len)), length: off + len - offset };
+};
+// utility: pack 3-bit values into bytes
+const packTypeBits = (types) => {
+    let bits = '';
+    for (const t of types)
+        bits += t.toString(2).padStart(3, '0');
+    return (0, CompressionUtil_1.bitsToBytes)(bits);
+};
+// utility: unpack bytes into 3-bit type array
+const unpackTypeBits = (bytes, totalValues) => {
+    const bitStr = (0, CompressionUtil_1.bytesToBits)(bytes);
+    const types = [];
+    for (let i = 0; i < totalValues; i++) {
+        types.push(parseInt(bitStr.slice(i * 3, i * 3 + 3), 2));
+    }
+    return types;
+};
+// main compression
+const compressJSON = (value) => {
+    const bools = [];
+    const payload = [];
+    const typeList = [];
+    const encodeValue = (val) => {
+        if (val === null) {
+            typeList.push(JSONType.NULL);
+        }
+        else if (typeof val === 'boolean') {
+            typeList.push(JSONType.BOOL);
+            bools.push(val);
+        }
+        else if (Number.isInteger(val)) {
+            typeList.push(JSONType.INT);
+            payload.push(...(0, CompressionUtil_1.convertVarInt)((0, CompressionUtil_1.mapZigZag)(val)));
+        }
+        else if (typeof val === 'number') {
+            typeList.push(JSONType.FLOAT);
+            payload.push(...(0, CompressionUtil_1.convertFloat)(val));
+        }
+        else if (typeof val === 'string') {
+            typeList.push(JSONType.STRING);
+            payload.push(...encodeString(val));
+        }
+        else if (Array.isArray(val)) {
+            typeList.push(JSONType.ARRAY);
+            payload.push(...(0, CompressionUtil_1.convertVarInt)(val.length));
+            for (const item of val)
+                encodeValue(item);
+        }
+        else if (typeof val === 'object') {
+            typeList.push(JSONType.OBJECT);
+            const keys = Object.keys(val);
+            payload.push(...(0, CompressionUtil_1.convertVarInt)(keys.length));
+            for (const key of keys) {
+                payload.push(...encodeString(key));
+                encodeValue(val[key]);
+            }
+        }
+        else {
+            throw new Error('Unsupported type');
+        }
+    };
+    encodeValue(value);
+    // boolean bitmap bytes
+    const boolBytes = bools.length
+        ? (0, BufferUtil_1.splitArray)(bools, 8).map((slice) => (0, CompressionUtil_1.compressBools)(slice))
+        : [];
+    // type map bytes (3-bit per value)
+    const typeBytes = packTypeBits(typeList);
+    // prepend lengths of boolBytes and typeBytes as varints
+    const header = [...(0, CompressionUtil_1.convertVarInt)(boolBytes.length), ...(0, CompressionUtil_1.convertVarInt)(typeBytes.length)];
+    return Uint8Array.from([...header, ...boolBytes.flat(), ...typeBytes, ...payload]);
+};
+exports.compressJSON = compressJSON;
+// decompression
+const decompressJSON = (bytes) => {
+    let offset = 0;
+    // read lengths
+    const [off1, boolByteLen] = (0, CompressionUtil_1.readVarInt)(bytes, offset);
+    offset = off1;
+    const [off2, typeByteLen] = (0, CompressionUtil_1.readVarInt)(bytes, offset);
+    offset = off2;
+    // boolean bitmap
+    const boolStream = [];
+    for (let i = 0; i < boolByteLen; i++) {
+        boolStream.push(...(0, CompressionUtil_1.decompressBools)(bytes[offset++]));
+    }
+    let boolIndex = 0;
+    // type map
+    const typeBytes = bytes.subarray(offset, offset + typeByteLen);
+    offset += typeByteLen;
+    const typeList = unpackTypeBits(typeBytes, typeBytes.length * 8 / 3); // overestimate, will only use while decoding
+    let typeIndex = 0;
+    const decodeValue = (depth) => {
+        if (depth > 500)
+            throw new Error("JSON array too deep.");
+        const type = typeList[typeIndex++];
+        switch (type) {
+            case JSONType.NULL: return null;
+            case JSONType.BOOL: return boolStream[boolIndex++];
+            case JSONType.INT: {
+                const [off, n] = (0, CompressionUtil_1.readVarInt)(bytes, offset);
+                offset = off;
+                return (0, CompressionUtil_1.demapZigZag)(n);
+            }
+            case JSONType.FLOAT: {
+                const val = (0, CompressionUtil_1.deconvertFloat)(Array.from(bytes.subarray(offset, offset + 4)));
+                offset += 4;
+                return val;
+            }
+            case JSONType.STRING: {
+                const { value, length } = decodeString(bytes, offset);
+                offset += length;
+                return value;
+            }
+            case JSONType.ARRAY: {
+                const [off, len] = (0, CompressionUtil_1.readVarInt)(bytes, offset);
+                offset = off;
+                const arr = [];
+                for (let i = 0; i < len; i++)
+                    arr.push(decodeValue(depth + 1));
+                return arr;
+            }
+            case JSONType.OBJECT: {
+                const [off, numKeys] = (0, CompressionUtil_1.readVarInt)(bytes, offset);
+                offset = off;
+                const obj = {};
+                for (let i = 0; i < numKeys; i++) {
+                    const { value: key, length: keyLen } = decodeString(bytes, offset);
+                    offset += keyLen;
+                    obj[key] = decodeValue(depth + 1);
+                }
+                return obj;
+            }
+            default:
+                throw new Error(`Unknown type ${type}`);
+        }
+    };
+    return decodeValue(0);
+};
+exports.decompressJSON = decompressJSON;

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

@@ -1,5 +1 @@
-/**
- * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
- */
 export {};

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

@@ -1,6 +1,126 @@
-/**
+"use strict";
+/*
  * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
+ *
+ * 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;
+/**
+ * Holds and maps packets to indexed keys and tags for serialization and lookup
+ * @internal
  */
-
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.PacketHolder=void 0;exports.PacketHolder=class{key;keys;tags;packetMap;packets;constructor(t){this.key=1,this.keys={},this.tags={},this.packetMap={},t&&this.holdPackets(t)}createKey(t){this.keys[t]=this.key,this.tags[this.key]=t,this.key++}holdPackets(t){this.packets=t;for(const e of t)this.createKey(e.tag),this.packetMap[e.tag]=e}getKey(t){if(!(t in this.keys))throw new Error(`Not a valid tag: ${t}`);return this.keys[t]}getTag(t){if(t in this.tags)return this.tags[t]}getPacket(t){if(!(t in this.packetMap))throw new Error("Unknown packet tag: "+t);return this.packetMap[t]}hasKey(t){return t in this.tags}hasTag(t){return t in this.keys}getKeys(){return this.keys}getTagMap(){return this.tags}getTags(){return Object.values(this.tags)}getPackets(){return this.packets}serialize(){return this.packets.map(t=>t.serialize()).flat()}};
+class PacketHolder {
+    /** Current key index for packet tags */
+    key;
+    /** Maps tags to keys */
+    keys;
+    /** Maps keys to tags */
+    tags;
+    /** Maps tags to packet instances */
+    packetMap;
+    /** List of all packet instances */
+    packets;
+    /**
+     * Creates a new PacketHolder with an array of packets
+     * @param packets Array of packets to register
+     */
+    constructor(packets) {
+        // reserves:
+        // 0 - enum update
+        this.key = 1;
+        this.keys = {};
+        this.tags = {};
+        this.packetMap = {};
+        if (!packets)
+            return;
+        this.holdPackets(packets);
+    }
+    /** Assigns a new unique key to a tag */
+    createKey(tag) {
+        this.keys[tag] = this.key;
+        this.tags[this.key] = tag;
+        this.key++;
+    }
+    /**
+     * Registers an array of packets and assigns them keys
+     * @param packets Array of packets to register
+     */
+    holdPackets(packets) {
+        this.packets = packets;
+        for (const packet of packets)
+            this.createKey(packet.tag), this.packetMap[packet.tag] = packet;
+    }
+    /**
+     * Returns the numeric key for a given tag
+     * @param tag The packet tag
+     */
+    getKey(tag) {
+        if (!(tag in this.keys))
+            throw new Error(`Not a valid tag: ${tag}`);
+        return this.keys[tag];
+    }
+    /**
+     * Returns the tag associated with a given character key
+     * @param key Key bytre
+     */
+    getTag(key) {
+        if (!(key in this.tags))
+            return undefined;
+        return this.tags[key];
+    }
+    /**
+     * Returns the packet instance associated with a tag
+     * @param tag The packet tag
+     */
+    getPacket(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 string index
+     */
+    hasKey(key) {
+        return key in this.tags;
+    }
+    /**
+     * Checks if a tag has been assigned a key
+     * @param tag The packet tag
+     */
+    hasTag(tag) {
+        return tag in this.keys;
+    }
+    /** Returns the mapping of tags to keys */
+    getKeys() {
+        return this.keys;
+    }
+    /** Returns the mapping of keys to tags */
+    getTagMap() {
+        return this.tags;
+    }
+    /** Returns an array of all registered tags */
+    getTags() {
+        return Object.values(this.tags);
+    }
+    /** Returns the list of all registered packets */
+    getPackets() {
+        return this.packets;
+    }
+    /** Serializes all registered packets into a string */
+    serialize() {
+        return this.packets.map(p => p.serialize()).flat();
+    }
+}
+exports.PacketHolder = PacketHolder;

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

@@ -1,7 +1,3 @@
-/**
- * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
- */
 import { ConvertType, Packet, ValidatorFunction } from "../../packets/Packets";
 import { PacketType } from "../../packets/PacketType";
 import { EnumPackage } from "../enums/EnumType";

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

@@ -1,6 +1,283 @@
-/**
+"use strict";
+/*
  * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
+ *
+ * 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.processPacket = processPacket;
+exports.listenPacket = listenPacket;
+exports.CreatePacket = CreatePacket;
+exports.CreateObjPacket = CreateObjPacket;
+exports.CreateEnumPacket = CreateEnumPacket;
+exports.CreateKeyEffective = CreateKeyEffective;
+exports.FlattenData = FlattenData;
+exports.UnFlattenData = UnFlattenData;
+const Packets_1 = require("../../packets/Packets");
+const PacketType_1 = require("../../packets/PacketType");
+const EnumType_1 = require("../enums/EnumType");
+const CompressionUtil_1 = require("./CompressionUtil");
+const HashUtil_1 = require("./HashUtil");
+/**
+ * Processes and verifies values into a sendable format
+ * @param packets Packet holder
+ * @param tag The tag of the packet
+ * @param values The values
+ * @returns The indexed code, the data, and the packet schema
+ * @internal
+ */
+async function processPacket(packets, tag, values, sendQueue, id, force = false) {
+    const code = packets.getKey(tag);
+    const packet = packets.getPacket(tag);
+    return handleQueue(sendQueue, packets, id, tag, values, force, async () => {
+        if (packet.rereference) {
+            if (id === -1)
+                throw new Error("Cannot send a re-referenced packet from the server-wide sender!");
+            const serialized = (0, HashUtil_1.hashValue)(values);
+            if (packet.lastSent[id] === serialized) {
+                return [code, CompressionUtil_1.EMPTY_UINT8, packet];
+            }
+            packet.lastSent[id] = serialized;
+        }
+        if (packet.autoFlatten) {
+            values = FlattenData(values[0]);
+        }
+        else {
+            if (values.length > packet.maxSize)
+                throw new Error(`Packet "${tag}" only allows ${packet.maxSize} values!`);
+            if (values.length < packet.minSize)
+                throw new Error(`Packet "${tag}" requires at least ${packet.minSize} values!`);
+        }
+        if (!packet.object) {
+            if (packet.type !== PacketType_1.PacketType.JSON) {
+                const found = values.find(v => typeof v === 'object' && v != null);
+                if (found)
+                    console.warn(`Passing an array will result in undefined behavior (${JSON.stringify(found)}). Spread the array with ...arr`);
+            }
+        }
+        else {
+            values = values.map(x => !Array.isArray(x) ? [x] : x);
+            if (!packet.autoFlatten) {
+                const dataMins = packet.dataMin;
+                const dataMaxes = packet.dataMax;
+                for (let i = 0; i < dataMins.length; i++) {
+                    if (values[i].length < dataMins[i])
+                        throw new Error(`Section ${i + 1} of packet "${tag}" requires at least ${dataMins[i]} values!`);
+                    if (values[i].length > dataMaxes[i])
+                        throw new Error(`Section ${i + 1} of packet "${tag}" only allows ${dataMaxes[i]} values!`);
+                }
+            }
+        }
+        const sendData = values.length > 0 ? await packet.processSend(values) : CompressionUtil_1.EMPTY_UINT8;
+        return [code, sendData, packet];
+    });
+}
+/**
+ * @internal
+ */
+async function handleQueue(sendQueue, packets, id, tag, values, force, fn) {
+    if (sendQueue[0] && !force) {
+        return new Promise((resolve) => sendQueue[1].push([resolve, tag, values]));
+    }
+    sendQueue[0] = true;
+    const result = await fn();
+    if (sendQueue[1].length > 0) {
+        const [resolve, nextTag, nextValues] = sendQueue[1].shift();
+        queueMicrotask(async () => {
+            resolve(await processPacket(packets, nextTag, nextValues, sendQueue, id, true));
+        });
+    }
+    else {
+        sendQueue[0] = false;
+    }
+    return result;
+}
+/**
+ * Calls the listener for a packet with error callback
+ * @param listened The listened data
+ * @param listeners The listeners to run
+ * @param errorCB The callback if something goes wrong
+ * @internal
+ */
+async function listenPacket(listened, listeners, errorCB) {
+    if (typeof listened === 'string')
+        return errorCB(listened);
+    const [processed, flatten] = listened;
+    try {
+        if (flatten && Array.isArray(processed)) {
+            for (const l of listeners) {
+                await l(...processed);
+            }
+        }
+        else {
+            for (const l of listeners) {
+                await l(processed);
+            }
+        }
+    }
+    catch (err) {
+        console.error(err);
+        errorCB(err);
+    }
+}
+/**
+ * Determines if a type is a invalid packet type
+ * @param type A possible type
+ * @internal
+ */
+function isInvalidType(type) {
+    return (!(typeof type == 'number' && type in PacketType_1.PacketType) && !(type instanceof EnumType_1.EnumPackage)) || type == PacketType_1.PacketType.KEY_EFFECTIVE;
+}
+const MAX_DATA_MAX = 2048383;
+/** Clamps data max between 0 and MAX_DATA_MAX @internal */
+function clampDataMax(dataMax) {
+    if (dataMax < 0) {
+        console.warn(`Having a data maximum below 0 does not do anything!`);
+        return 0;
+    }
+    // dfkjgsdkfgjk
+    if (dataMax > MAX_DATA_MAX) {
+        console.warn(`Only ${MAX_DATA_MAX} values can be sent on a type! Uhh make an issue if you want to send more.`);
+        return MAX_DATA_MAX;
+    }
+    return dataMax;
+}
+/** Clamps data min between 0 and datamax @internal */
+function clampDataMin(dataMin, dataMax) {
+    if (dataMin < 0) {
+        console.warn(`Having a data minimum below 0 does not do anything!`);
+        return 0;
+    }
+    // also catches >MAX_DATA_MAX
+    if (dataMin > dataMax) {
+        console.warn(`Data minimum can not be higher than the data maximum!`);
+        return dataMax;
+    }
+    return dataMin;
+}
+/**
+ * Creates a structure for a simple single-typed packet.
+ * This packet can be sent and received with the specified tag, type, and data cap.
+ * @param settings The settings object containing `tag`, `type`, `dataMax`, `dataMin`, `noDataRange`, `dontSpread`, `validator`, `dataBatching`, and/or `maxBatchSize`.
+ * @returns The constructed packet structure data.
+ * @throws {Error} If the `type` is invalid.
+ */
+function CreatePacket(settings) {
+    let { tag, type = PacketType_1.PacketType.NONE, dataMax = 1, dataMin = 1, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false, gzipCompression = type == PacketType_1.PacketType.JSON, rereference = false } = settings;
+    if (!tag)
+        throw new Error("Tag not selected!");
+    if (noDataRange) {
+        dataMin = rereference ? 1 : 0;
+        dataMax = MAX_DATA_MAX;
+    }
+    else if (dataMin == undefined)
+        dataMin = type == PacketType_1.PacketType.NONE ? 0 : dataMax;
+    if (rereference && dataMin == 0)
+        throw new Error("Rereference cannot be true if the dataMin is 0");
+    if (isInvalidType(type)) {
+        throw new Error(`Invalid packet type: ${type}`);
+    }
+    const schema = new Packets_1.PacketSchema(false, type, async, clampDataMin(dataMin, dataMax), clampDataMax(dataMax), rateLimit, dontSpread, false, rereference, dataBatching, maxBatchSize, gzipCompression);
+    return new Packets_1.Packet(tag, schema, validator, enabled, false);
+}
+/**
+ * Creates a structure for an object (multi-typed) packet.
+ * This packet allows multiple types and their associated data caps.
+ * @param settings The settings object containing `tag`, `types`, `dataMaxes`, `dataMins`, `noDataRange`, `dontSpread`, `autoFlatten`, `largePacket`, `validator`, `dataBatching`, and/or `maxBatchSize`.
+ * @returns The constructed packet structure data.
+ * @throws {Error} If any type in `types` is invalid.
+ */
+function CreateObjPacket(settings) {
+    let { tag, types = [], dataMaxes, dataMins, noDataRange = false, dontSpread = false, autoFlatten = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false, gzipCompression = types && types.includes(PacketType_1.PacketType.JSON) } = settings;
+    if (!tag)
+        throw new Error("Tag not selected!");
+    if (!types || types.length == 0)
+        throw new Error("Types is set to 0 length");
+    for (const type of types) {
+        if (!isInvalidType(type))
+            continue;
+        throw new Error(`Invalid packet type in "${tag}" packet: ${type}`);
+    }
+    if (noDataRange) {
+        dataMaxes = Array.from({ length: types.length }).map(() => MAX_DATA_MAX);
+        dataMins = Array.from({ length: types.length }).map(() => 0);
+    }
+    else {
+        if (dataMaxes == undefined)
+            dataMaxes = Array.from({ length: types.length }).map(() => 1);
+        else if (!Array.isArray(dataMaxes))
+            dataMaxes = Array.from({ length: types.length }).map(() => dataMaxes);
+        if (dataMins == undefined)
+            dataMins = Array.from({ length: types.length }).map((_, i) => dataMaxes[i]);
+        else if (!Array.isArray(dataMins))
+            dataMins = Array.from({ length: types.length }).map(() => dataMins);
+    }
+    const clampedDataMaxes = dataMaxes.map(clampDataMax);
+    const clampedDataMins = dataMins.map((m, i) => types[i] == PacketType_1.PacketType.NONE ? 0 : clampDataMin(m, clampedDataMaxes[i]));
+    const schema = new Packets_1.PacketSchema(true, types, async, clampedDataMins, clampedDataMaxes, rateLimit, dontSpread, autoFlatten, false, dataBatching, maxBatchSize, gzipCompression);
+    return new Packets_1.Packet(tag, schema, validator, enabled, false);
+}
+/**
+ * Creates and defines an enum packet. This can be used to create an enum-based packet
+ * with a specific tag and possible values.
+ * @param settings The settings object containing `tag`, `enumTag`, `values`, `dataMax`, `dataMin`, `noDataRange`, `dontSpread`, `validator`, `dataBatching`, and/or `maxBatchSize`.
+ * @returns The constructed packet structure data.
+ */
+function CreateEnumPacket(settings) {
+    const { tag, enumData, dataMax = 1, dataMin = 0, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false } = settings;
+    return CreatePacket({
+        tag: tag,
+        type: enumData,
+        dataMax,
+        dataMin,
+        noDataRange,
+        dontSpread,
+        validator,
+        dataBatching,
+        maxBatchSize,
+        rateLimit,
+        enabled,
+        async,
+    });
+}
+function CreateKeyEffective(settings) {
+    const { tag, count = 2, validator = null, async = false } = settings;
+    if (!tag)
+        throw new Error("Tag not selected!");
+    if (count < 2)
+        throw new Error("Must have at least 2 key consumptions on key effective packet!");
+    throw new Error("Currently W.I.P.");
+}
+/**
+ * Flattens a 2-depth array for efficient wire transfer
+ * Turns [[x,y,z],[x,y,z]...] to [[x,x...],[y,y...],[z,z...]]
+ * @param array A 2-depth array of multi-valued
+ */
+function FlattenData(arr) {
+    if (arr == null)
+        return [];
+    const setup = arr[0];
+    if (setup == null)
+        return [];
+    if (!Array.isArray(setup))
+        throw new Error(`Cannot flatten array: ${arr}`);
+    return setup.map((_, i) => arr.map(row => row[i])) ?? [];
+}
+/**
+ * Unflattens an array into 2-depth; reverse of FlattenData()
+ * turns [[x,x...],[y,y...],[z,z...]] to [[x,y,z],[x,y,z]...]
+ * @param array A flattened array
  */
-
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.processPacket=o,exports.listenPacket=async function(e,t,a){if("string"==typeof e)return a(e);const[n,r]=e;try{if(r&&Array.isArray(n))for(const e of t)await e(...n);else for(const e of t)await e(n)}catch(e){console.error(e),a(e)}},exports.CreatePacket=u,exports.CreateObjPacket=function(a){let{tag:n,types:r=[],dataMaxes:o,dataMins:u,noDataRange:f=!1,dontSpread:p=!1,autoFlatten:h=!1,validator:y=null,dataBatching:m=0,maxBatchSize:d=10,rateLimit:w=0,enabled:g=!0,async:k=!1,gzipCompression:P=r&&r.includes(t.PacketType.JSON)}=a;if(!n)throw new Error("Tag not selected!");if(!r||0==r.length)throw new Error("Types is set to 0 length");for(const e of r)if(i(e))throw new Error(`Invalid packet type in "${n}" packet: ${e}`);f?(o=Array.from({length:r.length}).map(()=>s),u=Array.from({length:r.length}).map(()=>0)):(null==o?o=Array.from({length:r.length}).map(()=>1):Array.isArray(o)||(o=Array.from({length:r.length}).map(()=>o)),null==u?u=Array.from({length:r.length}).map((e,t)=>o[t]):Array.isArray(u)||(u=Array.from({length:r.length}).map(()=>u)));const E=o.map(c),S=u.map((e,a)=>r[a]==t.PacketType.NONE?0:l(e,E[a])),x=new e.PacketSchema(!0,r,k,S,E,w,p,h,!1,m,d,P);return new e.Packet(n,x,y,g,!1)},exports.CreateEnumPacket=function(e){const{tag:t,enumData:a,dataMax:n=1,dataMin:r=0,noDataRange:o=!1,dontSpread:i=!1,validator:s=null,dataBatching:c=0,maxBatchSize:l=10,rateLimit:f=0,enabled:p=!0,async:h=!1}=e;return u({tag:t,type:a,dataMax:n,dataMin:r,noDataRange:o,dontSpread:i,validator:s,dataBatching:c,maxBatchSize:l,rateLimit:f,enabled:p,async:h})},exports.CreateKeyEffective=function(e){const{tag:t,count:a=2,validator:n=null,async:r=!1}=e;if(!t)throw new Error("Tag not selected!");if(a<2)throw new Error("Must have at least 2 key consumptions on key effective packet!");throw new Error("Currently W.I.P.")},exports.FlattenData=f,exports.UnFlattenData=function(e){return e[0]?.map((t,a)=>e.map(e=>e[a]))??[]};const e=require("../../packets/Packets"),t=require("../../packets/PacketType"),a=require("../enums/EnumType"),n=require("./CompressionUtil"),r=require("./HashUtil");async function o(e,a,i,s,c,l=!1){const u=e.getKey(a),p=e.getPacket(a);return async function(e,t,a,n,r,i,s){if(e[0]&&!i)return new Promise(t=>e[1].push([t,n,r]));e[0]=!0;const c=await s();if(e[1].length>0){const[n,r,i]=e[1].shift();queueMicrotask(async()=>{n(await o(t,r,i,e,a,!0))})}else e[0]=!1;return c}(s,e,c,a,i,l,async()=>{if(p.rereference){if(-1===c)throw new Error("Cannot send a re-referenced packet from the server-wide sender!");const e=(0,r.hashValue)(i);if(p.lastSent[c]===e)return[u,n.EMPTY_UINT8,p];p.lastSent[c]=e}if(p.autoFlatten)i=f(i[0]);else{if(i.length>p.maxSize)throw new Error(`Packet "${a}" only allows ${p.maxSize} values!`);if(i.length<p.minSize)throw new Error(`Packet "${a}" requires at least ${p.minSize} values!`)}if(p.object){if(i=i.map(e=>Array.isArray(e)?e:[e]),!p.autoFlatten){const e=p.dataMin,t=p.dataMax;for(let n=0;n<e.length;n++){if(i[n].length<e[n])throw new Error(`Section ${n+1} of packet "${a}" requires at least ${e[n]} values!`);if(i[n].length>t[n])throw new Error(`Section ${n+1} of packet "${a}" only allows ${t[n]} values!`)}}}else if(p.type!==t.PacketType.JSON){const e=i.find(e=>"object"==typeof e&&null!=e);e&&console.warn(`Passing an array will result in undefined behavior (${JSON.stringify(e)}). Spread the array with ...arr`)}const e=i.length>0?await p.processSend(i):n.EMPTY_UINT8;return[u,e,p]})}function i(e){return!(("number"==typeof e&&e in t.PacketType||e instanceof a.EnumPackage)&&e!=t.PacketType.KEY_EFFECTIVE)}const s=2048383;function c(e){return e<0?(console.warn("Having a data maximum below 0 does not do anything!"),0):e>s?(console.warn(`Only ${s} values can be sent on a type! Uhh make an issue if you want to send more.`),s):e}function l(e,t){return e<0?(console.warn("Having a data minimum below 0 does not do anything!"),0):e>t?(console.warn("Data minimum can not be higher than the data maximum!"),t):e}function u(a){let{tag:n,type:r=t.PacketType.NONE,dataMax:o=1,dataMin:u=1,noDataRange:f=!1,dontSpread:p=!1,validator:h=null,dataBatching:y=0,maxBatchSize:m=10,rateLimit:d=0,enabled:w=!0,async:g=!1,gzipCompression:k=r==t.PacketType.JSON,rereference:P=!1}=a;if(!n)throw new Error("Tag not selected!");if(f?(u=P?1:0,o=s):null==u&&(u=r==t.PacketType.NONE?0:o),P&&0==u)throw new Error("Rereference cannot be true if the dataMin is 0");if(i(r))throw new Error(`Invalid packet type: ${r}`);const E=new e.PacketSchema(!1,r,g,l(u,o),c(o),d,p,!1,P,y,m,k);return new e.Packet(n,E,h,w,!1)}function f(e){if(null==e)return[];const t=e[0];if(null==t)return[];if(!Array.isArray(t))throw new Error(`Cannot flatten array: ${e}`);return t.map((t,a)=>e.map(e=>e[a]))??[]}
+function UnFlattenData(arr) {
+    return arr[0]?.map((_, i) => arr.map(col => col[i])) ?? [];
+}

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

@@ -1,5 +1 @@
-/**
- * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
- */
 export {};