sonic-ws 1.3.3 → 2.0.0

package/dist/ws/server/SonicWSConnection.js

@@ -1,298 +0,0 @@
-"use strict";
-/*
- * Copyright 2026 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.SonicWSConnection = void 0;
-const PacketUtils_1 = require("../util/packets/PacketUtils");
-const BatchHelper_1 = require("../util/packets/BatchHelper");
-const RateHandler_1 = require("../util/packets/RateHandler");
-const BufferUtil_1 = require("../util/BufferUtil");
-const Connection_1 = require("../Connection");
-const CLIENT_RATELIMIT_TAG = "C", SERVER_RATELIMIT_TAG = "S";
-class SonicWSConnection extends Connection_1.Connection {
-    host;
-    print = false;
-    handshakePacket;
-    handshakeLambda;
-    messageLambda = (data) => this.messageHandler(this.parseData(data));
-    handshakedMessageLambda = (data) => {
-        const parsed = this.parseData(data);
-        if (parsed == null)
-            return this.socket.close(Connection_1.CloseCodes.INVALID_DATA);
-        if (parsed[0] == this.handshakePacket)
-            return this.socket.close(Connection_1.CloseCodes.REPEATED_HANDSHAKE);
-        this.messageHandler(parsed);
-    };
-    rater;
-    enabledPackets = {};
-    /** If the packet handshake has been completed; `wss.requireHandshake(packet)` */
-    handshakeComplete = false;
-    asyncMap = {};
-    asyncData = {};
-    constructor(socket, host, id, handshakePacket, clientRateLimit, serverRateLimit) {
-        super(socket, id, "Socket " + id, socket.addEventListener.bind(socket), socket.removeEventListener.bind(socket));
-        this.host = host;
-        this.handshakePacket = handshakePacket;
-        for (const pack of host.clientPackets.getPackets()) {
-            const tag = pack.tag;
-            this.listeners[tag] = [];
-            pack.lastReceived[this.id] = undefined;
-            this.enabledPackets[tag] = pack.defaultEnabled;
-            this.asyncMap[tag] = pack.async;
-            if (pack.async)
-                this.asyncData[tag] = [false, []];
-        }
-        this.setInterval = this.setInterval.bind(this);
-        this.batcher.registerSendPackets(this.host.serverPackets, this);
-        this.invalidPacket = this.invalidPacket.bind(this);
-        this.rater = new RateHandler_1.RateHandler(this);
-        this.rater.registerRate(CLIENT_RATELIMIT_TAG, clientRateLimit);
-        this.rater.registerRate(SERVER_RATELIMIT_TAG, serverRateLimit);
-        this.rater.registerAll(host.clientPackets, "client");
-        this.rater.registerAll(host.serverPackets, "server");
-        this.rater.start();
-        if (this.handshakePacket == null) {
-            this.socket.addEventListener('message', this.messageLambda);
-        }
-        else {
-            this.handshakeLambda = (data) => this.handshakeHandler(data);
-            this.socket.addEventListener('message', this.handshakeLambda);
-        }
-        this.socket.on('close', () => {
-            for (const packet of host.clientPackets.getPackets()) {
-                delete packet.lastReceived[this.id];
-            }
-            for (const packet of host.serverPackets.getPackets()) {
-                delete packet.lastSent[this.id];
-            }
-        });
-    }
-    parseData(event) {
-        if (this.rater.trigger(CLIENT_RATELIMIT_TAG))
-            return null;
-        if (!(event.data instanceof Buffer))
-            return null;
-        const message = new Uint8Array(event.data);
-        if (this.print)
-            console.log(`\x1b[31m⬇ \x1b[38;5;245m(${this.id},${message.byteLength})\x1b[0m`, (message.length > 0 && this.host.clientPackets.getTag(message[0])) || "<INVALID>", (0, BufferUtil_1.stringifyBuffer)(message));
-        if (message.byteLength < 1) {
-            this.socket.close(Connection_1.CloseCodes.SMALL);
-            return null;
-        }
-        const key = message[0];
-        const value = message.slice(1);
-        // not a key, bye bye
-        if (!this.host.clientPackets.hasKey(key)) {
-            this.socket.close(Connection_1.CloseCodes.INVALID_KEY);
-            return null;
-        }
-        const tag = this.host.clientPackets.getTag(key);
-        // disabled, bye bye
-        if (!this.enabledPackets[tag]) {
-            this.socket.close(Connection_1.CloseCodes.DISABLED_PACKET);
-            return null;
-        }
-        if (this.rater.trigger("client" + key))
-            return null;
-        return [tag, value];
-    }
-    handshakeHandler(data) {
-        const parsed = this.parseData(data);
-        if (parsed == null)
-            return this.socket.close(Connection_1.CloseCodes.INVALID_DATA);
-        if (parsed[0] != this.handshakePacket) {
-            this.socket.close(Connection_1.CloseCodes.INVALID_DATA);
-            return;
-        }
-        this.messageHandler(parsed);
-        this.socket.removeEventListener('message', this.handshakeLambda);
-        this.socket.addEventListener('message', this.handshakedMessageLambda);
-        this.handshakeComplete = true;
-    }
-    invalidPacket(listened) {
-        console.log("Closure cause", listened);
-        this.socket.close(Connection_1.CloseCodes.INVALID_PACKET, listened);
-    }
-    isAsync(tag) {
-        return this.asyncMap[tag];
-    }
-    listenLock = false;
-    packetQueue = [];
-    async listenPacket(data, tag, packetQueue, isAsync, asyncData) {
-        if (this.closed)
-            return;
-        await (0, PacketUtils_1.listenPacket)(data, this.listeners[tag], this.invalidPacket);
-        await this.callMiddleware('onReceive_post', tag, typeof data == 'string' ? [data] : data[0]);
-        if (isAsync)
-            asyncData[0] = false;
-        else
-            this.listenLock = false;
-        if (packetQueue.length != 0) {
-            this.messageHandler(packetQueue.shift());
-            return;
-        }
-    }
-    async messageHandler(data, recall = false) {
-        if (data == null)
-            return;
-        const [tag, value] = data;
-        const isAsync = this.isAsync(tag);
-        let locked, packetQueue, asyncData;
-        if (isAsync) {
-            asyncData = this.asyncData[tag];
-            locked = asyncData[0];
-            packetQueue = asyncData[1];
-        }
-        else {
-            locked = this.listenLock;
-            packetQueue = this.packetQueue;
-        }
-        if (locked) {
-            packetQueue.push(data);
-            return;
-        }
-        if (isAsync)
-            asyncData[0] = true;
-        else
-            this.listenLock = true;
-        const packet = this.host.clientPackets.getPacket(tag);
-        if (!recall && await this.callMiddleware('onReceive_pre', packet.tag, value, value.length))
-            return;
-        if (packet.rereference && value.length == 0) {
-            const lastRecv = packet.lastReceived[this.id];
-            if (lastRecv === undefined)
-                return this.invalidPacket("No previous value to rereference");
-            await this.listenPacket(lastRecv, tag, packetQueue, isAsync, asyncData);
-            return;
-        }
-        if (packet.dataBatching == 0) {
-            const res = await packet.listen(value, this);
-            packet.lastReceived[this.id] = res;
-            await this.listenPacket(res, tag, packetQueue, isAsync, asyncData);
-            return;
-        }
-        const batchData = await BatchHelper_1.BatchHelper.unravelBatch(packet, value, this);
-        if (typeof batchData == 'string')
-            return this.invalidPacket(batchData);
-        for (const data of batchData) {
-            if (isAsync)
-                asyncData[0] = true;
-            else
-                this.listenLock = true;
-            await this.listenPacket(data, tag, packetQueue, isAsync, asyncData);
-        }
-    }
-    /**
-     * Enables a packet for the client.
-     * @param tag The tag of the packet
-     */
-    enablePacket(tag) {
-        this.enabledPackets[tag] = true;
-    }
-    /**
-     * Disables a packet for the client.
-     * @param tag The tag of the packet
-     */
-    disablePacket(tag) {
-        this.enabledPackets[tag] = false;
-    }
-    /**
-     * Listens for when the connection closes
-     * @param listener Called when it closes
-     */
-    on_close(listener) {
-        this.socket.on('close', (code, reason) => listener(code, String(reason)));
-    }
-    /**
-     * Listens for a packet
-     * @param tag The tag of the key to listen for
-     * @param listener A function to listen for it
-     */
-    on(tag, listener) {
-        if (!this.host.clientPackets.hasTag(tag))
-            throw new Error(`Tag "${String(tag)}" has not been created!`);
-        this.listeners[tag] ??= [];
-        this.listeners[tag].push(listener);
-    }
-    /**
-     * For internal use.
-     */
-    send_processed(code, data, packet) {
-        if (this.rater.trigger("server" + code))
-            return;
-        if (packet.dataBatching == 0)
-            this.raw_send((0, BufferUtil_1.toPacketBuffer)(code, data));
-        else
-            this.batcher.batchPacket(code, data);
-    }
-    sendQueue = [false, [], undefined];
-    /**
-     * Sends a packet with the tag and values
-     * @param tag The tag to send
-     * @param values The values to send
-     */
-    async send(tag, ...values) {
-        if (await this.callMiddleware('onSend_pre', tag, values, Date.now(), performance.now()))
-            return;
-        const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.host.serverPackets, tag, values, this.sendQueue, this.id);
-        if (await this.callMiddleware('onSend_post', tag, data, data.length))
-            return;
-        this.send_processed(code, data, packet);
-    }
-    /**
-     * Broadcasts a packet to all other users connected
-     * @param tag The tag to send
-     * @param values The values to send
-     */
-    broadcastFiltered(tag, filter, ...values) {
-        this.host.broadcastFiltered(tag, (socket) => socket != this && filter(socket), ...values);
-    }
-    /**
-     * Broadcasts a packet to all other users connected
-     * @param tag The tag to send
-     * @param values The values to send
-     */
-    broadcast(tag, ...values) {
-        this.broadcastFiltered(tag, () => true, ...values);
-    }
-    /**
-     * Toggles printing all sent and received messages
-     */
-    togglePrint() {
-        this.print = !this.print;
-    }
-    /* JSDocs in Connection.ts class */
-    raw_send(data) {
-        if (this.isClosed()) {
-            console.warn("WARN! Connection already closed when trying to send message!", this.id, (0, BufferUtil_1.stringifyBuffer)(data));
-            return;
-        }
-        if (this.rater.trigger(SERVER_RATELIMIT_TAG))
-            return;
-        if (this.print)
-            console.log(`\x1b[32m⬆ \x1b[38;5;245m(${this.id},${data.byteLength})\x1b[0m`, (data.length > 0 && this.host.serverPackets.getTag(data[0])) || "<INVALID>", (0, BufferUtil_1.stringifyBuffer)(data));
-        super.raw_send(data);
-    }
-    /**
-     * Tags the socket with a key
-     * @param tag The tag to add
-     * @param replace If it should replace a previous tag; defaults to true. If using false, you can add multiple tags.
-     */
-    tag(tag, replace = true) {
-        this.host.tag(this, tag, replace);
-    }
-}
-exports.SonicWSConnection = SonicWSConnection;

