@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/sctp/chunk.js

@@ -0,0 +1,515 @@
+// ID Value    Chunk Type
+// -----       ----------
+// 0          - Payload Data (DATA)
+// 1          - Initiation (INIT)
+// 2          - Initiation Acknowledgement (INIT ACK)
+// 3          - Selective Acknowledgement (SACK)
+// 4          - Heartbeat Request (HEARTBEAT)
+// 5          - Heartbeat Acknowledgement (HEARTBEAT ACK)
+// 6          - Abort (ABORT)
+// 7          - Shutdown (SHUTDOWN)
+// 8          - Shutdown Acknowledgement (SHUTDOWN ACK)
+// 9          - Operation Error (ERROR)
+// 10         - State Cookie (COOKIE ECHO)
+// 11         - Cookie Acknowledgement (COOKIE ACK)
+// 12         - Reserved for Explicit Congestion Notification Echo
+//              (ECNE)
+// 13         - Reserved for Congestion Window Reduced (CWR)
+// 14         - Shutdown Complete (SHUTDOWN COMPLETE)
+// 15 to 62   - available
+// 63         - reserved for IETF-defined Chunk Extensions
+// 64 to 126  - available
+// 127        - reserved for IETF-defined Chunk Extensions
+// 128 to 190 - available
+// 191        - reserved for IETF-defined Chunk Extensions
+// 192 to 254 - available
+// 255        - reserved for IETF-defined Chunk Extensions
+import { crc32c } from './imports/common.js';
+export const SCTP_PADDING_MULTIPLE = 4;
+export const SCTP_COMMON_HEADER_SIZE = 12;
+export const SCTP_CHUNK_HEADER_SIZE = 4;
+export const SCTP_DATA_FIXED_HEADER_SIZE = 12;
+export const SCTP_DATA_CHUNK_HEADER_SIZE = SCTP_CHUNK_HEADER_SIZE + SCTP_DATA_FIXED_HEADER_SIZE;
+export class Chunk {
+    get body() {
+        return this._body;
+    }
+    set body(value) {
+        this._body = value;
+    }
+    static { this.type = -1; }
+    constructor(flags = 0, _body = Buffer.from('')) {
+        this.flags = flags;
+        this._body = _body;
+    }
+    get type() {
+        return Chunk.type;
+    }
+    get bytes() {
+        if (!this.body)
+            throw new Error();
+        const header = Buffer.alloc(SCTP_CHUNK_HEADER_SIZE);
+        header.writeUInt8(this.type, 0);
+        header.writeUInt8(this.flags, 1);
+        header.writeUInt16BE(this.body.length + SCTP_CHUNK_HEADER_SIZE, 2);
+        const data = Buffer.concat([
+            header,
+            this.body,
+            ...[...Array(padL(this.body.length))].map(() => Buffer.from('\x00'))
+        ]);
+        return data;
+    }
+}
+export class BaseInitChunk extends Chunk {
+    constructor(flags = 0, body) {
+        super(flags, body);
+        this.flags = flags;
+        if (body) {
+            this.initiateTag = body.readUInt32BE(0);
+            this.advertisedRwnd = body.readUInt32BE(4);
+            this.outboundStreams = body.readUInt16BE(8);
+            this.inboundStreams = body.readUInt16BE(10);
+            this.initialTsn = body.readUInt32BE(12);
+            this.params = decodeParams(body.slice(16));
+        }
+        else {
+            this.initiateTag = 0;
+            this.advertisedRwnd = 0;
+            this.outboundStreams = 0;
+            this.inboundStreams = 0;
+            this.initialTsn = 0;
+            this.params = [];
+        }
+    }
+    get body() {
+        const body = Buffer.alloc(16);
+        body.writeUInt32BE(this.initiateTag, 0);
+        body.writeUInt32BE(this.advertisedRwnd, 4);
+        body.writeUInt16BE(this.outboundStreams, 8);
+        body.writeUInt16BE(this.inboundStreams, 10);
+        body.writeUInt32BE(this.initialTsn, 12);
+        return Buffer.concat([body, encodeParams(this.params)]);
+    }
+}
+export class InitChunk extends BaseInitChunk {
+    static { this.type = 1; }
+    get type() {
+        return InitChunk.type;
+    }
+}
+export class InitAckChunk extends BaseInitChunk {
+    static { this.type = 2; }
+    get type() {
+        return InitAckChunk.type;
+    }
+}
+export class ReConfigChunk extends BaseInitChunk {
+    static { this.type = 130; }
+    get type() {
+        return ReConfigChunk.type;
+    }
+}
+export class ForwardTsnChunk extends Chunk {
+    static { this.type = 192; }
+    constructor(flags = 0, body) {
+        super(flags, body);
+        this.flags = flags;
+        this.streams = [];
+        if (body) {
+            this.cumulativeTsn = body.readUInt32BE(0);
+            let pos = 4;
+            while (pos < body.length) {
+                this.streams.push([body.readUInt16BE(pos), body.readUInt16BE(pos + 2)]);
+                pos += 4;
+            }
+        }
+        else {
+            this.cumulativeTsn = 0;
+        }
+    }
+    get type() {
+        return ForwardTsnChunk.type;
+    }
+    set body(_) { }
+    get body() {
+        const body = Buffer.alloc(4);
+        body.writeUInt32BE(this.cumulativeTsn, 0);
+        return Buffer.concat([
+            body,
+            ...this.streams.map(([id, seq]) => {
+                const streamBuffer = Buffer.alloc(4);
+                streamBuffer.writeUInt16BE(id, 0);
+                streamBuffer.writeUInt16BE(seq, 2);
+                return streamBuffer;
+            })
+        ]);
+    }
+}
+export class DataChunk extends Chunk {
+    static { this.type = 0; }
+    get type() {
+        return DataChunk.type;
+    }
+    constructor(flags = 0, body) {
+        super(flags, body);
+        this.flags = flags;
+        this.tsn = 0;
+        this.streamId = 0;
+        this.streamSeqNum = 0;
+        this.protocol = 0;
+        this.userData = Buffer.from('');
+        this.abandoned = false;
+        this.acked = false;
+        this.misses = 0;
+        this.retransmit = false;
+        this.sentCount = 0;
+        this.bookSize = 0;
+        if (body) {
+            this.tsn = body.readUInt32BE(0);
+            this.streamId = body.readUInt16BE(4);
+            this.streamSeqNum = body.readUInt16BE(6);
+            this.protocol = body.readUInt32BE(8);
+            this.userData = body.slice(12);
+        }
+    }
+    get bytes() {
+        const length = SCTP_DATA_CHUNK_HEADER_SIZE + this.userData.length;
+        const header = Buffer.alloc(SCTP_DATA_CHUNK_HEADER_SIZE);
+        header.writeUInt8(this.type, 0);
+        header.writeUInt8(this.flags, 1);
+        header.writeUInt16BE(length, 2);
+        header.writeUInt32BE(this.tsn, 4);
+        header.writeUInt16BE(this.streamId, 8);
+        header.writeUInt16BE(this.streamSeqNum, 10);
+        header.writeUInt32BE(this.protocol, 12);
+        let data = Buffer.concat([header, this.userData]);
+        if (length % 4) {
+            data = Buffer.concat([
+                data,
+                ...[...Array(padL(length))].map(() => Buffer.from('\x00'))
+            ]);
+        }
+        return data;
+    }
+}
+export class CookieEchoChunk extends Chunk {
+    static { this.type = 10; }
+    get type() {
+        return CookieEchoChunk.type;
+    }
+}
+export class CookieAckChunk extends Chunk {
+    static { this.type = 11; }
+    get type() {
+        return CookieAckChunk.type;
+    }
+}
+export class BaseParamsChunk extends Chunk {
+    constructor(flags = 0, body = undefined) {
+        super(flags, body);
+        this.flags = flags;
+        this.params = [];
+        if (body) {
+            this.params = decodeParams(body);
+        }
+    }
+    get body() {
+        return encodeParams(this.params);
+    }
+}
+export class AbortChunk extends BaseParamsChunk {
+    static { this.type = 6; }
+    get type() {
+        return AbortChunk.type;
+    }
+}
+export class ErrorChunk extends BaseParamsChunk {
+    static { this.type = 9; }
+    static { this.CODE = {
+        InvalidStreamIdentifier: 1,
+        MissingMandatoryParameter: 2,
+        StaleCookieError: 3,
+        OutofResource: 4,
+        UnresolvableAddress: 5,
+        UnrecognizedChunkType: 6,
+        InvalidMandatoryParameter: 7,
+        UnrecognizedParameters: 8,
+        NoUserData: 9,
+        CookieReceivedWhileShuttingDown: 10,
+        RestartofanAssociationwithNewAddresses: 11,
+        UserInitiatedAbort: 12,
+        ProtocolViolation: 13
+    }; }
+    get type() {
+        return ErrorChunk.type;
+    }
+    get descriptions() {
+        return this.params.map(([code, body]) => {
+            const name = (Object.entries(ErrorChunk.CODE).find(([, num]) => num === code) || [])[0];
+            return { name, body };
+        });
+    }
+}
+export class HeartbeatChunk extends BaseParamsChunk {
+    static { this.type = 4; }
+    get type() {
+        return HeartbeatChunk.type;
+    }
+}
+export class HeartbeatAckChunk extends BaseParamsChunk {
+    static { this.type = 5; }
+    get type() {
+        return HeartbeatAckChunk.type;
+    }
+}
+// https://tools.ietf.org/html/rfc6525#section-3.1
+// chunkReconfig represents an SCTP Chunk used to reconfigure streams.
+//
+//  0                   1                   2                   3
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// | Type = 130    |  Chunk Flags  |      Chunk Length             |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// \                                                               \
+// /                  Re-configuration Parameter                   /
+// \                                                               \
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// \                                                               \
+// /             Re-configuration Parameter (optional)             /
+// \                                                               \
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+export class ReconfigChunk extends BaseParamsChunk {
+    static { this.type = 130; }
+    get type() {
+        return ReconfigChunk.type;
+    }
+}
+export class SackChunk extends Chunk {
+    static { this.type = 3; }
+    get type() {
+        return SackChunk.type;
+    }
+    constructor(flags = 0, body) {
+        super(flags, body);
+        this.flags = flags;
+        this.gaps = [];
+        this.duplicates = [];
+        this.cumulativeTsn = 0;
+        this.advertisedRwnd = 0;
+        if (body) {
+            this.cumulativeTsn = body.readUInt32BE(0);
+            this.advertisedRwnd = body.readUInt32BE(4);
+            const nbGaps = body.readUInt16BE(8);
+            const nbDuplicates = body.readUInt16BE(10);
+            let pos = 12;
+            [...Array(nbGaps)].forEach(() => {
+                this.gaps.push([body.readUInt16BE(pos), body.readUInt16BE(pos + 2)]);
+                pos += 4;
+            });
+            [...Array(nbDuplicates)].forEach(() => {
+                this.duplicates.push(body.readUInt32BE(pos));
+                pos += 4;
+            });
+        }
+    }
+    get bytes() {
+        const length = 16 + 4 * (this.gaps.length + this.duplicates.length);
+        const header = Buffer.alloc(16);
+        header.writeUInt8(this.type, 0);
+        header.writeUInt8(this.flags, 1);
+        header.writeUInt16BE(length, 2);
+        header.writeUInt32BE(this.cumulativeTsn, 4);
+        header.writeUInt32BE(this.advertisedRwnd, 8);
+        header.writeUInt16BE(this.gaps.length, 12);
+        header.writeUInt16BE(this.duplicates.length, 14);
+        let data = Buffer.concat([
+            header,
+            ...this.gaps.map((gap) => {
+                const gapBuffer = Buffer.alloc(4);
+                gapBuffer.writeUInt16BE(gap[0], 0);
+                gapBuffer.writeUInt16BE(gap[1], 2);
+                return gapBuffer;
+            })
+        ]);
+        data = Buffer.concat([
+            data,
+            ...this.duplicates.map((tsn) => {
+                const tsnBuffer = Buffer.alloc(4);
+                tsnBuffer.writeUInt32BE(tsn, 0);
+                return tsnBuffer;
+            })
+        ]);
+        return data;
+    }
+}
+export class ShutdownChunk extends Chunk {
+    static { this.type = 7; }
+    get type() {
+        return ShutdownChunk.type;
+    }
+    constructor(flags = 0, body) {
+        super(flags, body);
+        this.flags = flags;
+        this.cumulativeTsn = 0;
+        if (body) {
+            this.cumulativeTsn = body.readUInt32BE(0);
+        }
+    }
+    get body() {
+        const body = Buffer.alloc(4);
+        body.writeUInt32BE(this.cumulativeTsn, 0);
+        return body;
+    }
+}
+export class ShutdownAckChunk extends Chunk {
+    static { this.type = 8; }
+    get type() {
+        return ShutdownAckChunk.type;
+    }
+}
+export class ShutdownCompleteChunk extends Chunk {
+    static { this.type = 14; }
+    get type() {
+        return ShutdownCompleteChunk.type;
+    }
+}
+const CHUNK_CLASSES = [
+    DataChunk,
+    InitChunk,
+    InitAckChunk,
+    SackChunk,
+    HeartbeatChunk,
+    HeartbeatAckChunk,
+    AbortChunk,
+    ShutdownChunk,
+    ShutdownAckChunk,
+    ErrorChunk,
+    CookieEchoChunk,
+    CookieAckChunk,
+    ShutdownCompleteChunk,
+    ReconfigChunk,
+    ForwardTsnChunk
+];
+export const CHUNK_BY_TYPE = CHUNK_CLASSES.reduce((acc, cur) => {
+    acc[cur.type] = cur;
+    return acc;
+}, {});
+function padL(l) {
+    const m = l % SCTP_PADDING_MULTIPLE;
+    return m ? SCTP_PADDING_MULTIPLE - m : 0;
+}
+function encodeParams(params) {
+    let body = Buffer.from('');
+    let padding = Buffer.from('');
+    params.forEach(([type, value]) => {
+        const length = value.length + 4;
+        const paramHeader = Buffer.alloc(4);
+        paramHeader.writeUInt16BE(type, 0);
+        paramHeader.writeUInt16BE(length, 2);
+        body = Buffer.concat([body, padding, paramHeader, value]);
+        padding = Buffer.concat([...Array(padL(length))].map(() => Buffer.from('\x00')));
+    });
+    return body;
+}
+export function decodeParams(body) {
+    const params = [];
+    let pos = 0;
+    while (pos <= body.length - 4) {
+        const type = body.readUInt16BE(pos);
+        const length = body.readUInt16BE(pos + 2);
+        params.push([type, body.slice(pos + 4, pos + length)]);
+        pos += length + padL(length);
+    }
+    return params;
+}
+export function parsePacket(data) {
+    if (data.length < SCTP_COMMON_HEADER_SIZE)
+        throw new Error('SCTP packet length is less than 12 bytes');
+    const sourcePort = data.readUInt16BE(0);
+    const destinationPort = data.readUInt16BE(2);
+    const verificationTag = data.readUInt32BE(4);
+    const checkSum = data.readUInt32LE(8);
+    //The checksum covers the packet with its own field as zeros: computed in three parts instead of on a copy
+    let expect = crc32c(data.subarray(0, 8));
+    expect = crc32c(ZERO_CHECKSUM, expect);
+    expect = crc32c(data.subarray(SCTP_COMMON_HEADER_SIZE), expect);
+    if (checkSum !== expect >>> 0)
+        throw new Error('SCTP packet has invalid checksum');
+    const chunks = [];
+    let pos = SCTP_COMMON_HEADER_SIZE;
+    while (pos + 4 <= data.length) {
+        const chunkType = data.readUInt8(pos);
+        const chunkFlags = data.readUInt8(pos + 1);
+        const chunkLength = data.readUInt16BE(pos + 2);
+        const chunkBody = data.slice(pos + 4, pos + chunkLength);
+        const ChunkClass = CHUNK_BY_TYPE[chunkType.toString()];
+        if (ChunkClass) {
+            chunks.push(new ChunkClass(chunkFlags, chunkBody));
+        }
+        else {
+            throw new Error('unknown');
+        }
+        pos += chunkLength + padL(chunkLength);
+    }
+    return [sourcePort, destinationPort, verificationTag, chunks];
+}
+const ZERO_CHECKSUM = Buffer.alloc(4);
+//The length of a chunk on the wire, its padding included
+function wireLength(chunk, bytes) {
+    if (chunk instanceof DataChunk) {
+        const length = SCTP_DATA_CHUNK_HEADER_SIZE + chunk.userData.length;
+        return length + padL(length);
+    }
+    return bytes.length;
+}
+/**
+ * One SCTP packet with several chunks (bundling, RFC 9260 section 6.10): the control chunks go first. The packet is
+ * written in one buffer, DATA chunks without an intermediate copy
+ */
+export function serializePackets(sourcePort, destinationPort, verificationTag, chunks) {
+    const serialized = chunks.map((chunk) => chunk instanceof DataChunk ? undefined : chunk.bytes);
+    let total = SCTP_COMMON_HEADER_SIZE;
+    for (let i = 0; i < chunks.length; i++) {
+        total += wireLength(chunks[i], serialized[i]);
+    }
+    const packet = Buffer.allocUnsafe(total);
+    packet.writeUInt16BE(sourcePort, 0);
+    packet.writeUInt16BE(destinationPort, 2);
+    packet.writeUInt32BE(verificationTag, 4);
+    packet.writeUInt32LE(0, 8);
+    let offset = SCTP_COMMON_HEADER_SIZE;
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        const bytes = serialized[i];
+        if (bytes) {
+            bytes.copy(packet, offset);
+            offset += bytes.length;
+            continue;
+        }
+        const data = chunk;
+        const length = SCTP_DATA_CHUNK_HEADER_SIZE + data.userData.length;
+        packet.writeUInt8(data.type, offset);
+        packet.writeUInt8(data.flags, offset + 1);
+        packet.writeUInt16BE(length, offset + 2);
+        packet.writeUInt32BE(data.tsn, offset + 4);
+        packet.writeUInt16BE(data.streamId, offset + 8);
+        packet.writeUInt16BE(data.streamSeqNum, offset + 10);
+        packet.writeUInt32BE(data.protocol, offset + 12);
+        data.userData.copy(packet, offset + SCTP_DATA_CHUNK_HEADER_SIZE);
+        const padding = padL(length);
+        if (padding)
+            packet.fill(0, offset + length, offset + length + padding);
+        offset += length + padding;
+    }
+    packet.writeUInt32LE(crc32c(packet) >>> 0, 8);
+    return packet;
+}
+/**
+ * The length of a chunk in a packet, padding included
+ */
+export function chunkWireLength(chunk) {
+    return wireLength(chunk, chunk instanceof DataChunk ? undefined : chunk.bytes);
+}
+export function serializePacket(sourcePort, destinationPort, verificationTag, chunk) {
+    return serializePackets(sourcePort, destinationPort, verificationTag, [chunk]);
+}

