livekit-client 1.14.4 → 1.15.1

package/dist/ts4.2/src/room/PCTransportManager.d.ts

@@ -0,0 +1,51 @@
+import { SignalTarget } from '../proto/livekit_rtc_pb';
+import PCTransport from './PCTransport';
+export declare enum PCTransportState {
+    NEW = 0,
+    CONNECTING = 1,
+    CONNECTED = 2,
+    FAILED = 3,
+    CLOSING = 4,
+    CLOSED = 5
+}
+export declare class PCTransportManager {
+    publisher: PCTransport;
+    subscriber: PCTransport;
+    peerConnectionTimeout: number;
+    get needsPublisher(): boolean;
+    get needsSubscriber(): boolean;
+    get currentState(): PCTransportState;
+    onStateChange?: (state: PCTransportState, pubState: RTCPeerConnectionState, subState: RTCPeerConnectionState) => void;
+    onIceCandidate?: (ev: RTCIceCandidate, target: SignalTarget) => void;
+    onDataChannel?: (ev: RTCDataChannelEvent) => void;
+    onTrack?: (ev: RTCTrackEvent) => void;
+    onPublisherOffer?: (offer: RTCSessionDescriptionInit) => void;
+    private isPublisherConnectionRequired;
+    private isSubscriberConnectionRequired;
+    private state;
+    private connectionLock;
+    constructor(rtcConfig: RTCConfiguration, subscriberPrimary: boolean);
+    requirePublisher(require?: boolean): void;
+    requireSubscriber(require?: boolean): void;
+    createAndSendPublisherOffer(options?: RTCOfferOptions): Promise<void>;
+    setPublisherAnswer(sd: RTCSessionDescriptionInit): Promise<void>;
+    removeTrack(sender: RTCRtpSender): void | undefined;
+    close(): Promise<void>;
+    triggerIceRestart(): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidateInit, target: SignalTarget): Promise<void>;
+    createSubscriberAnswerFromOffer(sd: RTCSessionDescriptionInit): Promise<RTCSessionDescriptionInit>;
+    updateConfiguration(config: RTCConfiguration, iceRestart?: boolean): void;
+    ensurePCTransportConnection(abortController?: AbortController, timeout?: number): Promise<void>;
+    negotiate(abortController: AbortController): Promise<void>;
+    addPublisherTransceiver(track: MediaStreamTrack, transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
+    addPublisherTrack(track: MediaStreamTrack): RTCRtpSender;
+    createPublisherDataChannel(label: string, dataChannelDict: RTCDataChannelInit): RTCDataChannel;
+    /**
+     * Returns the first required transport's address if no explicit target is specified
+     */
+    getConnectedAddress(target?: SignalTarget): Promise<string | undefined>;
+    private get requiredTransports();
+    private updateState;
+    private ensureTransportConnected;
+}
+//# sourceMappingURL=PCTransportManager.d.ts.map

package/dist/ts4.2/src/room/RTCEngine.d.ts

@@ -3,24 +3,26 @@ import type { SignalOptions } from '../api/SignalClient';
 import { SignalClient } from '../api/SignalClient';
 import type { InternalRoomOptions } from '../options';
 import { DataPacket, DataPacket_Kind, DisconnectReason, ParticipantInfo, Room as RoomModel, SpeakerInfo, TrackInfo, UserPacket } from '../proto/livekit_models_pb';
-import { AddTrackRequest, ConnectionQualityUpdate, JoinResponse, StreamStateUpdate, SubscriptionPermissionUpdate, SubscriptionResponse } from '../proto/livekit_rtc_pb';
+import type { AddTrackRequest, ConnectionQualityUpdate, JoinResponse, StreamStateUpdate, SubscriptionPermissionUpdate, SubscriptionResponse } from '../proto/livekit_rtc_pb';
 import PCTransport from './PCTransport';
+import { PCTransportManager } from './PCTransportManager';
 import type { RegionUrlProvider } from './RegionUrlProvider';
 import type LocalTrack from './track/LocalTrack';
+import type LocalTrackPublication from './track/LocalTrackPublication';
 import type LocalVideoTrack from './track/LocalVideoTrack';
 import type { SimulcastTrackInfo } from './track/LocalVideoTrack';
