@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/sctp/chunk.d.ts

@@ -0,0 +1,164 @@
+export declare const SCTP_PADDING_MULTIPLE = 4;
+export declare const SCTP_COMMON_HEADER_SIZE = 12;
+export declare const SCTP_CHUNK_HEADER_SIZE = 4;
+export declare const SCTP_DATA_FIXED_HEADER_SIZE = 12;
+export declare const SCTP_DATA_CHUNK_HEADER_SIZE: number;
+export declare class Chunk {
+    flags: number;
+    private _body;
+    get body(): Buffer | undefined;
+    set body(value: Buffer | undefined);
+    static type: number;
+    constructor(flags?: number, _body?: Buffer | undefined);
+    get type(): number;
+    get bytes(): Buffer<ArrayBuffer>;
+}
+export declare class BaseInitChunk extends Chunk {
+    flags: number;
+    initiateTag: number;
+    advertisedRwnd: number;
+    outboundStreams: number;
+    inboundStreams: number;
+    initialTsn: number;
+    params: [number, Buffer][];
+    constructor(flags?: number, body?: Buffer);
+    get body(): Buffer<ArrayBuffer>;
+}
+export declare class InitChunk extends BaseInitChunk {
+    static type: 1;
+    get type(): 1;
+}
+export declare class InitAckChunk extends BaseInitChunk {
+    static type: 2;
+    get type(): 2;
+}
+export declare class ReConfigChunk extends BaseInitChunk {
+    static type: 130;
+    get type(): 130;
+}
+export declare class ForwardTsnChunk extends Chunk {
+    flags: number;
+    static type: 192;
+    streams: [number, number][];
+    cumulativeTsn: number;
+    constructor(flags: number | undefined, body: Buffer | undefined);
+    get type(): 192;
+    set body(_: Buffer);
+    get body(): Buffer;
+}
+export declare class DataChunk extends Chunk {
+    flags: number;
+    static type: 0;
+    get type(): 0;
+    tsn: number;
+    streamId: number;
+    streamSeqNum: number;
+    protocol: number;
+    userData: Buffer;
+    abandoned: boolean;
+    acked: boolean;
+    misses: number;
+    retransmit: boolean;
+    sentCount: number;
+    bookSize: number;
+    expiry?: number;
+    maxRetransmits?: number;
+    sentTime?: number;
+    constructor(flags: number | undefined, body: Buffer | undefined);
+    get bytes(): Buffer<ArrayBuffer>;
+}
+export declare class CookieEchoChunk extends Chunk {
+    static type: 10;
+    get type(): 10;
+}
+export declare class CookieAckChunk extends Chunk {
+    static type: 11;
+    get type(): 11;
+}
+export declare class BaseParamsChunk extends Chunk {
+    flags: number;
+    params: [number, Buffer][];
+    constructor(flags?: number, body?: Buffer | undefined);
+    get body(): Buffer<ArrayBuffer>;
+}
+export declare class AbortChunk extends BaseParamsChunk {
+    static type: 6;
+    get type(): 6;
+}
+export declare class ErrorChunk extends BaseParamsChunk {
+    static type: 9;
+    static readonly CODE: {
+        readonly InvalidStreamIdentifier: 1;
+        readonly MissingMandatoryParameter: 2;
+        readonly StaleCookieError: 3;
+        readonly OutofResource: 4;
+        readonly UnresolvableAddress: 5;
+        readonly UnrecognizedChunkType: 6;
+        readonly InvalidMandatoryParameter: 7;
+        readonly UnrecognizedParameters: 8;
+        readonly NoUserData: 9;
+        readonly CookieReceivedWhileShuttingDown: 10;
+        readonly RestartofanAssociationwithNewAddresses: 11;
+        readonly UserInitiatedAbort: 12;
+        readonly ProtocolViolation: 13;
+    };
+    get type(): 9;
+    get descriptions(): {
+        name: string | undefined;
+        body: Buffer<ArrayBufferLike>;
+    }[];
+}
+export declare class HeartbeatChunk extends BaseParamsChunk {
+    static type: 4;
+    get type(): 4;
+}
+export declare class HeartbeatAckChunk extends BaseParamsChunk {
+    static type: 5;
+    get type(): 5;
+}
+export declare class ReconfigChunk extends BaseParamsChunk {
+    static type: 130;
+    get type(): 130;
+}
+export declare class SackChunk extends Chunk {
+    flags: number;
+    static type: number;
+    get type(): number;
+    gaps: [number, number][];
+    duplicates: number[];
+    cumulativeTsn: number;
+    advertisedRwnd: number;
+    constructor(flags: number | undefined, body: Buffer | undefined);
+    get bytes(): Buffer<ArrayBuffer>;
+}
+export declare class ShutdownChunk extends Chunk {
+    flags: number;
+    static type: number;
+    get type(): number;
+    cumulativeTsn: number;
+    constructor(flags: number | undefined, body: Buffer | undefined);
+    get body(): Buffer<ArrayBuffer>;
+}
+export declare class ShutdownAckChunk extends Chunk {
+    static type: number;
+    get type(): number;
+}
+export declare class ShutdownCompleteChunk extends Chunk {
+    static type: number;
+    get type(): number;
+}
+export declare const CHUNK_BY_TYPE: {
+    [key: string]: typeof Chunk;
+};
+export declare function decodeParams(body: Buffer): [number, Buffer][];
+export declare function parsePacket(data: Buffer): [number, number, number, Chunk[]];
+/**
+ * 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 declare function serializePackets(sourcePort: number, destinationPort: number, verificationTag: number, chunks: Chunk[]): Buffer;
+/**
+ * The length of a chunk in a packet, padding included
+ */
+export declare function chunkWireLength(chunk: Chunk): number;
+export declare function serializePacket(sourcePort: number, destinationPort: number, verificationTag: number, chunk: Chunk): Buffer<ArrayBufferLike>;

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

