@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/esm/peer/PeerConnection.js

@@ -0,0 +1,694 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO, Provider } from '@lakutata/core';
+import { Autoload, Configurable, Transient } from '@lakutata/core/decorator/di';
+import { MediaStream } from '../lib/peer/media/track.js';
+import { RTCPeerConnection } from '../lib/peer/peerConnection.js';
+import { engineConfigOf } from './EngineConfig.js';
+import { engineConnections } from './EngineConnection.js';
+import { Events } from './Events.js';
+import { DEFAULT_CODECS, SUPPORTED_CODECS } from './MediaCodecs.js';
+import { engineTrackOf, keyFrameRequested, trackOf } from './MediaTrack.js';
+import { PeerChannel } from './PeerChannel.js';
+import { engineSenderOf, receiverOf, senderOf, transceiverOf } from './RtpTransceiver.js';
+/**
+ * A local ICE candidate, as `RTCIceCandidate`
+ */
+class IceCandidate {
+    constructor(init) {
+        this.candidate = init.candidate;
+        this.sdpMid = init.sdpMid ?? null;
+        this.sdpMLineIndex = init.sdpMLineIndex ?? null;
+        this.usernameFragment = init.usernameFragment ?? null;
+    }
+    toJSON() {
+        return { candidate: this.candidate, sdpMid: this.sdpMid, sdpMLineIndex: this.sdpMLineIndex, usernameFragment: this.usernameFragment };
+    }
+}
+/**
+ * A plain description
+ * @param description
+ */
+function plainDescription(description) {
+    return description ? { type: description.type, sdp: description.sdp } : null;
+}
+/**
+ * A peer-to-peer connection of Node.js (and of Bun, of the main process of Electron), implemented in TypeScript: the
+ * same interface as `RTCPeerConnection` of the browsers (offers and answers, candidates, data channels, audio and video
+ * tracks, ICE restart, perfect negotiation), so the code and the signaling are the ones of a browser. Its events may be
+ * listened to in the W3C style (`addEventListener`, the `on…` properties) or in the Node.js style
+ * (`on('datachannel', (channel) => …)`). The tracks carry encoded audio and video, as RTP packets: see
+ * {@link MediaTrack}.
+ *
+ * Get a new one each time with `getObject(PeerConnection, options)` (it is `@Transient`, and needs no registration);
+ * `close()` closes it and destroys the object, and the ones still open are closed when the application stops. With the
+ * signaling of this package, `SignalingClient` creates the connections itself.
+ * @example
+ * ```typescript
+ * import {Component} from 'lakutata'
+ * import {PeerConnection, type PeerChannel, type SignalingCandidate, type SignalingDescription} from '@lakutata/webrtc'
+ *
+ * class Device extends Component {
+ *     //Answer an offer received some other way (an HTTP request, a QR code)
+ *     public async answer(offer: SignalingDescription): Promise<SignalingDescription | null> {
+ *         const connection: PeerConnection = await this.getObject(PeerConnection, {iceServers: [{urls: 'stun:stun.example.com:3478'}]})
+ *         connection.on('datachannel', (channel: PeerChannel): void => {
+ *             channel.on('message', (data: string | Buffer | ArrayBuffer): void => channel.send(`echo: ${data.toString()}`))
+ *         })
+ *         await connection.setRemoteDescription(offer)
+ *         await connection.setLocalDescription()
+ *         //Wait for the candidates, to answer without trickle ICE
+ *         await new Promise<void>((resolve: () => void): void => {
+ *             connection.on('icecandidate', (candidate: SignalingCandidate | null): void => {
+ *                 if (!candidate) resolve()
+ *             })
+ *         })
+ *         return connection.localDescription
+ *     }
+ * }
+ * ```
+ */
+let PeerConnection = class PeerConnection extends Provider {
+    #events = new Events(this);
+    #channels = new WeakMap();
+    #connection;
+    #closed = false;
+    /**
+     * Create the connection.
+     * @protected
+     */
+    async init() {
+        const options = {
+            iceServers: this.iceServers,
+            iceTransportPolicy: this.iceTransportPolicy,
+            iceUseIpv4: this.iceUseIpv4,
+            iceUseIpv6: this.iceUseIpv6,
+            codecs: this.codecs,
+            headerExtensions: this.headerExtensions,
+            ...this.icePortRange ? { icePortRange: this.icePortRange } : {},
+            ...this.iceAdditionalHostAddresses ? { iceAdditionalHostAddresses: this.iceAdditionalHostAddresses } : {}
+        };
+        let connection;
+        if (this.threads) {
+            //Served in a worker thread: its proxy has the members of the engine used here
+            connection = await (await this.getObject(this.threads)).open(options);
+        }
+        else {
+            connection = new RTCPeerConnection(engineConfigOf(options));
+            engineConnections.set(this, connection);
+        }
+        this.#connection = connection;
+        connection.onIceCandidate.subscribe((candidate) => {
+            const iceCandidate = candidate ? new IceCandidate(candidate) : null;
+            this.#fire('icecandidate', { candidate: iceCandidate }, iceCandidate ? iceCandidate.toJSON() : null);
+        });
+        connection.onDataChannel.subscribe((channel) => {
+            const wrapped = this.#wrap(channel);
+            this.#fire('datachannel', { channel: wrapped }, wrapped);
+        });
+        connection.on('track', (event) => {
+            const track = trackOf(event.track, event.receiver);
+            const streamIds = event.streams.map((stream) => stream.id);
+            const transceiver = transceiverOf(event.transceiver);
+            this.#fire('track', {
+                track: track,
+                streams: streamIds.map((id) => ({ id: id })),
+                receiver: receiverOf(event.receiver),
+                transceiver: transceiver
+            }, track, streamIds, transceiver);
+        });
+        //The key frame requests of the other peer go to the track sent
+        connection.onTransceiverAdded.subscribe((transceiver) => {
+            transceiver.sender.onPictureLossIndication.subscribe(() => {
+                if (transceiver.sender.track)
+                    keyFrameRequested(trackOf(transceiver.sender.track));
+            });
+        });
+        connection.onNegotiationneeded.subscribe(() => this.#fire('negotiationneeded', {}));
+        connection.connectionStateChange.subscribe((state) => this.#fire('connectionstatechange', {}, state));
+        connection.iceConnectionStateChange.subscribe((state) => this.#fire('iceconnectionstatechange', {}, state));
+        connection.iceGatheringStateChange.subscribe((state) => this.#fire('icegatheringstatechange', {}, state));
+        connection.signalingStateChange.subscribe((state) => this.#fire('signalingstatechange', {}, state));
+    }
+    /**
+     * Close the connection.
+     * @protected
+     */
+    async destroy() {
+        this.#closed = true;
+        await this.#connection?.close();
+    }
+    /**
+     * `new`, `connecting`, `connected`, `disconnected`, `failed` or `closed`.
+     */
+    get connectionState() {
+        return this.#connection.connectionState;
+    }
+    /**
+     * The state of ICE: `new`, `checking`, `connected`, `completed`, `disconnected`, `failed` or `closed`.
+     */
+    get iceConnectionState() {
+        return this.#connection.iceConnectionState;
+    }
+    /**
+     * The state of the gathering of the local candidates: `new`, `gathering` or `complete`.
+     */
+    get iceGatheringState() {
+        return this.#connection.iceGatheringState;
+    }
+    /**
+     * The state of the offer and answer exchange: `stable`, `have-local-offer`, `have-remote-offer`,
+     * `have-local-pranswer`, `have-remote-pranswer` or `closed`.
+     */
+    get signalingState() {
+        return this.#connection.signalingState;
+    }
+    /**
+     * The local description: the pending one during a negotiation, else the current one.
+     */
+    get localDescription() {
+        return plainDescription(this.#connection.localDescription);
+    }
+    /**
+     * The remote description: the pending one during a negotiation, else the current one.
+     */
+    get remoteDescription() {
+        return plainDescription(this.#connection.remoteDescription);
+    }
+    /**
+     * The SCTP transport of the data channels, once negotiated: `maxMessageSize` is the largest message the other peer
+     * accepts, in bytes.
+     */
+    get sctp() {
+        const transport = this.#connection.sctpTransport;
+        return transport ? { maxMessageSize: transport.remoteMaxMessageSize } : null;
+    }
+    /**
+     * The listener of `icecandidate`, given an event whose `candidate` is the candidate (`null` at the end).
+     */
+    get onicecandidate() {
+        return this.#events.handler('icecandidate');
+    }
+    set onicecandidate(listener) {
+        this.#events.setHandler('icecandidate', listener);
+    }
+    /**
+     * The listener of `datachannel`, given an event whose `channel` is the {@link PeerChannel}.
+     */
+    get ondatachannel() {
+        return this.#events.handler('datachannel');
+    }
+    set ondatachannel(listener) {
+        this.#events.setHandler('datachannel', listener);
+    }
+    /**
+     * The listener of `track`, given a {@link PeerTrackEvent}: the track, its streams, its receiver and transceiver.
+     */
+    get ontrack() {
+        return this.#events.handler('track');
+    }
+    set ontrack(listener) {
+        this.#events.setHandler('track', listener);
+    }
+    /**
+     * The listener of `negotiationneeded`.
+     */
+    get onnegotiationneeded() {
+        return this.#events.handler('negotiationneeded');
+    }
+    set onnegotiationneeded(listener) {
+        this.#events.setHandler('negotiationneeded', listener);
+    }
+    /**
+     * The listener of `connectionstatechange`.
+     */
+    get onconnectionstatechange() {
+        return this.#events.handler('connectionstatechange');
+    }
+    set onconnectionstatechange(listener) {
+        this.#events.setHandler('connectionstatechange', listener);
+    }
+    /**
+     * The listener of `iceconnectionstatechange`.
+     */
+    get oniceconnectionstatechange() {
+        return this.#events.handler('iceconnectionstatechange');
+    }
+    set oniceconnectionstatechange(listener) {
+        this.#events.setHandler('iceconnectionstatechange', listener);
+    }
+    /**
+     * The listener of `icegatheringstatechange`.
+     */
+    get onicegatheringstatechange() {
+        return this.#events.handler('icegatheringstatechange');
+    }
+    set onicegatheringstatechange(listener) {
+        this.#events.setHandler('icegatheringstatechange', listener);
+    }
+    /**
+     * The listener of `signalingstatechange`.
+     */
+    get onsignalingstatechange() {
+        return this.#events.handler('signalingstatechange');
+    }
+    set onsignalingstatechange(listener) {
+        this.#events.setHandler('signalingstatechange', listener);
+    }
+    /**
+     * Create an offer.
+     * @param options `iceRestart` to gather new candidates.
+     * @returns The offer, to give to `setLocalDescription()`.
+     * @example
+     * ```typescript
+     * import type {PeerConnection, SignalingDescription} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * const offer: SignalingDescription = await connection.createOffer()
+     * await connection.setLocalDescription(offer)
+     * ```
+     */
+    async createOffer(options = {}) {
+        return plainDescription(await this.#connection.createOffer(options));
+    }
+    /**
+     * Create an answer to the remote offer.
+     * @returns The answer, to give to `setLocalDescription()`.
+     * @example
+     * ```typescript
+     * import type {PeerConnection, SignalingDescription} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * declare const offer: SignalingDescription
+     * await connection.setRemoteDescription(offer)
+     * await connection.setLocalDescription(await connection.createAnswer())
+     * ```
+     */
+    async createAnswer() {
+        return plainDescription(await this.#connection.createAnswer());
+    }
+    /**
+     * Set the local description; without one, the offer or the answer the state calls for is created.
+     * @param description The offer, the answer, a rollback, or none.
+     * @returns Resolves once it is set.
+     * @example
+     * ```typescript
+     * import type {PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * await connection.setLocalDescription()
+     * console.log(connection.localDescription)
+     * ```
+     */
+    async setLocalDescription(description) {
+        await this.#connection.setLocalDescription(description);
+    }
+    /**
+     * Set the remote description; an offer received while an offer of this side is pending rolls it back.
+     * @param description The offer or the answer of the other peer.
+     * @returns Resolves once it is set.
+     * @example
+     * ```typescript
+     * import type {PeerConnection, SignalingDescription} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * declare const answer: SignalingDescription
+     * await connection.setRemoteDescription(answer)
+     * ```
+     */
+    async setRemoteDescription(description) {
+        await this.#connection.setRemoteDescription(description);
+    }
+    /**
+     * Add a candidate of the other peer.
+     * @param candidate The candidate; none, or an empty one, for the end of the candidates.
+     * @returns Resolves once it is added.
+     * @example
+     * ```typescript
+     * import type {PeerConnection, SignalingCandidate} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * declare const candidate: SignalingCandidate
+     * await connection.addIceCandidate(candidate)
+     * ```
+     */
+    async addIceCandidate(candidate) {
+        if (!candidate?.candidate)
+            return;
+        await this.#connection.addIceCandidate({
+            candidate: candidate.candidate,
+            sdpMid: candidate.sdpMid ?? undefined,
+            sdpMLineIndex: candidate.sdpMLineIndex ?? undefined,
+            usernameFragment: candidate.usernameFragment ?? undefined
+        });
+    }
+    /**
+     * Create a data channel; the first one makes the connection negotiate (`negotiationneeded`).
+     * @param label The label of the channel.
+     * @param options Whether it is ordered, reliable, negotiated.
+     * @returns The channel.
+     * @example
+     * ```typescript
+     * import type {PeerChannel, PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * //Unordered and unreliable: a lost position is not sent again
+     * const channel: PeerChannel = connection.createDataChannel('position', {ordered: false, maxRetransmits: 0})
+     * ```
+     */
+    createDataChannel(label, options = {}) {
+        return this.#wrap(this.#connection.createDataChannel(label, options));
+    }
+    /**
+     * Add a track to send: it gets a transceiver (a new one, or one the other peer offered and nothing is sent on), and
+     * the connection negotiates (`negotiationneeded`).
+     * @param track The track: one to send, or one received from another connection (to forward it).
+     * @param streamIds The ids of its streams: the other peer groups the tracks of a stream (to play the audio and the
+     * video together).
+     * @returns Its sender.
+     * @example
+     * ```typescript
+     * import {MediaTrack, type PeerConnection, type RtpSender} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * const audio: MediaTrack = new MediaTrack('audio', {codec: 'audio/opus'})
+     * const video: MediaTrack = new MediaTrack('video', {codec: 'video/H264'})
+     * //One stream: the browser plays them together (event.streams[0])
+     * const senders: RtpSender[] = [connection.addTrack(audio, 'camera'), connection.addTrack(video, 'camera')]
+     * ```
+     */
+    addTrack(track, ...streamIds) {
+        const streams = streamIds.map((id) => new MediaStream({ id: id }));
+        return senderOf(this.#connection.addTrack(engineTrackOf(track), ...streams));
+    }
+    /**
+     * Stop sending the track of a sender (its transceiver stays, receiving only); the connection negotiates.
+     * @param sender The sender, given by `addTrack()`.
+     * @example
+     * ```typescript
+     * import type {PeerConnection, RtpSender} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * declare const sender: RtpSender
+     * connection.removeTrack(sender)
+     * ```
+     */
+    removeTrack(sender) {
+        this.#connection.removeTrack(engineSenderOf(sender));
+    }
+    /**
+     * Add a transceiver: for a track to send, or of a kind, to receive one (`recvonly`); the connection negotiates.
+     * @param trackOrKind The track to send, or `audio` or `video`.
+     * @param init The direction, the ids of the streams of the track.
+     * @returns The transceiver.
+     * @example
+     * ```typescript
+     * import type {MediaTrack, PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * //Offer to receive the camera and the microphone of the other peer
+     * connection.addTransceiver('audio', {direction: 'recvonly'})
+     * connection.addTransceiver('video', {direction: 'recvonly'})
+     * connection.on('track', (track: MediaTrack): void => console.log(`${track.kind} received`))
+     * ```
+     */
+    addTransceiver(trackOrKind, init = {}) {
+        const streams = (init.streams ?? []).map((id) => new MediaStream({ id: id }));
+        return transceiverOf(this.#connection.addTransceiver(typeof trackOrKind === 'string' ? trackOrKind : engineTrackOf(trackOrKind), {
+            direction: init.direction ?? 'sendrecv',
+            streams: streams
+        }));
+    }
+    /**
+     * The transceivers, in the order of their lines.
+     * @returns The transceivers.
+     * @example
+     * ```typescript
+     * import type {PeerConnection, RtpTransceiver} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * connection.getTransceivers().forEach((transceiver: RtpTransceiver): void => console.log(transceiver.mid, transceiver.currentDirection))
+     * ```
+     */
+    getTransceivers() {
+        return this.#connection.getTransceivers().map(transceiverOf);
+    }
+    /**
+     * The senders of the transceivers.
+     * @returns The senders.
+     * @example
+     * ```typescript
+     * import type {PeerConnection, RtpSender} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * const sending: RtpSender[] = connection.getSenders().filter((sender: RtpSender): boolean => sender.track !== null)
+     * ```
+     */
+    getSenders() {
+        return this.#connection.getSenders().map(senderOf);
+    }
+    /**
+     * The receivers of the transceivers.
+     * @returns The receivers.
+     * @example
+     * ```typescript
+     * import type {PeerConnection, RtpReceiver} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * const receivers: RtpReceiver[] = connection.getReceivers()
+     * ```
+     */
+    getReceivers() {
+        return this.#connection.getReceivers().map(receiverOf);
+    }
+    /**
+     * Restart ICE: the next offer gathers new candidates (`negotiationneeded` fires), for a connection whose network
+     * changed.
+     * @example
+     * ```typescript
+     * import type {PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * connection.on('connectionstatechange', (state: string): void => {
+     *     if (state === 'failed') connection.restartIce()
+     * })
+     * ```
+     */
+    restartIce() {
+        this.#connection.restartIce();
+    }
+    /**
+     * The configuration.
+     * @returns The ICE servers and the transport policy.
+     * @example
+     * ```typescript
+     * import type {PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * console.log(connection.getConfiguration().iceServers)
+     * ```
+     */
+    getConfiguration() {
+        const config = this.#connection.getConfiguration();
+        return { iceServers: config.iceServers, iceTransportPolicy: config.iceTransportPolicy };
+    }
+    /**
+     * Change the ICE servers (new TURN credentials) or the transport policy; they are used from the next gathering.
+     * @param configuration The ICE servers, the transport policy.
+     * @example
+     * ```typescript
+     * import type {PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * connection.setConfiguration({iceServers: [{urls: 'turn:turn.example.com:3478', username: 'u', credential: 'p'}]})
+     * ```
+     */
+    setConfiguration(configuration) {
+        const config = {};
+        if (configuration.iceServers)
+            config.iceServers = configuration.iceServers;
+        if (configuration.iceTransportPolicy)
+            config.iceTransportPolicy = configuration.iceTransportPolicy;
+        this.#connection.setConfiguration(config);
+    }
+    /**
+     * Close the connection and its channels, and destroy the object.
+     * @example
+     * ```typescript
+     * import type {PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * connection.close()
+     * ```
+     */
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#connection.close().catch(() => undefined);
+        void this.dispose().catch(() => undefined);
+    }
+    /**
+     * Add a listener of an event, given an event object (the W3C style).
+     * @param type The event: `icecandidate`, `datachannel`, `track`, `negotiationneeded`, `connectionstatechange`,
+     * `iceconnectionstatechange`, `icegatheringstatechange`, `signalingstatechange`.
+     * @param listener The listener.
+     * @param options `once`, `signal`.
+     * @example
+     * ```typescript
+     * import type {PeerConnection, SignalingCandidate} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * connection.addEventListener('icecandidate', (event: {candidate: SignalingCandidate | null}): void => console.log(event.candidate))
+     * ```
+     */
+    addEventListener(type, listener, options) {
+        this.#events.addEventListener(type, listener, options);
+    }
+    /**
+     * Remove a listener added with `addEventListener`.
+     * @param type The event.
+     * @param listener The listener.
+     * @param options `capture`.
+     * @example
+     * ```typescript
+     * import type {PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * const listener = (): void => console.log(connection.connectionState)
+     * connection.addEventListener('connectionstatechange', listener)
+     * connection.removeEventListener('connectionstatechange', listener)
+     * ```
+     */
+    removeEventListener(type, listener, options) {
+        this.#events.removeEventListener(type, listener, options);
+    }
+    /**
+     * Add a listener of an event, given the value of the event (the Node.js style).
+     * @param event The event.
+     * @param listener The listener: given the candidate, the channel, the track, the new state.
+     * @returns The connection.
+     * @example
+     * ```typescript
+     * import type {PeerChannel, PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * connection.on('datachannel', (channel: PeerChannel): void => console.log(channel.label))
+     * ```
+     */
+    on(event, listener) {
+        this.#events.on(event, listener);
+        return this;
+    }
+    /**
+     * Add a listener of the next emission of an event, given the value of the event.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns The connection.
+     * @example
+     * ```typescript
+     * import type {PeerChannel, PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * connection.once('datachannel', (channel: PeerChannel): void => console.log(channel.label))
+     * ```
+     */
+    once(event, listener) {
+        this.#events.once(event, listener);
+        return this;
+    }
+    /**
+     * Remove a listener added with `on` or `once`.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns The connection.
+     * @example
+     * ```typescript
+     * import type {PeerConnection} from '@lakutata/webrtc'
+     *
+     * declare const connection: PeerConnection
+     * const listener = (state: string): void => console.log(state)
+     * connection.on('connectionstatechange', listener)
+     * connection.off('connectionstatechange', listener)
+     * ```
+     */
+    off(event, listener) {
+        this.#events.off(event, listener);
+        return this;
+    }
+    /**
+     * The channel object of a channel of the engine, created once
+     * @param channel
+     */
+    #wrap(channel) {
+        let wrapped = this.#channels.get(channel);
+        if (!wrapped) {
+            wrapped = new PeerChannel(channel);
+            this.#channels.set(channel, wrapped);
+        }
+        return wrapped;
+    }
+    /**
+     * Fire an event, unless the connection is closed
+     * @param type
+     * @param properties
+     * @param args
+     */
+    #fire(type, properties, ...args) {
+        if (this.#closed && type !== 'connectionstatechange' && type !== 'iceconnectionstatechange' && type !== 'signalingstatechange')
+            return;
+        this.#events.fire(type, properties, ...args);
+    }
+};
+__decorate([
+    Configurable(DTO.Array().items(DTO.Object({
+        urls: DTO.Alternatives(DTO.String(), DTO.Array().items(DTO.String())).required(),
+        username: DTO.String().optional(),
+        credential: DTO.String().optional()
+    })).optional().default([])),
+    __metadata("design:type", Array)
+], PeerConnection.prototype, "iceServers", void 0);
+__decorate([
+    Configurable(DTO.String().valid('all', 'relay').optional().default('all')),
+    __metadata("design:type", String)
+], PeerConnection.prototype, "iceTransportPolicy", void 0);
+__decorate([
+    Configurable(DTO.Array().items(DTO.Number().port()).length(2).optional()),
+    __metadata("design:type", Array)
+], PeerConnection.prototype, "icePortRange", void 0);
+__decorate([
+    Configurable(DTO.Array().items(DTO.String()).optional()),
+    __metadata("design:type", Array)
+], PeerConnection.prototype, "iceAdditionalHostAddresses", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], PeerConnection.prototype, "iceUseIpv4", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], PeerConnection.prototype, "iceUseIpv6", void 0);
+__decorate([
+    Configurable(DTO.Array().items(DTO.String().valid(...SUPPORTED_CODECS).insensitive()).optional().default(DEFAULT_CODECS)),
+    __metadata("design:type", Array)
+], PeerConnection.prototype, "codecs", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], PeerConnection.prototype, "headerExtensions", void 0);
+__decorate([
+    Configurable(DTO.String().optional()),
+    __metadata("design:type", String)
+], PeerConnection.prototype, "threads", void 0);
+PeerConnection = __decorate([
+    Autoload(),
+    Transient()
+], PeerConnection);
+export { PeerConnection };