@webex/web-client-media-engine 3.20.4 → 3.22.0

package/dist/cjs/index.js

@@ -330,149 +330,149 @@ var logger$1$1 = {exports: {}};
 
 var Logger$2 = logger$1$1.exports;
 
-const DEFAULT_LOGGER_NAME$1 = 'webrtc-core';
-const logger$3 = Logger$2.get(DEFAULT_LOGGER_NAME$1);
-Logger$2.useDefaults({
-    defaultLevel: Logger$2.DEBUG,
-    /* eslint-disable-next-line jsdoc/require-jsdoc */
-    formatter: (messages, context) => {
-        messages.unshift(`[${context.name}]`);
-    },
+const DEFAULT_LOGGER_NAME$1 = 'webrtc-core';
+const logger$3 = Logger$2.get(DEFAULT_LOGGER_NAME$1);
+Logger$2.useDefaults({
+    defaultLevel: Logger$2.DEBUG,
+    /* eslint-disable-next-line jsdoc/require-jsdoc */
+    formatter: (messages, context) => {
+        messages.unshift(`[${context.name}]`);
+    },
 });
 
-var DeviceKind$1;
-(function (DeviceKind) {
-    DeviceKind["AudioInput"] = "audioinput";
-    DeviceKind["AudioOutput"] = "audiooutput";
-    DeviceKind["VideoInput"] = "videoinput";
-})(DeviceKind$1 || (DeviceKind$1 = {}));
-/**
- * Prompts the user for permission to use a media input which produces a MediaStream with tracks
- * containing the requested types of media.
- *
- * @param constraints - A MediaStreamConstraints object specifying the types of media to request,
- *     along with any requirements for each type.
- * @returns A Promise whose fulfillment handler receives a MediaStream object when the requested
- *     media has successfully been obtained.
- */
-function getUserMedia(constraints) {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        return navigator.mediaDevices.getUserMedia(constraints);
-    });
-}
-/**
- * Prompts the user for permission to use a user's display media and audio. If a video track is
- * absent from the constraints argument, one will still be provided.
- *
- * @param constraints - A MediaStreamConstraints object specifying the types of media to request,
- *     along with any requirements for each type.
- * @returns A Promise whose fulfillment handler receives a MediaStream object when the requested
- *     media has successfully been obtained.
- */
-function getDisplayMedia(constraints) {
-    return navigator.mediaDevices.getDisplayMedia(constraints);
-}
-/**
- * Requests a list of the available media input and output devices, such as microphones, cameras,
- * headsets, and so forth.
- *
- * @returns A Promise that receives an array of MediaDeviceInfo objects when the promise is
- *     fulfilled.
- */
-function enumerateDevices() {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        return navigator.mediaDevices.enumerateDevices();
-    });
-}
-/**
- * Adds the callback handler to be notified of a media device change (for example, a headset is
- * unplugged from the user's computer).
- *
- * @param handler - The callback function to execute.
- */
-function setOnDeviceChangeHandler$1(handler) {
-    navigator.mediaDevices.ondevicechange = handler;
-}
-/**
- * Checks permissions using the navigator's permissions api.
- *
- * @param deviceKinds - Array of DeviceKind items.
- * @throws An error if camera or microphone aren't available options for query() (Firefox), or if
- *    navigator.permissions is undefined (Safari and others).
- * @returns Array of Permission Status objects.
- */
-function checkNavigatorPermissions(deviceKinds) {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        const permissionRequests = [];
-        if (deviceKinds.includes(DeviceKind$1.VideoInput)) {
-            permissionRequests.push(navigator.permissions.query({ name: 'camera' }));
-        }
-        if (deviceKinds.includes(DeviceKind$1.AudioInput)) {
-            permissionRequests.push(navigator.permissions.query({ name: 'microphone' }));
-        }
-        return Promise.all(permissionRequests);
-    });
-}
-/**
- * Check to see if the user has granted the application permission to use their devices.
- *
- * @param deviceKinds - Array of DeviceKind items.
- * @returns True if device permissions exist, false if otherwise.
- */
-function checkDevicePermissions(deviceKinds) {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        try {
-            const permissions = yield checkNavigatorPermissions(deviceKinds);
-            if (permissions.every((permission) => permission.state === 'granted')) {
-                return true;
-            }
-            // eslint-disable-next-line no-empty
-        }
-        catch (e) { }
-        try {
-            const devices = yield enumerateDevices();
-            // If permissions are granted, the MediaDeviceInfo objects will have labels.
-            return devices
-                .filter((device) => deviceKinds.includes(device.kind))
-                .every((device) => device.label);
-            // eslint-disable-next-line no-empty
-        }
-        catch (e) { }
-        return false;
-    });
-}
-/**
- * Ensures that the user has granted permissions to the microphone and camera.
- *
- * @param deviceKinds - Array of DeviceKind items.
- * @param callback - Function that will be executed while device permissions are granted. After this
- *    returns, permissions (for example device labels in Firefox) may not be available anymore.
- * @returns The callback's response.
- */
-function ensureDevicePermissions(deviceKinds, callback) {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        try {
-            const hasDevicePermissions = yield checkDevicePermissions(deviceKinds);
-            if (!hasDevicePermissions) {
-                const stream = yield getUserMedia({
-                    audio: deviceKinds.includes(DeviceKind$1.AudioInput),
-                    video: deviceKinds.includes(DeviceKind$1.VideoInput),
-                });
-                // Callback is here to call a function while an active capture exists, so that the browser
-                // (Firefox) will allow the user to access device information.
-                const callbackRes = yield callback();
-                // Stop tracks in the stream so the browser (Safari) will know that there is not an active
-                // stream running.
-                stream.getTracks().forEach((track) => track.stop());
-                return callbackRes;
-            }
-            return callback();
-        }
-        catch (e) {
-            logger$3.error(e);
-            throw new Error('Failed to ensure device permissions.');
-        }
-    });
+var DeviceKind$1;
+(function (DeviceKind) {
+    DeviceKind["AudioInput"] = "audioinput";
+    DeviceKind["AudioOutput"] = "audiooutput";
+    DeviceKind["VideoInput"] = "videoinput";
+})(DeviceKind$1 || (DeviceKind$1 = {}));
+/**
+ * Prompts the user for permission to use a media input which produces a MediaStream with tracks
+ * containing the requested types of media.
+ *
+ * @param constraints - A MediaStreamConstraints object specifying the types of media to request,
+ *     along with any requirements for each type.
+ * @returns A Promise whose fulfillment handler receives a MediaStream object when the requested
+ *     media has successfully been obtained.
+ */
+function getUserMedia(constraints) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        return navigator.mediaDevices.getUserMedia(constraints);
+    });
+}
+/**
+ * Prompts the user for permission to use a user's display media and audio. If a video track is
+ * absent from the constraints argument, one will still be provided.
+ *
+ * @param constraints - A MediaStreamConstraints object specifying the types of media to request,
+ *     along with any requirements for each type.
+ * @returns A Promise whose fulfillment handler receives a MediaStream object when the requested
+ *     media has successfully been obtained.
+ */
+function getDisplayMedia(constraints) {
+    return navigator.mediaDevices.getDisplayMedia(constraints);
+}
+/**
+ * Requests a list of the available media input and output devices, such as microphones, cameras,
+ * headsets, and so forth.
+ *
+ * @returns A Promise that receives an array of MediaDeviceInfo objects when the promise is
+ *     fulfilled.
+ */
+function enumerateDevices() {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        return navigator.mediaDevices.enumerateDevices();
+    });
+}
+/**
+ * Adds the callback handler to be notified of a media device change (for example, a headset is
+ * unplugged from the user's computer).
+ *
+ * @param handler - The callback function to execute.
+ */
+function setOnDeviceChangeHandler$1(handler) {
+    navigator.mediaDevices.ondevicechange = handler;
+}
+/**
+ * Checks permissions using the navigator's permissions api.
+ *
+ * @param deviceKinds - Array of DeviceKind items.
+ * @throws An error if camera or microphone aren't available options for query() (Firefox), or if
+ *    navigator.permissions is undefined (Safari and others).
+ * @returns Array of Permission Status objects.
+ */
+function checkNavigatorPermissions(deviceKinds) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        const permissionRequests = [];
+        if (deviceKinds.includes(DeviceKind$1.VideoInput)) {
+            permissionRequests.push(navigator.permissions.query({ name: 'camera' }));
+        }
+        if (deviceKinds.includes(DeviceKind$1.AudioInput)) {
+            permissionRequests.push(navigator.permissions.query({ name: 'microphone' }));
+        }
+        return Promise.all(permissionRequests);
+    });
+}
+/**
+ * Check to see if the user has granted the application permission to use their devices.
+ *
+ * @param deviceKinds - Array of DeviceKind items.
+ * @returns True if device permissions exist, false if otherwise.
+ */
+function checkDevicePermissions(deviceKinds) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        try {
+            const permissions = yield checkNavigatorPermissions(deviceKinds);
+            if (permissions.every((permission) => permission.state === 'granted')) {
+                return true;
+            }
+            // eslint-disable-next-line no-empty
+        }
+        catch (e) { }
+        try {
+            const devices = yield enumerateDevices();
+            // If permissions are granted, the MediaDeviceInfo objects will have labels.
+            return devices
+                .filter((device) => deviceKinds.includes(device.kind))
+                .every((device) => device.label);
+            // eslint-disable-next-line no-empty
+        }
+        catch (e) { }
+        return false;
+    });
+}
+/**
+ * Ensures that the user has granted permissions to the microphone and camera.
+ *
+ * @param deviceKinds - Array of DeviceKind items.
+ * @param callback - Function that will be executed while device permissions are granted. After this
+ *    returns, permissions (for example device labels in Firefox) may not be available anymore.
+ * @returns The callback's response.
+ */
+function ensureDevicePermissions(deviceKinds, callback) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        try {
+            const hasDevicePermissions = yield checkDevicePermissions(deviceKinds);
+            if (!hasDevicePermissions) {
+                const stream = yield getUserMedia({
+                    audio: deviceKinds.includes(DeviceKind$1.AudioInput),
+                    video: deviceKinds.includes(DeviceKind$1.VideoInput),
+                });
+                // Callback is here to call a function while an active capture exists, so that the browser
+                // (Firefox) will allow the user to access device information.
+                const callbackRes = yield callback();
+                // Stop tracks in the stream so the browser (Safari) will know that there is not an active
+                // stream running.
+                stream.getTracks().forEach((track) => track.stop());
+                return callbackRes;
+            }
+            return callback();
+        }
+        catch (e) {
+            logger$3.error(e);
+            throw new Error('Failed to ensure device permissions.');
+        }
+    });
 }
 
 var media = /*#__PURE__*/Object.freeze({
@@ -486,175 +486,175 @@ var media = /*#__PURE__*/Object.freeze({
     ensureDevicePermissions: ensureDevicePermissions
 });
 
-exports.WebrtcCoreErrorType = void 0;
-(function (WebrtcCoreErrorType) {
-    WebrtcCoreErrorType["DEVICE_PERMISSION_DENIED"] = "DEVICE_PERMISSION_DENIED";
-    WebrtcCoreErrorType["CREATE_STREAM_FAILED"] = "CREATE_STREAM_FAILED";
-    WebrtcCoreErrorType["ADD_EFFECT_FAILED"] = "ADD_EFFECT_FAILED";
-})(exports.WebrtcCoreErrorType || (exports.WebrtcCoreErrorType = {}));
-/**
- * Represents a WebRTC core error, which contains error type and error message.
- */
-class WebrtcCoreError {
-    /**
-     * Creates new error.
-     *
-     * @param type - Error type.
-     * @param message - Error message.
-     */
-    constructor(type, message = '') {
-        this.type = type;
-        this.message = message;
-    }
+exports.WebrtcCoreErrorType = void 0;
+(function (WebrtcCoreErrorType) {
+    WebrtcCoreErrorType["DEVICE_PERMISSION_DENIED"] = "DEVICE_PERMISSION_DENIED";
+    WebrtcCoreErrorType["CREATE_STREAM_FAILED"] = "CREATE_STREAM_FAILED";
+    WebrtcCoreErrorType["ADD_EFFECT_FAILED"] = "ADD_EFFECT_FAILED";
+})(exports.WebrtcCoreErrorType || (exports.WebrtcCoreErrorType = {}));
+/**
+ * Represents a WebRTC core error, which contains error type and error message.
+ */
+class WebrtcCoreError {
+    /**
+     * Creates new error.
+     *
+     * @param type - Error type.
+     * @param message - Error message.
+     */
+    constructor(type, message = '') {
+        this.type = type;
+        this.message = message;
+    }
 }
 
-/**
- * Creates a camera stream. Please note that the constraint params in second getUserMedia call would NOT take effect when:
- *
- * 1. Previous captured video stream from the same device is not stopped.
- * 2. Previous createCameraStream() call for the same device is in progress.
- *
- * @param constructor - Constructor for the local camera stream.
- * @param constraints - Video device constraints.
- * @returns A LocalCameraStream object or an error.
- */
-function createCameraStream(constructor, constraints) {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        let stream;
-        try {
-            stream = yield getUserMedia({ video: Object.assign({}, constraints) });
-        }
-        catch (error) {
-            throw new WebrtcCoreError(exports.WebrtcCoreErrorType.CREATE_STREAM_FAILED, `Failed to create camera stream: ${error}`);
-        }
-        return new constructor(stream);
-    });
-}
-/**
- * Creates a LocalMicrophoneStream with the given constraints.
- *
- * @param constructor - Constructor for the local microphone stream.
- * @param constraints - Audio device constraints.
- * @returns A LocalMicrophoneStream object or an error.
- */
-function createMicrophoneStream(constructor, constraints) {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        let stream;
-        try {
-            stream = yield getUserMedia({ audio: Object.assign({}, constraints) });
-        }
-        catch (error) {
-            throw new WebrtcCoreError(exports.WebrtcCoreErrorType.CREATE_STREAM_FAILED, `Failed to create microphone stream: ${error}`);
-        }
-        return new constructor(stream);
-    });
-}
-/**
- * Creates a LocalDisplayStream with the given parameters.
- *
- * @param constructor - Constructor for the local display stream.
- * @param videoContentHint - An optional parameter to give a hint for the content of the stream.
- * @returns A Promise that resolves to a LocalDisplayStream or an error.
- */
-function createDisplayStream(constructor, videoContentHint) {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        let stream;
-        try {
-            stream = yield getDisplayMedia({ video: true });
-        }
-        catch (error) {
-            throw new WebrtcCoreError(exports.WebrtcCoreErrorType.CREATE_STREAM_FAILED, `Failed to create display stream: ${error}`);
-        }
-        const localDisplayStream = new constructor(stream);
-        if (videoContentHint) {
-            localDisplayStream.contentHint = videoContentHint;
-        }
-        return localDisplayStream;
-    });
-}
-/**
- * Creates a LocalDisplayStream and a LocalSystemAudioStream with the given parameters.
- *
- * @param displayStreamConstructor - Constructor for the local display stream.
- * @param systemAudioStreamConstructor - Constructor for the local system audio stream.
- * @param videoContentHint - An optional parameter to give a hint for the content of the stream.
- * @returns A Promise that resolves to a LocalDisplayStream and a LocalSystemAudioStream or an
- * error. If no system audio is available, the LocalSystemAudioStream will be resolved as null
- * instead.
- */
-function createDisplayStreamWithAudio(displayStreamConstructor, systemAudioStreamConstructor, videoContentHint) {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        let stream;
-        try {
-            stream = yield getDisplayMedia({ video: true, audio: true });
-        }
-        catch (error) {
-            throw new WebrtcCoreError(exports.WebrtcCoreErrorType.CREATE_STREAM_FAILED, `Failed to create display and system audio streams: ${error}`);
-        }
-        // eslint-disable-next-line new-cap
-        const localDisplayStream = new displayStreamConstructor(new MediaStream(stream.getVideoTracks()));
-        if (videoContentHint) {
-            localDisplayStream.contentHint = videoContentHint;
-        }
-        let localSystemAudioStream = null;
-        if (stream.getAudioTracks().length > 0) {
-            // eslint-disable-next-line new-cap
-            localSystemAudioStream = new systemAudioStreamConstructor(new MediaStream(stream.getAudioTracks()));
-        }
-        return [localDisplayStream, localSystemAudioStream];
-    });
-}
-/**
- * Enumerates the media input and output devices available.
- *
- * @param deviceKind - Optional filter to return a specific device kind.
- * @returns List of media devices in an array of MediaDeviceInfo objects.
- */
-function getDevices(deviceKind) {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        let devices;
-        try {
-            devices = yield ensureDevicePermissions([DeviceKind$1.AudioInput, DeviceKind$1.VideoInput], enumerateDevices);
-        }
-        catch (error) {
-            throw new WebrtcCoreError(exports.WebrtcCoreErrorType.DEVICE_PERMISSION_DENIED, 'Failed to ensure device permissions');
-        }
-        return devices.filter((v) => (deviceKind ? v.kind === deviceKind : true));
-    });
-}
-/**
- * Helper function to get a list of microphone devices.
- *
- * @returns List of microphone devices in an array of MediaDeviceInfo objects.
- */
-function getAudioInputDevices() {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        return getDevices(DeviceKind$1.AudioInput);
-    });
-}
-/**
- * Helper function to get a list of speaker devices.
- *
- * @returns List of speaker devices in an array of MediaDeviceInfo objects.
- */
-function getAudioOutputDevices() {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        return getDevices(DeviceKind$1.AudioOutput);
-    });
-}
-/**
- * Helper function to get a list of camera devices.
- *
- * @returns List of camera devices in an array of MediaDeviceInfo objects.
- */
-function getVideoInputDevices() {
-    return __awaiter$2(this, void 0, void 0, function* () {
-        return getDevices(DeviceKind$1.VideoInput);
-    });
-}
-/**
- * Export the setOnDeviceChangeHandler method directly from the core lib.
- */
+/**
+ * Creates a camera stream. Please note that the constraint params in second getUserMedia call would NOT take effect when:
+ *
+ * 1. Previous captured video stream from the same device is not stopped.
+ * 2. Previous createCameraStream() call for the same device is in progress.
+ *
+ * @param constructor - Constructor for the local camera stream.
+ * @param constraints - Video device constraints.
+ * @returns A LocalCameraStream object or an error.
+ */
+function createCameraStream(constructor, constraints) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        let stream;
+        try {
+            stream = yield getUserMedia({ video: Object.assign({}, constraints) });
+        }
+        catch (error) {
+            throw new WebrtcCoreError(exports.WebrtcCoreErrorType.CREATE_STREAM_FAILED, `Failed to create camera stream: ${error}`);
+        }
+        return new constructor(stream);
+    });
+}
+/**
+ * Creates a LocalMicrophoneStream with the given constraints.
+ *
+ * @param constructor - Constructor for the local microphone stream.
+ * @param constraints - Audio device constraints.
+ * @returns A LocalMicrophoneStream object or an error.
+ */
+function createMicrophoneStream(constructor, constraints) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        let stream;
+        try {
+            stream = yield getUserMedia({ audio: Object.assign({}, constraints) });
+        }
+        catch (error) {
+            throw new WebrtcCoreError(exports.WebrtcCoreErrorType.CREATE_STREAM_FAILED, `Failed to create microphone stream: ${error}`);
+        }
+        return new constructor(stream);
+    });
+}
+/**
+ * Creates a LocalDisplayStream with the given parameters.
+ *
+ * @param constructor - Constructor for the local display stream.
+ * @param videoContentHint - An optional parameter to give a hint for the content of the stream.
+ * @returns A Promise that resolves to a LocalDisplayStream or an error.
+ */
+function createDisplayStream(constructor, videoContentHint) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        let stream;
+        try {
+            stream = yield getDisplayMedia({ video: true });
+        }
+        catch (error) {
+            throw new WebrtcCoreError(exports.WebrtcCoreErrorType.CREATE_STREAM_FAILED, `Failed to create display stream: ${error}`);
+        }
+        const localDisplayStream = new constructor(stream);
+        if (videoContentHint) {
+            localDisplayStream.contentHint = videoContentHint;
+        }
+        return localDisplayStream;
+    });
+}
+/**
+ * Creates a LocalDisplayStream and a LocalSystemAudioStream with the given parameters.
+ *
+ * @param displayStreamConstructor - Constructor for the local display stream.
+ * @param systemAudioStreamConstructor - Constructor for the local system audio stream.
+ * @param videoContentHint - An optional parameter to give a hint for the content of the stream.
+ * @returns A Promise that resolves to a LocalDisplayStream and a LocalSystemAudioStream or an
+ * error. If no system audio is available, the LocalSystemAudioStream will be resolved as null
+ * instead.
+ */
+function createDisplayStreamWithAudio(displayStreamConstructor, systemAudioStreamConstructor, videoContentHint) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        let stream;
+        try {
+            stream = yield getDisplayMedia({ video: true, audio: true });
+        }
+        catch (error) {
+            throw new WebrtcCoreError(exports.WebrtcCoreErrorType.CREATE_STREAM_FAILED, `Failed to create display and system audio streams: ${error}`);
+        }
+        // eslint-disable-next-line new-cap
+        const localDisplayStream = new displayStreamConstructor(new MediaStream(stream.getVideoTracks()));
+        if (videoContentHint) {
+            localDisplayStream.contentHint = videoContentHint;
+        }
+        let localSystemAudioStream = null;
+        if (stream.getAudioTracks().length > 0) {
+            // eslint-disable-next-line new-cap
+            localSystemAudioStream = new systemAudioStreamConstructor(new MediaStream(stream.getAudioTracks()));
+        }
+        return [localDisplayStream, localSystemAudioStream];
+    });
+}
+/**
+ * Enumerates the media input and output devices available.
+ *
+ * @param deviceKind - Optional filter to return a specific device kind.
+ * @returns List of media devices in an array of MediaDeviceInfo objects.
+ */
+function getDevices(deviceKind) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        let devices;
+        try {
+            devices = yield ensureDevicePermissions([DeviceKind$1.AudioInput, DeviceKind$1.VideoInput], enumerateDevices);
+        }
+        catch (error) {
+            throw new WebrtcCoreError(exports.WebrtcCoreErrorType.DEVICE_PERMISSION_DENIED, 'Failed to ensure device permissions');
+        }
+        return devices.filter((v) => (deviceKind ? v.kind === deviceKind : true));
+    });
+}
+/**
+ * Helper function to get a list of microphone devices.
+ *
+ * @returns List of microphone devices in an array of MediaDeviceInfo objects.
+ */
+function getAudioInputDevices() {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        return getDevices(DeviceKind$1.AudioInput);
+    });
+}
+/**
+ * Helper function to get a list of speaker devices.
+ *
+ * @returns List of speaker devices in an array of MediaDeviceInfo objects.
+ */
+function getAudioOutputDevices() {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        return getDevices(DeviceKind$1.AudioOutput);
+    });
+}
+/**
+ * Helper function to get a list of camera devices.
+ *
+ * @returns List of camera devices in an array of MediaDeviceInfo objects.
+ */
+function getVideoInputDevices() {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        return getDevices(DeviceKind$1.VideoInput);
+    });
+}
+/**
+ * Export the setOnDeviceChangeHandler method directly from the core lib.
+ */
 const { setOnDeviceChangeHandler } = media;
 
 var events$1$1 = {exports: {}};