package/dist/ws/server/SonicWSServer.js

@@ -1,307 +0,0 @@
-"use strict";
-/*
- * Copyright 2026 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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SonicWSServer = void 0;
-const WS = __importStar(require("ws"));
-const SonicWSConnection_1 = require("./SonicWSConnection");
-const PacketHolder_1 = require("../util/packets/PacketHolder");
-const CompressionUtil_1 = require("../util/packets/CompressionUtil");
-const version_1 = require("../../version");
-const PacketUtils_1 = require("../util/packets/PacketUtils");
-const PacketProcessor_1 = require("../PacketProcessor");
-const HashUtil_1 = require("../util/packets/HashUtil");
-const Connection_1 = require("../Connection");
-const DebugServer_1 = require("../debug/DebugServer");
-class SonicWSServer extends PacketProcessor_1.MiddlewareHolder {
-    wss;
-    availableIds = [];
-    lastId = 0;
-    connectListeners = [];
-    clientPackets;
-    serverPackets;
-    connections = [];
-    connectionMap = {};
-    clientRateLimit = 500;
-    serverRateLimit = 500;
-    handshakePacket = null;
-    tags = new Map();
-    tagsInv = new Map();
-    serverwideSendQueue = [false, [], undefined];
-    /**
-     * Initializes and hosts a websocket with sonic protocol
-     * Rate limits can be set with wss.setClientRateLimit(x) and wss.setServerRateLimit(x); it is defaulted at 500/second per both
-     * @param settings Sonic Server Options such as schema data for client and server packets, alongside websocket options
-     */
-    constructor(settings) {
-        super();
-        const { clientPackets = [], serverPackets = [], websocketOptions = {} } = settings;
-        this.wss = new WS.WebSocketServer(websocketOptions);
-        this.clientPackets = new PacketHolder_1.PacketHolder(clientPackets);
-        this.serverPackets = new PacketHolder_1.PacketHolder(serverPackets);
-        const s_clientPackets = this.clientPackets.serialize();
-        const s_serverPackets = this.serverPackets.serialize();
-        const serverData = [...version_1.SERVER_SUFFIX_NUMS, version_1.VERSION];
-        const keyData = [...(0, CompressionUtil_1.convertVarInt)(s_clientPackets.length), ...s_clientPackets, ...s_serverPackets];
-        (0, HashUtil_1.setHashFunc)(settings.sonicServerSettings?.bit64Hash ?? true);
-        this.wss.on('connection', async (socket) => {
-            const sonicConnection = new SonicWSConnection_1.SonicWSConnection(socket, this, this.generateSocketID(), this.handshakePacket, this.clientRateLimit, this.serverRateLimit);
-            if (await this.callMiddleware("onClientConnect", sonicConnection)) {
-                sonicConnection.close(Connection_1.CloseCodes.MIDDLEWARE, "Connection blocked by middleware.");
-                this.callMiddleware("onClientDisconnect", sonicConnection, Connection_1.CloseCodes.MIDDLEWARE, Buffer.from("Connection blocked by middleware."));
-                this.availableIds.push(sonicConnection.id);
-                return;
-            }
-            // send tags to the client so it doesn't have to hard code them in
-            const data = new Uint8Array([...(0, CompressionUtil_1.convertVarInt)(sonicConnection.id), ...keyData]);
-            socket.send([...serverData, ...await (0, CompressionUtil_1.compressGzip)(data)]);
-            this.connections.push(sonicConnection);
-            this.connectionMap[sonicConnection.id] = sonicConnection;
-            this.connectListeners.forEach(l => l(sonicConnection));
-            socket.on('close', (code, reason) => {
-                this.connections.splice(this.connections.indexOf(sonicConnection), 1);
-                delete this.connectionMap[sonicConnection.id];
-                this.availableIds.push(sonicConnection.id);
-                if (this.tags.has(sonicConnection)) {
-                    for (const tag of this.tags.get(sonicConnection))
-                        this.tagsInv.get(tag)?.delete(sonicConnection);
-                    this.tags.delete(sonicConnection);
-                }
-                this.callMiddleware("onClientDisconnect", sonicConnection, code, reason);
-            });
-        });
-        if (settings.sonicServerSettings?.checkForUpdates ?? true) {
-            fetch('https://raw.githubusercontent.com/liwybloc/sonic-ws/refs/heads/main/release/version')
-                .then((res) => res.text())
-                .then((ver) => {
-                if (parseInt(ver) > version_1.VERSION) {
-                    console.warn(`SonicWS is currently running outdated! (current: ${version_1.VERSION}, latest: ${ver}) Update with "npm update sonic-ws"`);
-                }
-            })
-                .catch((err) => {
-                console.error(err);
-                console.warn(`Could not check SonicWS version.`);
-            });
-        }
-    }
-    generateSocketID() {
-        if (this.availableIds.length == 0)
-            this.availableIds.push(this.lastId + 1);
-        this.lastId = this.availableIds.shift();
-        return this.lastId;
-    }
-    /**
-     * Requires each client to send this packet upon initialization
-     *
-     * Recreates this:
-     * ```js
-     * let initiated = false;
-     * socket.on('init', () => {
-     *  if(initiated) return socket.close();
-     *  initiated = true;
-     *  // process
-     * });
-     *
-     * socket.on('otherPacket', () => {
-     *  if(!initiated) return socket.close();
-     *  // process
-     * })
-     * ```
-     *
-     * @param packet The tag of the packet to require as a handshake
-     */
-    requireHandshake(packet) {
-        if (!this.clientPackets.hasTag(packet))
-            throw new Error(`The client does not send "${packet}" and so it cannot use it as a handshake!`);
-        if (this.clientPackets.getPacket(packet).dataBatching != 0)
-            throw new Error(`The packet "${packet}" is a batched packet, and cannot be used as a handshake!`);
-        this.handshakePacket = packet;
-    }
-    /**
-     * Sets the rate limit for all client-side packets
-     * @param limit Amount of packets the sockets can send every second, or 0 for infinite
-     */
-    setClientRateLimit(limit) {
-        // so that i can store limits in 1 packet
-        if (limit > CompressionUtil_1.MAX_BYTE) {
-            limit = 0;
-            console.warn(`A rate limit above ${CompressionUtil_1.MAX_BYTE} is considered infinite.`);
-        }
-        this.clientRateLimit = limit;
-    }
-    /**
-     * Sets the rate limit for server-side packets per-socket
-     * @param limit Amount of packets the server can send every second, or 0 for infinite
-     */
-    setServerRateLimit(limit) {
-        // so that i can store limits in 1 packet
-        if (limit > CompressionUtil_1.MAX_BYTE) {
-            limit = 0;
-            console.warn(`A rate limit above ${CompressionUtil_1.MAX_BYTE} is considered infinite.`);
-        }
-        this.serverRateLimit = limit;
-    }
-    /**
-     * Enables a packet for all current & new clients.
-     * @param tag The tag of the packet
-     */
-    enablePacket(tag) {
-        this.clientPackets.getPacket(tag).defaultEnabled = true;
-        this.connections.forEach(socket => socket.enablePacket(tag));
-    }
-    /**
-     * Disables a packet for all current & new clients.
-     * @param tag The tag of the packet
-     */
-    disablePacket(tag) {
-        this.clientPackets.getPacket(tag).defaultEnabled = false;
-        this.connections.forEach(socket => socket.disablePacket(tag));
-    }
-    /**
-     * Listens for whenever a client connects
-     * @param runner Called when ready
-     */
-    on_connect(runner) {
-        this.connectListeners.push(runner);
-    }
-    /**
-     * Listens for whenever the server is ready
-     * @param runner Called when ready
-     */
-    on_ready(runner) {
-        this.wss.on('listening', runner);
-    }
-    /**
-     * Closes the server
-     * @param callback Called when server closes
-     */
-    shutdown(callback) {
-        this.wss.close(callback);
-    }
-    async broadcastInternal(packetTag, target, values) {
-        let recipients;
-        if (target.type === "all") {
-            recipients = this.connections;
-        }
-        else if (target.type === "tagged") {
-            if (!this.tagsInv.has(target.tag))
-                return;
-            recipients = Array.from(this.tagsInv.get(target.tag));
-        }
-        else {
-            recipients = this.connections.filter(target.filter);
-        }
-        if (await this.callMiddleware("onPacketBroadcast_pre", packetTag, { recipients, ...target }, values))
-            return;
-        if (recipients.length === 0)
-            return;
-        const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.serverPackets, packetTag, values, this.serverwideSendQueue, -1);
-        if (await this.callMiddleware("onPacketBroadcast_post", packetTag, { recipients, ...target }, data, data.length))
-            return;
-        recipients.forEach(conn => conn.send_processed(code, data, packet));
-    }
-    async broadcastTagged(tag, packetTag, ...values) {
-        await this.broadcastInternal(packetTag, { type: "tagged", tag }, values);
-    }
-    async broadcastFiltered(tag, filter, ...values) {
-        await this.broadcastInternal(tag, { type: "filter", filter }, values);
-    }
-    async broadcast(tag, ...values) {
-        await this.broadcastInternal(tag, { type: "all" }, values);
-    }
-    /**
-     * @returns All users connected to the socket
-     */
-    getConnected() {
-        return this.connections;
-    }
-    /**
-     * @param id The socket id
-     * @returns The socket
-     */
-    getSocket(id) {
-        return this.connectionMap[id];
-    }
-    /**
-     * Closes a socket by id
-     * @param id The socket id
-     */
-    closeSocket(id, code = 1000, reason) {
-        this.getSocket(id).close(code, reason);
-    }
-    /**
-     * Tags the socket with a key
-     * @param socket The socket to tag
-     * @param tag The tag to add
-     * @param replace If it should replace a previous tag; defaults to true. If using false, you can add multiple tags.
-     */
-    tag(socket, tag, replace = true) {
-        if (!this.tags.get(socket))
-            this.tags.set(socket, new Set());
-        if (!this.tagsInv.get(tag))
-            this.tagsInv.set(tag, new Set());
-        if (replace) {
-            this.tags.get(socket).forEach(v => this.tagsInv.get(v)?.delete(socket));
-        }
-        this.tags.get(socket).add(tag);
-        this.tagsInv.get(tag).add(socket);
-    }
-    debugServer = null;
-    /**
-     * Opens a debug menu; this launches the browser and starts a subserver
-     * @param port Port of the server/http, defaults to 0 which finds an open port
-     * @param password Toggles the requirement of a password to access the server. Defaults to empty, which doesn't ask for a password.
-     */
-    OpenDebug(data = {}) {
-        if (this.debugServer != null)
-            throw new Error("Attempted to open a debug server when one has already been opened.");
-        this.debugServer = new DebugServer_1.DebugServer(this, data);
-    }
-}
-exports.SonicWSServer = SonicWSServer;

package/dist/ws/util/BufferUtil.js

@@ -1,42 +0,0 @@
-"use strict";
-/*
- * Copyright 2026 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.splitArray = splitArray;
-exports.toPacketBuffer = toPacketBuffer;
-exports.splitBuffer = splitBuffer;
-exports.stringifyBuffer = stringifyBuffer;
-function splitArray(arr, size) {
-    const result = [];
-    for (let i = 0; i < arr.length; i += size) {
-        const chunk = arr.slice(i, i + size);
-        result.push(chunk);
-    }
-    return result;
-}
-function toPacketBuffer(code, data) {
-    const buffer = new Uint8Array(1 + data.length);
-    buffer[0] = code;
-    buffer.set(data, 1);
-    return buffer;
-}
-function splitBuffer(arr, x) {
-    return splitArray(Array.from(arr), x);
-}
-function stringifyBuffer(data) {
-    const contents = Array.from(data).map(n => n.toString(16).padStart(2, "0")).join(" ");
-    return `<Buffer ${contents}>`;
-}