@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/peer/transport/sctp.js

@@ -0,0 +1,382 @@
+import { randomUUID } from 'node:crypto';
+import { Event, debug, detached, runDetached } from '../imports/common.js';
+import { SCTP, SCTP_STATE } from '../../sctp/index.js';
+import { DATA_CHANNEL_ACK, DATA_CHANNEL_OPEN, DATA_CHANNEL_RELIABLE, WEBRTC_BINARY, WEBRTC_BINARY_EMPTY, WEBRTC_DCEP, WEBRTC_STRING, WEBRTC_STRING_EMPTY } from '../const.js';
+import { RTCDataChannel, RTCDataChannelParameters, getDataChannelMessageSize } from '../dataChannel.js';
+const log = debug('webrtc/peer/transport/sctp');
+export const DEFAULT_MAX_MESSAGE_SIZE = 65536;
+export class RTCSctpTransport {
+    constructor(port = 5000, maxMessageSize = DEFAULT_MAX_MESSAGE_SIZE, sctpOptions = {}) {
+        this.port = port;
+        this.maxMessageSize = maxMessageSize;
+        this.sctpOptions = sctpOptions;
+        this.onDataChannel = new Event();
+        this.id = randomUUID().toString();
+        this.bundled = false;
+        this.dataChannels = {};
+        this.remoteMaxMessageSize = DEFAULT_MAX_MESSAGE_SIZE;
+        this.dataChannelQueue = [];
+        this.eventDisposer = [];
+        this.datachannelReceive = async (streamId, ppId, data) => {
+            if (ppId === WEBRTC_DCEP && data.length > 0) {
+                log('DCEP', streamId, ppId, data);
+                switch (data[0]) {
+                    case DATA_CHANNEL_OPEN:
+                        {
+                            if (data.length < 12) {
+                                log('DATA_CHANNEL_OPEN data.length not enough');
+                                return;
+                            }
+                            if (!Object.keys(this.dataChannels).includes(streamId.toString())) {
+                                // !BBHLHH — 12 byte DCEP OPEN header (big-endian)
+                                const channelType = data.readUInt8(1);
+                                const reliability = data.readUInt32BE(4);
+                                const labelLength = data.readUInt16BE(8);
+                                const protocolLength = data.readUInt16BE(10);
+                                let pos = 12;
+                                const label = data.slice(pos, pos + labelLength).toString('utf8');
+                                pos += labelLength;
+                                const protocol = data
+                                    .slice(pos, pos + protocolLength)
+                                    .toString('utf8');
+                                log('DATA_CHANNEL_OPEN', {
+                                    channelType,
+                                    reliability,
+                                    streamId,
+                                    label,
+                                    protocol
+                                });
+                                const maxRetransmits = (channelType & 0x03) === 1 ? reliability : undefined;
+                                const maxPacketLifeTime = (channelType & 0x03) === 2 ? reliability : undefined;
+                                // # register channel
+                                const parameters = new RTCDataChannelParameters({
+                                    label,
+                                    ordered: (channelType & 0x80) === 0,
+                                    maxPacketLifeTime,
+                                    maxRetransmits,
+                                    protocol,
+                                    id: streamId
+                                });
+                                const channel = new RTCDataChannel(this, parameters, false);
+                                channel.isCreatedByRemote = true;
+                                this.dataChannels[streamId] = channel;
+                                this.onDataChannel.execute(channel);
+                                channel.setReadyState('open');
+                            }
+                            else {
+                                log('datachannel already opened', 'retransmit ack');
+                            }
+                            const channel = this.dataChannels[streamId];
+                            const ack = Buffer.allocUnsafe(1);
+                            ack.writeUInt8(DATA_CHANNEL_ACK, 0);
+                            this.dataChannelQueue.push([channel, WEBRTC_DCEP, ack]);
+                            await this.dataChannelFlush();
+                        }
+                        break;
+                    case DATA_CHANNEL_ACK:
+                        {
+                            log('DATA_CHANNEL_ACK', streamId, ppId);
+                            const channel = this.dataChannels[streamId];
+                            if (!channel) {
+                                throw new Error('channel not found');
+                            }
+                            channel.setReadyState('open');
+                        }
+                        break;
+                }
+            }
+            else {
+                const channel = this.dataChannels[streamId];
+                if (channel) {
+                    const msg = (() => {
+                        switch (ppId) {
+                            case WEBRTC_STRING:
+                                return data.toString('utf8');
+                            case WEBRTC_STRING_EMPTY:
+                                return '';
+                            case WEBRTC_BINARY:
+                                return data;
+                            case WEBRTC_BINARY_EMPTY:
+                                return Buffer.from([]);
+                            default:
+                                throw new Error();
+                        }
+                    })();
+                    // Update reception statistics
+                    channel.messagesReceived++;
+                    channel.bytesReceived += data.length;
+                    channel.onMessage.execute(msg);
+                    channel.emit('message', { data: msg });
+                    if (channel.onmessage) {
+                        runDetached(() => channel.onmessage({ data: msg }), (error) => log('onmessage failed', error));
+                    }
+                }
+            }
+        };
+        this.datachannelSend = (channel, data) => {
+            const size = getDataChannelMessageSize(data);
+            this.assertSendableMessageSize(size);
+            channel.addBufferedAmount(size);
+            //An empty message is one zero byte with the PPID of an empty message (RFC 8831 section 6.6)
+            if (size === 0) {
+                this.dataChannelQueue.push([
+                    channel,
+                    typeof data === 'string' ? WEBRTC_STRING_EMPTY : WEBRTC_BINARY_EMPTY,
+                    Buffer.from([0])
+                ]);
+            }
+            else {
+                const userData = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                this.dataChannelQueue.push(typeof data === 'string'
+                    ? [channel, WEBRTC_STRING, userData]
+                    : [channel, WEBRTC_BINARY, userData]);
+            }
+            if (this.sctp.associationState !== SCTP_STATE.ESTABLISHED) {
+                log('sctp not established', this.sctp.associationState);
+            }
+            this.dataChannelFlush().catch((error) => log('flush failed', error));
+            return size;
+        };
+    }
+    get transport() {
+        return this.dtlsTransport;
+    }
+    setDtlsTransport(dtlsTransport) {
+        if (this.dtlsTransport && this.dtlsTransport.id === dtlsTransport.id) {
+            return;
+        }
+        this.eventDisposer.forEach((dispose) => dispose());
+        this.dtlsTransport = dtlsTransport;
+        this.sctp = new SCTP(new BridgeDtls(this.dtlsTransport), this.port, this.sctpOptions);
+        this.eventDisposer = [
+            ...[
+                this.sctp.onReceive.subscribe(detached(this.datachannelReceive, (error) => log('receive failed', error))),
+                this.sctp.onReconfigStreams.subscribe((ids) => {
+                    ids.forEach((id) => {
+                        const dc = this.dataChannels[id];
+                        if (!dc)
+                            return;
+                        // todo fix
+                        dc.setReadyState('closing');
+                        dc.setReadyState('closed');
+                        delete this.dataChannels[id];
+                    });
+                }),
+                this.sctp.stateChanged.connected.subscribe(() => {
+                    Object.values(this.dataChannels).forEach((channel) => {
+                        if (channel.negotiated && channel.readyState !== 'open') {
+                            channel.setReadyState('open');
+                        }
+                    });
+                    this.dataChannelFlush().catch((error) => log('flush failed', error));
+                }),
+                this.sctp.stateChanged.closed.subscribe(() => {
+                    Object.values(this.dataChannels).forEach((dc) => {
+                        dc.setReadyState('closed');
+                    });
+                    this.dataChannels = {};
+                }),
+                this.dtlsTransport.onStateChange.subscribe((state) => {
+                    if (state === 'closed') {
+                        this.sctp.setState(SCTP_STATE.CLOSED);
+                    }
+                })
+            ].map((e) => e.unSubscribe),
+            () => (this.sctp.onSackReceived = async () => { }),
+            () => (this.sctp.onSent = undefined)
+        ];
+        this.sctp.onSackReceived = async () => {
+            await this.dataChannelFlush();
+        };
+        //A message leaves the send buffer of its channel when SCTP sends its chunks (bufferedAmount, W3C WebRTC)
+        this.sctp.onSent = (streamId, ppId, bytes) => {
+            if (ppId === WEBRTC_DCEP ||
+                ppId === WEBRTC_STRING_EMPTY ||
+                ppId === WEBRTC_BINARY_EMPTY) {
+                return;
+            }
+            this.dataChannels[streamId]?.addBufferedAmount(-bytes);
+        };
+    }
+    /**
+     * Keep bytes received out of the receive window while the application holds them (see SCTP.holdReceived)
+     * @param bytes
+     */
+    holdReceived(bytes) {
+        this.sctp.holdReceived(bytes);
+    }
+    /**
+     * Give back bytes held to the receive window (see SCTP.releaseReceived)
+     * @param bytes
+     */
+    releaseReceived(bytes) {
+        this.sctp.releaseReceived(bytes);
+    }
+    get isServer() {
+        return this.dtlsTransport.iceTransport.role !== 'controlling';
+    }
+    channelByLabel(label) {
+        return Object.values(this.dataChannels).find((d) => d.label === label);
+    }
+    dataChannelAddNegotiated(channel) {
+        if (channel.id == undefined) {
+            throw new Error();
+        }
+        if (this.dataChannels[channel.id]) {
+            throw new Error();
+        }
+        this.dataChannels[channel.id] = channel;
+        if (this.sctp.associationState === SCTP_STATE.ESTABLISHED) {
+            channel.setReadyState('open');
+        }
+    }
+    dataChannelOpen(channel) {
+        if (channel.id !== undefined) {
+            if (this.dataChannels[channel.id])
+                throw new Error(`Data channel with ID ${channel.id} already registered`);
+            this.dataChannels[channel.id] = channel;
+        }
+        //The reliability (RFC 8832 section 5.1), and the unordered flag with any of them
+        let channelType = DATA_CHANNEL_RELIABLE;
+        const priority = 0;
+        let reliability = 0;
+        if (channel.maxRetransmits !== null) {
+            channelType = 1;
+            reliability = channel.maxRetransmits;
+        }
+        else if (channel.maxPacketLifeTime !== null) {
+            channelType = 2;
+            reliability = channel.maxPacketLifeTime;
+        }
+        if (!channel.ordered) {
+            channelType |= 0x80;
+        }
+        // 5.1.  DATA_CHANNEL_OPEN Message
+        // !BBHLHH — message type / channel type / priority / reliability / label len / protocol len
+        const data = Buffer.allocUnsafe(12);
+        data.writeUInt8(DATA_CHANNEL_OPEN, 0);
+        data.writeUInt8(channelType, 1);
+        data.writeUInt16BE(priority, 2);
+        data.writeUInt32BE(reliability, 4);
+        //The lengths in bytes, of the UTF-8 label and protocol
+        const label = Buffer.from(channel.label, 'utf8');
+        const protocol = Buffer.from(channel.protocol, 'utf8');
+        data.writeUInt16BE(label.length, 8);
+        data.writeUInt16BE(protocol.length, 10);
+        const send = Buffer.concat([data, label, protocol]);
+        this.dataChannelQueue.push([channel, WEBRTC_DCEP, send]);
+        this.dataChannelFlush().catch((error) => log('flush failed', error));
+    }
+    async dataChannelFlush() {
+        // """
+        // Try to flush buffered data to the SCTP layer.
+        // We wait until the association is established, as we need to know
+        // whether we are a client or a server to correctly assign an odd/even ID
+        // to the data channels.
+        // """
+        if (this.sctp.associationState != SCTP_STATE.ESTABLISHED)
+            return;
+        while (this.dataChannelQueue.length > 0) {
+            const [channel, protocol, userData] = this.dataChannelQueue.shift();
+            let streamId = channel.id;
+            if (streamId === undefined) {
+                streamId = this.dataChannelId;
+                while (Object.keys(this.dataChannels).includes(streamId.toString())) {
+                    streamId += 2;
+                }
+                this.dataChannels[streamId] = channel;
+                channel.setId(streamId);
+            }
+            //Queued in SCTP at once: its windows pace the sending, onSent lowers bufferedAmount
+            if (protocol === WEBRTC_DCEP) {
+                this.sctp
+                    .send(streamId, protocol, userData, {
+                    ordered: true
+                })
+                    .catch((error) => log('send dcep failed', error.message));
+            }
+            else {
+                const expiry = channel.maxPacketLifeTime !== null
+                    ? Date.now() + channel.maxPacketLifeTime / 1000
+                    : undefined;
+                this.sctp
+                    .send(streamId, protocol, userData, {
+                    expiry,
+                    maxRetransmits: channel.maxRetransmits ?? undefined,
+                    ordered: channel.ordered
+                })
+                    .catch((error) => log('send data failed', error.message));
+            }
+        }
+        // Resetting the queue to empty array mitigates this.
+        this.dataChannelQueue = [];
+    }
+    assertSendableMessageSize(size) {
+        if (this.remoteMaxMessageSize !== 0 && size > this.remoteMaxMessageSize) {
+            throw new Error(`max-message-size exceeded: ${size} > ${this.remoteMaxMessageSize}`);
+        }
+    }
+    getCapabilities() {
+        return RTCSctpTransport.getCapabilities(this.maxMessageSize);
+    }
+    static getCapabilities(maxMessageSize = DEFAULT_MAX_MESSAGE_SIZE) {
+        return new RTCSctpCapabilities(maxMessageSize);
+    }
+    setRemoteMaxMessageSize(maxMessageSize) {
+        this.remoteMaxMessageSize = maxMessageSize ?? DEFAULT_MAX_MESSAGE_SIZE;
+    }
+    setRemotePort(port) {
+        this.sctp.setRemotePort(port);
+    }
+    async start(remotePort) {
+        //The DTLS client takes the even stream ids, the server the odd ones (RFC 8832 section 6): the roles of ICE may
+        //be the same way round or not
+        this.dataChannelId = this.dtlsTransport.role === 'server' ? 1 : 0;
+        this.sctp.isServer = this.isServer;
+        await this.sctp.start(remotePort);
+    }
+    async stop() {
+        this.dtlsTransport.dataReceiver = () => { };
+        await this.sctp.stop();
+    }
+    dataChannelClose(channel) {
+        if (!['closing', 'closed'].includes(channel.readyState)) {
+            channel.setReadyState('closing');
+            if (this.sctp.associationState === SCTP_STATE.ESTABLISHED) {
+                // Check if channel.id is already in reconfigQueue to prevent duplicates
+                if (!this.sctp.reconfigQueue.includes(channel.id)) {
+                    this.sctp.reconfigQueue.push(channel.id);
+                }
+                if (this.sctp.reconfigQueue.length === 1) {
+                    this.sctp.transmitReconfigRequest().catch((error) => log('reconfig failed', error));
+                }
+            }
+            else {
+                this.dataChannelQueue = this.dataChannelQueue.filter((queueItem) => queueItem[0].id !== channel.id);
+                // Remove any pending reconfiguration requests for this channel
+                this.sctp.reconfigQueue = this.sctp.reconfigQueue.filter((streamId) => streamId !== channel.id);
+                if (channel.id !== undefined) {
+                    delete this.dataChannels[channel.id];
+                }
+                channel.setReadyState('closed');
+            }
+        }
+    }
+}
+export class RTCSctpCapabilities {
+    constructor(maxMessageSize) {
+        this.maxMessageSize = maxMessageSize;
+    }
+}
+class BridgeDtls {
+    constructor(dtls) {
+        this.dtls = dtls;
+        this.send = (data) => {
+            return this.dtls.sendData(data);
+        };
+    }
+    set onData(onData) {
+        this.dtls.dataReceiver = onData;
+    }
+    close() { }
+}