+import type RemoteTrackPublication from './track/RemoteTrackPublication';
 import { Track } from './track/Track';
 import type { TrackPublishOptions, VideoCodec } from './track/options';
 declare const RTCEngine_base: new () => TypedEventEmitter<EngineEventCallbacks>;
 /** @internal */
 export default class RTCEngine extends RTCEngine_base {
     private options;
-    publisher?: PCTransport;
-    subscriber?: PCTransport;
     client: SignalClient;
     rtcConfig: RTCConfiguration;
     peerConnectionTimeout: number;
     fullReconnectOnNext: boolean;
+    pcManager?: PCTransportManager;
     /**
      * @internal
      */
@@ -32,11 +34,9 @@ export default class RTCEngine extends RTCEngine_base {
     private dcBufferStatus;
     private reliableDCSub?;
     private subscriberPrimary;
-    private primaryTransport?;
     private pcState;
     private _isClosed;
     private pendingTrackResolvers;
-    private hasPublished;
     private url?;
     private token?;
     private signalOpts?;
@@ -106,7 +106,10 @@ export default class RTCEngine extends RTCEngine_base {
     /** @internal */
     negotiate(): Promise<void>;
     dataChannelForKind(kind: DataPacket_Kind, sub?: boolean): RTCDataChannel | undefined;
+    /** @internal */
+    sendSyncState(remoteTracks: RemoteTrackPublication[], localTracks: LocalTrackPublication[]): void;
     failNext(): void;
+    private dataChannelsInfo;
     private clearReconnectTimeout;
     private clearPendingReconnect;
     private handleBrowserOnLine;

package/dist/ts4.2/src/room/Room.d.ts

@@ -63,6 +63,7 @@ declare class Room extends Room_base {
     private connectionReconcileInterval?;
     private regionUrlProvider?;
     private regionUrl?;
+    private isVideoPlaybackBlocked;
     /**
      * Creates a new Room, the primary construct for a LiveKit session.
      * @param options
@@ -133,10 +134,15 @@ declare class Room extends Room_base {
      * - `getUserMedia`
      */
     startAudio: () => Promise<void>;
+    startVideo: () => Promise<void>;
     /**
      * Returns true if audio playback is enabled
      */
     get canPlaybackAudio(): boolean;
+    /**
+     * Returns true if video playback is enabled
+     */
+    get canPlaybackVideo(): boolean;
     /**
      * Returns the active audio output device used in this room.
      * @return the previously successfully set audio output device ID or an empty string if the default device is used.
@@ -171,6 +177,8 @@ declare class Room extends Room_base {
     private handleDataPacket;
     private handleAudioPlaybackStarted;
     private handleAudioPlaybackFailed;
+    private handleVideoPlaybackStarted;
+    private handleVideoPlaybackFailed;
     private handleDeviceChange;
     private handleRoomUpdate;
     private handleConnectionQualityUpdate;
@@ -238,6 +246,7 @@ export type RoomEventCallbacks = {
     trackSubscriptionPermissionChanged: (publication: RemoteTrackPublication, status: TrackPublication.PermissionStatus, participant: RemoteParticipant) => void;
     trackSubscriptionStatusChanged: (publication: RemoteTrackPublication, status: TrackPublication.SubscriptionStatus, participant: RemoteParticipant) => void;
     audioPlaybackChanged: (playing: boolean) => void;
+    videoPlaybackChanged: (playing: boolean) => void;
     signalConnected: () => void;
     recordingStatusChanged: (recording: boolean) => void;
     participantEncryptionStatusChanged: (encrypted: boolean, participant?: Participant) => void;

package/dist/ts4.2/src/room/events.d.ts

@@ -215,6 +215,12 @@ export declare enum RoomEvent {
      * `Room.canPlaybackAudio` will indicate if audio playback is permitted.
      */
     AudioPlaybackStatusChanged = "audioPlaybackChanged",
+    /**
+     * LiveKit will attempt to autoplay all video tracks when you attach them to
+     * a video element. However, if that fails, we'll notify you via VideoPlaybackStatusChanged.
+     * Calling `room.startVideo()` in a user gesture event handler will resume the video playback.
+     */
+    VideoPlaybackStatusChanged = "videoPlaybackChanged",
     /**
      * When we have encountered an error while attempting to create a track.
      * The errors take place in getUserMedia().
@@ -449,6 +455,10 @@ export declare enum TrackEvent {
     /** @internal */
     VideoDimensionsChanged = "videoDimensionsChanged",
     /** @internal */
+    VideoPlaybackStarted = "videoPlaybackStarted",
+    /** @internal */
+    VideoPlaybackFailed = "videoPlaybackFailed",
+    /** @internal */
     ElementAttached = "elementAttached",
     /** @internal */
     ElementDetached = "elementDetached",

package/dist/ts4.2/src/room/participant/LocalParticipant.d.ts

@@ -1,6 +1,5 @@
 import type { InternalRoomOptions } from '../../options';
 import { DataPacket_Kind, ParticipantInfo, ParticipantPermission } from '../../proto/livekit_models_pb';
-import { DataChannelInfo, TrackPublishedResponse } from '../../proto/livekit_rtc_pb';
 import type RTCEngine from '../RTCEngine';
 import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
@@ -174,9 +173,5 @@ export default class LocalParticipant extends Participant {
     private handleLocalTrackUnpublished;
     private handleTrackEnded;
     private getPublicationForTrack;
-    /** @internal */
-    publishedTracksInfo(): TrackPublishedResponse[];
-    /** @internal */
-    dataChannelsInfo(): DataChannelInfo[];
 }
 //# sourceMappingURL=LocalParticipant.d.ts.map

package/dist/ts4.2/src/room/track/Track.d.ts

@@ -64,8 +64,10 @@ export declare abstract class Track extends Track_base {
     protected handleAppVisibilityChanged(): Promise<void>;
     protected addAppVisibilityListener(): void;
     protected removeAppVisibilityListener(): void;
+    private handleElementSuspended;
+    private handleElementPlay;
+    private debouncedPlaybackStateChange;
 }
-/** @internal */
 export declare function attachToElement(track: MediaStreamTrack, element: HTMLMediaElement): void;
 /** @internal */
 export declare function detachTrack(track: MediaStreamTrack, element: HTMLMediaElement): void;
@@ -112,10 +114,12 @@ export type TrackEventCallbacks = {
     updateSettings: () => void;
     updateSubscription: () => void;
     audioPlaybackStarted: () => void;
-    audioPlaybackFailed: (error: Error) => void;
+    audioPlaybackFailed: (error?: Error) => void;
     audioSilenceDetected: () => void;
     visibilityChanged: (visible: boolean, track?: any) => void;
     videoDimensionsChanged: (dimensions: Track.Dimensions, track?: any) => void;
+    videoPlaybackStarted: () => void;
+    videoPlaybackFailed: (error?: Error) => void;
     elementAttached: (element: HTMLMediaElement) => void;
     elementDetached: (element: HTMLMediaElement) => void;
     upstreamPaused: (track: any) => void;

package/dist/ts4.2/src/room/track/options.d.ts

@@ -12,6 +12,8 @@ export interface TrackPublishDefaults {
      *
      * You could customize specific encoding parameters of the backup track by
      * explicitly setting codec and encoding fields.
+     *
+     * Defaults to `true`
      */
     backupCodec?: true | false | {
         codec: BackupVideoCodec;

package/dist/ts4.2/src/room/track/utils.d.ts

@@ -1,4 +1,6 @@
+import { TrackPublishedResponse } from '../../proto/livekit_rtc_pb';
 import { Track } from './Track';
+import type { TrackPublication } from './TrackPublication';
 import type { AudioCaptureOptions, CreateLocalTracksOptions, ScreenShareCaptureOptions, VideoCaptureOptions } from './options';
 import type { AudioTrack } from './types';
 export declare function mergeDefaultOptions(options?: CreateLocalTracksOptions, audioDefaults?: AudioCaptureOptions, videoDefaults?: VideoCaptureOptions): CreateLocalTracksOptions;
@@ -25,4 +27,5 @@ export declare function sourceToKind(source: Track.Source): MediaDeviceKind | un
  */
 export declare function screenCaptureToDisplayMediaStreamOptions(options: ScreenShareCaptureOptions): DisplayMediaStreamOptions;
 export declare function mimeTypeToVideoCodecString(mimeType: string): "vp8" | "h264" | "vp9" | "av1";
+export declare function getTrackPublicationInfo<T extends TrackPublication>(tracks: T[]): TrackPublishedResponse[];
 //# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/src/test/mocks.d.ts

@@ -5,7 +5,7 @@ declare const mocks: {
     SignalClient: MockedClass<typeof SignalClient>;
     RTCEngine: MockedClass<typeof RTCEngine>;
     MockLocalVideoTrack: {
-        stop: import("@vitest/spy").Mock<any, any>;
+        stop: () => void;
     };
 };
 export default mocks;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.14.4",
+  "version": "1.15.1",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -28,35 +28,20 @@
         "./dist/ts4.2/src/index.d.ts"
       ],
       "./dist/src/e2ee/worker/e2ee.worker.d.ts": [
-        "./dist/ts4.2//dist/src/e2ee/worker/e2ee.worker.d.ts"
+        "./dist/ts4.2/dist/src/e2ee/worker/e2ee.worker.d.ts"
       ]
     }
   },
   "repository": "git@github.com:livekit/client-sdk-js.git",
   "author": "David Zhao <david@davidzhao.com>",
   "license": "Apache-2.0",
-  "scripts": {
-    "build": "rollup --config --bundleConfigAsCjs && rollup --config rollup.config.worker.js --bundleConfigAsCjs  && yarn downlevel-dts",
-    "build:watch": "rollup --watch --config rollup.config.js",
-    "build-docs": "typedoc",
-    "proto": "protoc --es_out src/proto --es_opt target=ts -I./protocol ./protocol/livekit_rtc.proto ./protocol/livekit_models.proto",
-    "sample": "vite example -c vite.config.js",
-    "lint": "eslint src",
-    "test": "vitest run src",
-    "deploy": "gh-pages -d example/dist",
-    "format": "prettier --write src example/sample.ts",
-    "format:check": "prettier --check src",
-    "release": "yarn build && yarn compat && changeset publish",
-    "downlevel-dts": "downlevel-dts ./dist/ ./dist/ts4.2 --to=4.2",
-    "compat": "eslint --no-eslintrc --config ./.eslintrc.dist.cjs ./dist/livekit-client.umd.js",
-    "size-limit": "size-limit"
-  },
   "dependencies": {
     "@bufbuild/protobuf": "^1.3.0",
     "events": "^3.3.0",
     "loglevel": "^1.8.0",
     "sdp-transform": "^2.14.1",
     "ts-debounce": "^4.0.0",
+    "tslib": "2.6.2",
     "typed-emitter": "^2.1.0",
     "webrtc-adapter": "^8.1.1"
   },
@@ -98,5 +83,21 @@
     "typescript": "5.2.2",
     "vite": "4.5.0",
     "vitest": "^0.34.0"
+  },
+  "scripts": {
+    "build": "rollup --config --bundleConfigAsCjs && rollup --config rollup.config.worker.js --bundleConfigAsCjs && pnpm downlevel-dts",
+    "build:watch": "rollup --watch --config rollup.config.js",
+    "build-docs": "typedoc",
+    "proto": "protoc --es_out src/proto --es_opt target=ts -I./protocol ./protocol/livekit_rtc.proto ./protocol/livekit_models.proto",
+    "sample": "vite example -c vite.config.js",
+    "lint": "eslint src",
+    "test": "vitest run src",
+    "deploy": "gh-pages -d example/dist",
+    "format": "prettier --write src example/sample.ts",
+    "format:check": "prettier --check src",
+    "ci:publish": "pnpm build && pnpm compat && changeset publish",
+    "downlevel-dts": "downlevel-dts ./dist/ ./dist/ts4.2 --to=4.2",
+    "compat": "eslint --no-eslintrc --config ./.eslintrc.dist.cjs ./dist/livekit-client.umd.js",
+    "size-limit": "size-limit"
   }
-}
+}

package/src/api/SignalClient.ts

@@ -558,6 +558,8 @@ export class SignalClient {
       log.debug('received unsupported message');
       return;
     }
+
+    let pingHandled = false;
     if (msg.case === 'answer') {
       const sd = fromProtoSessionDescription(msg.value);
       if (this.onAnswer) {
@@ -626,13 +628,17 @@ export class SignalClient {
         this.onSubscriptionError(msg.value);
       }
     } else if (msg.case === 'pong') {
-      this.resetPingTimeout();
     } else if (msg.case === 'pongResp') {
       this.rtt = Date.now() - Number.parseInt(msg.value.lastPingTimestamp.toString());
       this.resetPingTimeout();
+      pingHandled = true;
     } else {
       log.debug('unsupported message', msg);
     }
+
+    if (!pingHandled) {
+      this.resetPingTimeout();
+    }
   }
 
   setReconnected() {

package/src/connectionHelper/checks/webrtc.ts

@@ -38,8 +38,8 @@ export class WebRTCCheck extends Checker {
         }
       };
 
-      if (this.room.engine.subscriber) {
-        this.room.engine.subscriber.onIceCandidateError = (ev) => {
+      if (this.room.engine.pcManager) {
+        this.room.engine.pcManager.subscriber.onIceCandidateError = (ev) => {
           if (ev instanceof RTCPeerConnectionIceErrorEvent) {
             this.appendWarning(
               `error with ICE candidate: ${ev.errorCode} ${ev.errorText} ${ev.url}`,

package/src/room/PCTransport.ts

@@ -33,10 +33,16 @@ export default class PCTransport extends EventEmitter {
   private _pc: RTCPeerConnection | null;
 
   private get pc() {
-    if (this._pc) return this._pc;
-    throw new UnexpectedConnectionState('Expected peer connection to be available');
+    if (!this._pc) {
+      this._pc = this.createPC();
+    }
+    return this._pc;
   }
 
+  private config?: RTCConfiguration;
+
+  private mediaConstraints: Record<string, unknown>;
+
   pendingCandidates: RTCIceCandidateInit[] = [];
 
   restartingIce: boolean = false;
@@ -57,32 +63,53 @@ export default class PCTransport extends EventEmitter {
 
   onConnectionStateChange?: (state: RTCPeerConnectionState) => void;
 
+  onIceConnectionStateChange?: (state: RTCIceConnectionState) => void;
+
+  onSignalingStatechange?: (state: RTCSignalingState) => void;
+
   onDataChannel?: (ev: RTCDataChannelEvent) => void;
 
   onTrack?: (ev: RTCTrackEvent) => void;
 
   constructor(config?: RTCConfiguration, mediaConstraints: Record<string, unknown> = {}) {
     super();
-    this._pc = isChromiumBased()
+    this.config = config;
+    this.mediaConstraints = mediaConstraints;
+    this._pc = this.createPC();
+  }
+
+  private createPC() {
+    const pc = isChromiumBased()
       ? // @ts-expect-error chrome allows additional media constraints to be passed into the RTCPeerConnection constructor
-        new RTCPeerConnection(config, mediaConstraints)
-      : new RTCPeerConnection(config);
-    this._pc.onicecandidate = (ev) => {
+        new RTCPeerConnection(this.config, this.mediaConstraints)
+      : new RTCPeerConnection(this.config);
+
+    pc.onicecandidate = (ev) => {
       if (!ev.candidate) return;
       this.onIceCandidate?.(ev.candidate);
     };
-    this._pc.onicecandidateerror = (ev) => {
+    pc.onicecandidateerror = (ev) => {
       this.onIceCandidateError?.(ev);
     };
-    this._pc.onconnectionstatechange = () => {
-      this.onConnectionStateChange?.(this._pc?.connectionState ?? 'closed');
+
+    pc.oniceconnectionstatechange = () => {
+      this.onIceConnectionStateChange?.(pc.iceConnectionState);
     };
-    this._pc.ondatachannel = (ev) => {
+
+    pc.onsignalingstatechange = () => {
+      this.onSignalingStatechange?.(pc.signalingState);
+    };
+
+    pc.onconnectionstatechange = () => {
+      this.onConnectionStateChange?.(pc.connectionState);
+    };
+    pc.ondatachannel = (ev) => {
       this.onDataChannel?.(ev);
     };
-    this._pc.ontrack = (ev) => {
+    pc.ontrack = (ev) => {
       this.onTrack?.(ev);
     };
+    return pc;
   }
 
   get isICEConnected(): boolean {
@@ -168,7 +195,7 @@ export default class PCTransport extends EventEmitter {
 
     if (this.renegotiate) {
       this.renegotiate = false;
-      this.createAndSendOffer();
+      await this.createAndSendOffer();
     } else if (sd.type === 'answer') {
       this.emit(PCEvents.NegotiationComplete);
       if (sd.sdp) {
@@ -183,10 +210,10 @@ export default class PCTransport extends EventEmitter {
   }
 
   // debounced negotiate interface
-  negotiate = debounce((onError?: (e: Error) => void) => {
+  negotiate = debounce(async (onError?: (e: Error) => void) => {
     this.emit(PCEvents.NegotiationStarted);
     try {
-      this.createAndSendOffer();
+      await this.createAndSendOffer();
     } catch (e) {
       if (onError) {
         onError(e as Error);
@@ -209,11 +236,11 @@ export default class PCTransport extends EventEmitter {
     if (this._pc && this._pc.signalingState === 'have-local-offer') {
       // we're waiting for the peer to accept our offer, so we'll just wait
       // the only exception to this is when ICE restart is needed
-      const currentSD = this.pc.remoteDescription;
+      const currentSD = this._pc.remoteDescription;
       if (options?.iceRestart && currentSD) {
         // TODO: handle when ICE restart is needed but we don't have a remote description
         // the best thing to do is to recreate the peerconnection
-        await this.pc.setRemoteDescription(currentSD);
+        await this._pc.setRemoteDescription(currentSD);
       } else {
         this.renegotiate = true;
         return;
@@ -307,7 +334,10 @@ export default class PCTransport extends EventEmitter {
   }
 
   addTrack(track: MediaStreamTrack) {
-    return this.pc.addTrack(track);
+    if (!this._pc) {
+      throw new UnexpectedConnectionState('PC closed, cannot add track');
+    }
+    return this._pc.addTrack(track);
   }
 
   setTrackCodecBitrate(info: TrackBitrateInfo) {
@@ -315,43 +345,50 @@ export default class PCTransport extends EventEmitter {
   }
 
   setConfiguration(rtcConfig: RTCConfiguration) {
-    return this.pc.setConfiguration(rtcConfig);
+    if (!this._pc) {
+      throw new UnexpectedConnectionState('PC closed, cannot configure');
+    }
+    return this._pc?.setConfiguration(rtcConfig);
   }
 
   canRemoveTrack(): boolean {
-    return !!this.pc.removeTrack;
+    return !!this._pc?.removeTrack;
   }
 
   removeTrack(sender: RTCRtpSender) {
-    return this.pc.removeTrack(sender);
+    return this._pc?.removeTrack(sender);
   }
 
   getConnectionState() {
-    return this.pc.connectionState;
+    return this._pc?.connectionState ?? 'closed';
   }
 
   getICEConnectionState() {
-    return this.pc.iceConnectionState;
+    return this._pc?.iceConnectionState ?? 'closed';
   }
 
   getSignallingState() {
-    return this.pc.signalingState;
+    return this._pc?.signalingState ?? 'closed';
   }
 
   getTransceivers() {
-    return this.pc.getTransceivers();
+    return this._pc?.getTransceivers() ?? [];
   }
 
   getSenders() {
-    return this.pc.getSenders();
+    return this._pc?.getSenders() ?? [];
   }
 
   getLocalDescription() {
-    return this.pc.localDescription;
+    return this._pc?.localDescription;
   }
 
   getRemoteDescription() {
-    return this.pc.remoteDescription;
+    return this.pc?.remoteDescription;
+  }
+
+  getStats() {
+    return this.pc.getStats();
   }
 
   async getConnectedAddress(): Promise<string | undefined> {
@@ -391,7 +428,7 @@ export default class PCTransport extends EventEmitter {
     return candidates.get(selectedID);
   }
 
-  close() {
+  close = () => {
     if (!this._pc) {
       return;
     }
@@ -408,7 +445,7 @@ export default class PCTransport extends EventEmitter {
     this._pc.onconnectionstatechange = null;
     this._pc.oniceconnectionstatechange = null;
     this._pc = null;
-  }
+  };
 
   private async setMungedSDP(sd: RTCSessionDescriptionInit, munged?: string, remote?: boolean) {
     if (munged) {