@opentok/client 2.35.0-alpha.23 → 2.35.0-alpha.25

package/dist/js/opentok.js

@@ -1,11 +1,11 @@
 /**
- * @license OpenTok.js 2.35.0 b3cd7abe5
+ * @license OpenTok.js 2.35.0 a2a77b84b
  *
  * Copyright (c) 2010-2026 TokBox, Inc.
  * Subject to the applicable Software Development Kit (SDK) License Agreement:
  * https://www.vonage.com/legal/communications-apis/terms-of-use/
  *
- * Date: Wed, 13 May 2026 13:03:31 GMT
+ * Date: Tue, 19 May 2026 10:58:40 GMT
  */
 
 (function webpackUniversalModuleDefinition(root, factory) {
@@ -4628,43 +4628,58 @@ const _deviceHelpers = (0, _deviceHelpers2.default)(),
 
 /**
  * Enumerates the audio input devices (such as microphones) and video input devices
- * (cameras) available to the browser.
+ * (cameras) available to the browser. This returns a promise containing the array of
+ * devices. Each object has three properties: <code>kind</code>,
+ * <code>deviceId</code>, and <code>label</code>, each of which are strings.
  * <p>
- * The array of devices is passed in as the <code>devices</code> parameter of
- * the <code>callback</code> function passed into the method.
+ * The <code>kind</code> property is set to <code>"audioInput"</code> for audio input
+ * devices or <code>"videoInput"</code> for video input devices.
+ * <p>
+ * The <code>deviceId</code> property is a unique ID for the device. You can pass
+ * the <code>deviceId</code> in as the <code>audioSource</code> or <code>videoSource</code>
+ * property of the <code>options</code> parameter of the
+ * <a href="#initPublisher">OT.initPublisher()</a> method.
+ * <p>
+ * The <code>label</code> property identifies the device. The <code>label</code>
+ * property is set to an empty string if the user has not previously granted access to
+ * a camera and microphone.
  *
- * @param callback {Function} The callback function invoked when the list of devices
+ * @param callback {Function} Optional callback function invoked when the list of devices
  * devices is available. This function takes two parameters:
  * <ul>
  *   <li><code>error</code> &mdash; This is set to an error object when
  *   there is an error in calling this method; it is set to <code>null</code>
  *   when the call succeeds.</li>
- *
  *   <li><p><code>devices</code> &mdash; An array of objects corresponding to
- *   available microphones and cameras. Each object has three properties: <code>kind</code>,
- *   <code>deviceId</code>, and <code>label</code>, each of which are strings.
- *   <p>
- *   The <code>kind</code> property is set to <code>"audioInput"</code> for audio input
- *   devices or <code>"videoInput"</code> for video input devices.
- *   <p>
- *   The <code>deviceId</code> property is a unique ID for the device. You can pass
- *   the <code>deviceId</code> in as the <code>audioSource</code> or <code>videoSource</code>
- *   property of the <code>options</code> parameter of the
- *   <a href="#initPublisher">OT.initPublisher()</a> method.
- *   <p>
- *   The <code>label</code> property identifies the device. The <code>label</code>
- *   property is set to an empty string if the user has not previously granted access to
- *   a camera and microphone.</li>
+ *   available microphones and cameras.
+ *   </li>
  * </ul>
  * <i>Note:</i> The browser may limit the number of returned audio and video input devices
  * to one each before the user has granted access to a camera or microphone.
  *
+ * @returns {Promise<Device[]>} A promise containing the list of devices
+ *
  * @see <a href="#initPublisher">OT.initPublisher()</a>
  * @method OT.getDevices
  * @memberof OT
  */
 function getDevices(callback) {
-  getInputMediaDevices().then(devices => callback(undefined, devices), callback);
+  const hasCallback = typeof callback === 'function';
+  const promise = getInputMediaDevices().then(devices => {
+    if (hasCallback) {
+      callback(undefined, devices);
+    }
+    return devices;
+  }, err => {
+    if (hasCallback) {
+      callback(err);
+    }
+    throw err;
+  });
+  if (hasCallback) {
+    promise.catch(() => {});
+  }
+  return promise;
 }
 
 /***/ }),
@@ -23853,7 +23868,7 @@ function SubscriberFactory(_ref2) {
       }
       (0, _updateTrackOnStream.default)(mediaStream, oldTrack, newTrack);
     };