@@ -1167,627 +1167,627 @@ function AddEvents(Base) {
     };
 }
 
-var _a$2$1;
-exports.StreamEventNames = void 0;
-(function (StreamEventNames) {
-    StreamEventNames["Ended"] = "stream-ended";
-})(exports.StreamEventNames || (exports.StreamEventNames = {}));
-/**
- * Base stream class.
- */
-class _Stream {
-    /**
-     * Create a Stream from the given values.
-     *
-     * @param stream - The initial output MediaStream for this Stream.
-     */
-    constructor(stream) {
-        // TODO: these should be protected, but we need the helper type in ts-events
-        // to hide the 'emit' method from TypedEvent.
-        this[_a$2$1] = new TypedEvent$1();
-        this.outputStream = stream;
-        this.handleTrackEnded = this.handleTrackEnded.bind(this);
-        this.addTrackHandlersForStreamEvents(this.outputTrack);
-    }
-    /**
-     * Handler which is called when a track's ended event fires.
-     */
-    handleTrackEnded() {
-        this[exports.StreamEventNames.Ended].emit();
-    }
-    /**
-     * Helper function to add event handlers to a MediaStreamTrack. Unlike the virtual
-     * {@link addTrackHandlers} function, which can be overridden, this function is internal to this
-     * class and will only add the event handlers relevant to this class. It prevents, for example,
-     * accidentally adding the same event handlers multiple times, which could happen if the virtual
-     * `addTrackHandlers` method was called from a subclass's constructor.
-     *
-     * @param track - The MediaStreamTrack.
-     */
-    addTrackHandlersForStreamEvents(track) {
-        track.addEventListener('ended', this.handleTrackEnded);
-    }
-    /**
-     * Add event handlers to a MediaStreamTrack.
-     *
-     * @param track - The MediaStreamTrack.
-     */
-    addTrackHandlers(track) {
-        this.addTrackHandlersForStreamEvents(track);
-    }
-    /**
-     * Remove event handlers from a MediaStreamTrack.
-     *
-     * @param track - The MediaStreamTrack.
-     */
-    removeTrackHandlers(track) {
-        track.removeEventListener('ended', this.handleTrackEnded);
-    }
-    /**
-     * Get the ID of the output stream.
-     *
-     * @returns The ID of the output stream.
-     */
-    get id() {
-        return this.outputStream.id;
-    }
-    /**
-     * Get the track of the output stream.
-     *
-     * @returns The output track.
-     */
-    get outputTrack() {
-        return this.outputStream.getTracks()[0];
-    }
-}
-_a$2$1 = exports.StreamEventNames.Ended;
+var _a$2$1;
+exports.StreamEventNames = void 0;
+(function (StreamEventNames) {
+    StreamEventNames["Ended"] = "stream-ended";
+})(exports.StreamEventNames || (exports.StreamEventNames = {}));
+/**
+ * Base stream class.
+ */
+class _Stream {
+    /**
+     * Create a Stream from the given values.
+     *
+     * @param stream - The initial output MediaStream for this Stream.
+     */
+    constructor(stream) {
+        // TODO: these should be protected, but we need the helper type in ts-events
+        // to hide the 'emit' method from TypedEvent.
+        this[_a$2$1] = new TypedEvent$1();
+        this.outputStream = stream;
+        this.handleTrackEnded = this.handleTrackEnded.bind(this);
+        this.addTrackHandlersForStreamEvents(this.outputTrack);
+    }
+    /**
+     * Handler which is called when a track's ended event fires.
+     */
+    handleTrackEnded() {
+        this[exports.StreamEventNames.Ended].emit();
+    }
+    /**
+     * Helper function to add event handlers to a MediaStreamTrack. Unlike the virtual
+     * {@link addTrackHandlers} function, which can be overridden, this function is internal to this
+     * class and will only add the event handlers relevant to this class. It prevents, for example,
+     * accidentally adding the same event handlers multiple times, which could happen if the virtual
+     * `addTrackHandlers` method was called from a subclass's constructor.
+     *
+     * @param track - The MediaStreamTrack.
+     */
+    addTrackHandlersForStreamEvents(track) {
+        track.addEventListener('ended', this.handleTrackEnded);
+    }
+    /**
+     * Add event handlers to a MediaStreamTrack.
+     *
+     * @param track - The MediaStreamTrack.
+     */
+    addTrackHandlers(track) {
+        this.addTrackHandlersForStreamEvents(track);
+    }
+    /**
+     * Remove event handlers from a MediaStreamTrack.
+     *
+     * @param track - The MediaStreamTrack.
+     */
+    removeTrackHandlers(track) {
+        track.removeEventListener('ended', this.handleTrackEnded);
+    }
+    /**
+     * Get the ID of the output stream.
+     *
+     * @returns The ID of the output stream.
+     */
+    get id() {
+        return this.outputStream.id;
+    }
+    /**
+     * Get the track of the output stream.
+     *
+     * @returns The output track.
+     */
+    get outputTrack() {
+        return this.outputStream.getTracks()[0];
+    }
+}
+_a$2$1 = exports.StreamEventNames.Ended;
 const Stream = AddEvents(_Stream);
 