package/dist/esm/lib/sctp/const.js

@@ -0,0 +1,19 @@
+export var WEBRTC_PPID;
+(function (WEBRTC_PPID) {
+    WEBRTC_PPID[WEBRTC_PPID["DCEP"] = 50] = "DCEP";
+    WEBRTC_PPID[WEBRTC_PPID["STRING"] = 51] = "STRING";
+    WEBRTC_PPID[WEBRTC_PPID["BINARY"] = 53] = "BINARY";
+    WEBRTC_PPID[WEBRTC_PPID["STRING_EMPTY"] = 56] = "STRING_EMPTY";
+    WEBRTC_PPID[WEBRTC_PPID["BINARY_EMPTY"] = 57] = "BINARY_EMPTY";
+})(WEBRTC_PPID || (WEBRTC_PPID = {}));
+export var SCTP_STATE;
+(function (SCTP_STATE) {
+    SCTP_STATE[SCTP_STATE["CLOSED"] = 1] = "CLOSED";
+    SCTP_STATE[SCTP_STATE["COOKIE_WAIT"] = 2] = "COOKIE_WAIT";
+    SCTP_STATE[SCTP_STATE["COOKIE_ECHOED"] = 3] = "COOKIE_ECHOED";
+    SCTP_STATE[SCTP_STATE["ESTABLISHED"] = 4] = "ESTABLISHED";
+    SCTP_STATE[SCTP_STATE["SHUTDOWN_PENDING"] = 5] = "SHUTDOWN_PENDING";
+    SCTP_STATE[SCTP_STATE["SHUTDOWN_SENT"] = 6] = "SHUTDOWN_SENT";
+    SCTP_STATE[SCTP_STATE["SHUTDOWN_RECEIVED"] = 7] = "SHUTDOWN_RECEIVED";
+    SCTP_STATE[SCTP_STATE["SHUTDOWN_ACK_SENT"] = 8] = "SHUTDOWN_ACK_SENT";
+})(SCTP_STATE || (SCTP_STATE = {}));