-    const _audioConnector = createAudioConnector(webRTCStreams, {
+    const _audioConnector = createAudioConnector({
       updateTrackOnStream
     });
 
@@ -24992,7 +25007,7 @@ function SubscriberFactory(_ref2) {
               }
               _context8.prev = 2;
               _context8.next = 5;
-              return _audioConnector.applyAudioConnectorOnRoutedToRelayedTransition();
+              return _audioConnector.resetAndApplyAudioConnector(_webRTCStream);
             case 5:
               _logPendingSetAudioMediaProcessorConnector('Success', 'Audio connector applied on routed to relayed transition.');
               _context8.next = 11;
@@ -25685,7 +25700,7 @@ function SubscriberFactory(_ref2) {
               }
               _context15.prev = 10;
               _context15.next = 13;
-              return _audioConnector.applyAudioConnectorOnRelayedToRoutedTransition();
+              return _audioConnector.setAudioMediaProcessorConnector(_webRTCStream);
             case 13:
               _logPendingSetAudioMediaProcessorConnector('Success', 'Audio connector applied on relayed to routed transition.');
               _context15.next = 19;
@@ -25702,13 +25717,18 @@ function SubscriberFactory(_ref2) {
               _context15.next = 21;
               return bindWebRTCStream(_webRTCStream);
             case 21:
-              _context15.next = 23;
+              // Update the active source stream ID immediately to prevent any concurrent code
+              // (e.g. setAudioMediaProcessorConnector) from applying operations to the outgoing
+              // P2P stream after the MANTIS stream has been bound to the video element.
+              _activeSourceStreamId = 'MANTIS';
+              networkConditionChecker.setSourceStreamId(_activeSourceStreamId);
+
+              // remove and close p2p connection
+              _context15.next = 25;
               return removePeerConnectionBySourceStreamId('P2P');
-            case 23:
+            case 25:
               // Keep the loading spinner hidden so that the transition looks transparent.
               _widgetView.loading(false);
-              _activeSourceStreamId = 'MANTIS';
-              networkConditionChecker.setSourceStreamId(_activeSourceStreamId);
 
               // remove webRTCStream
               removeWebRTCStream('P2P');
@@ -26345,7 +26365,7 @@ function SubscriberFactory(_ref2) {
           _setAudioMediaProcessorConnector();
         } else {
           try {
-            _audioConnector.resetAudioStreamAndTrack(_activeSourceStreamId);
+            _audioConnector.resetAudioStreamAndTrack();
           } catch (error) {
             logAnalyticsEvent('subscribeToAudio', 'Failure', {
               message: `Error resetting track: ${error.message}`
@@ -27649,19 +27669,18 @@ function SubscriberFactory(_ref2) {
               logAnalyticsEvent('setAudioMediaProcessorConnector', 'Attempt', {
                 message: mediaProcessorConnector ? 'setting the connector' : 'clearing the connector'
               });
-              _audioConnector == null ? void 0 : _audioConnector.clearAudioMediaProcessorConnector(_activeSourceStreamId);
+              _audioConnector == null ? void 0 : _audioConnector.clearAudioMediaProcessorConnector();
               if (mediaProcessorConnector) {
-                _context31.next = 6;
+                _context31.next = 5;
                 break;
               }
-              _audioConnector == null ? void 0 : _audioConnector.resetAudioStreamAndTrack();
               logAnalyticsEvent('setAudioMediaProcessorConnector', 'Success', {
                 message: 'clearing the connector'
               });
               return _context31.abrupt("return");
-            case 6:
+            case 5:
               if (_mediaProcessorConnector.default.isValidConnector(mediaProcessorConnector)) {
-                _context31.next = 11;
+                _context31.next = 10;
                 break;
               }
               message = 'Tried to set invalid MediaProcessorConnector';
@@ -27670,12 +27689,12 @@ function SubscriberFactory(_ref2) {
                 message
               });
               throw otError(_Errors.default.INVALID_PARAMETER, new Error(`setAudioVideoMediaProcessorConnector: ${message}`));
-            case 11:
+            case 10:
               _audioConnector.initializeConnector(mediaProcessorConnector);
               _pendingSetAudioMediaProcessorConnector = true;
               isTransitioning = amrState.isTransitioning();
               if (!(isTransitioning || !_isSubscribingToAudio)) {
-                _context31.next = 17;
+                _context31.next = 16;
                 break;
               }
               // After the transition finishes, or when re-subscribing to audio, we will apply the
@@ -27685,10 +27704,10 @@ function SubscriberFactory(_ref2) {
                 subscribingToAudio: _isSubscribingToAudio
               });
               return _context31.abrupt("return");
-            case 17:
+            case 16:
               _audioConnector.resetAudioStreamAndTrack();
               _setAudioMediaProcessorConnector();
-            case 19:
+            case 18:
             case "end":
               return _context31.stop();
           }
@@ -27703,7 +27722,7 @@ function SubscriberFactory(_ref2) {
         return _regenerator.default.wrap(function _callee32$(_context32) {
           while (1) switch (_context32.prev = _context32.next) {
             case 0:
-              if (webRTCStreams[_activeSourceStreamId]) {
+              if (_webRTCStream) {
                 _context32.next = 2;
                 break;
               }
@@ -27711,7 +27730,7 @@ function SubscriberFactory(_ref2) {
             case 2:
               _context32.prev = 2;
               _context32.next = 5;
-              return _audioConnector == null ? void 0 : _audioConnector.setAudioMediaProcessorConnector(_activeSourceStreamId);
+              return _audioConnector == null ? void 0 : _audioConnector.setAudioMediaProcessorConnector(_webRTCStream);
             case 5:
               _logPendingSetAudioMediaProcessorConnector('Success');
               _context32.next = 13;
@@ -29218,6 +29237,8 @@ function RaptorSocketFactory(deps) {
 var _interopRequireDefault = __webpack_require__(95709);
 exports.__esModule = true;
 exports["default"] = getUserMediaFactory;
+var _regenerator = _interopRequireDefault(__webpack_require__(92207));
+var _asyncToGenerator2 = _interopRequireDefault(__webpack_require__(79092));
 var _assign = _interopRequireDefault(__webpack_require__(86139));
 var _isObject = _interopRequireDefault(__webpack_require__(23805));
 var _eventing = _interopRequireDefault(__webpack_require__(12607));
@@ -29505,23 +29526,41 @@ function getUserMediaFactory(deps) {
       // it when creating `finalized` above.
       const error = parseErrorEvent(browserError);
       if (error.name === Errors.UNABLE_TO_CAPTURE_SCREEN) {
-        return new Promise((resolve, reject) => {
-          screenSharing.checkCapability(response => {
-            if (response.extensionRequired === 'chrome') {
-              if (response.extensionRegistered && !response.extensionInstalled) {
-                const newErr = otError(Errors.SCREEN_SHARING_EXTENSION_NOT_INSTALLED, error);
-                newErr.message = 'Screen sharing extension not installed see https://tokbox.com/developer/guides/screen-sharing/js/#chrome-extension';
-                reject(newErr);
-              } else if (!response.extensionRegistered) {
-                const newErr = otError(Errors.SCREEN_SHARING_EXTENSION_NOT_REGISTERED, error);
-                newErr.message = 'Screen sharing extension not registered see https://tokbox.com/developer/guides/screen-sharing/js/#chrome-extension';
-                reject(newErr);
+        return new Promise( /*#__PURE__*/function () {
+          var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(_, reject) {
+            var response, newErr;
+            return _regenerator.default.wrap(function _callee$(_context2) {
+              while (1) switch (_context2.prev = _context2.next) {
+                case 0:
+                  _context2.next = 2;
+                  return screenSharing.checkCapability();
+                case 2:
+                  response = _context2.sent;
+                  if (response.extensionRequired === 'chrome') {
+                    if (response.extensionRegistered && !response.extensionInstalled) {
+                      newErr = otError(Errors.SCREEN_SHARING_EXTENSION_NOT_INSTALLED, error);
+                      newErr.message = 'Screen sharing extension not installed see https://tokbox.com/developer/guides/screen-sharing/js/#chrome-extension';
+                      reject(newErr);
+                    } else if (!response.extensionRegistered) {
+                      newErr = otError(Errors.SCREEN_SHARING_EXTENSION_NOT_REGISTERED, error);
+                      newErr.message = 'Screen sharing extension not registered see https://tokbox.com/developer/guides/screen-sharing/js/#chrome-extension';
+                      reject(newErr);
+                    } else {
+                      reject(error);
+                    }
+                  } else {
+                    reject(error);
+                  }
+                case 4:
+                case "end":
+                  return _context2.stop();
               }
-            } else {
-              reject(error);
-            }
-          });
-        });
+            }, _callee);
+          }));
+          return function (_x, _x2) {
+            return _ref.apply(this, arguments);
+          };
+        }());
       }
       throw error;
     }).then(stream => {
@@ -41658,7 +41697,7 @@ function staticConfigFactory(_temp) {
     _ref$axios = _ref.axios,
     axios = _ref$axios === void 0 ? _axios.default : _ref$axios,
     _ref$properties = _ref.properties,
-    properties = _ref$properties === void 0 ? {"version":"v2.35.0","buildHash":"b3cd7abe5","minimumVersion":{"firefox":52,"chrome":49},"debug":false,"websiteURL":"http://www.tokbox.com","configURL":"https://config.opentok.com","ipWhitelistConfigURL":"","cdnURL":"","loggingURL":"https://hlg.tokbox.com/prod","apiURL":"https://anvil.opentok.com","vonageApiURL":""} : _ref$properties;
+    properties = _ref$properties === void 0 ? {"version":"v2.35.0","buildHash":"a2a77b84b","minimumVersion":{"firefox":52,"chrome":49},"debug":false,"websiteURL":"http://www.tokbox.com","configURL":"https://config.opentok.com","ipWhitelistConfigURL":"","cdnURL":"","loggingURL":"https://hlg.tokbox.com/prod","apiURL":"https://anvil.opentok.com","vonageApiURL":""} : _ref$properties;
   /** @type builtInConfig */
   const builtInConfig = (0, _cloneDeep.default)(properties);
   /**
@@ -56769,11 +56808,12 @@ module.exports = __webpack_require__(58191)("forEach");
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
+/* provided dependency */ var Promise = __webpack_require__(86964);
 
 
 var _interopRequireDefault = __webpack_require__(95709);
 exports.__esModule = true;
-exports["default"] = void 0;
+exports["default"] = exports.TRANSIENT_DECODE_RECOVERY_WINDOW_MS = exports.TRANSIENT_DECODE_RECOVERY_TIMEOUT_MS = exports.TRANSIENT_DECODE_RECOVERY_MAX_ATTEMPTS = void 0;
 var _regenerator = _interopRequireDefault(__webpack_require__(92207));
 var _asyncToGenerator2 = _interopRequireDefault(__webpack_require__(79092));
 var _createClass2 = _interopRequireDefault(__webpack_require__(65044));
@@ -56802,6 +56842,12 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 
 const VIDEO_BUFFER_TIMEOUT = _amrStateDurations.default.VIDEO_BUFFER_TIMEOUT,
   VIDEO_LOADING_TIMEOUT = _amrStateDurations.default.VIDEO_LOADING_TIMEOUT;
+const TRANSIENT_DECODE_RECOVERY_WINDOW_MS = 3000;
+exports.TRANSIENT_DECODE_RECOVERY_WINDOW_MS = TRANSIENT_DECODE_RECOVERY_WINDOW_MS;
+const TRANSIENT_DECODE_RECOVERY_TIMEOUT_MS = 2000;
+exports.TRANSIENT_DECODE_RECOVERY_TIMEOUT_MS = TRANSIENT_DECODE_RECOVERY_TIMEOUT_MS;
+const TRANSIENT_DECODE_RECOVERY_MAX_ATTEMPTS = 2;
+exports.TRANSIENT_DECODE_RECOVERY_MAX_ATTEMPTS = TRANSIENT_DECODE_RECOVERY_MAX_ATTEMPTS;
 const defaultLogging = (0, _log.default)('WidgetView');
 
 // eslint-disable-next-line no-unused-vars
@@ -56881,6 +56927,10 @@ function WidgetViewFactory(_temp) {
       this._showPoster = undefined;
       this._poster = undefined;
       this._cancelBind = undefined;
+      this._decodeRecoveryAttempts = 0;
+      this._decodeRecoveryTimeout = undefined;
+      this._decodeRecoveryUntil = 0;
+      this._decodeRecoveryToken = 0;
       (0, _eventing.default)(this);
       if (/^(contain|cover)$/.test(fitMode) === false) {
         logging.warn(`Invalid fit value "${fitMode}" passed. Only "contain" and "cover" can be used.`);
@@ -57030,11 +57080,13 @@ function WidgetViewFactory(_temp) {
     };
     _proto.rebindSrcObject = function rebindSrcObject() {
       if (this._videoElementFacade) {
+        this._markDecodeRecoveryTransitionWindow();
         this._videoElementFacade._rebindSrcObject();
       }
     };
     _proto.pauseAndPlayVideoElement = function pauseAndPlayVideoElement() {
       if (this._videoElementFacade) {
+        this._markDecodeRecoveryTransitionWindow();
         this._videoElementFacade._pauseAndPlay();
       }
     }
@@ -57109,6 +57161,77 @@ function WidgetViewFactory(_temp) {
     _proto._emitBindEvent = function _emitBindEvent(action, variation, options) {
       this.emit('bindEvent', action, variation, options);
     };
+    _proto._clearDecodeRecoveryTimeout = function _clearDecodeRecoveryTimeout() {
+      if (this._decodeRecoveryTimeout) {
+        clearTimeout(this._decodeRecoveryTimeout);
+        this._decodeRecoveryTimeout = undefined;
+      }
+    };
+    _proto._markDecodeRecoveryTransitionWindow = function _markDecodeRecoveryTransitionWindow() {
+      if (!env.isAndroidWebView) {
+        return;
+      }
+      if (Date.now() > this._decodeRecoveryUntil) {
+        this._decodeRecoveryAttempts = 0;
+      }
+      this._decodeRecoveryUntil = Date.now() + TRANSIENT_DECODE_RECOVERY_WINDOW_MS;
+    };
+    _proto._resetDecodeRecoveryState = function _resetDecodeRecoveryState() {
+      this._clearDecodeRecoveryTimeout();
+      this._decodeRecoveryAttempts = 0;
+      this._decodeRecoveryToken += 1;
+    };
+    _proto._isTransientDecodeError = function _isTransientDecodeError(rawError, mappedError) {
+      const isMappedDecodeError = (mappedError == null ? void 0 : mappedError.name) === 'OT_MEDIA_ERR_DECODE';
+      const isRawDecodeError = !!((typeof window !== undefined ? window : global).MediaError && rawError && rawError.target && rawError.target.error && rawError.target.error.code === (typeof window !== undefined ? window : global).MediaError.MEDIA_ERR_DECODE);
+      return isMappedDecodeError || isRawDecodeError;
+    };
+    _proto._attemptDecodeRecovery = function _attemptDecodeRecovery(rawError, mappedError) {
+      if (!env.isAndroidWebView) {
+        return false;
+      }
+      if (!this._isTransientDecodeError(rawError, mappedError)) {
+        return false;
+      }
+      if (Date.now() > this._decodeRecoveryUntil) {
+        this._resetDecodeRecoveryState();
+        return false;
+      }
+      if (this._decodeRecoveryAttempts >= TRANSIENT_DECODE_RECOVERY_MAX_ATTEMPTS) {
+        return false;
+      }
+      this._decodeRecoveryAttempts += 1;
+      const decodeRecoveryToken = ++this._decodeRecoveryToken;
+      const decodeRecoveryUntil = this._decodeRecoveryUntil;
+      this._clearDecodeRecoveryTimeout();
+      this._markDecodeRecoveryTransitionWindow();
+      this._decodeRecoveryUntil = decodeRecoveryUntil;
+      try {
+        this.rebindSrcObject();
+        this.pauseAndPlayVideoElement();
+      } catch (err) {
+        logging.debug('decode recovery failed to trigger rebind/pause+play:', err);
+      } finally {
+        this._decodeRecoveryUntil = decodeRecoveryUntil;
+      }
+      const recoveryPlay = this._videoElementFacade && this._videoElementFacade.play ? this._videoElementFacade.play() : Promise.resolve();
+      Promise.resolve(recoveryPlay).then(() => {
+        if (this._decodeRecoveryToken !== decodeRecoveryToken) {
+          return;
+        }
+        this._resetDecodeRecoveryState();
+      }).catch(err => {
+        logging.debug('decode recovery play failed:', err);
+      });
+      this._decodeRecoveryTimeout = setTimeout(() => {
+        if (this._decodeRecoveryToken !== decodeRecoveryToken) {
+          return;
+        }
+        this._decodeRecoveryTimeout = undefined;
+        this.trigger('error', mappedError);
+      }, TRANSIENT_DECODE_RECOVERY_TIMEOUT_MS);
+      return true;
+    };
     _proto._createVideoElementFacade = function _createVideoElementFacade(_ref3) {
       let _inject = _ref3._inject,
         audioVolume = _ref3.audioVolume,
@@ -57124,8 +57247,23 @@ function WidgetViewFactory(_temp) {
       });
       const videoFacadeEvents = (0, _eventHelper.default)(this._videoElementFacade);
       this._videoFacadeEvents = videoFacadeEvents;
-      videoFacadeEvents.on('error', () => {
-        this.trigger('error');
+      videoFacadeEvents.on('error', (rawError, mappedError) => {
+        if (this._attemptDecodeRecovery(rawError, mappedError)) {
+          return;
+        }
+        this.trigger('error', mappedError);
+      });
+      // We now want to log binding duration to monitor the blink: OPENTOK-46931
+      // We propagate the event from videoFacade level to Subscriber
+      videoFacadeEvents.on('bindEvent', (action, variation, options) => {
+        if (action === 'transitionVideo') {
+          if (variation === 'Attempt') {
+            this._markDecodeRecoveryTransitionWindow();
+          } else if (variation === 'Success') {
+            this._resetDecodeRecoveryState();
+          }
+        }
+        this._emitBindEvent(action, variation, options);
       });
       videoFacadeEvents.on('videoDimensionsChanged', (oldValue, newValue) => {
         this.trigger('videoDimensionsChanged', oldValue, newValue);
@@ -57285,12 +57423,7 @@ function WidgetViewFactory(_temp) {
               return _context4.abrupt("return");
             case 20:
               this._emitBindEvent('loadVideoBuffer', 'Success');
-              // We now want to log binding duration to monitor the blink: OPENTOK-46931
-              // We propagate the event from videoFacade level to Subscriber
-              this._videoFacadeEvents.on('bindEvent', (action, variation, options) => {
-                this._emitBindEvent(action, variation, options);
-              });
-            case 22:
+            case 21:
             case "end":
               return _context4.stop();
           }
@@ -57329,6 +57462,7 @@ function WidgetViewFactory(_temp) {
               logging.debug('bindVideo ', {
                 webRTCStream
               });
+              this._markDecodeRecoveryTransitionWindow();
               hasExistingElement = !!this._videoElementFacade;
               cancellation = this._getNewBindCancellation();
               if (!hasExistingElement) {
@@ -57340,15 +57474,15 @@ function WidgetViewFactory(_temp) {
                 });
               }
               if (!(webRTCStream instanceof MediaStream && hasVideo && isSubscribingToVideo)) {
-                _context5.next = 9;
+                _context5.next = 10;
                 break;
               }
-              _context5.next = 9;
+              _context5.next = 10;
               return this._tryToLoadVideoBuffer(webRTCStream, cancellation, throwIfBufferFails, hasVideo && isSubscribingToVideo);
-            case 9:
-              _context5.next = 11;
+            case 10:
+              _context5.next = 12;
               return this._bindToStream(webRTCStream, cancellation);
-            case 11:
+            case 12:
               if (!hasExistingElement) {
                 this._triggerVideoElementCreated();
               }
@@ -57357,16 +57491,16 @@ function WidgetViewFactory(_temp) {
                 defaultVideoElementFacade: this._videoElementFacade,
                 maxWaitTime: 5000
               });
-              _context5.next = 16;
+              _context5.next = 17;
               return this._waitForVideoResolution(webRTCStream);
-            case 16:
+            case 17:
               logging.debug('Waiting for video to be playing');
-              _context5.next = 19;
+              _context5.next = 20;
               return whenVideoPlaying;
-            case 19:
+            case 20:
               logging.debug('Video is playing');
               throwIfBindCancelled(cancellation);
-            case 21:
+            case 22:
             case "end":
               return _context5.stop();
           }
@@ -57383,6 +57517,7 @@ function WidgetViewFactory(_temp) {
       }
     };
     _proto.destroyVideo = function destroyVideo() {
+      this._resetDecodeRecoveryState();
       if (this._videoElementFacade) {
         this._videoElementFacade.destroy();
         this._videoElementFacade = null;
@@ -59400,42 +59535,24 @@ function screenSharingFactory(deps) {
   screenSharing.pickHelper = () => screenSharingPickHelper();
 
   /**
-   * Checks for support for publishing screen-sharing streams on the client browser. The object
-   * passed to the callback function defines whether screen sharing is supported, as well as
+   * Checks for support for publishing screen-sharing streams on the client browser. The returned
+   * object in the promise defines whether screen sharing is supported, as well as
    * which screen-sharing sources (application, screen, or window) are supported. It also indicates
    * whether an extension is required, installed, and registered (if needed).
    * <p>
    * <pre>
-   * OT.checkScreenSharingCapability(function(response) {
-   *   if (!response.supported || response.extensionRegistered === false) {
-   *     // This browser does not support screen sharing
-   *   } else if (response.extensionInstalled === false) {
-   *     // Prompt to install the extension
-   *   } else {
-   *     // Screen sharing is available.
-   *   }
-   * });
+   * const response = await OT.checkScreenSharingCapability();
+   * if (!response.supported || response.extensionRegistered === false) {
+   * // This browser does not support screen sharing
+   * } else if (response.extensionInstalled === false) {
+   *   // Prompt to install the extension
+   * } else {
+   *   // Screen sharing is available.
+   * }
    * </pre>
    * <p>
-   * Chrome 72+, Firefox 52+, Safari 13+, Edge 79+, and Opera 59+ have screen-sharing
-   * support built-in, with no extension required. (Note that support for the Vonage Video API
-   * plugin for Internet Explorer is removed in Vonage Video API 2.17.) Screen sharing is
-   * <i>not</i> supported in mobile browsers. In Electron, screen sharing is supported if
-   * the <code>webPreferences.contextIsolation</code> option of the Electron BrowserWindow is
-   * set to <code>false</code> or if the app uses a preload script to access the desktop capturer.
-   * (The default value of <code>webPreferences.contextIsolation</code> option is <code>true</code>
-   * in Electron 12 and <code>false</code> in previous versions). To publish a screen-sharing video
-   * in older versions of Chrome or Opera, the client adds an extension that enables publishing a
-   * screen-sharing video stream on your domain. The Vonage Video API
-   * <a href="https://github.com/opentok/screensharing-extensions">screensharing-extensions</a>
-   * sample includes code for creating an extension for screen-sharing support in
-   * older versions of Chrome and Opera.
-   * <p>
-   * For more information, see the <a href="https://tokbox.com/developer/guides/screen-sharing/js/">
-   * Vonage Video API Screen Sharing</a> developer guide.
    *
-   * @param {function} callback The callback invoked with the support options object passed as
-   * the parameter. This object has the following properties that indicate support for publishing
+   * This object has the following properties that indicate support for publishing
    * screen-sharing streams in the client:
    * <p>
    * <ul>
@@ -59482,47 +59599,80 @@ function screenSharingFactory(deps) {
    *   </li>
    * </ul>
    *
+   * Chrome 72+, Firefox 52+, Safari 13+, Edge 79+, and Opera 59+ have screen-sharing
+   * support built-in, with no extension required. (Note that support for the Vonage Video API
+   * plugin for Internet Explorer is removed in Vonage Video API 2.17.) Screen sharing is
+   * <i>not</i> supported in mobile browsers. In Electron, screen sharing is supported if
+   * the <code>webPreferences.contextIsolation</code> option of the Electron BrowserWindow is
+   * set to <code>false</code> or if the app uses a preload script to access the desktop capturer.
+   * (The default value of <code>webPreferences.contextIsolation</code> option is <code>true</code>
+   * in Electron 12 and <code>false</code> in previous versions). To publish a screen-sharing video
+   * in older versions of Chrome or Opera, the client adds an extension that enables publishing a
+   * screen-sharing video stream on your domain. The Vonage Video API
+   * <a href="https://github.com/opentok/screensharing-extensions">screensharing-extensions</a>
+   * sample includes code for creating an extension for screen-sharing support in
+   * older versions of Chrome and Opera.
+   * <p>
+   * For more information, see the <a href="https://tokbox.com/developer/guides/screen-sharing/js/">
+   * Vonage Video API Screen Sharing</a> developer guide.
+   *
+   * @param {function} callback Optional callback invoked with the support options object passed as
+   * the parameter.
+   *
+   * @returns {Promise<ScreenSharingCapabilityResponse>} A promise with the capability
+   *
    * @see <a href="OT.html#initPublisher">OT.initPublisher()</a>
    * @see <a href="OT.html#registerScreenSharingExtension">OT.registerScreenSharingExtension()</a>
    * @method OT.checkScreenSharingCapability
    * @memberof OT
    */
-  screenSharing.checkCapability = callback => {
-    const response = {
-      supported: false,
-      extensionRequired: undefined,
-      extensionRegistered: undefined,
-      extensionInstalled: undefined,
-      supportedSources: {}
-    };
-
-    // find a supported browser
+  screenSharing.checkCapability = function (callback) {
+    if (callback === void 0) {
+      callback = () => {};
+    }
+    return new Promise(resolve => {
+      const response = {
+        supported: false,
+        extensionRequired: undefined,
+        extensionRegistered: undefined,
+        extensionInstalled: undefined,
+        supportedSources: {}
+      };
 
-    const helper = screenSharingPickHelper();
-    if (helper.name === undefined) {
-      setTimeout(callback.bind(null, response));
-      return;
-    }
-    response.supported = true;
-    response.extensionRequired = helper.proto.extensionRequired ? helper.name : undefined;
-    response.supportedSources = {
-      screen: helper.proto.sources.screen,
-      application: helper.proto.sources.application,
-      window: helper.proto.sources.window,
-      browser: helper.proto.sources.browser
-    };
-    if (!helper.instance) {
-      response.extensionRegistered = false;
-      if (response.extensionRequired) {
-        response.extensionInstalled = false;
+      // find a supported browser
+      const helper = screenSharingPickHelper();
+      if (helper.name === undefined) {
+        setTimeout(() => {
+          callback(response);
+        });
+        resolve(response);
+        return;
       }
-      setTimeout(callback.bind(null, response));
-      return;
-    }
-    response.extensionRegistered = response.extensionRequired ? true : undefined;
-    helper.instance.isInstalled(installed => {
-      response.extensionInstalled = response.extensionRequired || OTHelpers.env.name === 'Firefox' ? installed : undefined;
-      callback(response);
+      response.supported = true;
+      response.extensionRequired = helper.proto.extensionRequired ? helper.name : undefined;
+      response.supportedSources = {
+        screen: helper.proto.sources.screen,
+        application: helper.proto.sources.application,
+        window: helper.proto.sources.window,
+        browser: helper.proto.sources.browser
+      };
+      if (!helper.instance) {
+        response.extensionRegistered = false;
+        if (response.extensionRequired) {
+          response.extensionInstalled = false;
+        }
+        setTimeout(() => {
+          callback(response);
+        });
+        resolve(response);
+        return;
+      }
+      response.extensionRegistered = response.extensionRequired ? true : undefined;
+      helper.instance.isInstalled(installed => {
+        response.extensionInstalled = response.extensionRequired || OTHelpers.env.name === 'Firefox' ? installed : undefined;
+        callback(response);
+        resolve(response);
+      });
     });
   };
   screenSharing.registerExtensionHelper('electron', electronExtensionHelper);
@@ -59538,7 +59688,7 @@ function screenSharingFactory(deps) {
       videoSource = opt.videoSource,
       constraints = opt.constraints;
     return new Promise((resolve, reject) => {
-      screenSharing.checkCapability(response => {
+      screenSharing.checkCapability().then(response => {
         if (!response.supported) {
           let errorMessage = 'Screen Sharing is not supported in this browser';
           if (OTHelpers.env.isElectron) {
@@ -61739,41 +61889,51 @@ function reportIssueFactory(deps) {
   * <a href="https://tokbox.com/developer/tools/inspector/">Inspector</a> or when discussing
   * an issue with the Vonage API support team.
   *
-  * @param completionHandler {Function} A function that is called when the call to this method
+  * @param completionHandler {Function} Optional Function that is called when the call to this method
   * succeeds or fails. This function has two parameters. The first parameter is an
   * <a href="Error.html">Error</a> object that is set when the call to the
   * <code>reportIssue()</code> method fails (for example, if the client is not connected to the
   * network) or <code>null</code> when the call to the <code>reportIssue()</code> method succeeds.
   * The second parameter is set to the report ID (a unique string) when the call succeeds.
   *
+  * @returns {Promise<string>} A promise resolving to the report ID
+  *
   * @method OT.reportIssue
   * @memberof OT
   */
   return function reportIssue(completionHandler) {
-    if (completionHandler === void 0) {
-      completionHandler = () => {};
-    }
-    const reportIssueId = uuid();
-    function onDone(err) {
-      if (err) {
-        completionHandler(otError(errors.REPORT_ISSUE_FAILED, new Error('Error calling OT.reportIssue(). Check the client\'s network connection.'), ExceptionCodes.REPORT_ISSUE_ERROR));
+    const hasCompletionHandler = typeof completionHandler === 'function';
+    const callback = hasCompletionHandler ? completionHandler : () => {};
+    const promise = new Promise((resolve, reject) => {
+      const reportIssueId = uuid();
+      function onDone(err) {
+        if (err) {
+          const error = otError(errors.REPORT_ISSUE_FAILED, new Error('Error calling OT.reportIssue(). Check the client\'s network connection.'), ExceptionCodes.REPORT_ISSUE_ERROR);
+          callback(error);
+          reject(error);
+        } else {
+          callback(null, reportIssueId);
+          resolve(reportIssueId);
+        }
+      }
+      if (sessionObjects.sessions.length() === 0) {
+        analytics.logEvent({
+          action: 'ReportIssue',
+          variation: 'Event',
+          payload: {
+            reportIssueId
+          }
+        }, null, onDone);
       } else {
-        completionHandler(null, reportIssueId);
+        Promise.all(sessionObjects.sessions.map(session => session.reportIssue({
+          id: reportIssueId
+        }))).then(() => onDone(), err => onDone(err));
       }
+    });
+    if (hasCompletionHandler) {
+      promise.catch(() => {});
     }
-    if (sessionObjects.sessions.length() === 0) {
-      analytics.logEvent({
-        action: 'ReportIssue',
-        variation: 'Event',
-        payload: {
-          reportIssueId
-        }
-      }, null, onDone);
-    } else {
-      Promise.all(sessionObjects.sessions.map(session => session.reportIssue({
-        id: reportIssueId
-      }))).then(() => onDone(), err => onDone(err));
-    }
+    return promise;
   };
 }
 
@@ -62271,7 +62431,7 @@ function NativeVideoElementWrapperFactory(deps) {
         }, _callee);
       })));
       const onError = event => {
-        this.trigger('error', videoElementErrorMap(event.target.error));
+        this.trigger('error', event, videoElementErrorMap(event.target.error));
       };
       this._domElementEvents.on('error', onError, false);
       this._domElementEvents.on('pause', _playVideoOnPause);
@@ -67254,6 +67414,7 @@ exports["default"] = _default;
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
+/* provided dependency */ var Promise = __webpack_require__(86964);
 
 
 var _interopRequireDefault = __webpack_require__(95709);
@@ -67958,7 +68119,7 @@ function initPublisherFactory(deps) {
   * @method OT.initPublisher
   * @memberof OT
   */
-  return function initPublisher(targetElement, properties, completionHandler) {
+  function initPublisher(targetElement, properties, completionHandler) {
     logging.debug(`OT.initPublisher(${targetElement})`);
 
     // To support legacy (apikey, targetElement, properties) users
@@ -68015,7 +68176,6 @@ function initPublisherFactory(deps) {
     };
     let removeHandlersAndCallComplete = function removeHandlersAndCallComplete(err) {
       publisher.off('initSuccess', removeInitSuccessAndCallComplete);
-
       // We're only handling the error case here as we're just
       // initing the publisher, not actually attempting to publish.
       if (err) {
@@ -68026,7 +68186,24 @@ function initPublisherFactory(deps) {
     publisher.once('publishComplete', removeHandlersAndCallComplete);
     publisher.publish(targetElement);
     return publisher;
-  };
+  }
+
+  /**
+  * The <code>initPublisher</code> function is also available in a promisifed flavour.
+  * Note that this function will only resolve to a publisher object if there were no
+  * errors involved in its creation.
+  */
+  initPublisher.promise = (targetElement, properties) => new Promise((resolve, reject) => {
+    const args = [targetElement, properties].filter(arg => arg !== undefined);
+    const publisher = initPublisher(...args, error => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(publisher);
+      }
+    });
+  });
+  return initPublisher;
 }
 
 /***/ }),
@@ -68176,6 +68353,7 @@ module.exports = baseRest;
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
+/* provided dependency */ var Promise = __webpack_require__(86964);
 
 
 var _interopRequireDefault = __webpack_require__(95709);
@@ -68185,13 +68363,24 @@ var _get_rtc_stats_report_adapter = _interopRequireDefault(__webpack_require__(5
 var _createRtcStatsReportParser = _interopRequireDefault(__webpack_require__(14848));
 // This returns the array-ified list of stats our users are accustomed to
 var _default = (peerConnection, track, completion) => {
-  (0, _get_rtc_stats_report_adapter.default)(peerConnection, track, (err, rtcStatsReport) => {
-    if (err) {
-      completion(err);
-      return;
-    }
-    completion(null, (0, _createRtcStatsReportParser.default)()(rtcStatsReport));
+  const hasCompletion = typeof completion === 'function';
+  const callback = hasCompletion ? completion : () => {};
+  const promise = new Promise((resolve, reject) => {
+    (0, _get_rtc_stats_report_adapter.default)(peerConnection, track, (err, rtcStatsReport) => {
+      if (err) {
+        callback(err);
+        reject(err);
+        return;
+      }
+      const parsedReport = (0, _createRtcStatsReportParser.default)()(rtcStatsReport);
+      callback(null, parsedReport);
+      resolve(parsedReport);
+    });
   });
+  if (hasCompletion) {
+    promise.catch(() => {});
+  }
+  return promise;
 };
 exports["default"] = _default;
 
@@ -103506,36 +103695,37 @@ var _log = _interopRequireDefault(__webpack_require__(48669));
 var _updateTrackOnStream = _interopRequireDefault(__webpack_require__(29634));
 var _createAudioTrackHolder = _interopRequireDefault(__webpack_require__(37268));
 const logging = (0, _log.default)('Subscriber');
-const routedSourceStreamId = 'MANTIS';
-const relayedSourceStreamId = 'P2P';
-const createAudioConnector = function createAudioConnector(streams, deps) {
+const createAudioConnector = function createAudioConnector(deps) {
   if (deps === void 0) {
     deps = {};
   }
   const updateTrackOnStream = deps.updateTrackOnStream || _updateTrackOnStream.default;
   const createAudioTrackHolder = deps.createAudioTrackHolder || _createAudioTrackHolder.default;
-  const mediaStreams = streams;
   let _audioMediaProcessorConnector;
+  let _stream;
   let _originalAudioTrack;
   let _audioTrackHolder;
-  const clearConnectorAndAudioHolder = () => {
-    var _audioMediaProcessorC;
-    (_audioMediaProcessorC = _audioMediaProcessorConnector) == null ? void 0 : _audioMediaProcessorC.destroy();
-    _audioMediaProcessorConnector = null;
+  const clearAudioHolder = () => {
     if (_audioTrackHolder) {
       _audioTrackHolder.srcObject = null;
       _audioTrackHolder = null;
     }
+    _stream = null;
     _originalAudioTrack = null;
   };
+  const clearConnectorAndAudioHolder = () => {
+    var _audioMediaProcessorC;
+    (_audioMediaProcessorC = _audioMediaProcessorConnector) == null ? void 0 : _audioMediaProcessorC.destroy();
+    _audioMediaProcessorConnector = null;
+    clearAudioHolder();
+  };
   const applyAudioConnector = /*#__PURE__*/function () {
-    var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(sourceStreamId) {
-      var _mediaStreams$sourceS2;
-      var _mediaStreams$sourceS, originalAudioTrack, message, error, filteredAudioTrack;
+    var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(stream) {
+      var originalAudioTrack, message, error, filteredAudioTrack;
       return _regenerator.default.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            _mediaStreams$sourceS = (_mediaStreams$sourceS2 = mediaStreams[sourceStreamId]) == null ? void 0 : _mediaStreams$sourceS2.getAudioTracks(), originalAudioTrack = _mediaStreams$sourceS[0];
+            originalAudioTrack = stream === _stream ? _originalAudioTrack : stream == null ? void 0 : stream.getAudioTracks()[0];
             if (originalAudioTrack) {
               _context.next = 7;
               break;
@@ -103543,42 +103733,59 @@ const createAudioConnector = function createAudioConnector(streams, deps) {
             message = 'Connector not set as no audio track is present.';
             error = new Error(message);
             logging.error(`setAudioMediaProcessorConnector: ${message}`);
-            _audioMediaProcessorConnector = null;
+            clearConnectorAndAudioHolder();
             throw error;
           case 7:
             _context.prev = 7;
             // We create a video element to hold a new stream containing the original audio track.
             // If the track is not used in a stream, it is stopped and no audio is heard through
             // the filtered track.
+            if (_audioTrackHolder) {
+              _audioTrackHolder.srcObject = null;
+            }
             _audioTrackHolder = createAudioTrackHolder(originalAudioTrack);
-            _context.next = 11;
+            if (_audioMediaProcessorConnector) {
+              _context.next = 15;
+              break;
+            }
+            message = 'Audio Media Processor Connector has not been initialized.';
+            error = new Error(message);
+            logging.error(`setAudioMediaProcessorConnector: ${message}`);
+            throw error;
+          case 15:
+            _context.next = 17;
             return _audioMediaProcessorConnector.setTrack(originalAudioTrack);
-          case 11:
+          case 17:
             filteredAudioTrack = _context.sent;
+            _stream = stream;
             _originalAudioTrack = originalAudioTrack;
-            updateTrackOnStream(mediaStreams[sourceStreamId], originalAudioTrack, filteredAudioTrack);
-            _context.next = 20;
+            updateTrackOnStream(stream, originalAudioTrack, filteredAudioTrack);
+            _context.next = 27;
             break;
-          case 16:
-            _context.prev = 16;
+          case 23:
+            _context.prev = 23;
             _context.t0 = _context["catch"](7);
             clearConnectorAndAudioHolder();
             throw _context.t0;
-          case 20:
+          case 27:
           case "end":
             return _context.stop();
         }
-      }, _callee, null, [[7, 16]]);
+      }, _callee, null, [[7, 23]]);
     }));
     return function applyAudioConnector(_x) {
       return _ref.apply(this, arguments);
     };
   }();
-  const resetAudioStream = sourceStreamId => {
+  const resetAudioStream = () => {
     try {
-      const _mediaStreams$sourceS3 = mediaStreams[sourceStreamId].getAudioTracks(),
-        filteredAudioTrack = _mediaStreams$sourceS3[0];
-      updateTrackOnStream(mediaStreams[sourceStreamId], filteredAudioTrack, _originalAudioTrack);
+      var _stream2;
+      const audioTracks = (_stream2 = _stream) == null ? void 0 : _stream2.getAudioTracks();
+      if (audioTracks != null && audioTracks.length) {
+        const filteredAudioTrack = audioTracks[0];
+        updateTrackOnStream(_stream, filteredAudioTrack, _originalAudioTrack);
+      }
+      clearAudioHolder();
     } catch (error) {
       throw Error(`setAudioMediaProcessorConnector: Error resetting track: ${error.message}`);
     }
@@ -103588,15 +103795,17 @@ const createAudioConnector = function createAudioConnector(streams, deps) {
       return _audioMediaProcessorConnector;
     },
     initializeConnector(mediaProcessorConnector) {
+      var _audioMediaProcessorC2;
+      (_audioMediaProcessorC2 = _audioMediaProcessorConnector) == null ? void 0 : _audioMediaProcessorC2.destroy();
       _audioMediaProcessorConnector = new _mediaProcessorConnector.default(mediaProcessorConnector);
     },
-    setAudioMediaProcessorConnector(sourceStreamId) {
+    setAudioMediaProcessorConnector(stream) {
       return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
         return _regenerator.default.wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
               _context2.next = 2;
-              return applyAudioConnector(sourceStreamId);
+              return applyAudioConnector(stream);
             case 2:
             case "end":
               return _context2.stop();
@@ -103604,63 +103813,39 @@ const createAudioConnector = function createAudioConnector(streams, deps) {
         }, _callee2);
       }))();
     },
-    applyAudioConnectorOnRoutedToRelayedTransition() {
+    resetAndApplyAudioConnector(stream) {
       var _this = this;
       return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        var hadAudioMediaProcessorConnector;
         return _regenerator.default.wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
-              // We restore the Mantis stream's original track, so when we transition again,
-              // we can apply a filter to the unfiltered track.
-              _this.resetAudioStreamAndTrack(routedSourceStreamId);
-              if (_audioMediaProcessorConnector) {
-                _context3.next = 3;
+              hadAudioMediaProcessorConnector = !!_audioMediaProcessorConnector;
+              _this.resetAudioStreamAndTrack();
+              if (hadAudioMediaProcessorConnector) {
+                _context3.next = 4;
                 break;
               }
               return _context3.abrupt("return");
-            case 3:
-              _context3.next = 5;
-              return applyAudioConnector(relayedSourceStreamId);
-            case 5:
+            case 4:
+              _context3.next = 6;
+              return applyAudioConnector(stream);
+            case 6:
             case "end":
               return _context3.stop();
           }
         }, _callee3);
       }))();
     },
-    applyAudioConnectorOnRelayedToRoutedTransition() {
-      return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
-        return _regenerator.default.wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              if (_audioMediaProcessorConnector) {
-                _context4.next = 2;
-                break;
-              }
-              return _context4.abrupt("return");
-            case 2:
-              _context4.next = 4;
-              return applyAudioConnector(routedSourceStreamId);
-            case 4:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4);
-      }))();
-    },
-    clearAudioMediaProcessorConnector(sourceStreamId) {
-      if (!_originalAudioTrack) {
-        return;
-      }
-      resetAudioStream(sourceStreamId);
+    clearAudioMediaProcessorConnector() {
+      this.resetAudioStreamAndTrack();
       clearConnectorAndAudioHolder();
     },
-    resetAudioStreamAndTrack(sourceStreamId) {
+    resetAudioStreamAndTrack() {
       if (!_originalAudioTrack) {
         return;
       }
-      resetAudioStream(sourceStreamId);
-      _originalAudioTrack = null;
+      resetAudioStream();
     }
   };
 };