livekit-client 1.10.0 → 1.11.1

package/dist/livekit-client.esm.mjs

@@ -296,7 +296,7 @@ var LogLevel;
   LogLevel[LogLevel["silent"] = 5] = "silent";
 })(LogLevel || (LogLevel = {}));
 const livekitLogger = loglevelExports.getLogger('livekit');
-livekitLogger.setLevel(LogLevel.info);
+livekitLogger.setDefaultLevel(LogLevel.info);
 function setLogLevel(level) {
   livekitLogger.setLevel(level);
 }
@@ -306,9 +306,9 @@ function setLogLevel(level) {
  */
 function setLogExtension(extension) {
   const originalFactory = livekitLogger.methodFactory;
-  livekitLogger.methodFactory = (methodName, logLevel, loggerName) => {
-    const rawMethod = originalFactory(methodName, logLevel, loggerName);
-    const configLevel = livekitLogger.getLevel();
+  livekitLogger.methodFactory = (methodName, configLevel, loggerName) => {
+    const rawMethod = originalFactory(methodName, configLevel, loggerName);
+    const logLevel = LogLevel[methodName];
     const needLog = logLevel >= configLevel && logLevel < LogLevel.silent;
     return (msg, context) => {
       if (context) rawMethod(msg, context);else rawMethod(msg);
@@ -6654,386 +6654,322 @@ function __asyncValues(o) {
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 }
 
-var events = {exports: {}};
+var eventemitter3 = {exports: {}};
 
-var R = typeof Reflect === 'object' ? Reflect : null;
-var ReflectApply = R && typeof R.apply === 'function' ? R.apply : function ReflectApply(target, receiver, args) {
-  return Function.prototype.apply.call(target, receiver, args);
-};
-var ReflectOwnKeys;
-if (R && typeof R.ownKeys === 'function') {
-  ReflectOwnKeys = R.ownKeys;
-} else if (Object.getOwnPropertySymbols) {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
-  };
-} else {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target);
-  };
-}
-function ProcessEmitWarning(warning) {
-  if (console && console.warn) console.warn(warning);
-}
-var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
-  return value !== value;
-};
-function EventEmitter() {
-  EventEmitter.init.call(this);
-}
-events.exports = EventEmitter;
-events.exports.once = once;
+(function (module) {
 
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._eventsCount = 0;
-EventEmitter.prototype._maxListeners = undefined;
+  var has = Object.prototype.hasOwnProperty,
+    prefix = '~';
 
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-var defaultMaxListeners = 10;
-function checkListener(listener) {
-  if (typeof listener !== 'function') {
-    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
-  }
-}
-Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
-  enumerable: true,
-  get: function () {
-    return defaultMaxListeners;
-  },
-  set: function (arg) {
-    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
-    }
-    defaultMaxListeners = arg;
-  }
-});
-EventEmitter.init = function () {
-  if (this._events === undefined || this._events === Object.getPrototypeOf(this)._events) {
-    this._events = Object.create(null);
-    this._eventsCount = 0;
-  }
-  this._maxListeners = this._maxListeners || undefined;
-};
+  /**
+   * Constructor to create a storage for our `EE` objects.
+   * An `Events` instance is a plain object whose properties are event names.
+   *
+   * @constructor
+   * @private
+   */
+  function Events() {}
+
+  //
+  // We try to not inherit from `Object.prototype`. In some engines creating an
+  // instance in this way is faster than calling `Object.create(null)` directly.
+  // If `Object.create(null)` is not supported we prefix the event names with a
+  // character to make sure that the built-in object properties are not
+  // overridden or used as an attack vector.
+  //
+  if (Object.create) {
+    Events.prototype = Object.create(null);
 
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
-    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+    //
+    // This hack is needed because the `__proto__` property is still inherited in
+    // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+    //
+    if (!new Events().__proto__) prefix = false;
   }
-  this._maxListeners = n;
-  return this;
-};
-function _getMaxListeners(that) {
-  if (that._maxListeners === undefined) return EventEmitter.defaultMaxListeners;
-  return that._maxListeners;
-}
-EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-  return _getMaxListeners(this);
-};
-EventEmitter.prototype.emit = function emit(type) {
-  var args = [];
-  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-  var doError = type === 'error';
-  var events = this._events;
-  if (events !== undefined) doError = doError && events.error === undefined;else if (!doError) return false;
-
-  // If there is no 'error' event listener then throw.
-  if (doError) {
-    var er;
-    if (args.length > 0) er = args[0];
-    if (er instanceof Error) {
-      // Note: The comments on the `throw` lines are intentional, they show
-      // up in Node's output if this results in an unhandled exception.
-      throw er; // Unhandled 'error' event
-    }
-    // At least give some kind of context to the user
-    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
-    err.context = er;
-    throw err; // Unhandled 'error' event
-  }
-
-  var handler = events[type];
-  if (handler === undefined) return false;
-  if (typeof handler === 'function') {
-    ReflectApply(handler, this, args);
-  } else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
+
+  /**
+   * Representation of a single event listener.
+   *
+   * @param {Function} fn The listener function.
+   * @param {*} context The context to invoke the listener with.
+   * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+   * @constructor
+   * @private
+   */
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
   }
