@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/lib/dtls/record/message/header.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MACHeader = void 0;
+const common_js_1 = require("../../imports/common.js");
+const binary_js_1 = require("../../handshake/binary.js");
+const { decode, encode, types } = common_js_1.binaryData;
+class MACHeader {
+    static { this.spec = {
+        epoch: types.uint16be,
+        sequenceNumber: types.uint48be,
+        contentType: types.uint8,
+        protocolVersion: binary_js_1.ProtocolVersion,
+        contentLen: types.uint16be
+    }; }
+    constructor(epoch, sequenceNumber, contentType, protocolVersion, contentLen) {
+        this.epoch = epoch;
+        this.sequenceNumber = sequenceNumber;
+        this.contentType = contentType;
+        this.protocolVersion = protocolVersion;
+        this.contentLen = contentLen;
+    }
+    static createEmpty() {
+        return new MACHeader(undefined, undefined, undefined, undefined, undefined);
+    }
+    static deSerialize(buf) {
+        return new MACHeader(
+        //@ts-expect-error The decoded values are spread in the order of the spec, which TypeScript cannot follow
+        ...Object.values(decode(buf, MACHeader.spec)));
+    }
+    serialize() {
+        return encode(this, MACHeader.spec);
+    }
+}
+exports.MACHeader = MACHeader;

package/dist/cjs/lib/dtls/record/message/plaintext.d.ts

@@ -0,0 +1,14 @@
+import { type DtlsPlaintextHeader } from './header.js';
+export declare class DtlsPlaintext {
+    recordLayerHeader: DtlsPlaintextHeader;
+    fragment: Buffer;
+    constructor(recordLayerHeader: DtlsPlaintextHeader, fragment: Buffer);
+    get summary(): {
+        header: DtlsPlaintextHeader;
+        fragment: string;
+    };
+    static createEmpty(): DtlsPlaintext;
+    static deSerialize(buf: Buffer): DtlsPlaintext;
+    serialize(): Buffer<ArrayBuffer>;
+    computeMACHeader(): Buffer<ArrayBufferLike>;
+}

package/dist/cjs/lib/dtls/record/message/plaintext.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtlsPlaintext = void 0;
+const helper_js_1 = require("../../helper.js");
+const header_js_1 = require("./header.js");
+class DtlsPlaintext {
+    constructor(recordLayerHeader, fragment) {
+        this.recordLayerHeader = recordLayerHeader;
+        this.fragment = fragment;
+    }
+    get summary() {
+        return {
+            header: this.recordLayerHeader,
+            fragment: (0, helper_js_1.dumpBuffer)(this.fragment)
+        };
+    }
+    static createEmpty() {
+        return new DtlsPlaintext(undefined, undefined);
+    }
+    static deSerialize(buf) {
+        if (buf.length < 13) {
+            throw new Error('Invalid DTLS record: buffer is too short');
+        }
+        const contentType = buf.readUInt8(0);
+        const majorVersion = buf.readUInt8(1);
+        const minorVersion = buf.readUInt8(2);
+        const epoch = buf.readUInt16BE(3);
+        // Read the 6-byte sequence number as a 48-bit integer
+        const sequenceNumber = buf.slice(5, 11).readUIntBE(0, 6);
+        const contentLen = buf.readUInt16BE(11);
+        // Ensure the buffer has enough data for the fragment
+        if (buf.length < 13 + contentLen) {
+            throw new Error('Invalid DTLS record: fragment length exceeds buffer');
+        }
+        const fragment = buf.slice(13, 13 + contentLen);
+        const r = new DtlsPlaintext({
+            contentType,
+            protocolVersion: { major: majorVersion, minor: minorVersion },
+            epoch,
+            sequenceNumber,
+            contentLen
+        }, fragment);
+        return r;
+    }
+    serialize() {
+        const fragmentLength = this.fragment.length;
+        // 13 bytes for headers + fragment length
+        const totalLength = 13 + fragmentLength;
+        const buffer = Buffer.alloc(totalLength);
+        buffer.writeUInt8(this.recordLayerHeader.contentType, 0);
+        buffer.writeUInt8(this.recordLayerHeader.protocolVersion.major, 1);
+        buffer.writeUInt8(this.recordLayerHeader.protocolVersion.minor, 2);
+        buffer.writeUInt16BE(this.recordLayerHeader.epoch, 3);
+        buffer.writeUIntBE(this.recordLayerHeader.sequenceNumber, 5, 6);
+        buffer.writeUInt16BE(fragmentLength, 11);
+        this.fragment.copy(buffer, 13);
+        return buffer;
+    }
+    computeMACHeader() {
+        return new header_js_1.MACHeader(this.recordLayerHeader.epoch, this.recordLayerHeader.sequenceNumber, this.recordLayerHeader.contentType, this.recordLayerHeader.protocolVersion, this.recordLayerHeader.contentLen).serialize();
+    }
+}
+exports.DtlsPlaintext = DtlsPlaintext;