@@ -0,0 +1,542 @@
+"use strict";
+// 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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHUNK_BY_TYPE = exports.ShutdownCompleteChunk = exports.ShutdownAckChunk = exports.ShutdownChunk = exports.SackChunk = exports.ReconfigChunk = exports.HeartbeatAckChunk = exports.HeartbeatChunk = exports.ErrorChunk = exports.AbortChunk = exports.BaseParamsChunk = exports.CookieAckChunk = exports.CookieEchoChunk = exports.DataChunk = exports.ForwardTsnChunk = exports.ReConfigChunk = exports.InitAckChunk = exports.InitChunk = exports.BaseInitChunk = exports.Chunk = exports.SCTP_DATA_CHUNK_HEADER_SIZE = exports.SCTP_DATA_FIXED_HEADER_SIZE = exports.SCTP_CHUNK_HEADER_SIZE = exports.SCTP_COMMON_HEADER_SIZE = exports.SCTP_PADDING_MULTIPLE = void 0;
+exports.decodeParams = decodeParams;
+exports.parsePacket = parsePacket;
+exports.serializePackets = serializePackets;
+exports.chunkWireLength = chunkWireLength;
+exports.serializePacket = serializePacket;
+const common_js_1 = require("./imports/common.js");
+exports.SCTP_PADDING_MULTIPLE = 4;
+exports.SCTP_COMMON_HEADER_SIZE = 12;
+exports.SCTP_CHUNK_HEADER_SIZE = 4;
+exports.SCTP_DATA_FIXED_HEADER_SIZE = 12;
+exports.SCTP_DATA_CHUNK_HEADER_SIZE = exports.SCTP_CHUNK_HEADER_SIZE + exports.SCTP_DATA_FIXED_HEADER_SIZE;
+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(exports.SCTP_CHUNK_HEADER_SIZE);
+        header.writeUInt8(this.type, 0);
+        header.writeUInt8(this.flags, 1);
+        header.writeUInt16BE(this.body.length + exports.SCTP_CHUNK_HEADER_SIZE, 2);
+        const data = Buffer.concat([
+            header,
+            this.body,
+            ...[...Array(padL(this.body.length))].map(() => Buffer.from('\x00'))
+        ]);
+        return data;
+    }
+}
+exports.Chunk = Chunk;
+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)]);
+    }
+}
+exports.BaseInitChunk = BaseInitChunk;
+class InitChunk extends BaseInitChunk {
+    static { this.type = 1; }
+    get type() {
+        return InitChunk.type;
+    }
+}
+exports.InitChunk = InitChunk;
+class InitAckChunk extends BaseInitChunk {
+    static { this.type = 2; }
+    get type() {
+        return InitAckChunk.type;
+    }
+}
+exports.InitAckChunk = InitAckChunk;
+class ReConfigChunk extends BaseInitChunk {
+    static { this.type = 130; }
+    get type() {
+        return ReConfigChunk.type;
+    }
+}
+exports.ReConfigChunk = ReConfigChunk;
+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;
+            })
+        ]);
+    }
+}
+exports.ForwardTsnChunk = ForwardTsnChunk;
+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 = exports.SCTP_DATA_CHUNK_HEADER_SIZE + this.userData.length;
+        const header = Buffer.alloc(exports.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;
+    }
+}
+exports.DataChunk = DataChunk;
+class CookieEchoChunk extends Chunk {
+    static { this.type = 10; }
+    get type() {
+        return CookieEchoChunk.type;
+    }
+}
+exports.CookieEchoChunk = CookieEchoChunk;
+class CookieAckChunk extends Chunk {
+    static { this.type = 11; }
+    get type() {
+        return CookieAckChunk.type;
+    }
+}
+exports.CookieAckChunk = CookieAckChunk;
+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);
+    }
+}
+exports.BaseParamsChunk = BaseParamsChunk;
+class AbortChunk extends BaseParamsChunk {
+    static { this.type = 6; }
+    get type() {
+        return AbortChunk.type;
+    }
+}
+exports.AbortChunk = AbortChunk;
+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 };
+        });
+    }
+}
+exports.ErrorChunk = ErrorChunk;
+class HeartbeatChunk extends BaseParamsChunk {
+    static { this.type = 4; }
+    get type() {
+        return HeartbeatChunk.type;
+    }
+}
+exports.HeartbeatChunk = HeartbeatChunk;
+class HeartbeatAckChunk extends BaseParamsChunk {
+    static { this.type = 5; }
+    get type() {
+        return HeartbeatAckChunk.type;
+    }
+}
+exports.HeartbeatAckChunk = HeartbeatAckChunk;
+// 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)             /
+// \                                                               \
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+class ReconfigChunk extends BaseParamsChunk {
+    static { this.type = 130; }
+    get type() {
+        return ReconfigChunk.type;
+    }
+}
+exports.ReconfigChunk = ReconfigChunk;
+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;
+    }
+}
+exports.SackChunk = SackChunk;
+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;
+    }
+}
+exports.ShutdownChunk = ShutdownChunk;
+class ShutdownAckChunk extends Chunk {
+    static { this.type = 8; }
+    get type() {
+        return ShutdownAckChunk.type;
+    }
+}
+exports.ShutdownAckChunk = ShutdownAckChunk;
+class ShutdownCompleteChunk extends Chunk {
+    static { this.type = 14; }
+    get type() {
+        return ShutdownCompleteChunk.type;
+    }
+}
+exports.ShutdownCompleteChunk = ShutdownCompleteChunk;
+const CHUNK_CLASSES = [
+    DataChunk,
+    InitChunk,
+    InitAckChunk,
+    SackChunk,
+    HeartbeatChunk,
+    HeartbeatAckChunk,
+    AbortChunk,
+    ShutdownChunk,
+    ShutdownAckChunk,
+    ErrorChunk,
+    CookieEchoChunk,
+    CookieAckChunk,
+    ShutdownCompleteChunk,
+    ReconfigChunk,
+    ForwardTsnChunk
+];
+exports.CHUNK_BY_TYPE = CHUNK_CLASSES.reduce((acc, cur) => {
+    acc[cur.type] = cur;
+    return acc;
+}, {});
+function padL(l) {
+    const m = l % exports.SCTP_PADDING_MULTIPLE;
+    return m ? exports.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;
+}
+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;
+}
+function parsePacket(data) {
+    if (data.length < exports.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 = (0, common_js_1.crc32c)(data.subarray(0, 8));
+    expect = (0, common_js_1.crc32c)(ZERO_CHECKSUM, expect);
+    expect = (0, common_js_1.crc32c)(data.subarray(exports.SCTP_COMMON_HEADER_SIZE), expect);
+    if (checkSum !== expect >>> 0)
+        throw new Error('SCTP packet has invalid checksum');
+    const chunks = [];
+    let pos = exports.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 = exports.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 = exports.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
+ */
+function serializePackets(sourcePort, destinationPort, verificationTag, chunks) {
+    const serialized = chunks.map((chunk) => chunk instanceof DataChunk ? undefined : chunk.bytes);
+    let total = exports.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 = exports.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 = exports.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 + exports.SCTP_DATA_CHUNK_HEADER_SIZE);
+        const padding = padL(length);
+        if (padding)
+            packet.fill(0, offset + length, offset + length + padding);
+        offset += length + padding;
+    }
+    packet.writeUInt32LE((0, common_js_1.crc32c)(packet) >>> 0, 8);
+    return packet;
+}
+/**
+ * The length of a chunk in a packet, padding included
+ */
+function chunkWireLength(chunk) {
+    return wireLength(chunk, chunk instanceof DataChunk ? undefined : chunk.bytes);
+}
+function serializePacket(sourcePort, destinationPort, verificationTag, chunk) {
+    return serializePackets(sourcePort, destinationPort, verificationTag, [chunk]);
+}