-var _a$1$1, _b, _c, _d, _e;
-exports.LocalStreamEventNames = void 0;
-(function (LocalStreamEventNames) {
-    LocalStreamEventNames["UserMuteStateChange"] = "user-mute-state-change";
-    LocalStreamEventNames["SystemMuteStateChange"] = "system-mute-state-change";
-    LocalStreamEventNames["ConstraintsChange"] = "constraints-change";
-    LocalStreamEventNames["OutputTrackChange"] = "output-track-change";
-    LocalStreamEventNames["EffectAdded"] = "effect-added";
-})(exports.LocalStreamEventNames || (exports.LocalStreamEventNames = {}));
-/**
- * A stream which originates on the local device.
- */
-class _LocalStream extends Stream {
-    /**
-     * Create a LocalStream from the given values.
-     *
-     * @param stream - The initial output MediaStream for this Stream.
-     */
-    constructor(stream) {
-        super(stream);
-        this[_a$1$1] = new TypedEvent$1();
-        this[_b] = new TypedEvent$1();
-        this[_c] = new TypedEvent$1();
-        this[_d] = new TypedEvent$1();
-        this[_e] = new TypedEvent$1();
-        this.effects = [];
-        this.loadingEffects = new Map();
-        this.inputStream = stream;
-        this.handleTrackMutedBySystem = this.handleTrackMutedBySystem.bind(this);
-        this.handleTrackUnmutedBySystem = this.handleTrackUnmutedBySystem.bind(this);
-        this.addTrackHandlersForLocalStreamEvents(this.inputTrack);
-    }
-    /**
-     * Handler which is called when a track's mute event fires.
-     */
-    handleTrackMutedBySystem() {
-        this[exports.LocalStreamEventNames.SystemMuteStateChange].emit(true);
-    }
-    /**
-     * Handler which is called when a track's unmute event fires.
-     */
-    handleTrackUnmutedBySystem() {
-        this[exports.LocalStreamEventNames.SystemMuteStateChange].emit(false);
-    }
-    /**
-     * Helper function to add event handlers to a MediaStreamTrack. See
-     * {@link Stream.addTrackHandlersForStreamEvents} for why this is useful.
-     *
-     * @param track - The MediaStreamTrack.
-     */
-    addTrackHandlersForLocalStreamEvents(track) {
-        track.addEventListener('mute', this.handleTrackMutedBySystem);
-        track.addEventListener('unmute', this.handleTrackUnmutedBySystem);
-    }
-    /**
-     * @inheritdoc
-     */
-    addTrackHandlers(track) {
-        super.addTrackHandlers(track);
-        this.addTrackHandlersForLocalStreamEvents(track);
-    }
-    /**
-     * @inheritdoc
-     */
-    removeTrackHandlers(track) {
-        super.removeTrackHandlers(track);
-        track.removeEventListener('mute', this.handleTrackMutedBySystem);
-        track.removeEventListener('unmute', this.handleTrackUnmutedBySystem);
-    }
-    /**
-     * Get the track within the MediaStream with which this LocalStream was created.
-     *
-     * @returns The track within the MediaStream with which this LocalStream
-     * was created.
-     */
-    get inputTrack() {
-        return this.inputStream.getTracks()[0];
-    }
-    /**
-     * Check whether or not this stream is muted. This considers both whether the stream has been
-     * muted by the user (see {@link userMuted}) and whether the stream has been muted by the system
-     * (see {@link systemMuted}).
-     *
-     * @returns True if the stream is muted, false otherwise.
-     */
-    get muted() {
-        return this.userMuted || this.systemMuted;
-    }
-    /**
-     * Check whether or not this stream has been muted by the user. This is equivalent to checking the
-     * MediaStreamTrack "enabled" state.
-     *
-     * @returns True if the stream has been muted by the user, false otherwise.
-     */
-    get userMuted() {
-        return !this.inputTrack.enabled;
-    }
-    /**
-     * Check whether or not this stream has been muted by the user. This is equivalent to checking the
-     * MediaStreamTrack "muted" state.
-     *
-     * @returns True if the stream has been muted by the system, false otherwise.
-     */
-    get systemMuted() {
-        return this.inputTrack.muted;
-    }
-    /**
-     * Set the user mute state of this stream.
-     *
-     * Note: This sets the user-toggled mute state, equivalent to changing the "enabled" state of the
-     * track. It is separate from the system-toggled mute state.
-     *
-     * @param isMuted - True to mute, false to unmute.
-     */
-    setUserMuted(isMuted) {
-        if (this.inputTrack.enabled === isMuted) {
-            this.inputTrack.enabled = !isMuted;
-            this[exports.LocalStreamEventNames.UserMuteStateChange].emit(isMuted);
-        }
-    }
-    /**
-     * @inheritdoc
-     */
-    getSettings() {
-        return this.inputTrack.getSettings();
-    }
-    /**
-     * Get the label of the input track on this stream.
-     *
-     * @returns The label of the track.
-     */
-    get label() {
-        return this.inputTrack.label;
-    }
-    /**
-     * Get the readyState of the input track on this stream.
-     *
-     * @returns The readyState of the track.
-     */
-    get readyState() {
-        return this.inputTrack.readyState;
-    }
-    /**
-     * Change the track of the output stream to a different track.
-     *
-     * Note: this method assumes and enforces that if both input and output streams have the same
-     * track, then they must also be the same stream.
-     *
-     * @param newTrack - The track to be used in the output stream.
-     */
-    changeOutputTrack(newTrack) {
-        if (this.outputTrack.id !== newTrack.id) {
-            // If the input track and the *old* output track are currently the same, then the streams must
-            // be the same too. We want to apply the new track to the output stream without affecting the
-            // input stream, so we separate them by setting the input stream to be its own stream.
-            if (this.inputTrack.id === this.outputTrack.id) {
-                this.inputStream = new MediaStream(this.inputStream);
-            }
-            this.outputStream.removeTrack(this.outputTrack);
-            this.outputStream.addTrack(newTrack);
-            // If the input track and the *new* output track are now the same, then we want the streams to
-            // be the same too.
-            if (this.inputTrack.id === this.outputTrack.id) {
-                this.inputStream = this.outputStream;
-            }
-            this[exports.LocalStreamEventNames.OutputTrackChange].emit(newTrack);
-        }
-    }
-    /**
-     * @inheritdoc
-     */
-    stop() {
-        this.inputTrack.stop();
-        this.outputTrack.stop();
-        this.disposeEffects();
-        // calling stop() will not automatically emit Ended, so we emit it here
-        this[exports.StreamEventNames.Ended].emit();
-    }
-    /**
-     * Adds an effect to a local stream.
-     *
-     * @param effect - The effect to add.
-     */
-    addEffect(effect) {
-        return __awaiter$2(this, void 0, void 0, function* () {
-            // Check if the effect has already been added.
-            if (this.effects.some((e) => e.id === effect.id)) {
-                return;
-            }
-            // Load the effect. Because loading is asynchronous, keep track of the loading effects.
-            this.loadingEffects.set(effect.kind, effect);
-            yield effect.load(this.outputTrack);
-            // After loading, check whether or not we still want to use this effect. If another effect of
-            // the same kind was added while this effect was loading, we only want to use the latest effect,
-            // so dispose this one. If the effects list was cleared while this effect was loading, also
-            // dispose it.
-            if (effect !== this.loadingEffects.get(effect.kind)) {
-                yield effect.dispose();
-                throw new WebrtcCoreError(exports.WebrtcCoreErrorType.ADD_EFFECT_FAILED, `Another effect with kind ${effect.kind} was added while effect ${effect.id} was loading, or the effects list was cleared.`);
-            }
-            this.loadingEffects.delete(effect.kind);
-            /**
-             * Handle when the effect's output track has been changed. This will update the input of the
-             * next effect in the effects list of the output of the stream.
-             *
-             * @param track - The new output track of the effect.
-             */
-            const handleEffectTrackUpdated = (track) => {
-                var _f;
-                const effectIndex = this.effects.findIndex((e) => e.id === effect.id);
-                if (effectIndex === this.effects.length - 1) {
-                    this.changeOutputTrack(track);
-                }
-                else if (effectIndex >= 0) {
-                    (_f = this.effects[effectIndex + 1]) === null || _f === void 0 ? void 0 : _f.replaceInputTrack(track);
-                }
-                else {
-                    logger$3.error(`Effect with ID ${effect.id} not found in effects list.`);
-                }
-            };
-            /**
-             * Handle when the effect has been disposed. This will remove all event listeners from the
-             * effect.
-             */
-            const handleEffectDisposed = () => {
-                effect.off('track-updated', handleEffectTrackUpdated);
-                effect.off('disposed', handleEffectDisposed);
-            };
-            // TODO: using EffectEvent.TrackUpdated or EffectEvent.Disposed will cause the entire
-            // web-media-effects lib to be rebuilt and inflates the size of the webrtc-core build, so
-            // we use type assertion here as a temporary workaround.
-            effect.on('track-updated', handleEffectTrackUpdated);
-            effect.on('disposed', handleEffectDisposed);
-            // Add the effect to the effects list. If an effect of the same kind has already been added,
-            // dispose the existing effect and replace it with the new effect. If the existing effect was
-            // enabled, also enable the new effect.
-            const existingEffectIndex = this.effects.findIndex((e) => e.kind === effect.kind);
-            if (existingEffectIndex >= 0) {
-                const [existingEffect] = this.effects.splice(existingEffectIndex, 1, effect);
-                if (existingEffect.isEnabled) {
-                    // If the existing effect is not the first effect in the effects list, then the input of the
-                    // new effect should be the output of the previous effect in the effects list. We know the
-                    // output track of the previous effect must exist because it must have been loaded (and all
-                    // loaded effects have an output track).
-                    const inputTrack = existingEffectIndex === 0
-                        ? this.inputTrack
-                        : this.effects[existingEffectIndex - 1].getOutputTrack();
-                    yield effect.replaceInputTrack(inputTrack);
-                    // Enabling the new effect will trigger the track-updated event, which will handle the new
-                    // effect's updated output track.
-                    yield effect.enable();
-                }
-                yield existingEffect.dispose();
-            }
-            else {
-                this.effects.push(effect);
-            }
-            // Emit an event with the effect so others can listen to the effect events.
-            this[exports.LocalStreamEventNames.EffectAdded].emit(effect);
-        });
-    }
-    /**
-     * Get an effect from the effects list by ID.
-     *
-     * @param id - The id of the effect you want to get.
-     * @returns The effect or undefined.
-     */
-    getEffectById(id) {
-        return this.effects.find((effect) => effect.id === id);
-    }
-    /**
-     * Get an effect from the effects list by kind.
-     *
-     * @param kind - The kind of the effect you want to get.
-     * @returns The effect or undefined.
-     */
-    getEffectByKind(kind) {
-        return this.effects.find((effect) => effect.kind === kind);
-    }
-    /**
-     * Get all the effects from the effects list.
-     *
-     * @returns A list of effects.
-     */
-    getEffects() {
-        return this.effects;
-    }
-    /**
-     * Method to serialize data about input, output streams
-     * and also effects from LocalStream.
-     *
-     * @returns - A JSON-compatible object representation with data from LocalStream.
-     */
-    toJSON() {
-        return {
-            muted: this.muted,
-            label: this.label,
-            readyState: this.readyState,
-            inputStream: {
-                active: this.inputStream.active,
-                id: this.inputStream.id,
-                enabled: this.inputTrack.enabled,
-                muted: this.inputTrack.muted,
-            },
-            outputStream: {
-                active: this.outputStream.active,
-                id: this.outputStream.id,
-            },
-            effects: this.effects.map((effect) => {
-                return {
-                    id: effect.id,
-                    kind: effect.kind,
-                    isEnabled: effect.isEnabled,
-                };
-            }),
-        };
-    }
-    /**
-     * Cleanup the local effects.
-     */
-    disposeEffects() {
-        return __awaiter$2(this, void 0, void 0, function* () {
-            this.loadingEffects.clear();
-            // Dispose of any effects currently in use
-            if (this.effects.length > 0) {
-                this.changeOutputTrack(this.inputTrack);
-                yield Promise.all(this.effects.map((effect) => effect.dispose()));
-                this.effects = [];
-            }
-        });
-    }
-}
-_a$1$1 = exports.LocalStreamEventNames.UserMuteStateChange, _b = exports.LocalStreamEventNames.SystemMuteStateChange, _c = exports.LocalStreamEventNames.ConstraintsChange, _d = exports.LocalStreamEventNames.OutputTrackChange, _e = exports.LocalStreamEventNames.EffectAdded;
+var _a$1$1, _b, _c, _d, _e;
+exports.LocalStreamEventNames = void 0;
+(function (LocalStreamEventNames) {
+    LocalStreamEventNames["UserMuteStateChange"] = "user-mute-state-change";
+    LocalStreamEventNames["SystemMuteStateChange"] = "system-mute-state-change";
+    LocalStreamEventNames["ConstraintsChange"] = "constraints-change";
+    LocalStreamEventNames["OutputTrackChange"] = "output-track-change";
+    LocalStreamEventNames["EffectAdded"] = "effect-added";
+})(exports.LocalStreamEventNames || (exports.LocalStreamEventNames = {}));
+/**
+ * A stream which originates on the local device.
+ */
+class _LocalStream extends Stream {
+    /**
+     * Create a LocalStream from the given values.
+     *
+     * @param stream - The initial output MediaStream for this Stream.
+     */
+    constructor(stream) {
+        super(stream);
+        this[_a$1$1] = new TypedEvent$1();
+        this[_b] = new TypedEvent$1();
+        this[_c] = new TypedEvent$1();
+        this[_d] = new TypedEvent$1();
+        this[_e] = new TypedEvent$1();
+        this.effects = [];
+        this.loadingEffects = new Map();
+        this.inputStream = stream;
+        this.handleTrackMutedBySystem = this.handleTrackMutedBySystem.bind(this);
+        this.handleTrackUnmutedBySystem = this.handleTrackUnmutedBySystem.bind(this);
+        this.addTrackHandlersForLocalStreamEvents(this.inputTrack);
+    }
+    /**
+     * Handler which is called when a track's mute event fires.
+     */
+    handleTrackMutedBySystem() {
+        this[exports.LocalStreamEventNames.SystemMuteStateChange].emit(true);
+    }
+    /**
+     * Handler which is called when a track's unmute event fires.
+     */
+    handleTrackUnmutedBySystem() {
+        this[exports.LocalStreamEventNames.SystemMuteStateChange].emit(false);
+    }
+    /**
+     * Helper function to add event handlers to a MediaStreamTrack. See
+     * {@link Stream.addTrackHandlersForStreamEvents} for why this is useful.
+     *
+     * @param track - The MediaStreamTrack.
+     */
+    addTrackHandlersForLocalStreamEvents(track) {
+        track.addEventListener('mute', this.handleTrackMutedBySystem);
+        track.addEventListener('unmute', this.handleTrackUnmutedBySystem);
+    }
+    /**
+     * @inheritdoc
+     */
+    addTrackHandlers(track) {
+        super.addTrackHandlers(track);
+        this.addTrackHandlersForLocalStreamEvents(track);
+    }
+    /**
+     * @inheritdoc
+     */
+    removeTrackHandlers(track) {
+        super.removeTrackHandlers(track);
+        track.removeEventListener('mute', this.handleTrackMutedBySystem);
+        track.removeEventListener('unmute', this.handleTrackUnmutedBySystem);
+    }
+    /**
+     * Get the track within the MediaStream with which this LocalStream was created.
+     *
+     * @returns The track within the MediaStream with which this LocalStream
+     * was created.
+     */
+    get inputTrack() {
+        return this.inputStream.getTracks()[0];
+    }
+    /**
+     * Check whether or not this stream is muted. This considers both whether the stream has been
+     * muted by the user (see {@link userMuted}) and whether the stream has been muted by the system
+     * (see {@link systemMuted}).
+     *
+     * @returns True if the stream is muted, false otherwise.
+     */
+    get muted() {
+        return this.userMuted || this.systemMuted;
+    }
+    /**
+     * Check whether or not this stream has been muted by the user. This is equivalent to checking the
+     * MediaStreamTrack "enabled" state.
+     *
+     * @returns True if the stream has been muted by the user, false otherwise.
+     */
+    get userMuted() {
+        return !this.inputTrack.enabled;
+    }
+    /**
+     * Check whether or not this stream has been muted by the user. This is equivalent to checking the
+     * MediaStreamTrack "muted" state.
+     *
+     * @returns True if the stream has been muted by the system, false otherwise.
+     */
+    get systemMuted() {
+        return this.inputTrack.muted;
+    }
+    /**
+     * Set the user mute state of this stream.
+     *
+     * Note: This sets the user-toggled mute state, equivalent to changing the "enabled" state of the
+     * track. It is separate from the system-toggled mute state.
+     *
+     * @param isMuted - True to mute, false to unmute.
+     */
+    setUserMuted(isMuted) {
+        if (this.inputTrack.enabled === isMuted) {
+            this.inputTrack.enabled = !isMuted;
+            this[exports.LocalStreamEventNames.UserMuteStateChange].emit(isMuted);
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    getSettings() {
+        return this.inputTrack.getSettings();
+    }
+    /**
+     * Get the label of the input track on this stream.
+     *
+     * @returns The label of the track.
+     */
+    get label() {
+        return this.inputTrack.label;
+    }
+    /**
+     * Get the readyState of the input track on this stream.
+     *
+     * @returns The readyState of the track.
+     */
+    get readyState() {
+        return this.inputTrack.readyState;
+    }
+    /**
+     * Change the track of the output stream to a different track.
+     *
+     * Note: this method assumes and enforces that if both input and output streams have the same
+     * track, then they must also be the same stream.
+     *
+     * @param newTrack - The track to be used in the output stream.
+     */
+    changeOutputTrack(newTrack) {
+        if (this.outputTrack.id !== newTrack.id) {
+            // If the input track and the *old* output track are currently the same, then the streams must
+            // be the same too. We want to apply the new track to the output stream without affecting the
+            // input stream, so we separate them by setting the input stream to be its own stream.
+            if (this.inputTrack.id === this.outputTrack.id) {
+                this.inputStream = new MediaStream(this.inputStream);
+            }
+            this.outputStream.removeTrack(this.outputTrack);
+            this.outputStream.addTrack(newTrack);
+            // If the input track and the *new* output track are now the same, then we want the streams to
+            // be the same too.
+            if (this.inputTrack.id === this.outputTrack.id) {
+                this.inputStream = this.outputStream;
+            }
+            this[exports.LocalStreamEventNames.OutputTrackChange].emit(newTrack);
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    stop() {
+        this.inputTrack.stop();
+        this.outputTrack.stop();
+        this.disposeEffects();
+        // calling stop() will not automatically emit Ended, so we emit it here
+        this[exports.StreamEventNames.Ended].emit();
+    }
+    /**
+     * Adds an effect to a local stream.
+     *
+     * @param effect - The effect to add.
+     */
+    addEffect(effect) {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            // Check if the effect has already been added.
+            if (this.effects.some((e) => e.id === effect.id)) {
+                return;
+            }
+            // Load the effect. Because loading is asynchronous, keep track of the loading effects.
+            this.loadingEffects.set(effect.kind, effect);
+            yield effect.load(this.outputTrack);
+            // After loading, check whether or not we still want to use this effect. If another effect of
+            // the same kind was added while this effect was loading, we only want to use the latest effect,
+            // so dispose this one. If the effects list was cleared while this effect was loading, also
+            // dispose it.
+            if (effect !== this.loadingEffects.get(effect.kind)) {
+                yield effect.dispose();
+                throw new WebrtcCoreError(exports.WebrtcCoreErrorType.ADD_EFFECT_FAILED, `Another effect with kind ${effect.kind} was added while effect ${effect.id} was loading, or the effects list was cleared.`);
+            }
+            this.loadingEffects.delete(effect.kind);
+            /**
+             * Handle when the effect's output track has been changed. This will update the input of the
+             * next effect in the effects list of the output of the stream.
+             *
+             * @param track - The new output track of the effect.
+             */
+            const handleEffectTrackUpdated = (track) => {
+                var _f;
+                const effectIndex = this.effects.findIndex((e) => e.id === effect.id);
+                if (effectIndex === this.effects.length - 1) {
+                    this.changeOutputTrack(track);
+                }
+                else if (effectIndex >= 0) {
+                    (_f = this.effects[effectIndex + 1]) === null || _f === void 0 ? void 0 : _f.replaceInputTrack(track);
+                }
+                else {
+                    logger$3.error(`Effect with ID ${effect.id} not found in effects list.`);
+                }
+            };
+            /**
+             * Handle when the effect has been disposed. This will remove all event listeners from the
+             * effect.
+             */
+            const handleEffectDisposed = () => {
+                effect.off('track-updated', handleEffectTrackUpdated);
+                effect.off('disposed', handleEffectDisposed);
+            };
+            // TODO: using EffectEvent.TrackUpdated or EffectEvent.Disposed will cause the entire
+            // web-media-effects lib to be rebuilt and inflates the size of the webrtc-core build, so
+            // we use type assertion here as a temporary workaround.
+            effect.on('track-updated', handleEffectTrackUpdated);
+            effect.on('disposed', handleEffectDisposed);
+            // Add the effect to the effects list. If an effect of the same kind has already been added,
+            // dispose the existing effect and replace it with the new effect. If the existing effect was
+            // enabled, also enable the new effect.
+            const existingEffectIndex = this.effects.findIndex((e) => e.kind === effect.kind);
+            if (existingEffectIndex >= 0) {
+                const [existingEffect] = this.effects.splice(existingEffectIndex, 1, effect);
+                if (existingEffect.isEnabled) {
+                    // If the existing effect is not the first effect in the effects list, then the input of the
+                    // new effect should be the output of the previous effect in the effects list. We know the
+                    // output track of the previous effect must exist because it must have been loaded (and all
+                    // loaded effects have an output track).
+                    const inputTrack = existingEffectIndex === 0
+                        ? this.inputTrack
+                        : this.effects[existingEffectIndex - 1].getOutputTrack();
+                    yield effect.replaceInputTrack(inputTrack);
+                    // Enabling the new effect will trigger the track-updated event, which will handle the new
+                    // effect's updated output track.
+                    yield effect.enable();
+                }
+                yield existingEffect.dispose();
+            }
+            else {
+                this.effects.push(effect);
+            }
+            // Emit an event with the effect so others can listen to the effect events.
+            this[exports.LocalStreamEventNames.EffectAdded].emit(effect);
+        });
+    }
+    /**
+     * Get an effect from the effects list by ID.
+     *
+     * @param id - The id of the effect you want to get.
+     * @returns The effect or undefined.
+     */
+    getEffectById(id) {
+        return this.effects.find((effect) => effect.id === id);
+    }
+    /**
+     * Get an effect from the effects list by kind.
+     *
+     * @param kind - The kind of the effect you want to get.
+     * @returns The effect or undefined.
+     */
+    getEffectByKind(kind) {
+        return this.effects.find((effect) => effect.kind === kind);
+    }
+    /**
+     * Get all the effects from the effects list.
+     *
+     * @returns A list of effects.
+     */
+    getEffects() {
+        return this.effects;
+    }
+    /**
+     * Method to serialize data about input, output streams
+     * and also effects from LocalStream.
+     *
+     * @returns - A JSON-compatible object representation with data from LocalStream.
+     */
+    toJSON() {
+        return {
+            muted: this.muted,
+            label: this.label,
+            readyState: this.readyState,
+            inputStream: {
+                active: this.inputStream.active,
+                id: this.inputStream.id,
+                enabled: this.inputTrack.enabled,
+                muted: this.inputTrack.muted,
+            },
+            outputStream: {
+                active: this.outputStream.active,
+                id: this.outputStream.id,
+            },
+            effects: this.effects.map((effect) => {
+                return {
+                    id: effect.id,
+                    kind: effect.kind,
+                    isEnabled: effect.isEnabled,
+                };
+            }),
+        };
+    }
+    /**
+     * Cleanup the local effects.
+     */
+    disposeEffects() {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            this.loadingEffects.clear();
+            // Dispose of any effects currently in use
+            if (this.effects.length > 0) {
+                this.changeOutputTrack(this.inputTrack);
+                yield Promise.all(this.effects.map((effect) => effect.dispose()));
+                this.effects = [];
+            }
+        });
+    }
+}
+_a$1$1 = exports.LocalStreamEventNames.UserMuteStateChange, _b = exports.LocalStreamEventNames.SystemMuteStateChange, _c = exports.LocalStreamEventNames.ConstraintsChange, _d = exports.LocalStreamEventNames.OutputTrackChange, _e = exports.LocalStreamEventNames.EffectAdded;
 const LocalStream = AddEvents(_LocalStream);
 