package/dist/cjs/lib/dtls/record/receive.d.ts

@@ -0,0 +1,9 @@
+import type { CipherContext } from '../context/cipher.js';
+import type { DtlsContext } from '../context/dtls.js';
+import { ContentType } from './const.js';
+import { DtlsPlaintext } from './message/plaintext.js';
+export declare const parsePacket: (data: Buffer) => DtlsPlaintext[];
+export declare const parsePlainText: (dtls: DtlsContext, cipher: CipherContext) => (plain: DtlsPlaintext) => {
+    type: ContentType;
+    data: any;
+}[];

package/dist/cjs/lib/dtls/record/receive.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePlainText = exports.parsePacket = void 0;
+const alert_js_1 = require("../handshake/message/alert.js");
+const common_js_1 = require("../imports/common.js");
+const const_js_1 = require("./const.js");
+const fragment_js_1 = require("./message/fragment.js");
+const plaintext_js_1 = require("./message/plaintext.js");
+const log = (0, common_js_1.debug)('webrtc/dtls/record/receive:log');
+const err = (0, common_js_1.debug)('webrtc/dtls/record/receive:err');
+const parsePacket = (data) => {
+    let start = 0;
+    const packets = [];
+    while (data.length > start) {
+        const fragmentLength = data.readUInt16BE(start + 11);
+        if (data.length < start + (12 + fragmentLength)) {
+            break;
+        }
+        const packet = plaintext_js_1.DtlsPlaintext.deSerialize(data.subarray(start));
+        packets.push(packet);
+        start += 13 + fragmentLength;
+    }
+    return packets;
+};
+exports.parsePacket = parsePacket;
+const parsePlainText = (dtls, cipher) => (plain) => {
+    const contentType = plain.recordLayerHeader.contentType;
+    switch (contentType) {
+        case const_js_1.ContentType.changeCipherSpec: {
+            log(dtls.sessionId, 'change cipher spec');
+            return [
+                {
+                    type: const_js_1.ContentType.changeCipherSpec,
+                    data: undefined
+                }
+            ];
+        }
+        case const_js_1.ContentType.handshake: {
+            let raw = plain.fragment;
+            try {
+                if (plain.recordLayerHeader.epoch > 0) {
+                    log(dtls.sessionId, 'decrypt handshake');
+                    raw = cipher.decryptPacket(plain);
+                }
+            }
+            catch (error) {
+                err(dtls.sessionId, 'decrypt failed', error);
+                throw error;
+            }
+            try {
+                let start = 0;
+                const handshakes = [];
+                while (raw.length > start) {
+                    const handshake = fragment_js_1.FragmentedHandshake.deSerialize(raw.subarray(start));
+                    handshakes.push({ type: const_js_1.ContentType.handshake, data: handshake });
+                    start += handshake.fragment_length + 12;
+                }
+                return handshakes;
+            }
+            catch (error) {
+                err(dtls.sessionId, 'decSerialize failed', error, raw);
+                throw error;
+            }
+        }
+        case const_js_1.ContentType.applicationData: {
+            return [
+                {
+                    type: const_js_1.ContentType.applicationData,
+                    data: cipher.decryptPacket(plain)
+                }
+            ];
+        }
+        case const_js_1.ContentType.alert: {
+            let alert = alert_js_1.Alert.deSerialize(plain.fragment);
+            // TODO impl more better about handle encrypted alert
+            if (const_js_1.AlertDesc[alert.description] == undefined) {
+                const dec = cipher.decryptPacket(plain);
+                alert = alert_js_1.Alert.deSerialize(dec);
+            }
+            err(dtls.sessionId, 'ContentType.alert', alert, const_js_1.AlertDesc[alert.description], 'flight', dtls.flight, 'lastFlight', dtls.lastFlight);
+            if (alert.level > 1) {
+                throw new Error('alert fatal error');
+            }
+            return [{ type: const_js_1.ContentType.alert, data: undefined }];
+        }
+        default: {
+            return [{ type: const_js_1.ContentType.alert, data: undefined }];
+        }
+    }
+};
+exports.parsePlainText = parsePlainText;

