@sanctumterra/raknet 1.3.79 → 1.4.0

package/dist/client/framer.js

@@ -1,467 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Framer = void 0;
-const proto_1 = require("../proto");
-const proto_2 = require("../proto");
-const utils_1 = require("../utils");
-const binarystream_1 = require("@serenityjs/binarystream");
-const connection_request_accepted_1 = require("../proto/packets/connection-request-accepted");
-// Constants for packet handling
-const PACKET_HEADER_MASK = 0xf0;
-const PACKET_HEADER_FRAMESET = 0x80;
-const PACKET_ENCAPSULATED = 0xfe;
-const PING_INTERVAL = 50; // Send ping every 50 ticks
-const MTU_HEADER_SIZE = 36;
-class Framer {
-    client;
-    lastInputSequence = -1;
-    receivedFrameSequences = new Set();
-    lostFrameSequences = new Set();
-    inputHighestSequenceIndex = new Array(64).fill(0);
-    inputOrderIndex = new Array(64).fill(0);
-    inputOrderingQueue = Array.from({ length: 64 }, () => new Map());
-    fragmentsQueue = new Map();
-    outputOrderIndex;
-    outputSequenceIndex;
-    outputFrameQueue;
-    outputSequence = 0;
-    outputSplitIndex = 0;
-    outputReliableIndex = 0;
-    outputFrames = [];
-    outputFramesByteLength = 0;
-    outputBackup = new Map();
-    _tickCount = 0;
-    mtuDiff;
-    BATCH_SIZE = 32; // Maximum frames to process in a batch
-    MAX_BATCH_INTERVAL = 50; // Maximum time (ms) to wait before processing a batch
-    lastBatchTime = 0;
-    ORDERING_QUEUE_TIMEOUT = 500;
-    constructor(client) {
-        this.client = client;
-        this.outputFrameQueue = new proto_2.Frameset();
-        this.outputFrameQueue.frames = [];
-        this.outputOrderIndex = new Array(32).fill(0);
-        this.outputSequenceIndex = new Array(32).fill(0);
-        this.mtuDiff = this.client.options.mtuSize - MTU_HEADER_SIZE;
-    }
-    tick() {
-        this._tickCount++;
-        const now = Date.now();
-        if (this.client.status === proto_1.Status.Disconnected ||
-            this.client.status === proto_1.Status.Disconnecting) {
-            return;
-        }
-        // Send a ping every PING_INTERVAL ticks
-        if (this._tickCount % PING_INTERVAL === 0) {
-            const ping = new proto_1.ConnectedPing();
-            ping.timestamp = BigInt(now);
-            this.frameAndSend(ping.serialize(), proto_1.Priority.Immediate);
-        }
-        // Batch process ACKs and NACKs
-        this.processBatchedAcksAndNacks();
-        // Process ordered frames in batches
-        this.processBatchedOrderedFrames(now);
-        // Send queued frames if we have enough or enough time has passed
-        if (this.outputFrames.length >= this.BATCH_SIZE ||
-            (this.outputFrames.length > 0 &&
-                now - this.lastBatchTime >= this.MAX_BATCH_INTERVAL)) {
-            this.sendQueue(this.outputFrames.length);
-            this.lastBatchTime = now;
-        }
-    }
-    processBatchedAcksAndNacks() {
-        // Batch process ACKs
-        if (this.receivedFrameSequences.size > 0) {
-            const ackSeqs = Array.from(this.receivedFrameSequences);
-            this.receivedFrameSequences.clear();
-            const ack = new proto_1.Ack();
-            ack.sequences = ackSeqs;
-            this.client.send(ack.serialize());
-        }
-        // Batch process NACKs
-        if (this.lostFrameSequences.size > 0) {
-            const nackSeqs = Array.from(this.lostFrameSequences);
-            this.lostFrameSequences.clear();
-            const nack = new proto_1.Nack();
-            nack.sequences = nackSeqs;
-            this.client.send(nack.serialize());
-        }
-    }
-    processBatchedOrderedFrames(now) {
-        const processedChannels = new Set();
-        for (let channel = 0; channel < this.inputOrderingQueue.length; channel++) {
-            if (processedChannels.has(channel))
-                continue;
-            const queue = this.inputOrderingQueue[channel];
-            let processed = 0;
-            let expected = this.inputOrderIndex[channel];
-            while (queue.has(expected) && processed < this.BATCH_SIZE) {
-                const queued = queue.get(expected);
-                if (!queued) {
-                    expected++;
-                    continue;
-                }
-                if (now - queued.timestamp > this.ORDERING_QUEUE_TIMEOUT) {
-                    this.processFrame(queued.frame);
-                    queue.delete(expected);
-                    expected++;
-                    processed++;
-                }
-                else {
-                    break;
-                }
-            }
-            if (processed > 0) {
-                this.inputOrderIndex[channel] = expected;
-                processedChannels.add(channel);
-            }
-        }
-    }
-    incomingMessage(payload, rinfo) {
-        let header = payload.readUint8();
-        if ((header & PACKET_HEADER_MASK) === PACKET_HEADER_FRAMESET)
-            header = PACKET_HEADER_FRAMESET;
-        switch (header) {
-            case proto_1.Packet.Ack: {
-                const ack = new proto_1.Ack(payload).deserialize();
-                for (let i = 0, len = ack.sequences.length; i < len; i++) {
-                    this.outputBackup.delete(ack.sequences[i]);
-                }
-                break;
-            }
-            case proto_1.Packet.Nack: {
-                const nack = new proto_1.Nack(payload).deserialize();
-                for (let i = 0, len = nack.sequences.length; i < len; i++) {
-                    const seq = nack.sequences[i];
-                    const lostFrames = this.outputBackup.get(seq) || [];
-                    for (let j = 0, lostLen = lostFrames.length; j < lostLen; j++) {
-                        this.sendFrame(lostFrames[j], proto_1.Priority.Immediate);
-                    }
-                }
-                break;
-            }
-            case proto_1.Packet.UnconnectedPong: {
-                const packet = new proto_1.UnconnectedPong(payload).deserialize();
-                this.client.emit("unconnected-pong", packet);
-                break;
-            }
-            case proto_1.Packet.OpenConnectionReplyOne: {
-                const packet = new proto_1.OpenConnectionReplyOne(payload).deserialize();
-                this.client.emit("open-connection-reply-one", packet);
-                this.client.serverAddress = new proto_1.Address(rinfo.address, rinfo.port, rinfo.family === "IPv4" ? 4 : 6);
-                const request = new proto_1.OpenConnectionRequestTwo();
-                request.mtu = packet.mtu;
-                request.address = this.client.serverAddress;
-                request.clientGuid = this.client.options.clientId;
-                this.client.emit("open-connection-request-two", request);
-                this.client.send(request.serialize());
-                break;
-            }
-            case proto_1.Packet.OpenConnectionReplyTwo: {
-                const packet = new proto_1.OpenConnectionReplyTwo(payload).deserialize();
-                this.client.emit("open-connection-reply-two", packet);
-                this.client.options.mtuSize = packet.mtu;
-                const conReq = new proto_1.ConnectionRequest();
-                conReq.clientGuid = this.client.options.clientId;
-                conReq.timestamp = BigInt(Date.now());
-                conReq.useSecurity = false;
-                this.client.emit("connection-request", conReq);
-                this.frameAndSend(conReq.serialize(), proto_1.Priority.Immediate);
-                break;
-            }
-            case PACKET_HEADER_FRAMESET: {
-                const frameset = new proto_2.Frameset(payload).deserialize();
-                this.client.emit("frameset", frameset);
-                this.handle(frameset);
-                break;
-            }
-            default: {
-                utils_1.Logger.error(`Unknown packet header: ${header}`);
-            }
-        }
-    }
-    processFrame(frame) {
-        const header = frame.payload[0];
-        if (this.client.options.debug) {
-            utils_1.Logger.debug(`[Framer] Processing frame with header ${header}`);
-        }
-        if (this.client.status === proto_1.Status.Connecting) {
-            switch (header) {
-                case proto_1.Packet.ConnectionRequest: {
-                    const packet = new proto_1.ConnectionRequest(frame.payload).deserialize();
-                    this.client.emit("connection-request", packet);
-                    break;
-                }
-                case proto_1.Packet.ConnectionRequestAccepted: {
-                    const packet = new connection_request_accepted_1.ConnectionRequestAccepted(frame.payload).deserialize();
-                    const newI = new proto_1.NewIncomingConnection();
-                    proto_1.SystemAddress.count = 20;
-                    if (!this.client.serverAddress) {
-                        utils_1.Logger.error("[Framer] Cannot create NewIncomingConnection: serverAddress is null");
-                        return;
-                    }
-                    newI.serverAddress = this.client.serverAddress;
-                    newI.incomingTimestamp = BigInt(Date.now());
-                    newI.serverTimestamp = packet.timestamp;
-                    this.client.emit("new-incoming-connection", newI);
-                    this.frameAndSend(newI.serialize(), proto_1.Priority.Immediate);
-                    proto_1.SystemAddress.count = 0;
-                    break;
-                }
-                case proto_1.Packet.DisconnectionNotification: {
-                    utils_1.Logger.info("[Framer] Received disconnection notification while connecting");
-                    this.client.cleanup();
-                    break;
-                }
-            }
-        }
-        else if (this.client.status === proto_1.Status.Connected) {
-            switch (header) {
-                case proto_1.Packet.ConnectedPing: {
-                    const packet = new proto_1.ConnectedPing(frame.payload).deserialize();
-                    this.client.emit("connected-ping", packet);
-                    const pong = new proto_1.ConnectedPong();
-                    pong.pongTime = BigInt(Date.now());
-                    pong.pingTime = packet.timestamp;
-                    this.frameAndSend(pong.serialize(), proto_1.Priority.Immediate);
-                    break;
-                }
-                case proto_1.Packet.ConnectedPong: {
-                    const packet = new proto_1.ConnectedPong(frame.payload).deserialize();
-                    if (this.client.options.debug) {
-                        utils_1.Logger.debug(`[Framer] Received pong, latency: ${Date.now() - Number(packet.pingTime)}ms`);
-                    }
-                    this.client.emit("connected-pong", packet);
-                    break;
-                }
-                case PACKET_ENCAPSULATED: {
-                    this.client.emit("encapsulated", frame.payload);
-                    break;
-                }
-                case proto_1.Packet.DisconnectionNotification: {
-                    utils_1.Logger.info("[Framer] Received disconnection notification");
-                    this.client.cleanup();
-                    break;
-                }
-            }
-        }
-    }
-    handle(frameSet) {
-        try {
-            if (this.receivedFrameSequences.has(frameSet.sequence)) {
-                if (this.client.options.debug) {
-                    utils_1.Logger.debug(`[Framer] Received duplicate frameset ${frameSet.sequence}`);
-                }
-                return;
-            }
-            this.lostFrameSequences.delete(frameSet.sequence);
-            if (frameSet.sequence <= this.lastInputSequence) {
-                if (this.client.options.debug) {
-                    utils_1.Logger.debug(`[Framer] Received out of order frameset ${frameSet.sequence}!`);
-                }
-                return;
-            }
-            this.receivedFrameSequences.add(frameSet.sequence);
-            const sequenceGap = frameSet.sequence - this.lastInputSequence;
-            if (sequenceGap > 1) {
-                if (this.client.options.debug) {
-                    utils_1.Logger.debug(`[Framer] Detected ${sequenceGap - 1} missing sequences between ${this.lastInputSequence} and ${frameSet.sequence}`);
-                }
-                for (let index = this.lastInputSequence + 1; index < frameSet.sequence; index++) {
-                    this.lostFrameSequences.add(index);
-                }
-            }
-            this.lastInputSequence = frameSet.sequence;
-            // Process frames in batches
-            const frames = frameSet.frames;
-            for (let i = 0; i < frames.length; i += this.BATCH_SIZE) {
-                const batch = frames.slice(i, i + this.BATCH_SIZE);
-                for (const frame of batch) {
-                    try {
-                        this.handleFrame(frame);
-                    }
-                    catch (err) {
-                        utils_1.Logger.error("[Framer] Error handling frame", err);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            utils_1.Logger.error("[Framer] Error handling frameset", err);
-        }
-    }
-    handleFrame(frame) {
-        if (frame.isSplit) {
-            this.handleSplit(frame);
-        }
-        else if (frame.isSequenced) {
-            this.handleSequenced(frame);
-        }
-        else if (frame.isOrdered) {
-            this.handleOrdered(frame);
-        }
-        else {
-            this.processFrame(frame);
-        }
-    }
-    handleOrdered(frame) {
-        const channel = frame.orderChannel;
-        const expectedOrderIndex = this.inputOrderIndex[channel];
-        if (frame.orderedFrameIndex === expectedOrderIndex) {
-            this.processOrderedFrames(frame);
-        }
-        else if (frame.orderedFrameIndex > expectedOrderIndex) {
-            this.inputOrderingQueue[channel].set(frame.orderedFrameIndex, {
-                frame,
-                timestamp: Date.now(),
-            });
-        }
-    }
-    processOrderedFrames(frame) {
-        const channel = frame.orderChannel;
-        this.inputOrderIndex[channel] = frame.orderedFrameIndex + 1;
-        this.inputHighestSequenceIndex[channel] = 0;
-        this.processFrame(frame);
-        const queue = this.inputOrderingQueue[channel];
-        let nextOrderIndex = this.inputOrderIndex[channel];
-        while (queue.has(nextOrderIndex)) {
-            const queued = queue.get(nextOrderIndex);
-            if (!queued) {
-                nextOrderIndex++;
-                continue;
-            }
-            this.processFrame(queued.frame);
-            queue.delete(nextOrderIndex);
-            nextOrderIndex++;
-        }
-        this.inputOrderIndex[channel] = nextOrderIndex;
-    }
-    handleSequenced(frame) {
-        const channel = frame.orderChannel;
-        const currentHighestSequence = this.inputHighestSequenceIndex[channel];
-        if (frame.sequenceFrameIndex < currentHighestSequence ||
-            frame.orderedFrameIndex === this.inputOrderIndex[channel]) {
-            return;
-        }
-        this.inputHighestSequenceIndex[channel] = frame.sequenceFrameIndex + 1;
-        this.processFrame(frame);
-    }
-    handleSplit(frame) {
-        const splitId = frame.splitId;
-        let entry = this.fragmentsQueue.get(splitId);
-        if (!entry) {
-            entry = { fragments: new Map(), timestamp: Date.now() };
-            this.fragmentsQueue.set(splitId, entry);
-        }
-        entry.fragments.set(frame.splitFrameIndex, frame);
-        if (entry.fragments.size === frame.splitCount) {
-            this.reassembleAndProcessFragment(frame, entry.fragments);
-            this.fragmentsQueue.delete(splitId);
-        }
-    }
-    reassembleAndProcessFragment(frame, fragment) {
-        const stream = new binarystream_1.BinaryStream();
-        for (let index = 0; index < frame.splitCount; index++) {
-            const sframe = fragment.get(index);
-            if (!sframe) {
-                utils_1.Logger.error(`Missing fragment at index ${index} for splitId=${frame.splitId}`);
-                return;
-            }
-            stream.writeBuffer(sframe.payload);
-        }
-        const reassembledFrame = new proto_1.Frame();
-        reassembledFrame.reliability = frame.reliability;
-        reassembledFrame.reliableFrameIndex = frame.reliableFrameIndex;
-        reassembledFrame.sequenceFrameIndex = frame.sequenceFrameIndex;
-        reassembledFrame.orderedFrameIndex = frame.orderedFrameIndex;
-        reassembledFrame.orderChannel = frame.orderChannel;
-        reassembledFrame.payload = stream.getBuffer();
-        this.handleFrame(reassembledFrame);
-    }
-    frameAndSend(payload, priority = proto_1.Priority.Normal) {
-        const frame = new proto_1.Frame();
-        frame.orderChannel = 0;
-        frame.payload = payload;
-        this.sendFrame(frame, priority);
-    }
-    sendFrame(frame, priority) {
-        const channel = frame.orderChannel;
-        if (frame.isSequenced) {
-            frame.orderedFrameIndex = this.outputOrderIndex[channel];
-            frame.sequenceFrameIndex = this.outputSequenceIndex[channel]++;
-        }
-        else if (frame.isOrdered) {
-            frame.orderedFrameIndex = this.outputOrderIndex[channel]++;
-            this.outputSequenceIndex[channel] = 0;
-        }
-        const maxSize = this.mtuDiff;
-        const payloadSize = frame.payload.byteLength;
-        if (payloadSize > maxSize) {
-            const splitSize = Math.ceil(payloadSize / maxSize);
-            const splitId = this.outputSplitIndex++ & 0xffff;
-            for (let index = 0; index < payloadSize; index += maxSize) {
-                const nframe = this.createSplitFrame(frame, index, maxSize, splitId, splitSize);
-                this.queueFrame(nframe, priority);
-            }
-        }
-        else {
-            if (frame.isReliable) {
-                frame.reliableFrameIndex = this.outputReliableIndex++;
-            }
-            this.queueFrame(frame, priority);
-        }
-    }
-    createSplitFrame(originalFrame, index, maxSize, splitId, splitSize) {
-        const nframe = new proto_1.Frame();
-        if (originalFrame.isReliable) {
-            nframe.reliableFrameIndex = this.outputReliableIndex++;
-        }
-        nframe.sequenceFrameIndex = originalFrame.sequenceFrameIndex;
-        nframe.orderedFrameIndex = originalFrame.orderedFrameIndex;
-        nframe.orderChannel = originalFrame.orderChannel;
-        nframe.reliability = originalFrame.reliability;
-        nframe.payload = originalFrame.payload.subarray(index, index + maxSize);
-        nframe.splitFrameIndex = index / maxSize;
-        nframe.splitId = splitId;
-        nframe.splitCount = splitSize;
-        return nframe;
-    }
-    queueFrame(frame, priority) {
-        const frameLength = frame.getByteLength();
-        const totalLength = 4 + this.outputFramesByteLength + frameLength;
-        if (totalLength > this.mtuDiff ||
-            this.outputFrames.length >= this.BATCH_SIZE) {
-            this.sendQueue(this.outputFrames.length);
-            this.lastBatchTime = Date.now();
-        }
-        this.outputFrames.push(frame);
-        this.outputFramesByteLength += frameLength;
-        if (priority === proto_1.Priority.Immediate) {
-            this.sendQueue(1);
-            this.lastBatchTime = Date.now();
-        }
-    }
-    sendQueue(amount) {
-        if (this.outputFrames.length === 0)
-            return;
-        const frameset = new proto_2.Frameset();
-        frameset.sequence = this.outputSequence++;
-        // Send in batches if amount is larger than batch size
-        const remainingFrames = [...this.outputFrames];
-        this.outputFrames = [];
-        while (remainingFrames.length > 0) {
-            const batchSize = Math.min(this.BATCH_SIZE, remainingFrames.length);
-            const framesToSend = remainingFrames.splice(0, batchSize);
-            frameset.frames = framesToSend;
-            const sentLength = framesToSend.reduce((sum, f) => sum + f.getByteLength(), 0);
-            this.outputFramesByteLength -= sentLength;
-            this.outputBackup.set(frameset.sequence, framesToSend);
-            this.client.send(frameset.serialize());
-            // Increment sequence for next batch if there are more frames
-            if (remainingFrames.length > 0) {
-                frameset.sequence = this.outputSequence++;
-            }
-        }
-    }
-}
-exports.Framer = Framer;

package/dist/proto/decorators/create.d.ts

@@ -1,8 +0,0 @@
-import type { BasePacket } from "../packets";
-/**
- * Thanks to SerenityJS as an example.
- * @param id
- * @returns
- */
-export declare function Create(id: number): (target: typeof BasePacket) => void;
-//# sourceMappingURL=create.d.ts.map

package/dist/proto/decorators/create.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/proto/decorators/create.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,YAAY,CAAC;AAQvD;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,IACxB,QAAQ,OAAO,UAAU,UAwEjC"}

package/dist/proto/decorators/create.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Create = Create;
-/**
- * Thanks to SerenityJS as an example.
- * @param id
- * @returns
- */
-function Create(id) {
-    return (target) => {
-        target.id = id;
-        const packetData = Reflect.getOwnMetadata("properties", target.prototype);
-        const properties = Object.getOwnPropertyNames(target.prototype);
-        if (!properties.includes("serialize")) {
-            target.prototype.serialize = function () {
-                this.flush();
-                if (id <= 255)
-                    this.writeUint8(id);
-                else if (id <= 65535)
-                    this.writeUint16(id);
-                else if (id <= 4294967295)
-                    this.writeUint32(id);
-                else
-                    throw new Error("Packet ID cannot be greater than 4294967295.");
-                if (!packetData)
-                    return this.getBuffer();
-                for (const { name, type, endian, parameter } of packetData) {
-                    if (parameter) {
-                        const value = this[parameter];
-                        const dtype = type;
-                        const data = this[name];
-                        dtype.write(this, data, endian, value);
-                    }
-                    else {
-                        const dtype = type;
-                        const data = this[name];
-                        dtype.write(this, data, endian);
-                    }
-                }
-                return Buffer.from(this.binary);
-            };
-        }
-        if (!properties.includes("deserialize")) {
-            target.prototype.deserialize = function () {
-                if (this.binary.length === 0)
-                    return this;
-                if (id <= 255)
-                    target.id = this.readUint8();
-                else if (id <= 65535)
-                    target.id = this.readUint16();
-                else if (id <= 4294967295)
-                    target.id = this.readUint32();
-                else
-                    throw new Error("Invalid packet ID range");
-                if (!packetData)
-                    return this;
-                for (const { name, type, endian, parameter } of packetData) {
-                    if (parameter) {
-                        const value = this[parameter];
-                        const dtype = type;
-                        const data = this[name];
-                        this[name] = dtype.read(this, endian, value);
-                    }
-                    else {
-                        const dtype = type;
-                        const data = this[name];
-                        this[name] = dtype.read(this, endian);
-                    }
-                }
-                return this;
-            };
-        }
-        if (!properties.includes("getId")) {
-            target.prototype.getId = () => target.id;
-        }
-    };
-}

package/dist/proto/decorators/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./create";
-export * from "./serialize";
-//# sourceMappingURL=index.d.ts.map

package/dist/proto/decorators/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/proto/decorators/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC"}

package/dist/proto/decorators/serialize.d.ts

@@ -1,4 +0,0 @@
-import { Endianness } from "@serenityjs/binarystream";
-import type { ValidTypes } from "../types";
-export declare function Serialize(type: ValidTypes, endian?: Endianness | boolean, parameter?: string): (target: object, propertyKey: string) => void;
-//# sourceMappingURL=serialize.d.ts.map

package/dist/proto/decorators/serialize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../../src/proto/decorators/serialize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3C,wBAAgB,SAAS,CACxB,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,UAAU,GAAG,OAAwB,EAC7C,SAAS,CAAC,EAAE,MAAM,IAGV,QAAQ,MAAM,EAAE,aAAa,MAAM,UAK3C"}

package/dist/proto/decorators/serialize.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Serialize = Serialize;
-function Serialize(type, endian = 0 /* Endianness.Big */, parameter) {
-    if (!type)
-        throw new Error("@Serialize() must be given a type.");
-    return (target, propertyKey) => {
-        const properties = Reflect.getMetadata("properties", target) || [];
-        properties.push({ name: propertyKey, type, endian, parameter });
-        Reflect.defineMetadata("properties", properties, target);
-    };
-}

package/dist/proto/enums/flags.d.ts

@@ -1,7 +0,0 @@
-export declare enum Flags {
-    Split = 16,
-    Valid = 128,
-    Ack = 64,
-    Nak = 32
-}
-//# sourceMappingURL=flags.d.ts.map

package/dist/proto/enums/flags.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../../src/proto/enums/flags.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK;IAChB,KAAK,KAAO;IACZ,KAAK,MAAO;IACZ,GAAG,KAAO;IACV,GAAG,KAAO;CACV"}

package/dist/proto/enums/flags.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Flags = void 0;
-var Flags;
-(function (Flags) {
-    Flags[Flags["Split"] = 16] = "Split";
-    Flags[Flags["Valid"] = 128] = "Valid";
-    Flags[Flags["Ack"] = 64] = "Ack";
-    Flags[Flags["Nak"] = 32] = "Nak";
-})(Flags || (exports.Flags = Flags = {}));

package/dist/proto/enums/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./packet";
-export * from "./flags";
-export * from "./reliability";
-export * from "./priority";
-export * from "./status";
-//# sourceMappingURL=index.d.ts.map

package/dist/proto/enums/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/proto/enums/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC"}