-  return true;
-};
-function _addListener(target, type, listener, prepend) {
-  var m;
-  var events;
-  var existing;
-  checkListener(listener);
-  events = target._events;
-  if (events === undefined) {
-    events = target._events = Object.create(null);
-    target._eventsCount = 0;
-  } else {
-    // To avoid recursion in the case that type === "newListener"! Before
-    // adding it to the listeners, first emit "newListener".
-    if (events.newListener !== undefined) {
-      target.emit('newListener', type, listener.listener ? listener.listener : listener);
 
-      // Re-assign `events` because a newListener handler could have caused the
-      // this._events to be assigned to a new object
-      events = target._events;
+  /**
+   * Add a listener for a given event.
+   *
+   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn The listener function.
+   * @param {*} context The context to invoke the listener with.
+   * @param {Boolean} once Specify if the listener is a one-time listener.
+   * @returns {EventEmitter}
+   * @private
+   */
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== 'function') {
+      throw new TypeError('The listener must be a function');
     }
-    existing = events[type];
+    var listener = new EE(fn, context || emitter, once),
+      evt = prefix ? prefix + event : event;
+    if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);else emitter._events[evt] = [emitter._events[evt], listener];
+    return emitter;
   }
-  if (existing === undefined) {
-    // Optimize the case of one listener. Don't need the extra array object.
-    existing = events[type] = listener;
-    ++target._eventsCount;
-  } else {
-    if (typeof existing === 'function') {
-      // Adding the second element, need to change to array.
-      existing = events[type] = prepend ? [listener, existing] : [existing, listener];
-      // If we've already got an array, just append.
-    } else if (prepend) {
-      existing.unshift(listener);
-    } else {
-      existing.push(listener);
-    }
 
-    // Check for listener leak
-    m = _getMaxListeners(target);
-    if (m > 0 && existing.length > m && !existing.warned) {
-      existing.warned = true;
-      // No error code for this since it is a Warning
-      // eslint-disable-next-line no-restricted-syntax
-      var w = new Error('Possible EventEmitter memory leak detected. ' + existing.length + ' ' + String(type) + ' listeners ' + 'added. Use emitter.setMaxListeners() to ' + 'increase limit');
-      w.name = 'MaxListenersExceededWarning';
-      w.emitter = target;
-      w.type = type;
-      w.count = existing.length;
-      ProcessEmitWarning(w);
-    }
+  /**
+   * Clear event by name.
+   *
+   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+   * @param {(String|Symbol)} evt The Event name.
+   * @private
+   */
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0) emitter._events = new Events();else delete emitter._events[evt];
   }
-  return target;
-}
-EventEmitter.prototype.addListener = function addListener(type, listener) {
-  return _addListener(this, type, listener, false);
-};
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-EventEmitter.prototype.prependListener = function prependListener(type, listener) {
-  return _addListener(this, type, listener, true);
-};
-function onceWrapper() {
-  if (!this.fired) {
-    this.target.removeListener(this.type, this.wrapFn);
-    this.fired = true;
-    if (arguments.length === 0) return this.listener.call(this.target);
-    return this.listener.apply(this.target, arguments);
-  }
-}
-function _onceWrap(target, type, listener) {
-  var state = {
-    fired: false,
-    wrapFn: undefined,
-    target: target,
-    type: type,
-    listener: listener
+
+  /**
+   * Minimal `EventEmitter` interface that is molded against the Node.js
+   * `EventEmitter` interface.
+   *
+   * @constructor
+   * @public
+   */
+  function EventEmitter() {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
+
+  /**
+   * Return an array listing the events for which the emitter has registered
+   * listeners.
+   *
+   * @returns {Array}
+   * @public
+   */
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = [],
+      events,
+      name;
+    if (this._eventsCount === 0) return names;
+    for (name in events = this._events) {
+      if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+    }
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+    return names;
   };
-  var wrapped = onceWrapper.bind(state);
-  wrapped.listener = listener;
-  state.wrapFn = wrapped;
-  return wrapped;
-}
-EventEmitter.prototype.once = function once(type, listener) {
-  checkListener(listener);
-  this.on(type, _onceWrap(this, type, listener));
-  return this;
-};
-EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
-  checkListener(listener);
-  this.prependListener(type, _onceWrap(this, type, listener));
-  return this;
-};
 