package/dist/esm/lib/sctp/helper.js

@@ -0,0 +1,10 @@
+import { Event } from './imports/common.js';
+export function enumerate(arr) {
+    return arr.map((v, i) => [i, v]);
+}
+export function createEventsFromList(list) {
+    return list.reduce((acc, cur) => {
+        acc[cur] = new Event();
+        return acc;
+    }, {});
+}

package/dist/esm/lib/sctp/imports/common.js

@@ -0,0 +1 @@
+export * from '../../common/index.js';

package/dist/esm/lib/sctp/index.js

@@ -0,0 +1,4 @@
+export { SCTP_STATE, WEBRTC_PPID } from './const.js';
+export { SCTP, DEFAULT_SCTP_MTU, maxPayloadSizeForMtu, validateSctpMtu } from './sctp.js';
+export { SCTP_COMMON_HEADER_SIZE, SCTP_CHUNK_HEADER_SIZE, SCTP_DATA_FIXED_HEADER_SIZE, SCTP_DATA_CHUNK_HEADER_SIZE, SCTP_PADDING_MULTIPLE } from './chunk.js';
+export { createUdpTransport, UdpTransport } from './transport.js';

package/dist/esm/lib/sctp/param.js

@@ -0,0 +1,126 @@
+// This parameter is used by the sender to request the reset of some or
+// all outgoing streams.
+//  0                   1                   2                   3
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |     Parameter Type = 13       | Parameter Length = 16 + 2 * N |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |           Re-configuration Request Sequence Number            |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |           Re-configuration Response Sequence Number           |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                Sender's Last Assigned TSN                     |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |  Stream Number 1 (optional)   |    Stream Number 2 (optional) |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// /                            ......                             /
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |  Stream Number N-1 (optional) |    Stream Number N (optional) |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+export class OutgoingSSNResetRequestParam {
+    static { this.type = 13; } // Outgoing SSN Reset Request Parameter
+    constructor(requestSequence, responseSequence, lastTsn, streams) {
+        this.requestSequence = requestSequence;
+        this.responseSequence = responseSequence;
+        this.lastTsn = lastTsn;
+        this.streams = streams;
+    }
+    get type() {
+        return OutgoingSSNResetRequestParam.type;
+    }
+    get bytes() {
+        // !LLL — requestSequence / responseSequence / lastTsn (big-endian uint32)
+        const data = Buffer.allocUnsafe(12);
+        data.writeUInt32BE(this.requestSequence, 0);
+        data.writeUInt32BE(this.responseSequence, 4);
+        data.writeUInt32BE(this.lastTsn, 8);
+        return Buffer.concat([
+            data,
+            ...this.streams.map((stream) => {
+                const buf = Buffer.allocUnsafe(2);
+                buf.writeUInt16BE(stream, 0);
+                return buf;
+            })
+        ]);
+    }
+    static parse(data) {
+        const requestSequence = data.readUInt32BE(0);
+        const responseSequence = data.readUInt32BE(4);
+        const lastTsn = data.readUInt32BE(8);
+        const stream = [];
+        for (let pos = 12; pos < data.length; pos += 2) {
+            stream.push(data.readUInt16BE(pos));
+        }
+        return new OutgoingSSNResetRequestParam(requestSequence, responseSequence, lastTsn, stream);
+    }
+}
+export class StreamAddOutgoingParam {
+    static { this.type = 17; } // Add Outgoing Streams Request Parameter
+    constructor(requestSequence, newStreams) {
+        this.requestSequence = requestSequence;
+        this.newStreams = newStreams;
+    }
+    get type() {
+        return StreamAddOutgoingParam.type;
+    }
+    get bytes() {
+        // !LHH — requestSequence / newStreams / reserved
+        const buf = Buffer.allocUnsafe(8);
+        buf.writeUInt32BE(this.requestSequence, 0);
+        buf.writeUInt16BE(this.newStreams, 4);
+        buf.writeUInt16BE(0, 6);
+        return buf;
+    }
+    static parse(data) {
+        const requestSequence = data.readUInt32BE(0);
+        const newStreams = data.readUInt16BE(4);
+        return new StreamAddOutgoingParam(requestSequence, newStreams);
+    }
+}
+// This parameter is used by the receiver of a Re-configuration Request
+// Parameter to respond to the request.
+//
+// 0                   1                   2                   3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |     Parameter Type = 16       |      Parameter Length         |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |         Re-configuration Response Sequence Number             |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                            Result                             |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                   Sender's Next TSN (optional)                |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                  Receiver's Next TSN (optional)               |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+export const reconfigResult = {
+    ReconfigResultSuccessPerformed: 1,
+    BadSequenceNumber: 5
+};
+export class ReconfigResponseParam {
+    static { this.type = 16; } // Re-configuration Response Parameter
+    constructor(responseSequence, result) {
+        this.responseSequence = responseSequence;
+        this.result = result;
+    }
+    get type() {
+        return ReconfigResponseParam.type;
+    }
+    get bytes() {
+        // !LL — responseSequence / result
+        const buf = Buffer.allocUnsafe(8);
+        buf.writeUInt32BE(this.responseSequence, 0);
+        buf.writeUInt32BE(this.result, 4);
+        return buf;
+    }
+    static parse(data) {
+        const requestSequence = data.readUInt32BE(0);
+        const result = data.readUInt32BE(4);
+        return new ReconfigResponseParam(requestSequence, result);
+    }
+}
+export const RECONFIG_PARAM_BY_TYPES = {
+    13: OutgoingSSNResetRequestParam, // Outgoing SSN Reset Request Parameter
+    16: ReconfigResponseParam, // Re-configuration Response Parameter
+    17: StreamAddOutgoingParam // Add Outgoing Streams Request Parameter
+};