package/dist/esm/lib/peer/types/domain.js

@@ -0,0 +1,16 @@
+export const SignalingStates = [
+    'stable',
+    'have-local-offer',
+    'have-remote-offer',
+    'have-local-pranswer',
+    'have-remote-pranswer',
+    'closed'
+];
+export const ConnectionStates = [
+    'closed',
+    'failed',
+    'disconnected',
+    'new',
+    'connecting',
+    'connected'
+];

package/dist/esm/lib/peer/types/util.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/lib/peer/utils.js

@@ -0,0 +1,286 @@
+import { createHash } from 'node:crypto';
+import { createSocket } from 'node:dgram';
+import { performance } from 'node:perf_hooks';
+import { debug, randomPort } from './imports/common.js';
+import { CipherContext } from './imports/dtls.js';
+import { Directions } from './media/rtpTransceiver.js';
+import { MediaStreamTrack } from './media/track.js';
+const log = debug('webrtc/peer/utils');
+export function fingerprint(file, hashName) {
+    const upper = (s) => s.toUpperCase();
+    const colon = (s) => s.match(/(.{2})/g).join(':');
+    const hash = createHash(hashName).update(file).digest('hex');
+    return colon(upper(hash));
+}
+const fingerprintHashAlgorithms = {
+    sha1: 'sha1',
+    'sha-1': 'sha1',
+    sha224: 'sha224',
+    'sha-224': 'sha224',
+    sha256: 'sha256',
+    'sha-256': 'sha256',
+    sha384: 'sha384',
+    'sha-384': 'sha384',
+    sha512: 'sha512',
+    'sha-512': 'sha512'
+};
+export function normalizeFingerprintAlgorithm(algorithm) {
+    return fingerprintHashAlgorithms[algorithm.trim().toLowerCase()];
+}
+export function normalizeFingerprintValue(value) {
+    return value.replace(/[^0-9a-f]/gi, '').toLowerCase();
+}
+export function isDtls(buf) {
+    const firstByte = buf[0];
+    return firstByte > 19 && firstByte < 64;
+}
+export function reverseSimulcastDirection(dir) {
+    if (dir === 'recv')
+        return 'send';
+    return 'recv';
+}
+export const andDirection = (a, b) => Directions[Directions.indexOf(a) & Directions.indexOf(b)];
+export function reverseDirection(dir) {
+    if (dir === 'sendonly')
+        return 'recvonly';
+    if (dir === 'recvonly')
+        return 'sendonly';
+    return dir;
+}
+export const milliTime = Date.now;
+const startupTimestampInMicroseconds = BigInt(Date.now()) * 1000n - process.hrtime.bigint() / 1000n;
+export const microTime = () => {
+    return startupTimestampInMicroseconds + process.hrtime.bigint() / 1000n;
+};
+export const timestampSeconds = () => Date.now() / 1000;
+/**https://datatracker.ietf.org/doc/html/rfc3550#section-4 */
+//The NTP epoch (1900) from the Unix epoch, in milliseconds
+const NTP_EPOCH_MS = Date.UTC(1900, 0, 1);
+/**
+ * The time now as an NTP timestamp (RFC 5905): 32 bits of seconds since 1900, then 32 bits of fraction of a second
+ */
+export const ntpTime = (epochMs = performance.timeOrigin + performance.now()) => {
+    const ms = epochMs - NTP_EPOCH_MS;
+    const seconds = Math.floor(ms / 1000);
+    const fraction = Math.floor(((ms - seconds * 1000) / 1000) * 2 ** 32);
+    return (BigInt(seconds) << 32n) | BigInt(fraction);
+};
+/**
+ * The abs-send-time header extension of a time: the 6 low bits of the seconds and the 18 high bits of the fraction of
+ * its NTP timestamp, without the bigints of ntpTime() (it is computed for each packet)
+ * @param epochMs The time, in milliseconds since the Unix epoch.
+ */
+export const absSendTimeOf = (epochMs) => {
+    const ms = epochMs - NTP_EPOCH_MS;
+    const seconds = Math.floor(ms / 1000);
+    const fraction = Math.floor(((ms - seconds * 1000) / 1000) * 2 ** 32);
+    const buf = Buffer.allocUnsafe(3);
+    buf.writeUIntBE(((seconds & 0x3f) << 18) | (fraction >>> 14), 0, 3);
+    return buf;
+};
+/**
+ * The time of an NTP timestamp, in milliseconds since the Unix epoch
+ * @param ntp
+ */
+export const ntpTimeToEpochMs = (ntp) => {
+    const seconds = Number(ntp >> 32n);
+    const fraction = Number(ntp & 0xffffffffn);
+    return seconds * 1000 + (fraction / 2 ** 32) * 1000 + NTP_EPOCH_MS;
+};
+/**
+ * https://datatracker.ietf.org/doc/html/rfc3550#section-4
+ * @param ntp
+ * @returns 32bit
+ */
+export const compactNtp = (ntp) => {
+    //The middle 32 bits: the low 16 bits of the seconds, the high 16 bits of the fraction
+    return Number((ntp >> 16n) & 0xffffffffn);
+};
+export function parseIceServers(iceServers) {
+    //The first STUN and TURN URLs, and all of them in stunServers and turnServers
+    const options = { stunServers: [], turnServers: [] };
+    for (const iceServer of iceServers) {
+        const urls = Array.isArray(iceServer.urls)
+            ? iceServer.urls
+            : [iceServer.urls];
+        for (const url of urls) {
+            const parsed = parseIceServerUrl(url);
+            if (!parsed) {
+                continue;
+            }
+            if (parsed.kind === 'stun') {
+                options.stunServer ??= parsed.address;
+                options.stunServers.push(parsed.address);
+            }
+            if (parsed.kind === 'turn') {
+                if (!options.turnServer) {
+                    options.turnServer = parsed.address;
+                    options.turnTransport = parsed.transport;
+                    options.turnUsername = iceServer.username;
+                    options.turnPassword = iceServer.credential;
+                }
+                if (iceServer.username && iceServer.credential) {
+                    options.turnServers.push({
+                        address: parsed.address,
+                        username: iceServer.username,
+                        password: iceServer.credential,
+                        transport: parsed.transport
+                    });
+                }
+            }
+        }
+    }
+    log('iceOptions', options);
+    return options;
+}
+export function resolveTurnTransport({ configuredTurnTransport, forceTurnTCP, parsedTurnTransport }) {
+    if (parsedTurnTransport) {
+        return parsedTurnTransport;
+    }
+    if (configuredTurnTransport) {
+        return configuredTurnTransport;
+    }
+    if (forceTurnTCP) {
+        return 'tcp';
+    }
+    return undefined;
+}
+function parseIceServerUrl(url) {
+    const matched = /^(stun|stuns|turn|turns):(.+)$/i.exec(url.trim());
+    if (!matched) {
+        return;
+    }
+    const [, rawScheme, rawRest] = matched;
+    const scheme = rawScheme.toLowerCase();
+    const [authority] = rawRest.split('?', 1);
+    const [, query = ''] = rawRest.split('?');
+    const address = parseAddress(authority, defaultPort(scheme));
+    if (!address) {
+        return;
+    }
+    if (scheme === 'stun' || scheme === 'stuns') {
+        return { kind: 'stun', address };
+    }
+    const queryParams = new URLSearchParams(query);
+    const transportParam = queryParams.get('transport');
+    const transport = resolveParsedTurnTransport({
+        scheme,
+        transportParam
+    });
+    if (transport === 'invalid') {
+        return;
+    }
+    return {
+        kind: 'turn',
+        address,
+        transport
+    };
+}
+function resolveParsedTurnTransport({ scheme, transportParam }) {
+    if (transportParam == null) {
+        return scheme === 'turns' ? 'tls' : undefined;
+    }
+    if (transportParam === 'udp') {
+        return scheme === 'turns' ? 'invalid' : 'udp';
+    }
+    if (transportParam === 'tcp') {
+        return scheme === 'turns' ? 'tls' : 'tcp';
+    }
+    return 'invalid';
+}
+function defaultPort(scheme) {
+    if (scheme === 'stuns' || scheme === 'turns') {
+        return 5349;
+    }
+    return 3478;
+}
+function parseAddress(value, fallbackPort) {
+    const authority = value.startsWith('//') ? value.slice(2) : value;
+    if (!authority) {
+        return;
+    }
+    if (authority.startsWith('[')) {
+        const closingBracket = authority.indexOf(']');
+        if (closingBracket === -1) {
+            return;
+        }
+        const host = authority.slice(1, closingBracket);
+        const port = parsePort(authority.slice(closingBracket + 1), fallbackPort);
+        return [host, port];
+    }
+    const firstColon = authority.indexOf(':');
+    const lastColon = authority.lastIndexOf(':');
+    if (firstColon !== -1 && firstColon === lastColon) {
+        return [
+            authority.slice(0, firstColon),
+            parsePort(authority.slice(firstColon + 1), fallbackPort)
+        ];
+    }
+    return [authority, fallbackPort];
+}
+function parsePort(value, fallbackPort) {
+    const portString = value.startsWith(':') ? value.slice(1) : value;
+    const port = Number.parseInt(portString, 10);
+    return Number.isFinite(port) ? port : fallbackPort;
+}
+/**
+ *
+ * @param signatureHash
+ * @param namedCurveAlgorithm necessary when use ecdsa
+ */
+export const createSelfSignedCertificate = CipherContext.createSelfSignedCertificateWithKey;
+export class MediaStreamTrackFactory {
+    static async rtpSource({ port, kind, cb }) {
+        port ??= await randomPort();
+        const track = new MediaStreamTrack({ kind });
+        const udp = createSocket('udp4');
+        udp.bind(port);
+        const onMessage = (msg) => {
+            if (cb) {
+                msg = cb(msg);
+            }
+            track.writeRtp(msg);
+        };
+        udp.addListener('message', onMessage);
+        const dispose = () => {
+            udp.removeListener('message', onMessage);
+            try {
+                udp.close();
+            }
+            catch {
+                //Already closed
+            }
+        };
+        return [track, port, dispose];
+    }
+}
+/**
+ * Merge two objects. If a property value in the source object is undefined or
+ * when casted is equal to undefined (== undefined), then it will not overwrite
+ * the value of the property in the destination object.
+ */
+export const deepMerge = (dst, src) => {
+    if (!dst || typeof dst !== 'object') {
+        if (src !== null && typeof src === 'object') {
+            return src;
+        }
+        else {
+            return dst;
+        }
+    }
+    if (!src || typeof src !== 'object') {
+        if (src == undefined) {
+            return dst;
+        }
+        return src;
+    }
+    for (const key in src) {
+        if (Object.prototype.hasOwnProperty.call(src, key)) {
+            const sourceValue = src[key];
+            if (sourceValue != undefined) {
+                dst[key] = sourceValue;
+            }
+        }
+    }
+    return dst;
+};