-// Emits a 'removeListener' event if and only if the listener was removed.
-EventEmitter.prototype.removeListener = function removeListener(type, listener) {
-  var list, events, position, i, originalListener;
-  checkListener(listener);
-  events = this._events;
-  if (events === undefined) return this;
-  list = events[type];
-  if (list === undefined) return this;
-  if (list === listener || list.listener === listener) {
-    if (--this._eventsCount === 0) this._events = Object.create(null);else {
-      delete events[type];
-      if (events.removeListener) this.emit('removeListener', type, list.listener || listener);
-    }
-  } else if (typeof list !== 'function') {
-    position = -1;
-    for (i = list.length - 1; i >= 0; i--) {
-      if (list[i] === listener || list[i].listener === listener) {
-        originalListener = list[i].listener;
-        position = i;
-        break;
+  /**
+   * Return the listeners registered for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @returns {Array} The registered listeners.
+   * @public
+   */
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event,
+      handlers = this._events[evt];
+    if (!handlers) return [];
+    if (handlers.fn) return [handlers.fn];
+    for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+    return ee;
+  };
+
+  /**
+   * Return the number of listeners listening to a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @returns {Number} The number of listeners.
+   * @public
+   */
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event,
+      listeners = this._events[evt];
+    if (!listeners) return 0;
+    if (listeners.fn) return 1;
+    return listeners.length;
+  };
+
+  /**
+   * Calls each of the listeners registered for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @returns {Boolean} `true` if the event had listeners, else `false`.
+   * @public
+   */
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt]) return false;
+    var listeners = this._events[evt],
+      len = arguments.length,
+      args,
+      i;
+    if (listeners.fn) {
+      if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+      switch (len) {
+        case 1:
+          return listeners.fn.call(listeners.context), true;
+        case 2:
+          return listeners.fn.call(listeners.context, a1), true;
+        case 3:
+          return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4:
+          return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+      for (i = 1, args = new Array(len - 1); i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length,
+        j;
+      for (i = 0; i < length; i++) {
+        if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+        switch (len) {
+          case 1:
+            listeners[i].fn.call(listeners[i].context);
+            break;
+          case 2:
+            listeners[i].fn.call(listeners[i].context, a1);
+            break;
+          case 3:
+            listeners[i].fn.call(listeners[i].context, a1, a2);
+            break;
+          case 4:
+            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+            break;
+          default:
+            if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+              args[j - 1] = arguments[j];
+            }
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
       }
     }
-    if (position < 0) return this;
-    if (position === 0) list.shift();else {
-      spliceOne(list, position);
+    return true;
+  };
+
+  /**
+   * Add a listener for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn The listener function.
+   * @param {*} [context=this] The context to invoke the listener with.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+
+  /**
+   * Add a one-time listener for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn The listener function.
+   * @param {*} [context=this] The context to invoke the listener with.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+
+  /**
+   * Remove the listeners of a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn Only remove the listeners that match this function.
+   * @param {*} context Only remove the listeners that have this context.
+   * @param {Boolean} once Only remove one-time listeners.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt]) return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
     }
-    if (list.length === 1) events[type] = list[0];
-    if (events.removeListener !== undefined) this.emit('removeListener', type, originalListener || listener);
-  }
-  return this;
-};
-EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
-  var listeners, events, i;
-  events = this._events;
-  if (events === undefined) return this;
-
-  // not listening for removeListener, no need to emit
-  if (events.removeListener === undefined) {
-    if (arguments.length === 0) {
-      this._events = Object.create(null);
-      this._eventsCount = 0;
-    } else if (events[type] !== undefined) {
-      if (--this._eventsCount === 0) this._events = Object.create(null);else delete events[type];
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
+        }
+      }
+
+      //
+      // Reset the array, or remove it completely if we have no more listeners.
+      //
+      if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;else clearEvent(this, evt);
     }
     return this;
-  }
+  };
 
-  // emit removeListener for all listeners on all events
-  if (arguments.length === 0) {
-    var keys = Object.keys(events);
-    var key;
-    for (i = 0; i < keys.length; ++i) {
-      key = keys[i];
-      if (key === 'removeListener') continue;
-      this.removeAllListeners(key);
+  /**
+   * Remove all listeners, or those of the specified event.
+   *
+   * @param {(String|Symbol)} [event] The event name.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt]) clearEvent(this, evt);
+    } else {
+      this._events = new Events();
+      this._eventsCount = 0;
     }
-    this.removeAllListeners('removeListener');
-    this._events = Object.create(null);
-    this._eventsCount = 0;
     return this;
+  };
+
+  //
+  // Alias methods names because people roll like that.
+  //
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+  //
+  // Expose the prefix.
+  //
+  EventEmitter.prefixed = prefix;
+
+  //
+  // Allow `EventEmitter` to be imported as module namespace.
+  //
+  EventEmitter.EventEmitter = EventEmitter;
+
+  //
+  // Expose the module.
+  //
+  {
+    module.exports = EventEmitter;
   }
-  listeners = events[type];
-  if (typeof listeners === 'function') {
-    this.removeListener(type, listeners);
-  } else if (listeners !== undefined) {
-    // LIFO order
-    for (i = listeners.length - 1; i >= 0; i--) {
-      this.removeListener(type, listeners[i]);
-    }
-  }
-  return this;
-};
-function _listeners(target, type, unwrap) {
-  var events = target._events;
-  if (events === undefined) return [];
-  var evlistener = events[type];
-  if (evlistener === undefined) return [];
-  if (typeof evlistener === 'function') return unwrap ? [evlistener.listener || evlistener] : [evlistener];
-  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
-}
-EventEmitter.prototype.listeners = function listeners(type) {
-  return _listeners(this, type, true);
-};
-EventEmitter.prototype.rawListeners = function rawListeners(type) {
-  return _listeners(this, type, false);
-};
-EventEmitter.listenerCount = function (emitter, type) {
-  if (typeof emitter.listenerCount === 'function') {
-    return emitter.listenerCount(type);
-  } else {
-    return listenerCount.call(emitter, type);
-  }
-};
-EventEmitter.prototype.listenerCount = listenerCount;
-function listenerCount(type) {
-  var events = this._events;
-  if (events !== undefined) {
-    var evlistener = events[type];
-    if (typeof evlistener === 'function') {
-      return 1;
-    } else if (evlistener !== undefined) {
-      return evlistener.length;
-    }
-  }
-  return 0;
-}
-EventEmitter.prototype.eventNames = function eventNames() {
-  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
-};
-function arrayClone(arr, n) {
-  var copy = new Array(n);
-  for (var i = 0; i < n; ++i) copy[i] = arr[i];
-  return copy;
-}
-function spliceOne(list, index) {
-  for (; index + 1 < list.length; index++) list[index] = list[index + 1];
-  list.pop();
-}
-function unwrapListeners(arr) {
-  var ret = new Array(arr.length);
-  for (var i = 0; i < ret.length; ++i) {
-    ret[i] = arr[i].listener || arr[i];
-  }
-  return ret;
-}
-function once(emitter, name) {
-  return new Promise(function (resolve, reject) {
-    function errorListener(err) {
-      emitter.removeListener(name, resolver);
-      reject(err);
-    }
-    function resolver() {
-      if (typeof emitter.removeListener === 'function') {
-        emitter.removeListener('error', errorListener);
-      }
-      resolve([].slice.call(arguments));
-    }
-    eventTargetAgnosticAddListener(emitter, name, resolver, {
-      once: true
-    });
-    if (name !== 'error') {
-      addErrorHandlerIfEventEmitter(emitter, errorListener, {
-        once: true
-      });
-    }
-  });
-}
-function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
-  if (typeof emitter.on === 'function') {
-    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
-  }
-}
-function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
-  if (typeof emitter.on === 'function') {
-    if (flags.once) {
-      emitter.once(name, listener);
-    } else {
-      emitter.on(name, listener);
-    }
-  } else if (typeof emitter.addEventListener === 'function') {
-    // EventTarget does not have `error` event semantics like Node
-    // EventEmitters, we do not listen for `error` events here.
-    emitter.addEventListener(name, function wrapListener(arg) {
-      // IE does not have builtin `{ once: true }` support so we
-      // have to do it manually.
-      if (flags.once) {
-        emitter.removeEventListener(name, wrapListener);
-      }
-      listener(arg);
-    });
-  } else {
-    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
-  }
-}
-var eventsExports = events.exports;
+})(eventemitter3);
+var eventemitter3Exports = eventemitter3.exports;
+var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
@@ -14251,7 +14187,7 @@ function getMatch(exp, ua) {
   return match && match.length >= id && match[id] || '';
 }
 
-var version$1 = "1.10.0";
+var version$1 = "1.11.1";
 
 const version = version$1;
 const protocolVersion = 9;
@@ -14566,7 +14502,7 @@ function getEmptyVideoStreamTrack() {
   if (!emptyVideoStreamTrack) {
     emptyVideoStreamTrack = createDummyVideoStreamTrack();
   }
-  return emptyVideoStreamTrack;
+  return emptyVideoStreamTrack.clone();
 }
 function createDummyVideoStreamTrack() {
   let width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 16;
@@ -14601,8 +14537,11 @@ function getEmptyAudioStreamTrack() {
     // implementation adapted from https://blog.mozilla.org/webrtc/warm-up-with-replacetrack/
     const ctx = new AudioContext();
     const oscillator = ctx.createOscillator();
+    const gain = ctx.createGain();
+    gain.gain.setValueAtTime(0, 0);
     const dst = ctx.createMediaStreamDestination();
-    oscillator.connect(dst);
+    oscillator.connect(gain);
+    gain.connect(dst);
     oscillator.start();
     [emptyAudioStreamTrack] = dst.stream.getAudioTracks();
     if (!emptyAudioStreamTrack) {
@@ -14610,7 +14549,7 @@ function getEmptyAudioStreamTrack() {
     }
     emptyAudioStreamTrack.enabled = false;
   }
-  return emptyAudioStreamTrack;
+  return emptyAudioStreamTrack.clone();
 }
 class Future {
   constructor(futureBase, onFinally) {
@@ -16082,7 +16021,7 @@ const PCEvents = {
   NegotiationComplete: 'negotiationComplete'
 };
 /** @internal */
-class PCTransport extends eventsExports.EventEmitter {
+class PCTransport extends EventEmitter {
   constructor(config) {
     let mediaConstraints = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     super();
@@ -17017,7 +16956,7 @@ const BACKGROUND_REACTION_DELAY = 5000;
 // keep old audio elements when detached, we would re-use them since on iOS
 // Safari tracks which audio elements have been "blessed" by the user.
 const recycledElements = [];
-class Track extends eventsExports.EventEmitter {
+class Track extends EventEmitter {
   constructor(mediaTrack, kind) {
     super();
     this.attachedElements = [];
@@ -17041,7 +16980,6 @@ class Track extends eventsExports.EventEmitter {
         this.handleAppVisibilityChanged();
       }
     };
-    this.setMaxListeners(100);
     this.kind = kind;
     this._mediaStreamTrack = mediaTrack;
     this._mediaStreamID = mediaTrack.id;
@@ -17361,7 +17299,7 @@ var PCState;
   PCState[PCState["Closed"] = 4] = "Closed";
 })(PCState || (PCState = {}));
 /** @internal */
-class RTCEngine extends eventsExports.EventEmitter {
+class RTCEngine extends EventEmitter {
   get isClosed() {
     return this._isClosed;
   }
@@ -17499,6 +17437,7 @@ class RTCEngine extends eventsExports.EventEmitter {
         };
         this.once(EngineEvent.Restarted, onRestarted);
         this.once(EngineEvent.Disconnected, onDisconnected);
+        this.once(EngineEvent.Closing, onDisconnected);
       });
     };
     this.updateAndEmitDCBufferStatus = kind => {
@@ -18291,7 +18230,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       }
       this.hasPublished = true;
       const handleClosed = () => {
-        livekitLogger.debug('engine disconnected while negotiation was ongoing');
+        livekitLogger.warn('engine disconnected while negotiation was ongoing');
         cleanup();
         resolve();
         return;
@@ -18438,14 +18377,66 @@ class LocalTrack extends Track {
       if (this.isInBackground) {
         this.reacquireTrack = true;
       }
+      this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
+      this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
       this.emit(TrackEvent.Ended, this);
     };
-    this._mediaStreamTrack.addEventListener('ended', this.handleEnded);
-    this.constraints = constraints !== null && constraints !== void 0 ? constraints : mediaTrack.getConstraints();
+    /**
+     * pauses publishing to the server without disabling the local MediaStreamTrack
+     * this is used to display a user's own video locally while pausing publishing to
+     * the server.
+     * this API is unsupported on Safari < 12 due to a bug
+     **/
+    this.pauseUpstream = () => __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.pauseUpstreamLock.lock();
+      try {
+        if (this._isUpstreamPaused === true) {
+          return;
+        }
+        if (!this.sender) {
+          livekitLogger.warn('unable to pause upstream for an unpublished track');
+          return;
+        }
+        this._isUpstreamPaused = true;
+        this.emit(TrackEvent.UpstreamPaused, this);
+        const browser = getBrowser();
+        if ((browser === null || browser === void 0 ? void 0 : browser.name) === 'Safari' && compareVersions(browser.version, '12.0') < 0) {
+          // https://bugs.webkit.org/show_bug.cgi?id=184911
+          throw new DeviceUnsupportedError('pauseUpstream is not supported on Safari < 12.');
+        }
+        yield this.sender.replaceTrack(null);
+      } finally {
+        unlock();
+      }
+    });
+    this.resumeUpstream = () => __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.pauseUpstreamLock.lock();
+      try {
+        if (this._isUpstreamPaused === false) {
+          return;
+        }
+        if (!this.sender) {
+          livekitLogger.warn('unable to resume upstream for an unpublished track');
+          return;
+        }
+        this._isUpstreamPaused = false;
+        this.emit(TrackEvent.UpstreamResumed, this);
+        // this operation is noop if mediastreamtrack is already being sent
+        yield this.sender.replaceTrack(this._mediaStreamTrack);
+      } finally {
+        unlock();
+      }
+    });
     this.reacquireTrack = false;
     this.providedByUser = userProvidedTrack;
     this.muteLock = new Mutex();
     this.pauseUpstreamLock = new Mutex();
+    // added to satisfy TS compiler, constraints are synced with MediaStreamTrack
+    this.constraints = mediaTrack.getConstraints();
+    this.setMediaStreamTrack(mediaTrack);
+    if (constraints) {
+      this.constraints = constraints;
+    }
   }
   get id() {
     return this._mediaStreamTrack.id;
@@ -18476,6 +18467,50 @@ class LocalTrack extends Track {
     var _a, _b;
     return (_b = (_a = this.processor) === null || _a === void 0 ? void 0 : _a.processedTrack) !== null && _b !== void 0 ? _b : this._mediaStreamTrack;
   }
+  setMediaStreamTrack(newTrack) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (newTrack === this._mediaStreamTrack) {
+        return;
+      }
+      if (this._mediaStreamTrack) {
+        // detach
+        this.attachedElements.forEach(el => {
+          detachTrack(this._mediaStreamTrack, el);
+        });
+        this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
+        this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
+        this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
+        if (!this.providedByUser) {
+          this._mediaStreamTrack.stop();
+        }
+      }
+      this.mediaStream = new MediaStream([newTrack]);
+      if (newTrack) {
+        newTrack.addEventListener('ended', this.handleEnded);
+        // when underlying track emits mute, it indicates that the device is unable
+        // to produce media. In this case we'll need to signal with remote that
+        // the track is "muted"
+        // note this is different from LocalTrack.mute because we do not want to
+        // touch MediaStreamTrack.enabled
+        newTrack.addEventListener('mute', this.pauseUpstream);
+        newTrack.addEventListener('unmute', this.resumeUpstream);
+        this.constraints = newTrack.getConstraints();
+      }
+      if (this.sender) {
+        yield this.sender.replaceTrack(newTrack);
+      }
+      this._mediaStreamTrack = newTrack;
+      if (newTrack) {
+        // sync muted state with the enabled state of the newly provided track
+        this._mediaStreamTrack.enabled = !this.isMuted;
+        // when a valid track is replace, we'd want to start producing
+        yield this.resumeUpstream();
+        this.attachedElements.forEach(el => {
+          attachToElement(newTrack, el);
+        });
+      }
+    });
+  }
   waitForDimensions() {
     let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultDimensionsTimeout;
     return __awaiter(this, void 0, void 0, function* () {
@@ -18528,30 +18563,10 @@ class LocalTrack extends Track {
       if (!this.sender) {
         throw new TrackInvalidError('unable to replace an unpublished track');
       }
-      // detach
-      this.attachedElements.forEach(el => {
-        detachTrack(this._mediaStreamTrack, el);
-      });
-      this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
-      // on Safari, the old audio track must be stopped before attempting to acquire
-      // the new track, otherwise the new track will stop with
-      // 'A MediaStreamTrack ended due to a capture failure`
-      if (!this.providedByUser) {
-        this._mediaStreamTrack.stop();
-      }
-      track.addEventListener('ended', this.handleEnded);
       livekitLogger.debug('replace MediaStreamTrack');
-      if (this.sender) {
-        yield this.sender.replaceTrack(track);
-      }
-      this._mediaStreamTrack = track;
-      // sync muted state with the enabled state of the newly provided track
-      this._mediaStreamTrack.enabled = !this.isMuted;
-      yield this.resumeUpstream();
-      this.attachedElements.forEach(el => {
-        attachToElement(track, el);
-      });
-      this.mediaStream = new MediaStream([track]);
+      this.setMediaStreamTrack(track);
+      // this must be synced *after* setting mediaStreamTrack above, since it relies
+      // on the previous state in order to cleanup
       this.providedByUser = userProvidedTrack;
       if (this.processor) {
         yield this.stopProcessor();
@@ -18574,7 +18589,8 @@ class LocalTrack extends Track {
       } else {
         streamConstraints.audio = constraints;
       }
-      // detach
+      // these steps are duplicated from setMediaStreamTrack because we must stop
+      // the previous tracks before new tracks can be acquired
       this.attachedElements.forEach(el => {
         detachTrack(this.mediaStreamTrack, el);
       });
@@ -18588,13 +18604,7 @@ class LocalTrack extends Track {
       const newTrack = mediaStream.getTracks()[0];
       newTrack.addEventListener('ended', this.handleEnded);
       livekitLogger.debug('re-acquired MediaStreamTrack');
-      if (this.sender) {
-        // Track can be restarted after it's unpublished
-        yield this.sender.replaceTrack(newTrack);
-      }
-      this._mediaStreamTrack = newTrack;
-      yield this.resumeUpstream();
-      this.mediaStream = mediaStream;
+      this.setMediaStreamTrack(newTrack);
       this.constraints = constraints;
       if (this.processor) {
         const processor = this.processor;
@@ -18640,58 +18650,12 @@ class LocalTrack extends Track {
   stop() {
     var _a;
     super.stop();
+    this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
+    this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
+    this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
     (_a = this.processor) === null || _a === void 0 ? void 0 : _a.destroy();
     this.processor = undefined;
   }
-  /**
-   * pauses publishing to the server without disabling the local MediaStreamTrack
-   * this is used to display a user's own video locally while pausing publishing to
-   * the server.
-   * this API is unsupported on Safari < 12 due to a bug
-   **/
-  pauseUpstream() {
-    return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.pauseUpstreamLock.lock();
-      try {
-        if (this._isUpstreamPaused === true) {
-          return;
-        }
-        if (!this.sender) {
-          livekitLogger.warn('unable to pause upstream for an unpublished track');
-          return;
-        }
-        this._isUpstreamPaused = true;
-        this.emit(TrackEvent.UpstreamPaused, this);
-        const browser = getBrowser();
-        if ((browser === null || browser === void 0 ? void 0 : browser.name) === 'Safari' && compareVersions(browser.version, '12.0') < 0) {
-          // https://bugs.webkit.org/show_bug.cgi?id=184911
-          throw new DeviceUnsupportedError('pauseUpstream is not supported on Safari < 12.');
-        }
-        yield this.sender.replaceTrack(null);
-      } finally {
-        unlock();
-      }
-    });
-  }
-  resumeUpstream() {
-    return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.pauseUpstreamLock.lock();
-      try {
-        if (this._isUpstreamPaused === false) {
-          return;
-        }
-        if (!this.sender) {
-          livekitLogger.warn('unable to resume upstream for an unpublished track');
-          return;
-        }
-        this._isUpstreamPaused = false;
-        this.emit(TrackEvent.UpstreamResumed, this);
-        yield this.sender.replaceTrack(this._mediaStreamTrack);
-      } finally {
-        unlock();
-      }
-    });
-  }
   /**
    * Sets a processor on this track.
    * See https://github.com/livekit/track-processors-js for example usage
@@ -19003,25 +18967,23 @@ function computeVideoEncodings(isScreenShare, width, height, options) {
   const original = new VideoPreset(width, height, videoEncoding.maxBitrate, videoEncoding.maxFramerate);
   if (scalabilityMode && isSVCCodec(videoCodec)) {
     livekitLogger.debug("using svc with scalabilityMode ".concat(scalabilityMode));
+    const sm = new ScalabilityMode(scalabilityMode);
     const encodings = [];
-    // svc use first encoding as the original, so we sort encoding from high to low
-    switch (scalabilityMode) {
-      case 'L3T3':
-      case 'L3T3_KEY':
-        encodings.push({
-          rid: videoRids[2],
-          maxBitrate: videoEncoding.maxBitrate,
-          /* @ts-ignore */
-          maxFramerate: original.encoding.maxFramerate,
-          /* @ts-ignore */
-          scalabilityMode: scalabilityMode
-        });
-        livekitLogger.debug('encodings', encodings);
-        return encodings;
-      default:
-        // TODO : support other scalability modes
-        throw new Error("unsupported scalabilityMode: ".concat(scalabilityMode));
+    if (sm.spatial > 3) {
+      throw new Error("unsupported scalabilityMode: ".concat(scalabilityMode));
+    }
+    for (let i = 0; i < sm.spatial; i += 1) {
+      encodings.push({
+        rid: videoRids[2 - i],
+        maxBitrate: videoEncoding.maxBitrate / Math.pow(3, i),
+        /* @ts-ignore */
+        maxFramerate: original.encoding.maxFramerate
+      });
     }
+    /* @ts-ignore */
+    encodings[0].scalabilityMode = scalabilityMode;
+    livekitLogger.debug('encodings', encodings);
+    return encodings;
   }
   if (!useSimulcast) {
     return [videoEncoding];
@@ -19554,44 +19516,13 @@ function setPublishingLayersForSender(sender, senderEncodings, qualities, sender
         return;
       }
       let hasChanged = false;
-      /* @ts-ignore */
-      if (encodings.length === 1 && encodings[0].scalabilityMode) {
-        // svc dynacast encodings
-        const encoding = encodings[0];
-        /* @ts-ignore */
-        // const mode = new ScalabilityMode(encoding.scalabilityMode);
-        let maxQuality = VideoQuality.OFF;
-        qualities.forEach(q => {
-          if (q.enabled && (maxQuality === VideoQuality.OFF || q.quality > maxQuality)) {
-            maxQuality = q.quality;
-          }
-        });
-        if (maxQuality === VideoQuality.OFF) {
-          if (encoding.active) {
-            encoding.active = false;
-            hasChanged = true;
-          }
-        } else if (!encoding.active /* || mode.spatial !== maxQuality + 1*/) {
-          hasChanged = true;
-          encoding.active = true;
-          /* disable closable spatial layer as it has video blur/frozen issue with current server/client
-            1. chrome 113: when switching to up layer with scalability Mode change, it will generate a
+      /* disable closable spatial layer as it has video blur / frozen issue with current server / client
+      1. chrome 113: when switching to up layer with scalability Mode change, it will generate a
             low resolution frame and recover very quickly, but noticable
-            2. livekit sfu: additional pli request cause video frozen for a few frames, also noticable
-          @ts-ignore
-          const originalMode = new ScalabilityMode(senderEncodings[0].scalabilityMode)
-          mode.spatial = maxQuality + 1;
-          mode.suffix = originalMode.suffix;
-          if (mode.spatial === 1) {
-            // no suffix for L1Tx
-            mode.suffix = undefined;
-          }
-          @ts-ignore
-          encoding.scalabilityMode = mode.toString();
-          encoding.scaleResolutionDownBy = 2 ** (2 - maxQuality);
-          */
-        }
-      } else {
+      2. livekit sfu: additional pli request cause video frozen for a few frames, also noticable */
+      const closableSpatial = false;
+      /* @ts-ignore */
+      if (closableSpatial && encodings[0].scalabilityMode) ; else {
         // simulcast dynacast encodings
         encodings.forEach((encoding, idx) => {
           var _a;
@@ -19648,7 +19579,7 @@ function videoQualityForRid(rid) {
       return VideoQuality.UNRECOGNIZED;
   }
 }
-function videoLayersFromEncodings(width, height, encodings) {
+function videoLayersFromEncodings(width, height, encodings, svc) {
   // default to a single layer, HQ
   if (!encodings) {
     return [{
@@ -19659,8 +19590,7 @@ function videoLayersFromEncodings(width, height, encodings) {
       ssrc: 0
     }];
   }
-  /* @ts-ignore */
-  if (encodings.length === 1 && encodings[0].scalabilityMode) {
+  if (svc) {
     // svc layers
     /* @ts-ignore */
     const sm = new ScalabilityMode(encodings[0].scalabilityMode);
@@ -20114,20 +20044,19 @@ class RemoteVideoTrack extends RemoteTrack {
     this.emit(TrackEvent.VisibilityChanged, isVisible, this);
   }
   updateDimensions() {
-    var _a, _b, _c, _d;
+    var _a, _b;
     let maxWidth = 0;
     let maxHeight = 0;
+    const pixelDensity = this.getPixelDensity();
     for (const info of this.elementInfos) {
-      const pixelDensity = (_b = (_a = this.adaptiveStreamSettings) === null || _a === void 0 ? void 0 : _a.pixelDensity) !== null && _b !== void 0 ? _b : 1;
-      const pixelDensityValue = pixelDensity === 'screen' ? getDevicePixelRatio() : pixelDensity;
-      const currentElementWidth = info.width() * pixelDensityValue;
-      const currentElementHeight = info.height() * pixelDensityValue;
+      const currentElementWidth = info.width() * pixelDensity;
+      const currentElementHeight = info.height() * pixelDensity;
       if (currentElementWidth + currentElementHeight > maxWidth + maxHeight) {
         maxWidth = currentElementWidth;
         maxHeight = currentElementHeight;
       }
     }
-    if (((_c = this.lastDimensions) === null || _c === void 0 ? void 0 : _c.width) === maxWidth && ((_d = this.lastDimensions) === null || _d === void 0 ? void 0 : _d.height) === maxHeight) {
+    if (((_a = this.lastDimensions) === null || _a === void 0 ? void 0 : _a.width) === maxWidth && ((_b = this.lastDimensions) === null || _b === void 0 ? void 0 : _b.height) === maxHeight) {
       return;
     }
     this.lastDimensions = {
@@ -20136,6 +20065,24 @@ class RemoteVideoTrack extends RemoteTrack {
     };
     this.emit(TrackEvent.VideoDimensionsChanged, this.lastDimensions, this);
   }
+  getPixelDensity() {
+    var _a;
+    const pixelDensity = (_a = this.adaptiveStreamSettings) === null || _a === void 0 ? void 0 : _a.pixelDensity;
+    if (pixelDensity === 'screen') {
+      return getDevicePixelRatio();
+    } else if (!pixelDensity) {
+      // when unset, we'll pick a sane default here.
+      // for higher pixel density devices (mobile phones, etc), we'll use 2
+      // otherwise it defaults to 1
+      const devicePixelRatio = getDevicePixelRatio();
+      if (devicePixelRatio > 2) {
+        return 2;
+      } else {
+        return 1;
+      }
+    }
+    return pixelDensity;
+  }
 }
 class HTMLElementInfo {
   get visible() {
@@ -20221,7 +20168,7 @@ function isElementInViewport(el) {
   return top < window.pageYOffset + window.innerHeight && left < window.pageXOffset + window.innerWidth && top + height > window.pageYOffset && left + width > window.pageXOffset && !hidden && (opacity !== '' ? parseFloat(opacity) > 0 : true) && display !== 'none';
 }
 
-class TrackPublication extends eventsExports.EventEmitter {
+class TrackPublication extends EventEmitter {
   constructor(kind, id, name) {
     super();
     this.metadataMuted = false;
@@ -20231,7 +20178,6 @@ class TrackPublication extends eventsExports.EventEmitter {
     this.handleUnmuted = () => {
       this.emit(TrackEvent.Unmuted);
     };
-    this.setMaxListeners(100);
     this.kind = kind;
     this.trackSid = id;
     this.trackName = name;
@@ -20401,7 +20347,7 @@ function qualityFromProto(q) {
       return ConnectionQuality.Unknown;
   }
 }
-class Participant extends eventsExports.EventEmitter {
+class Participant extends EventEmitter {
   /** @internal */
   constructor(sid, identity, name, metadata) {
     super();
@@ -20410,7 +20356,6 @@ class Participant extends eventsExports.EventEmitter {
     /** if participant is currently speaking */
     this.isSpeaking = false;
     this._connectionQuality = ConnectionQuality.Unknown;
-    this.setMaxListeners(100);
     this.sid = sid;
     this.identity = identity;
     this.name = name;
@@ -21114,8 +21059,11 @@ class LocalParticipant extends Participant {
     };
     this.handleDisconnected = () => {
       var _a, _b;
-      (_b = (_a = this.reconnectFuture) === null || _a === void 0 ? void 0 : _a.reject) === null || _b === void 0 ? void 0 : _b.call(_a, 'Got disconnected during publishing attempt');
-      this.reconnectFuture = undefined;
+      if (this.reconnectFuture) {
+        this.reconnectFuture.promise.catch(e => livekitLogger.warn(e));
+        (_b = (_a = this.reconnectFuture) === null || _a === void 0 ? void 0 : _a.reject) === null || _b === void 0 ? void 0 : _b.call(_a, 'Got disconnected during reconnection attempt');
+        this.reconnectFuture = undefined;
+      }
     };
     this.updateTrackSubscriptionPermissions = () => {
       livekitLogger.debug('updating track subscription permissions', {
@@ -21727,7 +21675,7 @@ class LocalParticipant extends Participant {
           }
         }
         encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, dims.width, dims.height, opts);
-        req.layers = videoLayersFromEncodings(req.width, req.height, encodings);
+        req.layers = videoLayersFromEncodings(req.width, req.height, encodings, isSVCCodec(opts.videoCodec));
       } else if (track.kind === Track.Kind.Audio) {
         encodings = [{
           maxBitrate: (_h = (_g = opts.audioPreset) === null || _g === void 0 ? void 0 : _g.maxBitrate) !== null && _h !== void 0 ? _h : opts.audioBitrate,
@@ -22107,7 +22055,7 @@ const RoomState = ConnectionState;
  *
  * @noInheritDoc
  */
-class Room extends eventsExports.EventEmitter {
+class Room extends EventEmitter {
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -22272,6 +22220,9 @@ class Room extends eventsExports.EventEmitter {
         // capturing both 'pagehide' and 'beforeunload' to capture broadest set of browser behaviors
         window.addEventListener('pagehide', this.onPageLeave);
         window.addEventListener('beforeunload', this.onPageLeave);
+      }
+      if (isWeb()) {
+        document.addEventListener('freeze', this.onPageLeave);
         (_b = navigator.mediaDevices) === null || _b === void 0 ? void 0 : _b.addEventListener('devicechange', this.handleDeviceChange);
       }
       this.setAndEmitConnectionState(ConnectionState.Connected);
@@ -22589,7 +22540,6 @@ class Room extends eventsExports.EventEmitter {
     this.onLocalParticipantPermissionsChanged = prevPermissions => {
       this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, this.localParticipant);
     };
-    this.setMaxListeners(100);
     this.participants = new Map();
     this.cachedParticipantSids = [];
     this.identityToSid = new Map();
@@ -22813,6 +22763,28 @@ class Room extends eventsExports.EventEmitter {
     return __awaiter(this, void 0, void 0, function* () {
       yield this.acquireAudioContext();
       const elements = [];
+      if (isSafari()) {
+        /**
+         * iOS Safari blocks audio element playback if
+         * - user is not publishing audio themselves and
+         * - no other audio source is playing
+         *
+         * as a workaround, we create an audio element with an empty track, so that
+         * silent audio is always playing
+         */
+        const audioId = 'livekit-dummy-audio-el';
+        let dummyAudioEl = document.getElementById(audioId);
+        if (!dummyAudioEl) {
+          dummyAudioEl = document.createElement('audio');
+          dummyAudioEl.autoplay = true;
+          dummyAudioEl.hidden = true;
+          const track = getEmptyAudioStreamTrack();
+          track.enabled = true;
+          dummyAudioEl.srcObject = new MediaStream([track]);
+          document.body.append(dummyAudioEl);
+        }
+        elements.push(dummyAudioEl);
+      }
       this.participants.forEach(p => {
         p.audioTracks.forEach(t => {
           if (t.track) {
@@ -23008,6 +22980,7 @@ class Room extends eventsExports.EventEmitter {
       if (isWeb()) {
         window.removeEventListener('beforeunload', this.onPageLeave);
         window.removeEventListener('pagehide', this.onPageLeave);
+        window.removeEventListener('freeze', this.onPageLeave);
         (_a = navigator.mediaDevices) === null || _a === void 0 ? void 0 : _a.removeEventListener('devicechange', this.handleDeviceChange);
       }
     } finally {
@@ -23321,6 +23294,10 @@ class Room extends eventsExports.EventEmitter {
     for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
       args[_key2 - 1] = arguments[_key2];
     }
+    // emit<E extends keyof RoomEventCallbacks>(
+    //   event: E,
+    //   ...args: Parameters<RoomEventCallbacks[E]>
+    // ): boolean {
     // active speaker updates are too spammy
     if (event !== RoomEvent.ActiveSpeakersChanged) {
       livekitLogger.debug("room event ".concat(event), {
@@ -23340,7 +23317,7 @@ var CheckStatus;
   CheckStatus[CheckStatus["SUCCESS"] = 3] = "SUCCESS";
   CheckStatus[CheckStatus["FAILED"] = 4] = "FAILED";
 })(CheckStatus || (CheckStatus = {}));
-class Checker extends eventsExports.EventEmitter {
+class Checker extends EventEmitter {
   constructor(url, token) {
     let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     super();
@@ -23752,7 +23729,7 @@ class WebSocketCheck extends Checker {
   }
 }
 
-class ConnectionCheck extends eventsExports.EventEmitter {
+class ConnectionCheck extends EventEmitter {
   constructor(url, token) {
     super();
     this.checkResults = new Map();