package/dist/cjs/lib/dtls/server.d.ts

@@ -0,0 +1,6 @@
+import { DtlsSocket, type Options } from './socket.js';
+export declare class DtlsServer extends DtlsSocket {
+    constructor(options: Options);
+    private flight6?;
+    private handleHandshakes;
+}

package/dist/cjs/lib/dtls/server.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtlsServer = void 0;
+const abstract_js_1 = require("./cipher/suites/abstract.js");
+const flight2_js_1 = require("./flight/server/flight2.js");
+const flight4_js_1 = require("./flight/server/flight4.js");
+const flight6_js_1 = require("./flight/server/flight6.js");
+const const_js_1 = require("./handshake/const.js");
+const hello_js_1 = require("./handshake/message/client/hello.js");
+const common_js_1 = require("./imports/common.js");
+const socket_js_1 = require("./socket.js");
+const log = (0, common_js_1.debug)('webrtc/dtls/server:log');
+class DtlsServer extends socket_js_1.DtlsSocket {
+    constructor(options) {
+        super(options, abstract_js_1.SessionType.SERVER);
+        this.handleHandshakes = async (assembled) => {
+            log(this.dtls.sessionId, 'handleHandshakes', assembled.map((a) => a.msg_type));
+            for (const handshake of assembled) {
+                switch (handshake.msg_type) {
+                    // flight1,3
+                    case const_js_1.HandshakeType.client_hello_1:
+                        {
+                            if (this.connected) {
+                                this.renegotiation();
+                            }
+                            const clientHello = hello_js_1.ClientHello.deSerialize(handshake.fragment);
+                            if (clientHello.cookie.length === 0) {
+                                log(this.dtls.sessionId, 'send flight2');
+                                (0, flight2_js_1.flight2)(this.transport, this.dtls, this.cipher, this.srtp)(clientHello);
+                            }
+                            else if (this.dtls.cookie &&
+                                clientHello.cookie.equals(this.dtls.cookie)) {
+                                log(this.dtls.sessionId, 'send flight4');
+                                await new flight4_js_1.Flight4(this.transport, this.dtls, this.cipher, this.srtp).exec(handshake, this.options.certificateRequest);
+                            }
+                            else {
+                                log('wrong state', {
+                                    dtlsCookie: this.dtls.cookie?.toString('hex').slice(10),
+                                    helloCookie: clientHello.cookie.toString('hex').slice(10)
+                                });
+                            }
+                        }
+                        break;
+                    // flight 5
+                    case const_js_1.HandshakeType.certificate_11:
+                    case const_js_1.HandshakeType.certificate_verify_15:
+                    case const_js_1.HandshakeType.client_key_exchange_16:
+                        {
+                            if (this.connected)
+                                return;
+                            this.flight6 = new flight6_js_1.Flight6(this.transport, this.dtls, this.cipher);
+                            this.flight6.handleHandshake(handshake);
+                        }
+                        break;
+                    case const_js_1.HandshakeType.finished_20:
+                        {
+                            await this.waitForReady(() => !!this.flight6);
+                            this.flight6?.handleHandshake(handshake);
+                            const requiredHandshakes = [
+                                16,
+                                this.options.certificateRequest && 11,
+                                this.options.certificateRequest && 15
+                            ].filter((type) => typeof type === 'number');
+                            await this.waitForReady(() => this.dtls.checkHandshakesExist(requiredHandshakes));
+                            await this.flight6?.exec();
+                            this.connected = true;
+                            this.onConnect.execute();
+                            log(this.dtls.sessionId, 'dtls connected');
+                        }
+                        break;
+                }
+            }
+        };
+        this.onHandleHandshakes = this.handleHandshakes;
+        log(this.dtls.sessionId, 'start server');
+    }
+}
+exports.DtlsServer = DtlsServer;

package/dist/cjs/lib/dtls/socket.d.ts