-/**
- * An audio LocalStream.
- */
-class LocalAudioStream extends LocalStream {
-    /**
-     * Apply constraints to the stream.
-     *
-     * @param constraints - The constraints to apply.
-     * @returns A promise which resolves when the constraints have been successfully applied.
-     */
-    applyConstraints(constraints) {
-        return __awaiter$2(this, void 0, void 0, function* () {
-            logger$3.log(`Applying constraints to local track:`, constraints);
-            return this.inputTrack.applyConstraints(constraints).then(() => {
-                this[exports.LocalStreamEventNames.ConstraintsChange].emit();
-            });
-        });
-    }
+/**
+ * An audio LocalStream.
+ */
+class LocalAudioStream extends LocalStream {
+    /**
+     * Apply constraints to the stream.
+     *
+     * @param constraints - The constraints to apply.
+     * @returns A promise which resolves when the constraints have been successfully applied.
+     */
+    applyConstraints(constraints) {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            logger$3.log(`Applying constraints to local track:`, constraints);
+            return this.inputTrack.applyConstraints(constraints).then(() => {
+                this[exports.LocalStreamEventNames.ConstraintsChange].emit();
+            });
+        });
+    }
+}
+
+/**
+ * A video LocalStream.
+ */
+class LocalVideoStream extends LocalStream {
+    /**
+     * Apply constraints to the stream.
+     *
+     * @param constraints - The constraints to apply.
+     * @returns A promise which resolves when the constraints have been successfully applied.
+     */
+    applyConstraints(constraints) {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            logger$3.log(`Applying constraints to local track:`, constraints);
+            return this.inputTrack.applyConstraints(constraints).then(() => {
+                this[exports.LocalStreamEventNames.ConstraintsChange].emit();
+            });
+        });
+    }
+    /**
+     * Get the content hint for this stream.
+     *
+     * @returns The content hint setting for this stream, or undefined if none has been set.
+     */
+    get contentHint() {
+        return this.inputTrack.contentHint;
+    }
+    /**
+     * Set the content hint for this stream.
+     *
+     * @param hint - The content hint to set.
+     */
+    set contentHint(hint) {
+        this.inputTrack.contentHint = hint;
+    }
+    /**
+     * Check the resolution and then return how many layers will be active.
+     *
+     * @returns The active layers count.
+     */
+    getNumActiveSimulcastLayers() {
+        let activeSimulcastLayersNumber = 0;
+        const videoHeight = this.inputTrack.getSettings().height;
+        if (videoHeight <= 180) {
+            activeSimulcastLayersNumber = 1;
+        }
+        else if (videoHeight <= 360) {
+            activeSimulcastLayersNumber = 2;
+        }
+        else {
+            activeSimulcastLayersNumber = 3;
+        }
+        return activeSimulcastLayersNumber;
+    }
+}
+
+/**
+ * A local camera stream.
+ */
+class LocalCameraStream extends LocalVideoStream {
+}
+
+/**
+ * A local display stream.
+ */
+class LocalDisplayStream extends LocalVideoStream {
+}
+
+/**
+ * A local microphone stream.
+ */
+class LocalMicrophoneStream extends LocalAudioStream {
+}
+
+/**
+ * A local system audio stream.
+ */
+class LocalSystemAudioStream extends LocalAudioStream {
+}
+
+var _a$6;
+exports.RemoteMediaState = void 0;
+(function (RemoteMediaState) {
+    RemoteMediaState["Started"] = "started";
+    RemoteMediaState["Stopped"] = "stopped";
+})(exports.RemoteMediaState || (exports.RemoteMediaState = {}));
+exports.RemoteStreamEventNames = void 0;
+(function (RemoteStreamEventNames) {
+    RemoteStreamEventNames["MediaStateChange"] = "media-state-change";
+})(exports.RemoteStreamEventNames || (exports.RemoteStreamEventNames = {}));
+/**
+ * A stream originating from a remote peer.
+ */
+class _RemoteStream extends Stream {
+    /**
+     * Create a RemoteStream from the given values.
+     *
+     * @param stream - The initial output MediaStream for this Stream.
+     */
+    constructor(stream) {
+        super(stream);
+        this[_a$6] = new TypedEvent$1();
+        this.handleMediaStarted = this.handleMediaStarted.bind(this);
+        this.handleMediaStopped = this.handleMediaStopped.bind(this);
+        this.outputTrack.addEventListener('mute', this.handleMediaStopped);
+        this.outputTrack.addEventListener('unmute', this.handleMediaStarted);
+    }
+    /**
+     * @inheritdoc
+     */
+    handleMediaStarted() {
+        this[exports.RemoteStreamEventNames.MediaStateChange].emit(exports.RemoteMediaState.Started);
+    }
+    /**
+     * @inheritdoc
+     */
+    handleMediaStopped() {
+        this[exports.RemoteStreamEventNames.MediaStateChange].emit(exports.RemoteMediaState.Stopped);
+    }
+    /**
+     * Helper function to add event handlers to a MediaStreamTrack. See
+     * {@link Stream.addTrackHandlersForStreamEvents} for why this is useful.
+     *
+     * @param track - The MediaStreamTrack.
+     */
+    addTrackHandlersForRemoteStreamEvents(track) {
+        track.addEventListener('mute', this.handleMediaStopped);
+        track.addEventListener('unmute', this.handleMediaStarted);
+    }
+    /**
+     * @inheritdoc
+     */
+    addTrackHandlers(track) {
+        super.addTrackHandlers(track);
+        this.addTrackHandlersForRemoteStreamEvents(track);
+    }
+    /**
+     * @inheritdoc
+     */
+    removeTrackHandlers(track) {
+        super.removeTrackHandlers(track);
+        track.removeEventListener('mute', this.handleMediaStopped);
+        track.removeEventListener('unmute', this.handleMediaStarted);
+    }
+    /**
+     * Get whether the media on this stream has started or stopped.
+     *
+     * @returns The state of the media.
+     */
+    get mediaState() {
+        return this.outputTrack.muted ? exports.RemoteMediaState.Stopped : exports.RemoteMediaState.Started;
+    }
+    /**
+     * @inheritdoc
+     */
+    getSettings() {
+        return this.outputTrack.getSettings();
+    }
+    /**
+     * Replace the existing track on the output stream for a new track.
+     *
+     * @param newTrack - The track to add to the stream.
+     */
+    replaceTrack(newTrack) {
+        const oldTrack = this.outputTrack;
+        this.removeTrackHandlers(oldTrack);
+        this.outputStream.removeTrack(oldTrack);
+        this.outputStream.addTrack(newTrack);
+        this.addTrackHandlers(newTrack);
+        if (oldTrack.muted !== newTrack.muted) {
+            if (newTrack.muted) {
+                this.handleMediaStopped();
+            }
+            else {
+                this.handleMediaStarted();
+            }
+        }
+        // TODO: Chrome/React may not automatically refresh the media element with the new track when
+        // the output track has changed, so we may need to emit an event here if this is the case.
+        // this[StreamEventNames.OutputTrackChange].emit(newTrack);
+    }
+    /**
+     * @inheritdoc
+     */
+    stop() {
+        this.outputTrack.stop();
+        // calling stop() will not automatically emit Ended, so we emit it here
+        this[exports.StreamEventNames.Ended].emit();
+    }
 }
