kcp.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Kcp = exports.setToken = exports.getToken = exports.setConv = exports.getConv = void 0;
//
// Copyright (c) 2022 chiya.dev
//
// Use of this source code is governed by the MIT License
// which can be found below:
//
//   https://opensource.org/licenses/MIT
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// This is a pure TypeScript Node.js KCP implementation for Genshin Impact.
// Evolution of KCP:
//
// - https://github.com/skywind3000/kcp
//   The original KCP protocol was written in C by skywind3000.
//
// - https://github.com/Matrix-Zhang/kcp
//   The original implementation was ported to Rust by Matrix-Zhang.
//
// - <somewhere on the invisible internet>
//   The Rust port was modified to support Genshin Impact by PartyPooper.
//
// - https://github.com/boba-ps/kcp-ts
//   The modified Rust port was ported to TypeScript by phosphene47.
//
const denque_1 = __importDefault(require("denque"));
const EMPTY_BUFFER = Buffer.alloc(0);
const KCP_RTO_NDL = 30;
const KCP_RTO_MIN = 100;
const KCP_RTO_DEF = 200;
const KCP_RTO_MAX = 60000;
const KCP_CMD_PUSH = 81;
const KCP_CMD_ACK = 82;
const KCP_CMD_WASK = 83;
const KCP_CMD_WINS = 84;
const KCP_ASK_SEND = 1;
const KCP_ASK_TELL = 2;
const KCP_WND_SND = 32;
//const KCP_WND_RCV: u16 = 128;
const KCP_WND_RCV = 256;
const KCP_MTU_DEF = 1400;
// const KCP_ACK_FAST: u32 = 3;
const KCP_INTERVAL = 100;
//pub const KCP_OVERHEAD: usize = 24;
const KCP_OVERHEAD = 28;
// const KCP_DEADLINK: u32 = 20;
const KCP_THRESH_INIT = 2;
const KCP_THRESH_MIN = 2;
const KCP_PROBE_INIT = 7000;
const KCP_PROBE_LIMIT = 120000;
/// Read `conv` from raw buffer
function getConv(packet) {
    return packet.readUInt32LE();
}
exports.getConv = getConv;
/// Set `conv` to raw buffer
function setConv(packet, conv) {
    packet.writeUInt32LE(conv);
}
exports.setConv = setConv;
/// Get `token` from raw buffer
function getToken(packet) {
    return packet.readUInt32LE(4);
}
exports.getToken = getToken;
/// Set `token` to raw buffer
function setToken(packet, token) {
    packet.writeUInt32LE(token, 4);
}
exports.setToken = setToken;
function createSegment(data) {
    return {
        conv: 0,
        token: 0,
        cmd: 0,
        frg: 0,
        wnd: 0,
        ts: 0,
        sn: 0,
        una: 0,
        resendTs: 0,
        rto: 0,
        fastAck: 0,
        xmit: 0,
        data,
    };
}
function encodeSegment(buf, seg) {
    const size = segmentSize(seg);
    if (buf.length < size) {
        throw Error(`buffer too small to encode kcp segment of size ${size}`);
    }
    buf.writeUInt32LE(seg.conv);
    buf.writeUInt32LE(seg.token, 4);
    buf.writeUInt8(seg.cmd, 8);
    buf.writeUInt8(seg.frg, 9);
    buf.writeUInt16LE(seg.wnd, 10);
    buf.writeUInt32LE(seg.ts, 12);
    buf.writeUInt32LE(seg.sn, 16);
    buf.writeUInt32LE(seg.una, 20);
    buf.writeUInt32LE(seg.data.length, 24);
    seg.data.copy(buf, 28);
    return size;
}
function segmentSize(seg) {
    return KCP_OVERHEAD + seg.data.length;
}
class Kcp {
    constructor(conv, token, output, stream = false) {
        this.conv = conv >>> 0;
        this.token = token >>> 0;
        this.sndUna = 0;
        this.sndNxt = 0;
        this.rcvNxt = 0;
        this.rxRttVal = 0;
        this.rxsRtt = 0;
        this.state = 0;
        this.cWnd = 0;
        this.probe = 0;
        this.current = 0;
        this.nodelay = false;
        this.updated = false;
        this.tsProbe = 0;
        this.probeWait = 0;
        this.deadLink = 10;
        this.incr = 0;
        this.fastResend = 0;
        this.nocwnd = false;
        this.stream = !!stream;
        this.sndWnd = KCP_WND_SND;
        this.rcvWnd = KCP_WND_RCV;
        this.rmtWnd = KCP_WND_RCV;
        this.mtu = KCP_MTU_DEF;
        this.mss = KCP_MTU_DEF - KCP_OVERHEAD;
        this.buf = Buffer.alloc((KCP_MTU_DEF + KCP_OVERHEAD) * 3);
        this.bufOffset = 0;
        this.sndQueue = new denque_1.default();
        this.rcvQueue = new denque_1.default();
        this.sndBuf = new denque_1.default();
        this.rcvBuf = new denque_1.default();
        this.acklist = new denque_1.default();
        this.rxRto = KCP_RTO_DEF;
        this.rxMinRto = KCP_RTO_MIN;
        this.interval = KCP_INTERVAL;
        this.tsFlush = KCP_INTERVAL;
        this.ssThresh = KCP_THRESH_INIT;
        this.output = output;
    }
    /// Check buffer size without actually consuming it
    peekSize() {
        const segment = this.rcvQueue.peekFront();
        if (!segment)
            return -1;
        if (segment.frg === 0) {
            return segment.data.length;
        }
        if (this.rcvQueue.length < segment.frg + 1) {
            return -1;
        }
        let len = 0;
        for (let i = 0; i < this.rcvQueue.length; i++) {
            const segment = this.rcvQueue.peekAt(i);
            len += segment.data.length;
            if (segment.frg === 0) {
                break;
            }
        }
        return len;
    }
    // move available data from rcv_buf -> rcv_queue
    moveBuf() {
        while (!this.rcvBuf.isEmpty()) {
            const nrcvQueue = this.rcvQueue.length;
            const seg = this.rcvBuf.peekFront();
            if (seg.sn === this.rcvNxt && nrcvQueue < this.rcvWnd) {
                this.rcvNxt += 1;
            }
            else {
                break;
            }
            this.rcvBuf.shift();
            this.rcvQueue.push(seg);
        }
    }
    /// Receive data from buffer
    recv(buf, offset = 0) {
        offset >>>= 0;
        if (!Buffer.isBuffer(buf) || this.rcvQueue.isEmpty()) {
            return -1;
        }
        const peekSize = this.peekSize();
        if (peekSize < 0)
            return -2;
        if (peekSize > buf.length)
            return -3;
        const recover = this.rcvQueue.length >= this.rcvWnd;
        // Merge fragment
        let seg;
        while ((seg = this.rcvQueue.shift())) {
            seg.data.copy(buf, offset);
            offset += seg.data.length;
            if (seg.frg === 0) {
                break;
            }
        }
        //assert(offset === peekSize);
        this.moveBuf();
        // fast recover
        if (this.rcvQueue.length < this.rcvWnd && recover) {
            this.probe |= KCP_ASK_TELL;
        }
        return peekSize;
    }
    /// Send bytes into buffer
    send(buf) {
        if (!Buffer.isBuffer(buf)) {
            return -1;
        }
        let sentSize = 0;
        //assert(this.mss > 0)
        // append to previous segment in streaming mode (if possible)
        if (this.stream) {
            const old = this.sndQueue.peekBack();
            if (old) {
                const l = old.data.length;
                if (l < this.mss) {
                    const capacity = (this.mss - l) >>> 0;
                    const extend = Math.min(buf.length, capacity);
                    const lf = buf.slice(0, extend);
                    const rt = buf.slice(extend);
                    old.data = Buffer.concat([old.data, lf]);
                    buf = rt;
                    old.frg = 0;
                    sentSize += extend;
                }
                if (buf.length === 0) {
                    return sentSize;
                }
            }
        }
        let count;
        if (buf.length <= this.mss) {
            count = 1;
        }
        else {
            count = ((buf.length + this.mss - 1) / this.mss) >>> 0;
        }
        if (count >= KCP_WND_RCV) {
            return -2;
        }
        //assert(count > 0)
        for (let i = 0; i < count; i++) {
            const size = Math.min(this.mss, buf.length);
            const lf = buf.slice(0, size);
            const rt = buf.slice(size);
            let newSegment = createSegment(lf);
            buf = rt;
            if (this.stream) {
                newSegment.frg = 0;
            }
            else {
                newSegment.frg = ((count - i - 1) << 24) >>> 24;
            }
            this.sndQueue.push(newSegment);
            sentSize += size;
        }
        return sentSize;
    }
    updateAck(rtt) {
        rtt >>>= 0;
        if (this.rxsRtt === 0) {
            this.rxsRtt = rtt;
            this.rxRttVal = (rtt / 2) >>> 0;
        }
        else {
            let delta;
            if (rtt > this.rxsRtt) {
                delta = rtt - this.rxsRtt;
            }
            else {
                delta = this.rxsRtt - rtt;
            }
            this.rxRttVal = ((3 * this.rxRttVal + delta) / 4) >>> 0;
            this.rxsRtt = ((7 * this.rxsRtt + rtt) / 8) >>> 0;
            if (this.rxsRtt < 1) {
                this.rxsRtt = 1;
            }
        }
        const rto = this.rxsRtt + Math.max(this.interval, 4 * this.rxRttVal);
        this.rxRto = Math.max(this.rxMinRto, Math.min(rto, KCP_RTO_MAX));
    }
    shrinkBuf() {
        const seg = this.sndBuf.peekFront();
        if (seg) {
            this.sndUna = seg.sn;
        }
        else {
            this.sndUna = this.sndNxt;
        }
    }
    parseAck(sn) {
        sn >>>= 0;
        if (sn - this.sndUna < 0 || sn - this.sndNxt >= 0) {
            return;
        }
        const bufSize = this.sndBuf.length;
        for (let i = 0; i < bufSize; i++) {
            const seg = this.sndBuf.peekAt(i);
            if (sn === seg.sn) {
                this.sndBuf.removeOne(i);
            }
            else if (sn < seg.sn) {
                break;
            }
        }
    }
    parseUna(una) {
        una >>>= 0;
        while (!this.sndBuf.isEmpty()) {
            if (una - this.sndBuf.peekFront().sn > 0) {
                this.sndBuf.shift();
            }
            else {
                break;
            }
        }
    }
    parseFastAck(sn) {
        sn >>>= 0;
        if (sn - this.sndUna < 0 || sn - this.sndNxt >= 0) {
            return;
        }
        for (let i = 0; i < this.sndBuf.length; i++) {
            const seg = this.sndBuf.peekAt(i);
            if (sn - seg.sn < 0) {
                break;
            }
            else if (sn !== seg.sn) {
                seg.fastAck += 1;
            }
        }
    }
    ackPush(sn, ts) {
        this.acklist.push([sn >>> 0, ts >>> 0]);
    }
    parseData(newSegment) {
        const sn = newSegment.sn;
        if (sn - (this.rcvNxt + this.rcvWnd) >= 0 || sn - this.rcvNxt < 0) {
            return;
        }
        let repeat = false;
        let newIndex = this.rcvBuf.length;
        for (let i = this.rcvBuf.length - 1; i >= 0; i--) {
            const segment = this.rcvBuf.peekAt(i);
            if (segment.sn === sn) {
                repeat = true;
                break;
            }
            else if (sn - segment.sn > 0) {
                break;
            }
            newIndex -= 1;
        }
        if (!repeat) {
            this.rcvBuf.splice(newIndex, 0, newSegment);
        }
        // move available data from rcv_buf -> rcv_queue
        this.moveBuf();
    }
    /// Call this when you received a packet from raw connection
    input(buf) {
        if (!Buffer.isBuffer(buf) || buf.length < KCP_OVERHEAD) {
            return -1;
        }
        let totalRead = 0;
        let flag = false;
        let maxAck = 0;
        const oldUna = this.sndUna;
        while (buf.length >= KCP_OVERHEAD) {
            const conv = buf.readUInt32LE();
            const token = buf.readUInt32LE(4);
            const cmd = buf.readUInt8(8);
            const frg = buf.readUInt8(9);
            const wnd = buf.readUInt16LE(10);
            const ts = buf.readUInt32LE(12);
            const sn = buf.readUInt32LE(16);
            const una = buf.readUInt32LE(20);
            const len = buf.readUInt32LE(24);
            if (conv !== this.conv) {
                return -1;
            }
            if (token !== this.token) {
                return -1;
            }
            if (buf.length - KCP_OVERHEAD < len) {
                return -2;
            }
            switch (cmd) {
                case KCP_CMD_PUSH:
                case KCP_CMD_ACK:
                case KCP_CMD_WASK:
                case KCP_CMD_WINS:
                    break;
                default:
                    return -3;
            }
            this.rmtWnd = wnd;
            this.parseUna(una);
            this.shrinkBuf();
            switch (cmd) {
                case KCP_CMD_ACK: {
                    const rtt = this.current - ts;
                    if (rtt >= 0) {
                        this.updateAck(rtt);
                    }
                    this.parseAck(sn);
                    this.shrinkBuf();
                    if (!flag) {
                        maxAck = sn;
                        flag = true;
                    }
                    else if (sn - maxAck > 0) {
                        maxAck = sn;
                    }
                    break;
                }
                case KCP_CMD_PUSH: {
                    if (sn - (this.rcvNxt + this.rcvWnd) < 0) {
                        this.ackPush(sn, ts);
                        if (sn - this.rcvNxt >= 0) {
                            const sbuf = buf.slice(KCP_OVERHEAD, KCP_OVERHEAD + len);
                            const segment = createSegment(sbuf);
                            segment.conv = conv;
                            segment.token = token;
                            segment.cmd = cmd;
                            segment.frg = frg;
                            segment.wnd = wnd;
                            segment.ts = ts;
                            segment.sn = sn;
                            segment.una = una;
                            this.parseData(segment);
                        }
                    }
                    break;
                }
                case KCP_CMD_WASK: {
                    this.probe |= KCP_ASK_TELL;
                    break;
                }
                case KCP_CMD_WINS: {
                    // Do nothing
                    break;
                }
            }
            totalRead += KCP_OVERHEAD + len;
            buf = buf.slice(KCP_OVERHEAD + len);
        }
        if (flag) {
            this.parseFastAck(maxAck);
        }
        if (this.sndUna > oldUna && this.cWnd < this.rmtWnd) {
            const mss = this.mss;
            if (this.cWnd < this.ssThresh) {
                this.cWnd += 1;
                this.incr += mss;
            }
            else {
                if (this.incr < mss) {
                    this.incr = mss;
                }
                this.incr += (((mss * mss) / this.incr) >>> 0) + ((mss / 16) >>> 0);
                if ((this.cWnd + 1) * mss <= this.incr) {
                    this.cWnd += 1;
                }
            }
            if (this.cWnd > this.rmtWnd) {
                this.cWnd = this.rmtWnd;
                this.incr = this.rmtWnd * mss;
            }
        }
        return totalRead;
    }
    wndUnused() {
        if (this.rcvQueue.length < this.rcvWnd) {
            return this.rcvWnd - ((this.rcvQueue.length << 16) >>> 16);
        }
        else {
            return 0;
        }
    }
    _flushAck(segment) {
        // flush acknowledges
        for (let i = 0; i < this.acklist.length; i++) {
            const [sn, ts] = this.acklist.peekAt(i);
            if (this.bufOffset + KCP_OVERHEAD > this.mtu) {
                this.output(this.buf.slice(0, this.bufOffset));
                this.bufOffset = 0;
            }
            segment.sn = sn;
            segment.ts = ts;
            this.bufOffset += encodeSegment(this.buf.slice(this.bufOffset), segment);
        }
        this.acklist.clear();
    }
    probeWndSize() {
        // probe window size (if remote window size equals zero)
        if (this.rmtWnd === 0) {
            if (this.probeWait === 0) {
                this.probeWait = KCP_PROBE_INIT;
                this.tsProbe = this.current + this.probeWait;
            }
            else {
                if (this.current - this.tsProbe >= 0 &&
                    this.probeWait < KCP_PROBE_INIT) {
                    this.probeWait = KCP_PROBE_INIT;
                }
                this.probeWait += (this.probeWait / 2) >>> 0;
                if (this.probeWait > KCP_PROBE_LIMIT) {
                    this.probeWait = KCP_PROBE_LIMIT;
                }
                this.tsProbe = this.current + this.probeWait;
                this.probe |= KCP_ASK_SEND;
            }
        }
        else {
            this.tsProbe = 0;
            this.probeWait = 0;
        }
    }
    _flushProbeCommands(cmd, segment) {
        cmd = (cmd << 24) >>> 24;
        segment.cmd = cmd;
        if (this.bufOffset + KCP_OVERHEAD > this.mtu) {
            this.output(this.buf.slice(0, this.bufOffset));
            this.bufOffset = 0;
        }
        this.bufOffset += encodeSegment(this.buf.slice(this.bufOffset), segment);
    }
    flushProbeCommands(segment) {
        // flush window probing commands
        if ((this.probe & KCP_ASK_SEND) !== 0) {
            this._flushProbeCommands(KCP_CMD_WASK, segment);
        }
        // flush window probing commands
        if ((this.probe & KCP_ASK_TELL) !== 0) {
            this._flushProbeCommands(KCP_CMD_WINS, segment);
        }
        this.probe = 0;
    }
    /// Flush pending ACKs
    flushAck() {
        if (!this.updated) {
            return;
        }
        const segment = createSegment(EMPTY_BUFFER);
        segment.conv = this.conv;
        segment.cmd = KCP_CMD_ACK;
        segment.wnd = this.wndUnused();
        segment.una = this.rcvNxt;
        this._flushAck(segment);
    }
    /// Flush pending data in buffer.
    flush() {
        if (!this.updated) {
            return;
        }
        const segment = createSegment(EMPTY_BUFFER);
        segment.conv = this.conv;
        segment.token = this.token;
        segment.cmd = KCP_CMD_ACK;
        segment.wnd = this.wndUnused();
        segment.una = this.rcvNxt;
        this._flushAck(segment);
        this.probeWndSize();
        this.flushProbeCommands(segment);
        // calculate window size
        let cWnd = Math.min(this.sndWnd, this.rmtWnd);
        if (!this.nocwnd) {
            cWnd = Math.min(this.cWnd, cWnd);
        }
        // move data from snd_queue to snd_buf
        while (this.sndNxt - (this.sndUna + cWnd) < 0) {
            const newSegment = this.sndQueue.shift();
            if (!newSegment)
                break;
            newSegment.conv = this.conv;
            newSegment.token = this.token;
            newSegment.cmd = KCP_CMD_PUSH;
            newSegment.wnd = segment.wnd;
            newSegment.ts = this.current;
            newSegment.sn = this.sndNxt;
            this.sndNxt += 1;
            newSegment.una = this.rcvNxt;
            newSegment.resendTs = this.current;
            newSegment.rto = this.rxRto;
            newSegment.fastAck = 0;
            newSegment.xmit = 0;
            this.sndBuf.push(newSegment);
        }
        // calculate resent
        const resent = this.fastResend > 0 ? this.fastResend : 0xffffffff;
        const rtoMin = !this.nodelay ? this.rxRto >>> 3 : 0;
        let lost = false;
        let change = 0;
        for (let i = 0; i < this.sndBuf.length; i++) {
            const sndSegment = this.sndBuf.peekAt(i);
            let needSend = false;
            if (sndSegment.xmit === 0) {
                needSend = true;
                sndSegment.xmit += 1;
                sndSegment.rto = this.rxRto;
                sndSegment.resendTs = this.current + sndSegment.rto + rtoMin;
            }
            else if (this.current - sndSegment.resendTs >= 0) {
                needSend = true;
                sndSegment.xmit += 1;
                if (!this.nodelay) {
                    sndSegment.rto += this.rxRto;
                }
                else {
                    sndSegment.rto += (this.rxRto / 2) >>> 0;
                }
                sndSegment.resendTs = this.current + sndSegment.rto;
                lost = true;
            }
            else if (sndSegment.fastAck >= resent) {
                needSend = true;
                sndSegment.xmit += 1;
                sndSegment.fastAck = 0;
                sndSegment.resendTs = this.current + sndSegment.rto;
                change += 1;
            }
            if (needSend) {
                sndSegment.ts = this.current;
                sndSegment.wnd = segment.wnd;
                sndSegment.una = this.rcvNxt;
                const need = KCP_OVERHEAD + sndSegment.data.length;
                if (this.bufOffset + need > this.mtu) {
                    this.output(this.buf.slice(0, this.bufOffset));
                    this.bufOffset = 0;
                }
                this.bufOffset += encodeSegment(this.buf.slice(this.bufOffset), sndSegment);
                if (sndSegment.xmit >= this.deadLink) {
                    this.state = -1;
                }
            }
        }
        // Flush all data in buffer
        if (this.bufOffset > 0) {
            this.output(this.buf.slice(0, this.bufOffset));
            this.bufOffset = 0;
        }
        // update ssthresh
        if (change > 0) {
            const inflight = (this.sndNxt - this.sndUna) >>> 0;
            this.ssThresh = (((inflight << 16) >>> 16) / 2) >>> 0;
            if (this.ssThresh < KCP_THRESH_MIN) {
                this.ssThresh = KCP_THRESH_MIN;
            }
            this.cWnd = this.ssThresh + ((resent << 16) >>> 16);
            this.incr = this.cWnd * this.mss;
        }
        if (lost) {
            this.ssThresh = (cWnd / 2) >>> 0;
            if (this.ssThresh < KCP_THRESH_MIN) {
                this.ssThresh = KCP_THRESH_MIN;
            }
            this.cWnd = 1;
            this.incr = this.mss;
        }
        if (this.cWnd < 1) {
            this.cWnd = 1;
            this.incr = this.mss;
        }
    }
    /// Update state every 10ms ~ 100ms.
    ///
    /// Or you can ask `check` when to call this again.
    update(current) {
        current >>>= 0;
        this.current = current;
        if (!this.updated) {
            this.updated = true;
            this.tsFlush = this.current;
        }
        let slap = this.current - this.tsFlush;
        if (slap >= 10000 || slap < -10000) {
            this.tsFlush = this.current;
            slap = 0;
        }
        if (slap >= 0) {
            this.tsFlush += this.interval;
            if (this.current - this.tsFlush >= 0) {
                this.tsFlush = this.current + this.interval;
            }
            this.flush();
        }
    }
    /// Determine when you should call `update`.
    /// Return when you should invoke `update` in millisec, if there is no `input`/`send` calling.
    /// You can call `update` in that time without calling it repeatly.
    check(current) {
        current >>>= 0;
        if (!this.updated) {
            return 0;
        }
        let tsFlush = this.tsFlush;
        let tmPacket = 0xffffffff;
        if (current - tsFlush >= 10000 || current - tsFlush < -10000) {
            tsFlush = current;
        }
        if (current - tsFlush >= 0) {
            // return this.interval;
            return 0;
        }
        let tmFlush = (tsFlush - current) >>> 0;
        for (let i = 0; i < this.sndBuf.length; i++) {
            const seg = this.sndBuf.peekAt(i);
            const diff = seg.resendTs - current;
            if (diff <= 0) {
                // return this.interval;
                return 0;
            }
            if (diff < tmPacket) {
                tmPacket = diff;
            }
        }
        return Math.min(tmPacket, tmFlush, this.interval);
    }
    /// Change MTU size, default is 1400
    ///
    /// MTU = Maximum Transmission Unit
    setMtu(mtu) {
        mtu = Math.max(mtu >>> 0, 50, KCP_OVERHEAD);
        this.mtu = mtu;
        this.mss = (mtu - KCP_OVERHEAD) >>> 0;
        this.buf = Buffer.alloc((mtu + KCP_OVERHEAD) * 3);
    }
    /// Get MTU
    getMtu() {
        return this.mtu;
    }
    /// Set check interval
    setInterval(interval) {
        this.interval = Math.max(10, Math.min(interval >>> 0, 5000));
    }
    /// Set nodelay
    ///
    /// fastest config: nodelay(true, 20, 2, true)
    ///
    /// `nodelay`: default is disable (false)
    /// `resend`: 0:disable fast resend(default), 1:enable fast resend
    /// `nc`: `false`: normal congestion control(default), `true`: disable congestion control
    setNodelay(nodelay, resend, nc) {
        if (nodelay) {
            this.nodelay = true;
            this.rxMinRto = KCP_RTO_NDL;
        }
        else {
            this.nodelay = false;
            this.rxMinRto = KCP_RTO_MIN;
        }
        this.fastResend = Math.max(0, resend >>> 0);
        this.nocwnd = !!nc;
    }
    /// Set `wndsize`
    /// set maximum window size: `sndwnd=32`, `rcvwnd=32` by default
    setWndSize(sndWnd, rcvWnd) {
        this.sndWnd = (sndWnd << 16) >>> 16;
        this.rcvWnd = Math.max((rcvWnd << 16) >>> 16, KCP_WND_RCV);
    }
    /// `snd_wnd` Send window
    getSndWnd() {
        return this.sndWnd;
    }
    /// `rcv_wnd` Receive window
    getRcvWnd() {
        return this.rcvWnd;
    }
    /// Get `waitsnd`, how many packet is waiting to be sent
    getWaitSnd() {
        return this.sndBuf.length + this.sndQueue.length;
    }
    /// Set `rx_minrto`
    setRxMinRto(rto) {
        this.rxMinRto = rto >>> 0;
    }
    /// Set `fastresend`
    setFastResend(fr) {
        this.fastResend = fr >>> 0;
    }
    /// KCP header size
    getHeaderLen() {
        return KCP_OVERHEAD;
    }
    /// Enabled stream or not
    isStream() {
        return this.stream;
    }
    /// Maximum Segment Size
    getMss() {
        return this.mss;
    }
    /// Set maximum resend times
    setMaxResend(deadLink) {
        this.deadLink = deadLink >>> 0;
    }
    /// Check if KCP connection is dead (resend times excceeded)
    isDeadLink() {
        return this.state !== 0;
    }
}
exports.Kcp = Kcp;