@@ -0,0 +1,52 @@
+import { type Address, Event, type Transport } from './imports/common.js';
+import { type SignatureHash } from './cipher/const.js';
+import { type SessionTypes } from './cipher/suites/abstract.js';
+import { CipherContext } from './context/cipher.js';
+import { DtlsContext } from './context/dtls.js';
+import { SrtpContext } from './context/srtp.js';
+import { TransportContext } from './context/transport.js';
+import type { SrtpProfile } from './imports/rtp.js';
+import { FragmentedHandshake } from './record/message/fragment.js';
+import type { Extension } from './typings/domain.js';
+export declare class DtlsSocket {
+    options: Options;
+    sessionType: SessionTypes;
+    readonly onConnect: Event<any[]>;
+    readonly onData: Event<[Buffer<ArrayBufferLike>]>;
+    readonly onError: Event<[Error]>;
+    readonly onClose: Event<any[]>;
+    readonly transport: TransportContext;
+    cipher: CipherContext;
+    dtls: DtlsContext;
+    srtp: SrtpContext;
+    connected: boolean;
+    extensions: Extension[];
+    onHandleHandshakes: (assembled: FragmentedHandshake[]) => Promise<void>;
+    private bufferFragmentedHandshakes;
+    constructor(options: Options, sessionType: SessionTypes);
+    renegotiation(): void;
+    private udpOnMessage;
+    private setupExtensions;
+    protected waitForReady: (condition: () => boolean) => Promise<void>;
+    handleFragmentHandshake(messages: FragmentedHandshake[]): FragmentedHandshake[];
+    /**send application data */
+    send: (buf: Buffer, addr?: Address) => Promise<void>;
+    close(): void;
+    extractSessionKeys(keyLength: number, saltLength: number): {
+        localKey: Buffer<ArrayBufferLike>;
+        localSalt: Buffer<ArrayBufferLike>;
+        remoteKey: Buffer<ArrayBufferLike>;
+        remoteSalt: Buffer<ArrayBufferLike>;
+    };
+    exportKeyingMaterial(label: string, length: number): Buffer<ArrayBuffer>;
+    get remoteCertificate(): Buffer<ArrayBufferLike> | undefined;
+}
+export interface Options {
+    transport: Transport;
+    srtpProfiles?: SrtpProfile[];
+    cert?: string;
+    key?: string;
+    signatureHash?: SignatureHash;
+    certificateRequest?: boolean;
+    extendedMasterSecret?: boolean;
+}