-
-/**
- * A video LocalStream.
- */
-class LocalVideoStream extends LocalStream {
-    /**
-     * Apply constraints to the stream.
-     *
-     * @param constraints - The constraints to apply.
-     * @returns A promise which resolves when the constraints have been successfully applied.
-     */
-    applyConstraints(constraints) {
-        return __awaiter$2(this, void 0, void 0, function* () {
-            logger$3.log(`Applying constraints to local track:`, constraints);
-            return this.inputTrack.applyConstraints(constraints).then(() => {
-                this[exports.LocalStreamEventNames.ConstraintsChange].emit();
-            });
-        });
-    }
-    /**
-     * Get the content hint for this stream.
-     *
-     * @returns The content hint setting for this stream, or undefined if none has been set.
-     */
-    get contentHint() {
-        return this.inputTrack.contentHint;
-    }
-    /**
-     * Set the content hint for this stream.
-     *
-     * @param hint - The content hint to set.
-     */
-    set contentHint(hint) {
-        this.inputTrack.contentHint = hint;
-    }
-    /**
-     * Check the resolution and then return how many layers will be active.
-     *
-     * @returns The active layers count.
-     */
-    getNumActiveSimulcastLayers() {
-        let activeSimulcastLayersNumber = 0;
-        const videoHeight = this.inputTrack.getSettings().height;
-        if (videoHeight <= 180) {
-            activeSimulcastLayersNumber = 1;
-        }
-        else if (videoHeight <= 360) {
-            activeSimulcastLayersNumber = 2;
-        }
-        else {
-            activeSimulcastLayersNumber = 3;
-        }
-        return activeSimulcastLayersNumber;
-    }
-}
-
-/**
- * A local camera stream.
- */
-class LocalCameraStream extends LocalVideoStream {
-}
-
-/**
- * A local display stream.
- */
-class LocalDisplayStream extends LocalVideoStream {
-}
-
-/**
- * A local microphone stream.
- */
-class LocalMicrophoneStream extends LocalAudioStream {
-}
-
-/**
- * A local system audio stream.
- */
-class LocalSystemAudioStream extends LocalAudioStream {
-}
-
-var _a$6;
-exports.RemoteMediaState = void 0;
-(function (RemoteMediaState) {
-    RemoteMediaState["Started"] = "started";
-    RemoteMediaState["Stopped"] = "stopped";
-})(exports.RemoteMediaState || (exports.RemoteMediaState = {}));
-exports.RemoteStreamEventNames = void 0;
-(function (RemoteStreamEventNames) {
-    RemoteStreamEventNames["MediaStateChange"] = "media-state-change";
-})(exports.RemoteStreamEventNames || (exports.RemoteStreamEventNames = {}));
-/**
- * A stream originating from a remote peer.
- */
-class _RemoteStream extends Stream {
-    /**
-     * Create a RemoteStream from the given values.
-     *
-     * @param stream - The initial output MediaStream for this Stream.
-     */
-    constructor(stream) {
-        super(stream);
-        this[_a$6] = new TypedEvent$1();
-        this.handleMediaStarted = this.handleMediaStarted.bind(this);
-        this.handleMediaStopped = this.handleMediaStopped.bind(this);
-        this.outputTrack.addEventListener('mute', this.handleMediaStopped);
-        this.outputTrack.addEventListener('unmute', this.handleMediaStarted);
-    }
-    /**
-     * @inheritdoc
-     */
-    handleMediaStarted() {
-        this[exports.RemoteStreamEventNames.MediaStateChange].emit(exports.RemoteMediaState.Started);
-    }
-    /**
-     * @inheritdoc
-     */
-    handleMediaStopped() {
-        this[exports.RemoteStreamEventNames.MediaStateChange].emit(exports.RemoteMediaState.Stopped);
-    }
-    /**
-     * Helper function to add event handlers to a MediaStreamTrack. See
-     * {@link Stream.addTrackHandlersForStreamEvents} for why this is useful.
-     *
-     * @param track - The MediaStreamTrack.
-     */
-    addTrackHandlersForRemoteStreamEvents(track) {
-        track.addEventListener('mute', this.handleMediaStopped);
-        track.addEventListener('unmute', this.handleMediaStarted);
-    }
-    /**
-     * @inheritdoc
-     */
-    addTrackHandlers(track) {
-        super.addTrackHandlers(track);
-        this.addTrackHandlersForRemoteStreamEvents(track);
-    }
-    /**
-     * @inheritdoc
-     */
-    removeTrackHandlers(track) {
-        super.removeTrackHandlers(track);
-        track.removeEventListener('mute', this.handleMediaStopped);
-        track.removeEventListener('unmute', this.handleMediaStarted);
-    }
-    /**
-     * Get whether the media on this stream has started or stopped.
-     *
-     * @returns The state of the media.
-     */
-    get mediaState() {
-        return this.outputTrack.muted ? exports.RemoteMediaState.Stopped : exports.RemoteMediaState.Started;
-    }
-    /**
-     * @inheritdoc
-     */
-    getSettings() {
-        return this.outputTrack.getSettings();
-    }
-    /**
-     * Replace the existing track on the output stream for a new track.
-     *
-     * @param newTrack - The track to add to the stream.
-     */
-    replaceTrack(newTrack) {
-        const oldTrack = this.outputTrack;
-        this.removeTrackHandlers(oldTrack);
-        this.outputStream.removeTrack(oldTrack);
-        this.outputStream.addTrack(newTrack);
-        this.addTrackHandlers(newTrack);
-        if (oldTrack.muted !== newTrack.muted) {
-            if (newTrack.muted) {
-                this.handleMediaStopped();
-            }
-            else {
-                this.handleMediaStarted();
-            }
-        }
-        // TODO: Chrome/React may not automatically refresh the media element with the new track when
-        // the output track has changed, so we may need to emit an event here if this is the case.
-        // this[StreamEventNames.OutputTrackChange].emit(newTrack);
-    }
-    /**
-     * @inheritdoc
-     */
-    stop() {
-        this.outputTrack.stop();
-        // calling stop() will not automatically emit Ended, so we emit it here
-        this[exports.StreamEventNames.Ended].emit();
-    }
-}
-_a$6 = exports.RemoteStreamEventNames.MediaStateChange;
+_a$6 = exports.RemoteStreamEventNames.MediaStateChange;
 const RemoteStream = AddEvents(_RemoteStream);
 
 var commonjsGlobal$3 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -2347,104 +2347,114 @@ function eventTargetAgnosticAddListener$2(emitter, name, listener, flags) {
   }
 }
 
-/**
- *  Typed event emitter class.
- */
-class EventEmitter$4 extends events$2.exports.EventEmitter {
-}
-
-// Overall connection state (based on the ICE and DTLS connection states)
-exports.ConnectionState = void 0;
-(function (ConnectionState) {
-    ConnectionState["New"] = "New";
-    ConnectionState["Closed"] = "Closed";
-    ConnectionState["Connected"] = "Connected";
-    ConnectionState["Connecting"] = "Connecting";
-    ConnectionState["Disconnected"] = "Disconnected";
-    ConnectionState["Failed"] = "Failed";
-})(exports.ConnectionState || (exports.ConnectionState = {}));
-var ConnectionStateEvents;
-(function (ConnectionStateEvents) {
-    ConnectionStateEvents["ConnectionStateChanged"] = "ConnectionStateChanged";
-})(ConnectionStateEvents || (ConnectionStateEvents = {}));
-/**
- * Listens on the connection's ICE and DTLS state changes and emits a single
- * event that summarizes all the internal states into a single overall connection state.
- */
-class ConnectionStateHandler extends EventEmitter$4 {
-    /**
-     * Creates an instance of ConnectionStateHandler.
-     *
-     * @param getCurrentStatesCallback - Callback for getting the connection state information
-     *                                   from the peer connection.
-     */
-    constructor(getCurrentStatesCallback) {
-        super();
-        this.getCurrentStatesCallback = getCurrentStatesCallback;
-        this.mediaConnectionState = this.evaluateMediaConnectionState();
-    }
-    /**
-     * Handler for connection state change.
-     */
-    onConnectionStateChange() {
-        this.handleAnyConnectionStateChange();
-    }
-    /**
-     * Handler for ice connection state change.
-     */
-    onIceConnectionStateChange() {
-        this.handleAnyConnectionStateChange();
-    }
-    /**
-     * Method to be called whenever ice connection or dtls connection state is changed.
-     */
-    handleAnyConnectionStateChange() {
-        const newConnectionState = this.evaluateMediaConnectionState();
-        if (newConnectionState !== this.mediaConnectionState) {
-            this.mediaConnectionState = newConnectionState;
-            this.emit(ConnectionStateEvents.ConnectionStateChanged, this.mediaConnectionState);
-        }
-    }
-    /**
-     * Evaluates the overall connection state based on peer connection's
-     * connectionState and iceConnectionState.
-     *
-     * @returns Current overall connection state.
-     */
-    evaluateMediaConnectionState() {
-        const { connectionState, iceState } = this.getCurrentStatesCallback();
-        const connectionStates = [connectionState, iceState];
-        let mediaConnectionState;
-        if (connectionStates.every((value) => value === 'new')) {
-            mediaConnectionState = exports.ConnectionState.New;
-        }
-        else if (connectionStates.some((value) => value === 'closed')) {
-            mediaConnectionState = exports.ConnectionState.Closed;
-        }
-        else if (connectionStates.some((value) => value === 'failed')) {
-            mediaConnectionState = exports.ConnectionState.Failed;
-        }
-        else if (connectionStates.some((value) => value === 'disconnected')) {
-            mediaConnectionState = exports.ConnectionState.Disconnected;
-        }
-        else if (connectionStates.every((value) => value === 'connected' || value === 'completed')) {
-            mediaConnectionState = exports.ConnectionState.Connected;
-        }
-        else {
-            mediaConnectionState = exports.ConnectionState.Connecting;
-        }
-        logger$3.log(`iceConnectionState=${iceState} connectionState=${connectionState} => ${mediaConnectionState}`);
-        return mediaConnectionState;
-    }
-    /**
-     * Gets current connection state.
-     *
-     * @returns Current connection state.
-     */
-    getConnectionState() {
-        return this.mediaConnectionState;
-    }
-}
+/**
+ *  Typed event emitter class.
+ */
+class EventEmitter$4 extends events$2.exports.EventEmitter {
+}
+
+// Overall connection state (based on the ICE and DTLS connection states)
+exports.ConnectionState = void 0;
+(function (ConnectionState) {
+    ConnectionState["New"] = "New";
+    ConnectionState["Closed"] = "Closed";
+    ConnectionState["Connected"] = "Connected";
+    ConnectionState["Connecting"] = "Connecting";
+    ConnectionState["Disconnected"] = "Disconnected";
+    ConnectionState["Failed"] = "Failed";
+})(exports.ConnectionState || (exports.ConnectionState = {}));
+var ConnectionStateEvents;
+(function (ConnectionStateEvents) {
+    ConnectionStateEvents["PeerConnectionStateChanged"] = "PeerConnectionStateChanged";
+    ConnectionStateEvents["IceConnectionStateChanged"] = "IceConnectionStateChanged";
+})(ConnectionStateEvents || (ConnectionStateEvents = {}));
+/**
+ * Listens on the connection's ICE and DTLS state changes and emits a single
+ * event that summarizes all the internal states into a single overall connection state.
+ */
+class ConnectionStateHandler extends EventEmitter$4 {
+    /**
+     * Creates an instance of ConnectionStateHandler.
+     *
+     * @param getCurrentStatesCallback - Callback for getting the connection state information
+     *                                   from the peer connection.
+     */
+    constructor(getCurrentStatesCallback) {
+        super();
+        this.getCurrentStatesCallback = getCurrentStatesCallback;
+    }
+    /**
+     * Handler for connection state change.
+     */
+    onPeerConnectionStateChange() {
+        const state = this.getPeerConnectionState();
+        this.emit(ConnectionStateEvents.PeerConnectionStateChanged, state);
+    }
+    /**
+     * Handler for ice connection state change.
+     */
+    onIceConnectionStateChange() {
+        const state = this.getIceConnectionState();
+        this.emit(ConnectionStateEvents.IceConnectionStateChanged, state);
+    }
+    /**
+     * Evaluates the overall connection state based on peer connection's
+     * connectionState and iceConnectionState.
+     *
+     * @returns Current overall connection state.
+     */
+    evaluateMediaConnectionState() {
+        const { connectionState, iceState } = this.getCurrentStatesCallback();
+        const connectionStates = [connectionState, iceState];
+        let mediaConnectionState;
+        if (connectionStates.every((value) => value === 'new')) {
+            mediaConnectionState = exports.ConnectionState.New;
+        }
+        else if (connectionStates.some((value) => value === 'closed')) {
+            mediaConnectionState = exports.ConnectionState.Closed;
+        }
+        else if (connectionStates.some((value) => value === 'failed')) {
+            mediaConnectionState = exports.ConnectionState.Failed;
+        }
+        else if (connectionStates.some((value) => value === 'disconnected')) {
+            mediaConnectionState = exports.ConnectionState.Disconnected;
+        }
+        else if (connectionStates.every((value) => value === 'connected' || value === 'completed')) {
+            mediaConnectionState = exports.ConnectionState.Connected;
+        }
+        else {
+            mediaConnectionState = exports.ConnectionState.Connecting;
+        }
+        logger$3.log(`iceConnectionState=${iceState} connectionState=${connectionState} => ${mediaConnectionState}`);
+        return mediaConnectionState;
+    }
+    /**
+     * Gets current connection state.
+     *
+     * @returns Current connection state.
+     */
+    getPeerConnectionState() {
+        const { connectionState } = this.getCurrentStatesCallback();
+        return connectionState;
+    }
+    /**
+     * Gets current ice connection state.
+     *
+     * @returns Current ice connection state.
+     */
+    getIceConnectionState() {
+        const { iceState } = this.getCurrentStatesCallback();
+        return iceState;
+    }
+    /**
+     * Gets current overall connection state.
+     *
+     * @returns Current overall connection state.
+     */
+    getConnectionState() {
+        return this.evaluateMediaConnectionState();
+    }
+}
 ConnectionStateHandler.Events = ConnectionStateEvents;
 
 /*
@@ -5802,320 +5812,345 @@ function adapterFactory({window} = {}, options = {
 
 adapterFactory({window: typeof window === 'undefined' ? undefined : window});
 
-/**
- * Creates an RTCPeerConnection.
- *
- * @param configuration - Config to the RTCPeerConnection constructor.
- * @returns An RTCPeerConnection instance.
- */
-function createRTCPeerConnection(configuration) {
-    return new RTCPeerConnection(configuration);
-}
-
-/**
- * A type-safe form of the DOMString used in the MediaStreamTrack.kind field.
- */
-exports.MediaStreamTrackKind = void 0;
-(function (MediaStreamTrackKind) {
-    MediaStreamTrackKind["Audio"] = "audio";
-    MediaStreamTrackKind["Video"] = "video";
-})(exports.MediaStreamTrackKind || (exports.MediaStreamTrackKind = {}));
-var PeerConnectionEvents;
-(function (PeerConnectionEvents) {
-    PeerConnectionEvents["IceGatheringStateChange"] = "icegatheringstatechange";
-    PeerConnectionEvents["IceCandidate"] = "icecandidate";
-    PeerConnectionEvents["ConnectionStateChange"] = "connectionstatechange";
-    PeerConnectionEvents["CreateOfferOnSuccess"] = "createofferonsuccess";
-    PeerConnectionEvents["CreateAnswerOnSuccess"] = "createansweronsuccess";
-    PeerConnectionEvents["SetLocalDescriptionOnSuccess"] = "setlocaldescriptiononsuccess";
-    PeerConnectionEvents["SetRemoteDescriptionOnSuccess"] = "setremotedescriptiononsuccess";
-})(PeerConnectionEvents || (PeerConnectionEvents = {}));
-/**
- * Manages a single RTCPeerConnection with the server.
- */
-class PeerConnection extends EventEmitter$4 {
-    /**
-     * Creates an instance of the RTCPeerConnection.
-     *
-     * @param configuration - Config to the RTCPeerConnection constructor.
-     */
-    constructor(configuration) {
-        super();
-        logger$3.log('PeerConnection init');
-        this.pc = createRTCPeerConnection(configuration);
-        this.connectionStateHandler = new ConnectionStateHandler(() => {
-            return {
-                connectionState: this.pc.connectionState,
-                iceState: this.pc.iceConnectionState,
-            };
-        });
-        this.connectionStateHandler.on(ConnectionStateHandler.Events.ConnectionStateChanged, (state) => {
-            this.emit(PeerConnection.Events.ConnectionStateChange, state);
-        });
-        // Forward the connection state related events to connection state handler
-        // eslint-disable-next-line jsdoc/require-jsdoc
-        this.pc.oniceconnectionstatechange = () => this.connectionStateHandler.onIceConnectionStateChange();
-        // eslint-disable-next-line jsdoc/require-jsdoc
-        this.pc.onconnectionstatechange = () => this.connectionStateHandler.onConnectionStateChange();
-        // Subscribe to underlying PeerConnection events and emit them via the EventEmitter
-        /* eslint-disable jsdoc/require-jsdoc */
-        this.pc.onicegatheringstatechange = (ev) => {
-            this.emit(PeerConnection.Events.IceGatheringStateChange, ev);
-        };
-        this.pc.onicecandidate = (ev) => {
-            this.emit(PeerConnection.Events.IceCandidate, ev);
-        };
-    }
-    /**
-     * Get the underlying RTCPeerConnection.
-     *
-     * @returns The underlying RTCPeerConnection.
-     */
-    getUnderlyingRTCPeerConnection() {
-        return this.pc;
-    }
-    /**
-     * Gets the overall connection state of the underlying RTCPeerConnection.
-     *
-     * @returns The underlying connection's overall state.
-     */
-    getConnectionState() {
-        return this.connectionStateHandler.getConnectionState();
-    }
-    /**
-     * Adds a new media track to the set of tracks which will be transmitted to the other peer.
-     *
-     * @param track - A MediaStreamTrack object representing the media track to add to the peer connection.
-     * @param streams - (Optional) One or more local MediaStream objects to which the track should be
-     *     added.
-     * @returns The RTCRtpSender object which will be used to transmit the media data, or null if
-     *     there is no underlying track when a track is added.
-     */
-    addTrack(track, ...streams) {
-        return this.pc.addTrack(track, ...streams);
-    }
-    /**
-     * Creates a new RTCRtpTransceiver and adds it to the set of transceivers associated with the
-     * PeerConnection.  Each transceiver represents a bidirectional stream, with both an RTCRtpSender
-     * and an RTCRtpReceiver associated with it.
-     *
-     * @param trackOrKind - A MediaStreamTrack to associate with the transceiver, or a string which is used
-     * as the kind of the receiver's track, and by extension the RTCRtpReceiver itself.
-     * @param init - Options that you may wish to specify when creating the new transceiver.
-     * @returns - The created RTCRtpTransceiver object.
-     */
-    addTransceiver(trackOrKind, init) {
-        return this.pc.addTransceiver(trackOrKind, init);
-    }
-    /**
-     * Tell the local end of the connection to stop sending media from the specified track, without
-     * actually removing the corresponding RTCRtpSender from the list of senders as reported by
-     * RTCPeerConnection.getSenders().  If the track is already stopped, or is not in the connection's
-     * senders list, the method has no effect.
-     *
-     * If the connection has already been negotiated (signalingState is set to 'stable'), it is marked
-     * as needing to be negotiated again; the remote peer won't experience the change until this
-     * negotiation occurs.  A negotiatedneeded event is sent to the RTCPeerConnection to let the local
-     * end know this negotiation must occur.
-     *
-     * @param sender - An RTCRtpSender specifying the sender to remove from the connection.
-     */
-    removeTrack(sender) {
-        this.pc.removeTrack(sender);
-    }
-    /**
-     * Creates a new data channel linked with the remote peer.
-     *
-     * @param label - A human-readable name for the channel.  May not be longer than 65,535 bytes.
-     * @param options - An object providing configuration options for the data channel.
-     * @returns An RTCDataChannel object.
-     */
-    createDataChannel(label, options) {
-        return this.pc.createDataChannel(label, options);
-    }
-    /**
-     * Creates an SDP answer to an offer received from a remote peer during the offer/answer
-     * negotiation of a WebRTC connection.
-     *
-     * @param options - (Optional) An object which contains options which customize the answer; this
-     *     is based on the RTCAnswerOptions dictionary.
-     * @returns A Promise whose fulfillment handler is called with an object conforming to the
-     *     RTCSessionDescriptionInit dictionary which contains the SDP answer to be delivered to the
-     *     other peer.
-     */
-    createAnswer(options) {
-        return __awaiter$2(this, void 0, void 0, function* () {
-            return this.pc.createAnswer(options).then((answer) => {
-                this.emit(PeerConnection.Events.CreateAnswerOnSuccess, answer);
-                return answer;
-            });
-        });
-    }
-    /**
-     * Initiates the creation of an SDP offer for the purpose of starting a new WebRTC connection to a
-     * remote peer.
-     *
-     * @param options - (Optional) An RTCOfferOptions dictionary providing options requested for the
-     *    offer.
-     * @returns A Promise whose fulfillment handler will receive an object conforming to the
-     *    RTCSessionDescriptionInit dictionary which contains the SDP describing the generated offer.
-     *    That received offer should be delivered through the signaling server to a remote peer.
-     */
-    createOffer(options) {
-        return __awaiter$2(this, void 0, void 0, function* () {
-            return this.pc.createOffer(options).then((offer) => {
-                this.emit(PeerConnection.Events.CreateOfferOnSuccess, offer);
-                return offer;
-            });
-        });
-    }
-    /**
-     * Changes the local description associated with the connection.
-     *
-     * @param description - An RTCSessionDescriptionInit or RTCSessionDescription which specifies the
-     *     configuration to be applied to the local end of the connection.
-     * @returns A Promise which is fulfilled once the value of RTCPeerConnection.localDescription is
-     *     successfully changed or rejected if the change cannot be applied.
-     */
-    setLocalDescription(description) {
-        var _a;
-        return __awaiter$2(this, void 0, void 0, function* () {
-            // In Firefox, setLocalDescription will not throw an error if an m-line has no codecs, even
-            // though it violates https://datatracker.ietf.org/doc/html/rfc8866. See
-            // https://bugzilla.mozilla.org/show_bug.cgi?id=1857612. So, we check the media lines here to
-            // preemptively throw an error on Firefox.
-            if (BrowserInfo$1.isFirefox()) {
-                (_a = description === null || description === void 0 ? void 0 : description.sdp) === null || _a === void 0 ? void 0 : _a.split(/(\r\n|\r|\n)/).filter((line) => line.startsWith('m')).forEach((mediaLine) => {
-                    if (mediaLine.trim().split(' ').length < 4) {
-                        throw new Error(`Invalid media line ${mediaLine}, expected at least 4 fields`);
-                    }
-                });
-            }
-            return this.pc.setLocalDescription(description).then(() => {
-                if (description) {
-                    this.emit(PeerConnection.Events.SetLocalDescriptionOnSuccess, description);
-                }
-            });
-        });
-    }
-    /**
-     * Sets the specified session description as the remote peer's current offer or answer.
-     *
-     * @param description - An RTCSessionDescriptionInit or RTCSessionDescription which specifies the
-     *     remote peer's current offer or answer.
-     * @returns A Promise which is fulfilled once the value of the connection's remoteDescription is
-     *     successfully changed or rejected if the change cannot be applied (for example, if the
-     *     specified description is incompatible with one or both of the peers on the connection).
-     */
-    setRemoteDescription(description) {
-        return __awaiter$2(this, void 0, void 0, function* () {
-            return this.pc.setRemoteDescription(description).then(() => {
-                this.emit(PeerConnection.Events.SetRemoteDescriptionOnSuccess, description);
-            });
-        });
-    }
-    /**
-     * Closes the current peer connection.
-     */
-    close() {
-        this.pc.close();
-    }
-    /**
-     * Get the local description from this PeerConnection.
-     *
-     * @returns An RTCSessionDescription representing the local description, or null if none has been set.
-     */
-    getLocalDescription() {
-        return this.pc.localDescription;
-    }
-    /**
-     * Get the remote description from this PeerConnection.
-     *
-     * @returns An RTCSessionDescription representing the remote description, or null if none has been set.
-     */
-    getRemoteDescription() {
-        return this.pc.remoteDescription;
-    }
-    /**
-     * Returns an array of RTCRtpSender objects, each of which represents the RTP sender responsible
-     * for transmitting one track's data.  A sender object provides methods and properties for
-     * examining and controlling the encoding and transmission of the track's data.
-     *
-     * @returns An array of RTCRtpSender objects, one for each track on the connection.  The array is
-     * empty if there are no RTP senders on the connection.
-     */
-    getSenders() {
-        return this.pc.getSenders();
-    }
-    /**
-     * Get the list of RTCRtpTransceiver objects being used to send and receive data on the
-     * connection.
-     *
-     * @returns - An array of the RTCRtpTransceiver objects representing the transceivers handling
-     * sending and receiving all media on the PeerConnection.  The list is in the order in which the
-     * transceivers were added to the connection.
-     */
-    getTransceivers() {
-        return this.pc.getTransceivers();
-    }
-    /**
-     * Get statistics about either the overall connection or about the specified MediaStreamTrack.
-     *
-     * @param selector - An optional MediaStreamTrack for which to gather statistics. If not provided,
-     * statistics will be gathered for the entire underlying RTCPeerConnection.
-     * @returns - A Promise which resolves with an RTCStatsReport object providing connection
-     * statistics.
-     */
-    getStats(selector) {
-        return this.pc.getStats(selector);
-    }
-    /**
-     * Returns a string that describes the connections' ICE gathering state.
-     *
-     * @returns - The ICE gathering state.
-     */
-    get iceGatheringState() {
-        return this.pc.iceGatheringState;
-    }
-    /**
-     * Returns the type of a connection that has been established.
-     *
-     * @returns The connection type which would be `ConnectionType`.
-     */
-    getCurrentConnectionType() {
-        var _a;
-        return __awaiter$2(this, void 0, void 0, function* () {
-            // make sure this method only can be called when the ice connection is established;
-            const isIceConnected = this.pc.iceConnectionState === 'connected' || this.pc.iceConnectionState === 'completed';
-            if (!isIceConnected) {
-                throw new Error('Ice connection is not established');
-            }
-            const succeededLocalCandidateIds = new Set();
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const localCandidateStatsReports = [];
-            (yield this.pc.getStats()).forEach((report) => {
-                var _a;
-                // collect all local candidate ids from `candidate-pair` stats reports with `succeeded` state.
-                if (report.type === 'candidate-pair' && ((_a = report.state) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'succeeded') {
-                    succeededLocalCandidateIds.add(report.localCandidateId);
-                }
-                // collect all `local-candidate` stats.
-                if (report.type === 'local-candidate') {
-                    localCandidateStatsReports.push(report);
-                }
-            });
-            // find the `local-candidate` stats which report id contains in `succeededLocalCandidateIds`.
-            const localCandidate = localCandidateStatsReports.find((report) => succeededLocalCandidateIds.has(report.id));
-            if (!localCandidate) {
-                return 'unknown';
-            }
-            if (localCandidate.relayProtocol) {
-                return `TURN-${localCandidate.relayProtocol.toUpperCase()}`;
-            }
-            return (_a = localCandidate.protocol) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-        });
-    }
-}
+/**
+ * Creates an RTCPeerConnection.
+ *
+ * @param configuration - Config to the RTCPeerConnection constructor.
+ * @returns An RTCPeerConnection instance.
+ */
+function createRTCPeerConnection(configuration) {
+    return new RTCPeerConnection(configuration);
+}
+
+/**
+ * A type-safe form of the DOMString used in the MediaStreamTrack.kind field.
+ */
+exports.MediaStreamTrackKind = void 0;
+(function (MediaStreamTrackKind) {
+    MediaStreamTrackKind["Audio"] = "audio";
+    MediaStreamTrackKind["Video"] = "video";
+})(exports.MediaStreamTrackKind || (exports.MediaStreamTrackKind = {}));
+var PeerConnectionEvents;
+(function (PeerConnectionEvents) {
+    PeerConnectionEvents["IceGatheringStateChange"] = "icegatheringstatechange";
+    PeerConnectionEvents["IceCandidate"] = "icecandidate";
+    PeerConnectionEvents["IceCandidateError"] = "icecandidateerror";
+    PeerConnectionEvents["PeerConnectionStateChange"] = "peerconnectionstatechange";
+    PeerConnectionEvents["IceConnectionStateChange"] = "iceconnectionstatechange";
+    PeerConnectionEvents["CreateOfferOnSuccess"] = "createofferonsuccess";
+    PeerConnectionEvents["CreateAnswerOnSuccess"] = "createansweronsuccess";
+    PeerConnectionEvents["SetLocalDescriptionOnSuccess"] = "setlocaldescriptiononsuccess";
+    PeerConnectionEvents["SetRemoteDescriptionOnSuccess"] = "setremotedescriptiononsuccess";
+})(PeerConnectionEvents || (PeerConnectionEvents = {}));
+/**
+ * Manages a single RTCPeerConnection with the server.
+ */
+class PeerConnection extends EventEmitter$4 {
+    /**
+     * Creates an instance of the RTCPeerConnection.
+     *
+     * @param configuration - Config to the RTCPeerConnection constructor.
+     */
+    constructor(configuration) {
+        super();
+        logger$3.log('PeerConnection init');
+        this.pc = createRTCPeerConnection(configuration);
+        this.connectionStateHandler = new ConnectionStateHandler(() => {
+            return {
+                connectionState: this.pc.connectionState,
+                iceState: this.pc.iceConnectionState,
+            };
+        });
+        this.connectionStateHandler.on(ConnectionStateHandler.Events.PeerConnectionStateChanged, (state) => {
+            this.emit(PeerConnection.Events.PeerConnectionStateChange, state);
+        });
+        this.connectionStateHandler.on(ConnectionStateHandler.Events.IceConnectionStateChanged, (state) => {
+            this.emit(PeerConnection.Events.IceConnectionStateChange, state);
+        });
+        // Forward the connection state related events to connection state handler
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        this.pc.oniceconnectionstatechange = () => this.connectionStateHandler.onIceConnectionStateChange();
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        this.pc.onconnectionstatechange = () => this.connectionStateHandler.onPeerConnectionStateChange();
+        // Subscribe to underlying PeerConnection events and emit them via the EventEmitter
+        /* eslint-disable jsdoc/require-jsdoc */
+        this.pc.onicegatheringstatechange = (ev) => {
+            this.emit(PeerConnection.Events.IceGatheringStateChange, ev);
+        };
+        /* eslint-disable jsdoc/require-jsdoc */
+        this.pc.onicecandidate = (ev) => {
+            this.emit(PeerConnection.Events.IceCandidate, ev);
+        };
+        this.pc.onicecandidateerror = (ev) => {
+            this.emit(PeerConnection.Events.IceCandidateError, ev);
+        };
+    }
+    /**
+     * Get the underlying RTCPeerConnection.
+     *
+     * @returns The underlying RTCPeerConnection.
+     */
+    getUnderlyingRTCPeerConnection() {
+        return this.pc;
+    }
+    /**
+     * Gets the overall connection state of the underlying RTCPeerConnection.
+     *
+     * @returns The underlying connection's overall state.
+     */
+    getConnectionState() {
+        return this.connectionStateHandler.getConnectionState();
+    }
+    /**
+     * Gets the connection state of the underlying RTCPeerConnection.
+     *
+     * @returns The underlying RTCPeerConnection connection state.
+     */
+    getPeerConnectionState() {
+        return this.connectionStateHandler.getPeerConnectionState();
+    }
+    /**
+     * Gets the ICE connection state of the underlying RTCPeerConnection.
+     *
+     * @returns The underlying RTCPeerConnection ICE connection state.
+     */
+    getIceConnectionState() {
+        return this.connectionStateHandler.getIceConnectionState();
+    }
+    /**
+     * Adds a new media track to the set of tracks which will be transmitted to the other peer.
+     *
+     * @param track - A MediaStreamTrack object representing the media track to add to the peer connection.
+     * @param streams - (Optional) One or more local MediaStream objects to which the track should be
+     *     added.
+     * @returns The RTCRtpSender object which will be used to transmit the media data, or null if
+     *     there is no underlying track when a track is added.
+     */
+    addTrack(track, ...streams) {
+        return this.pc.addTrack(track, ...streams);
+    }
+    /**
+     * Creates a new RTCRtpTransceiver and adds it to the set of transceivers associated with the
+     * PeerConnection.  Each transceiver represents a bidirectional stream, with both an RTCRtpSender
+     * and an RTCRtpReceiver associated with it.
+     *
+     * @param trackOrKind - A MediaStreamTrack to associate with the transceiver, or a string which is used
+     * as the kind of the receiver's track, and by extension the RTCRtpReceiver itself.
+     * @param init - Options that you may wish to specify when creating the new transceiver.
+     * @returns - The created RTCRtpTransceiver object.
+     */
+    addTransceiver(trackOrKind, init) {
+        return this.pc.addTransceiver(trackOrKind, init);
+    }
+    /**
+     * Tell the local end of the connection to stop sending media from the specified track, without
+     * actually removing the corresponding RTCRtpSender from the list of senders as reported by
+     * RTCPeerConnection.getSenders().  If the track is already stopped, or is not in the connection's
+     * senders list, the method has no effect.
+     *
+     * If the connection has already been negotiated (signalingState is set to 'stable'), it is marked
+     * as needing to be negotiated again; the remote peer won't experience the change until this
+     * negotiation occurs.  A negotiatedneeded event is sent to the RTCPeerConnection to let the local
+     * end know this negotiation must occur.
+     *
+     * @param sender - An RTCRtpSender specifying the sender to remove from the connection.
+     */
+    removeTrack(sender) {
+        this.pc.removeTrack(sender);
+    }
+    /**
+     * Creates a new data channel linked with the remote peer.
+     *
+     * @param label - A human-readable name for the channel.  May not be longer than 65,535 bytes.
+     * @param options - An object providing configuration options for the data channel.
+     * @returns An RTCDataChannel object.
+     */
+    createDataChannel(label, options) {
+        return this.pc.createDataChannel(label, options);
+    }
+    /**
+     * Creates an SDP answer to an offer received from a remote peer during the offer/answer
+     * negotiation of a WebRTC connection.
+     *
+     * @param options - (Optional) An object which contains options which customize the answer; this
+     *     is based on the RTCAnswerOptions dictionary.
+     * @returns A Promise whose fulfillment handler is called with an object conforming to the
+     *     RTCSessionDescriptionInit dictionary which contains the SDP answer to be delivered to the
+     *     other peer.
+     */
+    createAnswer(options) {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            return this.pc.createAnswer(options).then((answer) => {
+                this.emit(PeerConnection.Events.CreateAnswerOnSuccess, answer);
+                return answer;
+            });
+        });
+    }
+    /**
+     * Initiates the creation of an SDP offer for the purpose of starting a new WebRTC connection to a
+     * remote peer.
+     *
+     * @param options - (Optional) An RTCOfferOptions dictionary providing options requested for the
+     *    offer.
+     * @returns A Promise whose fulfillment handler will receive an object conforming to the
+     *    RTCSessionDescriptionInit dictionary which contains the SDP describing the generated offer.
+     *    That received offer should be delivered through the signaling server to a remote peer.
+     */
+    createOffer(options) {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            return this.pc.createOffer(options).then((offer) => {
+                this.emit(PeerConnection.Events.CreateOfferOnSuccess, offer);
+                return offer;
+            });
+        });
+    }
+    /**
+     * Changes the local description associated with the connection.
+     *
+     * @param description - An RTCSessionDescriptionInit or RTCSessionDescription which specifies the
+     *     configuration to be applied to the local end of the connection.
+     * @returns A Promise which is fulfilled once the value of RTCPeerConnection.localDescription is
+     *     successfully changed or rejected if the change cannot be applied.
+     */
+    setLocalDescription(description) {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            var _a;
+            // In Firefox, setLocalDescription will not throw an error if an m-line has no codecs, even
+            // though it violates https://datatracker.ietf.org/doc/html/rfc8866. See
+            // https://bugzilla.mozilla.org/show_bug.cgi?id=1857612. So, we check the media lines here to
+            // preemptively throw an error on Firefox.
+            if (BrowserInfo$1.isFirefox()) {
+                (_a = description === null || description === void 0 ? void 0 : description.sdp) === null || _a === void 0 ? void 0 : _a.split(/(\r\n|\r|\n)/).filter((line) => line.startsWith('m')).forEach((mediaLine) => {
+                    if (mediaLine.trim().split(' ').length < 4) {
+                        throw new Error(`Invalid media line ${mediaLine}, expected at least 4 fields`);
+                    }
+                });
+            }
+            return this.pc.setLocalDescription(description).then(() => {
+                if (description) {
+                    this.emit(PeerConnection.Events.SetLocalDescriptionOnSuccess, description);
+                }
+            });
+        });
+    }
+    /**
+     * Sets the specified session description as the remote peer's current offer or answer.
+     *
+     * @param description - An RTCSessionDescriptionInit or RTCSessionDescription which specifies the
+     *     remote peer's current offer or answer.
+     * @returns A Promise which is fulfilled once the value of the connection's remoteDescription is
+     *     successfully changed or rejected if the change cannot be applied (for example, if the
+     *     specified description is incompatible with one or both of the peers on the connection).
+     */
+    setRemoteDescription(description) {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            return this.pc.setRemoteDescription(description).then(() => {
+                this.emit(PeerConnection.Events.SetRemoteDescriptionOnSuccess, description);
+            });
+        });
+    }
+    /**
+     * Closes the current peer connection.
+     */
+    close() {
+        this.pc.close();
+    }
+    /**
+     * Get the local description from this PeerConnection.
+     *
+     * @returns An RTCSessionDescription representing the local description, or null if none has been set.
+     */
+    getLocalDescription() {
+        return this.pc.localDescription;
+    }
+    /**
+     * Get the remote description from this PeerConnection.
+     *
+     * @returns An RTCSessionDescription representing the remote description, or null if none has been set.
+     */
+    getRemoteDescription() {
+        return this.pc.remoteDescription;
+    }
+    /**
+     * Returns an array of RTCRtpSender objects, each of which represents the RTP sender responsible
+     * for transmitting one track's data.  A sender object provides methods and properties for
+     * examining and controlling the encoding and transmission of the track's data.
+     *
+     * @returns An array of RTCRtpSender objects, one for each track on the connection.  The array is
+     * empty if there are no RTP senders on the connection.
+     */
+    getSenders() {
+        return this.pc.getSenders();
+    }
+    /**
+     * Get the list of RTCRtpTransceiver objects being used to send and receive data on the
+     * connection.
+     *
+     * @returns - An array of the RTCRtpTransceiver objects representing the transceivers handling
+     * sending and receiving all media on the PeerConnection.  The list is in the order in which the
+     * transceivers were added to the connection.
+     */
+    getTransceivers() {
+        return this.pc.getTransceivers();
+    }
+    /**
+     * Get statistics about either the overall connection or about the specified MediaStreamTrack.
+     *
+     * @param selector - An optional MediaStreamTrack for which to gather statistics. If not provided,
+     * statistics will be gathered for the entire underlying RTCPeerConnection.
+     * @returns - A Promise which resolves with an RTCStatsReport object providing connection
+     * statistics.
+     */
+    getStats(selector) {
+        return this.pc.getStats(selector);
+    }
+    /**
+     * Returns a string that describes the connections' ICE gathering state.
+     *
+     * @returns - The ICE gathering state.
+     */
+    get iceGatheringState() {
+        return this.pc.iceGatheringState;
+    }
+    /**
+     * Returns the type of a connection that has been established.
+     *
+     * @returns The connection type which would be `ConnectionType`.
+     */
+    getCurrentConnectionType() {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            var _a;
+            // make sure this method only can be called when the ice connection is established;
+            const isIceConnected = this.pc.iceConnectionState === 'connected' || this.pc.iceConnectionState === 'completed';
+            if (!isIceConnected) {
+                throw new Error('Ice connection is not established');
+            }
+            const succeededLocalCandidateIds = new Set();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const localCandidateStatsReports = [];
+            (yield this.pc.getStats()).forEach((report) => {
+                var _a;
+                // collect all local candidate ids from `candidate-pair` stats reports with `succeeded` state.
+                if (report.type === 'candidate-pair' && ((_a = report.state) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'succeeded') {
+                    succeededLocalCandidateIds.add(report.localCandidateId);
+                }
+                // collect all `local-candidate` stats.
+                if (report.type === 'local-candidate') {
+                    localCandidateStatsReports.push(report);
+                }
+            });
+            // find the `local-candidate` stats which report id contains in `succeededLocalCandidateIds`.
+            const localCandidate = localCandidateStatsReports.find((report) => succeededLocalCandidateIds.has(report.id));
+            if (!localCandidate) {
+                return 'unknown';
+            }
+            if (localCandidate.relayProtocol) {
+                return `TURN-${localCandidate.relayProtocol.toUpperCase()}`;
+            }
+            return (_a = localCandidate.protocol) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+        });
+    }
+}
 PeerConnection.Events = PeerConnectionEvents;
 
 var commonjsGlobal$2 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -9505,10 +9540,6 @@ const simulcastMaxFrameSizes = {
 };
 
 class JmpLine extends Line {
-    constructor(versions) {
-        super();
-        this.versions = versions;
-    }
     static fromSdpLine(line) {
         if (!JmpLine.regex.test(line)) {
             return undefined;
@@ -9517,6 +9548,10 @@ class JmpLine extends Line {
         const versions = tokens[1].split(',').filter((v) => v.length);
         return new JmpLine(versions);
     }
+    constructor(versions) {
+        super();
+        this.versions = versions;
+    }
     toSdpLine() {
         return `a=jmp:${this.versions.join(',')}`;
     }
@@ -14702,13 +14737,15 @@ exports.MultistreamConnectionEventNames = void 0;
     MultistreamConnectionEventNames["VideoSourceCountUpdate"] = "video-source-count-update";
     MultistreamConnectionEventNames["AudioSourceCountUpdate"] = "audio-source-count-update";
     MultistreamConnectionEventNames["ActiveSpeakerNotification"] = "active-speaker-notification";
-    MultistreamConnectionEventNames["ConnectionStateUpdate"] = "connection-state-update";
+    MultistreamConnectionEventNames["PeerConnectionStateUpdate"] = "peer-connection-state-update";
+    MultistreamConnectionEventNames["IceConnectionStateUpdate"] = "ice-connection-state-update";
     MultistreamConnectionEventNames["IceGatheringStateUpdate"] = "ice-gathering-state-update";
     MultistreamConnectionEventNames["NegotiationNeeded"] = "negotiation-needed";
     MultistreamConnectionEventNames["CreateOfferOnSuccess"] = "createofferonsuccess";
     MultistreamConnectionEventNames["CreateAnswerOnSuccess"] = "createansweronsuccess";
     MultistreamConnectionEventNames["SetLocalDescriptionOnSuccess"] = "setlocaldescriptiononsuccess";
     MultistreamConnectionEventNames["SetRemoteDescriptionOnSuccess"] = "setremotedescriptiononsuccess";
+    MultistreamConnectionEventNames["IceCandidateError"] = "icecandidateerror";
 })(exports.MultistreamConnectionEventNames || (exports.MultistreamConnectionEventNames = {}));
 const defaultMultistreamConnectionOptions = {
     disableSimulcast: BrowserInfo.isFirefox(),
@@ -14756,8 +14793,11 @@ class MultistreamConnection extends EventEmitter$2 {
         this.createDataChannel();
     }
     propagatePeerConnectionEvents() {
-        this.pc.on(PeerConnection.Events.ConnectionStateChange, (state) => {
-            this.emit(exports.MultistreamConnectionEventNames.ConnectionStateUpdate, state);
+        this.pc.on(PeerConnection.Events.PeerConnectionStateChange, (state) => {
+            this.emit(exports.MultistreamConnectionEventNames.PeerConnectionStateUpdate, state);
+        });
+        this.pc.on(PeerConnection.Events.IceConnectionStateChange, (state) => {
+            this.emit(exports.MultistreamConnectionEventNames.IceConnectionStateUpdate, state);
         });
         this.pc.on(PeerConnection.Events.CreateOfferOnSuccess, (description) => {
             this.emit(exports.MultistreamConnectionEventNames.CreateOfferOnSuccess, description);
@@ -14774,10 +14814,22 @@ class MultistreamConnection extends EventEmitter$2 {
         this.pc.on(PeerConnection.Events.IceGatheringStateChange, () => {
             this.emit(exports.MultistreamConnectionEventNames.IceGatheringStateUpdate, this.getIceGatheringState());
         });
+        this.pc.on(PeerConnection.Events.IceCandidateError, (error) => {
+            this.emit(exports.MultistreamConnectionEventNames.IceCandidateError, error);
+        });
     }
     getConnectionState() {
         return this.pc.getConnectionState();
     }
+    getPeerConnectionState() {
+        return this.pc.getPeerConnectionState();
+    }
+    getIceConnectionState() {
+        return this.pc.getIceConnectionState();
+    }
+    getCurrentConnectionType() {
+        return this.pc.getCurrentConnectionType();
+    }
     getIceGatheringState() {
         return this.pc.iceGatheringState;
     }