package/dist/cjs/lib/dtls/socket.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtlsSocket = void 0;
+const promises_1 = require("node:timers/promises");
+const common_js_1 = require("./imports/common.js");
+const const_js_1 = require("./cipher/const.js");
+const prf_js_1 = require("./cipher/prf.js");
+const abstract_js_1 = require("./cipher/suites/abstract.js");
+const cipher_js_1 = require("./context/cipher.js");
+const dtls_js_1 = require("./context/dtls.js");
+const srtp_js_1 = require("./context/srtp.js");
+const transport_js_1 = require("./context/transport.js");
+const ellipticCurves_js_1 = require("./handshake/extensions/ellipticCurves.js");
+const extendedMasterSecret_js_1 = require("./handshake/extensions/extendedMasterSecret.js");
+const renegotiationIndication_js_1 = require("./handshake/extensions/renegotiationIndication.js");
+const signature_js_1 = require("./handshake/extensions/signature.js");
+const useSrtp_js_1 = require("./handshake/extensions/useSrtp.js");
+const builder_js_1 = require("./record/builder.js");
+const const_js_2 = require("./record/const.js");
+const fragment_js_1 = require("./record/message/fragment.js");
+const receive_js_1 = require("./record/receive.js");
+const { decode, types } = common_js_1.binaryData;
+const log = (0, common_js_1.debug)('webrtc/dtls/socket:log');
+const err = (0, common_js_1.debug)('webrtc/dtls/socket:err');
+class DtlsSocket {
+    constructor(options, sessionType) {
+        this.options = options;
+        this.sessionType = sessionType;
+        this.onConnect = new common_js_1.Event();
+        this.onData = new common_js_1.Event();
+        this.onError = new common_js_1.Event();
+        this.onClose = new common_js_1.Event();
+        this.srtp = new srtp_js_1.SrtpContext();
+        this.connected = false;
+        this.extensions = [];
+        this.bufferFragmentedHandshakes = [];
+        this.udpOnMessage = (data) => {
+            const packets = (0, receive_js_1.parsePacket)(data);
+            for (const packet of packets) {
+                try {
+                    const messages = (0, receive_js_1.parsePlainText)(this.dtls, this.cipher)(packet);
+                    for (const message of messages) {
+                        switch (message.type) {
+                            case const_js_2.ContentType.handshake:
+                                {
+                                    const handshake = message.data;
+                                    const handshakes = this.handleFragmentHandshake([handshake]);
+                                    const assembled = Object.values(handshakes.reduce((acc, cur) => {
+                                        if (!acc[cur.msg_type])
+                                            acc[cur.msg_type] = [];
+                                        acc[cur.msg_type].push(cur);
+                                        return acc;
+                                    }, {}))
+                                        .map((v) => fragment_js_1.FragmentedHandshake.assemble(v))
+                                        .sort((a, b) => a.msg_type - b.msg_type);
+                                    this.onHandleHandshakes(assembled).catch((error) => {
+                                        err(this.dtls.sessionId, 'onHandleHandshakes error', error);
+                                        this.onError.execute(error);
+                                    });
+                                }
+                                break;
+                            case const_js_2.ContentType.applicationData:
+                                {
+                                    this.onData.execute(message.data);
+                                }
+                                break;
+                            case const_js_2.ContentType.alert:
+                                this.onClose.execute();
+                                break;
+                        }
+                    }
+                }
+                catch (error) {
+                    err(this.dtls.sessionId, 'catch udpOnMessage error', error);
+                }
+            }
+        };
+        this.waitForReady = async (condition) => {
+            for (let i = 0; i < 10; i++) {
+                if (condition())
+                    return;
+                await (0, promises_1.setTimeout)(100 * i);
+            }
+            throw new Error('waitForReady timeout');
+        };
+        /**send application data */
+        this.send = async (buf, addr) => {
+            const pkt = (0, builder_js_1.createPlaintext)(this.dtls)([{ type: const_js_2.ContentType.applicationData, fragment: buf }], ++this.dtls.recordSequenceNumber)[0];
+            await this.transport.send(this.cipher.encryptPacket(pkt).serialize(), addr);
+        };
+        this.dtls = new dtls_js_1.DtlsContext(this.options, this.sessionType);
+        this.cipher = new cipher_js_1.CipherContext(this.sessionType, this.options.cert, this.options.key, this.options.signatureHash);
+        this.transport = new transport_js_1.TransportContext(this.options.transport);
+        this.setupExtensions();
+        this.transport.socket.onData = this.udpOnMessage;
+    }
+    renegotiation() {
+        log('renegotiation', this.sessionType);
+        this.connected = false;
+        this.cipher = new cipher_js_1.CipherContext(this.sessionType, this.options.cert, this.options.key, this.options.signatureHash);
+        this.dtls = new dtls_js_1.DtlsContext(this.options, this.sessionType);
+        this.srtp = new srtp_js_1.SrtpContext();
+        this.extensions = [];
+        this.bufferFragmentedHandshakes = [];
+    }
+    setupExtensions() {
+        log(this.dtls.sessionId, 'support srtpProfiles', this.options.srtpProfiles);
+        if (this.options.srtpProfiles && this.options.srtpProfiles.length > 0) {
+            const useSrtp = useSrtp_js_1.UseSRTP.create(this.options.srtpProfiles, Buffer.from([0x00]));
+            this.extensions.push(useSrtp.extension);
+        }
+        {
+            const curve = ellipticCurves_js_1.EllipticCurves.createEmpty();
+            curve.data = const_js_1.NamedCurveAlgorithmList;
+            this.extensions.push(curve.extension);
+        }
+        {
+            const signature = signature_js_1.Signature.createEmpty();
+            // libwebrtc/OpenSSL require 4=1 , 4=3 signatureHash
+            signature.data = const_js_1.signatures;
+            this.extensions.push(signature.extension);
+        }
+        if (this.options.extendedMasterSecret) {
+            this.extensions.push({
+                type: extendedMasterSecret_js_1.ExtendedMasterSecret.type,
+                data: Buffer.alloc(0)
+            });
+        }
+        {
+            const renegotiationIndication = renegotiationIndication_js_1.RenegotiationIndication.createEmpty();
+            this.extensions.push(renegotiationIndication.extension);
+        }
+    }
+    handleFragmentHandshake(messages) {
+        let handshakes = messages.filter((v) => {
+            // find fragmented
+            if (v.fragment_length !== v.length) {
+                this.bufferFragmentedHandshakes.push(v);
+                return false;
+            }
+            return true;
+        });
+        if (this.bufferFragmentedHandshakes.length > 1) {
+            const [last] = this.bufferFragmentedHandshakes.slice(-1);
+            if (last.fragment_offset + last.fragment_length === last.length) {
+                handshakes = [...this.bufferFragmentedHandshakes, ...handshakes];
+                this.bufferFragmentedHandshakes = [];
+            }
+        }
+        return handshakes; // return un fragmented handshakes
+    }
+    close() {
+        this.transport.close();
+        (0, common_js_1.runDetached)(() => this.transport.socket.close(), (error) => log('close failed', error));
+    }
+    extractSessionKeys(keyLength, saltLength) {
+        const keyingMaterial = this.exportKeyingMaterial('EXTRACTOR-dtls_srtp', keyLength * 2 + saltLength * 2);
+        const { clientKey, serverKey, clientSalt, serverSalt } = decode(keyingMaterial, {
+            clientKey: types.buffer(keyLength),
+            serverKey: types.buffer(keyLength),
+            clientSalt: types.buffer(saltLength),
+            serverSalt: types.buffer(saltLength)
+        });
+        if (this.sessionType === abstract_js_1.SessionType.CLIENT) {
+            return {
+                localKey: clientKey,
+                localSalt: clientSalt,
+                remoteKey: serverKey,
+                remoteSalt: serverSalt
+            };
+        }
+        else {
+            return {
+                localKey: serverKey,
+                localSalt: serverSalt,
+                remoteKey: clientKey,
+                remoteSalt: clientSalt
+            };
+        }
+    }
+    exportKeyingMaterial(label, length) {
+        return (0, prf_js_1.exportKeyingMaterial)(label, length, this.cipher.masterSecret, this.cipher.localRandom.serialize(), this.cipher.remoteRandom.serialize(), this.sessionType === abstract_js_1.SessionType.CLIENT);
+    }
+    get remoteCertificate() {
+        return this.cipher.remoteCertificate;
+    }
+}
+exports.DtlsSocket = DtlsSocket;

package/dist/cjs/lib/dtls/typings/domain.d.ts

@@ -0,0 +1,20 @@
+import type { HandshakeType } from '../handshake/const.js';
+import type { FragmentedHandshake } from '../record/message/fragment.js';
+export type Version = {
+    major: number;
+    minor: number;
+};
+export type Random = {
+    gmt_unix_time: number;
+    random_bytes: Buffer;
+};
+export type Handshake = {
+    msgType: HandshakeType;
+    messageSeq?: number;
+    serialize: () => Buffer;
+    toFragment: () => FragmentedHandshake;
+};
+export type Extension = {
+    type: number;
+    data: Buffer;
+};

package/dist/cjs/lib/dtls/typings/domain.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/dtls/util/binary.d.ts

@@ -0,0 +1,2 @@
+import { binaryData } from '../imports/common.js';
+export declare function encodeBuffer(obj: object, spec: binaryData.Schema): Buffer<ArrayBufferLike>;

package/dist/cjs/lib/dtls/util/binary.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBuffer = encodeBuffer;
+const common_js_1 = require("../imports/common.js");
+const { encode } = common_js_1.binaryData;
+function encodeBuffer(obj, spec) {
+    return encode(obj, spec);
+}

package/dist/cjs/lib/ice/candidate.d.ts

@@ -0,0 +1,35 @@
+export type TcpCandidateType = 'active' | 'passive' | 'so';
+export declare class Candidate {
+    foundation: string;
+    component: number;
+    transport: string;
+    priority: number;
+    host: string;
+    port: number;
+    type: string;
+    relatedAddress?: string | undefined;
+    relatedPort?: number | undefined;
+    tcptype?: string | undefined;
+    generation?: number | undefined;
+    ufrag?: string | undefined;
+    id: string;
+    constructor(foundation: string, component: number, transport: string, priority: number, host: string, port: number, type: string, relatedAddress?: string | undefined, relatedPort?: number | undefined, tcptype?: string | undefined, generation?: number | undefined, ufrag?: string | undefined);
+    refreshId(): void;
+    static fromSdp(sdp: string): Candidate;
+    canPairWith(other: Candidate): boolean;
+    toSdp(): string;
+}
+export declare function candidateLocalPreference({ candidateType, transport, tcptype, otherPreference }: {
+    candidateType: string;
+    transport?: string;
+    tcptype?: string;
+    otherPreference?: number;
+}): number;
+export declare function candidateFoundation(candidateType: string, candidateTransport: string, baseAddress: string, server?: string): string;
+export declare function candidatePriority(candidateType: string, options?: number | {
+    transport?: string;
+    tcptype?: string;
+    localPreference?: number;
+    otherPreference?: number;
+}): number;
+export declare function remoteTcpTypeForIncoming(localTcpType?: string): TcpCandidateType;