livekit-client 2.5.1 → 2.5.3

package/dist/livekit-client.esm.mjs

@@ -3397,6 +3397,218 @@ target => {
   }
 });
 
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A proto3 JSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a proto3 JSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ *
+ *
+ * @generated from message google.protobuf.Timestamp
+ */
+class Timestamp extends Message {
+  constructor(data) {
+    super();
+    /**
+     * Represents seconds of UTC time since Unix epoch
+     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     * 9999-12-31T23:59:59Z inclusive.
+     *
+     * @generated from field: int64 seconds = 1;
+     */
+    this.seconds = protoInt64.zero;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nanos values
+     * that count forward in time. Must be from 0 to 999,999,999
+     * inclusive.
+     *
+     * @generated from field: int32 nanos = 2;
+     */
+    this.nanos = 0;
+    proto3.util.initPartial(data, this);
+  }
+  fromJson(json, options) {
+    if (typeof json !== "string") {
+      throw new Error("cannot decode google.protobuf.Timestamp from JSON: ".concat(proto3.json.debug(json)));
+    }
+    const matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
+    if (!matches) {
+      throw new Error("cannot decode google.protobuf.Timestamp from JSON: invalid RFC 3339 string");
+    }
+    const ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
+    if (Number.isNaN(ms)) {
+      throw new Error("cannot decode google.protobuf.Timestamp from JSON: invalid RFC 3339 string");
+    }
+    if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) {
+      throw new Error("cannot decode message google.protobuf.Timestamp from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive");
+    }
+    this.seconds = protoInt64.parse(ms / 1000);
+    this.nanos = 0;
+    if (matches[7]) {
+      this.nanos = parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000;
+    }
+    return this;
+  }
+  toJson(options) {
+    const ms = Number(this.seconds) * 1000;
+    if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) {
+      throw new Error("cannot encode google.protobuf.Timestamp to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive");
+    }
+    if (this.nanos < 0) {
+      throw new Error("cannot encode google.protobuf.Timestamp to JSON: nanos must not be negative");
+    }
+    let z = "Z";
+    if (this.nanos > 0) {
+      const nanosStr = (this.nanos + 1000000000).toString().substring(1);
+      if (nanosStr.substring(3) === "000000") {
+        z = "." + nanosStr.substring(0, 3) + "Z";
+      } else if (nanosStr.substring(6) === "000") {
+        z = "." + nanosStr.substring(0, 6) + "Z";
+      } else {
+        z = "." + nanosStr + "Z";
+      }
+    }
+    return new Date(ms).toISOString().replace(".000Z", z);
+  }
+  toDate() {
+    return new Date(Number(this.seconds) * 1000 + Math.ceil(this.nanos / 1000000));
+  }
+  static now() {
+    return Timestamp.fromDate(new Date());
+  }
+  static fromDate(date) {
+    const ms = date.getTime();
+    return new Timestamp({
+      seconds: protoInt64.parse(Math.floor(ms / 1000)),
+      nanos: ms % 1000 * 1000000
+    });
+  }
+  static fromBinary(bytes, options) {
+    return new Timestamp().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new Timestamp().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new Timestamp().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proto3.util.equals(Timestamp, a, b);
+  }
+}
+Timestamp.runtime = proto3;
+Timestamp.typeName = "google.protobuf.Timestamp";
+Timestamp.fields = proto3.util.newFieldList(() => [{
+  no: 1,
+  name: "seconds",
+  kind: "scalar",
+  T: 3 /* ScalarType.INT64 */
+}, {
+  no: 2,
+  name: "nanos",
+  kind: "scalar",
+  T: 5 /* ScalarType.INT32 */
+}]);
+
 // @generated by protoc-gen-es v1.10.0 with parameter "target=js+dts"
 // @generated from file livekit_metrics.proto (package livekit, syntax proto3)
 /* eslint-disable */
@@ -3408,18 +3620,28 @@ target => {
  */
 const MetricsBatch = /*@__PURE__*/proto3.makeMessageType("livekit.MetricsBatch", () => [{
   no: 1,
+  name: "timestamp_ms",
+  kind: "scalar",
+  T: 3 /* ScalarType.INT64 */
+}, {
+  no: 2,
+  name: "normalized_timestamp",
+  kind: "message",
+  T: Timestamp
+}, {
+  no: 3,
   name: "str_data",
   kind: "scalar",
   T: 9 /* ScalarType.STRING */,
   repeated: true
 }, {
-  no: 2,
+  no: 4,
   name: "time_series",
   kind: "message",
   T: TimeSeriesMetric,
   repeated: true
 }, {
-  no: 3,
+  no: 5,
   name: "events",
   kind: "message",
   T: EventMetric,
@@ -3446,16 +3668,6 @@ const TimeSeriesMetric = /*@__PURE__*/proto3.makeMessageType("livekit.TimeSeries
   T: 13 /* ScalarType.UINT32 */
 }, {
   no: 4,
-  name: "start_timestamp",
-  kind: "scalar",
-  T: 3 /* ScalarType.INT64 */
-}, {
-  no: 5,
-  name: "end_timestamp",
-  kind: "scalar",
-  T: 3 /* ScalarType.INT64 */
-}, {
-  no: 6,
   name: "samples",
   kind: "message",
   T: MetricSample,
@@ -3467,11 +3679,16 @@ const TimeSeriesMetric = /*@__PURE__*/proto3.makeMessageType("livekit.TimeSeries
  */
 const MetricSample = /*@__PURE__*/proto3.makeMessageType("livekit.MetricSample", () => [{
   no: 1,
-  name: "timestamp",
+  name: "timestamp_ms",
   kind: "scalar",
   T: 3 /* ScalarType.INT64 */
 }, {
   no: 2,
+  name: "normalized_timestamp",
+  kind: "message",
+  T: Timestamp
+}, {
+  no: 3,
   name: "value",
   kind: "scalar",
   T: 2 /* ScalarType.FLOAT */
@@ -3497,17 +3714,28 @@ const EventMetric = /*@__PURE__*/proto3.makeMessageType("livekit.EventMetric", (
   T: 13 /* ScalarType.UINT32 */
 }, {
   no: 4,
-  name: "start_timestamp",
+  name: "start_timestamp_ms",
   kind: "scalar",
   T: 3 /* ScalarType.INT64 */
 }, {
   no: 5,
-  name: "end_timestamp",
+  name: "end_timestamp_ms",
   kind: "scalar",
   T: 3 /* ScalarType.INT64 */,
   opt: true
 }, {
   no: 6,
+  name: "normalized_start_timestamp",
+  kind: "message",
+  T: Timestamp
+}, {
+  no: 7,
+  name: "normalized_end_timestamp",
+  kind: "message",
+  T: Timestamp,
+  opt: true
+}, {
+  no: 8,
   name: "metadata",
   kind: "scalar",
   T: 9 /* ScalarType.STRING */
@@ -4185,6 +4413,12 @@ const DataPacket = /*@__PURE__*/proto3.makeMessageType("livekit.DataPacket", ()
   kind: "message",
   T: MetricsBatch,
   oneof: "value"
+}, {
+  no: 9,
+  name: "chat_message",
+  kind: "message",
+  T: ChatMessage,
+  oneof: "value"
 }]);
 
 /**
@@ -4356,6 +4590,42 @@ const TranscriptionSegment = /*@__PURE__*/proto3.makeMessageType("livekit.Transc
   T: 9 /* ScalarType.STRING */
 }]);
 
+/**
+ * @generated from message livekit.ChatMessage
+ */
+const ChatMessage = /*@__PURE__*/proto3.makeMessageType("livekit.ChatMessage", () => [{
+  no: 1,
+  name: "id",
+  kind: "scalar",
+  T: 9 /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "timestamp",
+  kind: "scalar",
+  T: 3 /* ScalarType.INT64 */
+}, {
+  no: 3,
+  name: "edit_timestamp",
+  kind: "scalar",
+  T: 3 /* ScalarType.INT64 */,
+  opt: true
+}, {
+  no: 4,
+  name: "message",
+  kind: "scalar",
+  T: 9 /* ScalarType.STRING */
+}, {
+  no: 5,
+  name: "deleted",
+  kind: "scalar",
+  T: 8 /* ScalarType.BOOL */
+}, {
+  no: 6,
+  name: "generated",
+  kind: "scalar",
+  T: 8 /* ScalarType.BOOL */
+}]);
+
 /**
  * @generated from message livekit.ParticipantTracks
  */
@@ -4518,6 +4788,12 @@ const ClientInfo_SDK = /*@__PURE__*/proto3.makeEnum("livekit.ClientInfo.SDK", [{
 }, {
   no: 10,
   name: "CPP"
+}, {
+  no: 11,
+  name: "UNITY_WEB"
+}, {
+  no: 12,
+  name: "NODE"
 }]);
 
 /**
@@ -6236,7 +6512,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
 function __awaiter(thisArg, _arguments, P, generator) {
@@ -10320,6 +10596,7 @@ var RoomEvent;
    * args: (kind: MediaDeviceKind, deviceId: string)
    */
   RoomEvent["ActiveDeviceChanged"] = "activeDeviceChanged";
+  RoomEvent["ChatMessage"] = "chatMessage";
   /**
    * fired when the first remote participant has subscribed to the localParticipant's track
    */
@@ -10491,6 +10768,8 @@ var ParticipantEvent;
    * fired on local participant only, when the first remote participant has subscribed to the track specified in the payload
    */
   ParticipantEvent["LocalTrackSubscribed"] = "localTrackSubscribed";
+  /** only emitted on local participant */
+  ParticipantEvent["ChatMessage"] = "chatMessage";
 })(ParticipantEvent || (ParticipantEvent = {}));
 /** @internal */
 var EngineEvent;
@@ -10714,7 +10993,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.5.1";
+var version$1 = "2.5.3";
 
 const version = version$1;
 const protocolVersion = 15;
@@ -11872,6 +12151,20 @@ function extractTranscriptionSegments(transcription, firstReceivedTimesMap) {
     };
   });
 }
+function extractChatMessage(msg) {
+  const {
+    id,
+    timestamp,
+    message,
+    editTimestamp
+  } = msg;
+  return {
+    id,
+    timestamp: Number.parseInt(timestamp.toString()),
+    editTimestamp: editTimestamp ? Number.parseInt(editTimestamp.toString()) : undefined,
+    message
+  };
+}
 
 const defaultId = 'default';
 class DeviceManager {
@@ -12139,17 +12432,21 @@ class LocalTrack extends Track {
    * @returns DeviceID of the device that is currently being used for this track
    */
   getDeviceId() {
-    return __awaiter(this, void 0, void 0, function* () {
-      // screen share doesn't have a usable device id
-      if (this.source === Track.Source.ScreenShare) {
-        return;
-      }
-      const {
-        deviceId,
-        groupId
-      } = this._mediaStreamTrack.getSettings();
-      const kind = this.kind === Track.Kind.Audio ? 'audioinput' : 'videoinput';
-      return DeviceManager.getInstance().normalizeDeviceId(kind, deviceId, groupId);
+    return __awaiter(this, arguments, void 0, function () {
+      var _this2 = this;
+      let normalize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      return function* () {
+        // screen share doesn't have a usable device id
+        if (_this2.source === Track.Source.ScreenShare) {
+          return;
+        }
+        const {
+          deviceId,
+          groupId
+        } = _this2._mediaStreamTrack.getSettings();
+        const kind = _this2.kind === Track.Kind.Audio ? 'audioinput' : 'videoinput';
+        return normalize ? DeviceManager.getInstance().normalizeDeviceId(kind, deviceId, groupId) : deviceId;
+      }();
     });
   }
   mute() {
@@ -12353,45 +12650,45 @@ class LocalTrack extends Track {
    */
   setProcessor(processor_1) {
     return __awaiter(this, arguments, void 0, function (processor) {
-      var _this2 = this;
+      var _this3 = this;
       let showProcessedStreamLocally = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
       return function* () {
         var _a;
-        const unlock = yield _this2.processorLock.lock();
+        const unlock = yield _this3.processorLock.lock();
         try {
-          _this2.log.debug('setting up processor', _this2.logContext);
-          const processorElement = document.createElement(_this2.kind);
+          _this3.log.debug('setting up processor', _this3.logContext);
+          const processorElement = document.createElement(_this3.kind);
           const processorOptions = {
-            kind: _this2.kind,
-            track: _this2._mediaStreamTrack,
+            kind: _this3.kind,
+            track: _this3._mediaStreamTrack,
             element: processorElement,
-            audioContext: _this2.audioContext
+            audioContext: _this3.audioContext
           };
           yield processor.init(processorOptions);
-          _this2.log.debug('processor initialized', _this2.logContext);
-          if (_this2.processor) {
-            yield _this2.stopProcessor();
+          _this3.log.debug('processor initialized', _this3.logContext);
+          if (_this3.processor) {
+            yield _this3.stopProcessor();
           }
-          if (_this2.kind === 'unknown') {
+          if (_this3.kind === 'unknown') {
             throw TypeError('cannot set processor on track of unknown kind');
           }
-          attachToElement(_this2._mediaStreamTrack, processorElement);
+          attachToElement(_this3._mediaStreamTrack, processorElement);
           processorElement.muted = true;
-          processorElement.play().catch(error => _this2.log.error('failed to play processor element', Object.assign(Object.assign({}, _this2.logContext), {
+          processorElement.play().catch(error => _this3.log.error('failed to play processor element', Object.assign(Object.assign({}, _this3.logContext), {
             error
           })));
-          _this2.processor = processor;
-          _this2.processorElement = processorElement;
-          if (_this2.processor.processedTrack) {
-            for (const el of _this2.attachedElements) {
-              if (el !== _this2.processorElement && showProcessedStreamLocally) {
-                detachTrack(_this2._mediaStreamTrack, el);
-                attachToElement(_this2.processor.processedTrack, el);
+          _this3.processor = processor;
+          _this3.processorElement = processorElement;
+          if (_this3.processor.processedTrack) {
+            for (const el of _this3.attachedElements) {
+              if (el !== _this3.processorElement && showProcessedStreamLocally) {
+                detachTrack(_this3._mediaStreamTrack, el);
+                attachToElement(_this3.processor.processedTrack, el);
               }
             }
-            yield (_a = _this2.sender) === null || _a === void 0 ? void 0 : _a.replaceTrack(_this2.processor.processedTrack);
+            yield (_a = _this3.sender) === null || _a === void 0 ? void 0 : _a.replaceTrack(_this3.processor.processedTrack);
           }
-          _this2.emit(TrackEvent.TrackProcessorUpdate, _this2.processor);
+          _this3.emit(TrackEvent.TrackProcessorUpdate, _this3.processor);
         } finally {
           unlock();
         }
@@ -12410,24 +12707,24 @@ class LocalTrack extends Track {
    */
   stopProcessor() {
     return __awaiter(this, arguments, void 0, function () {
-      var _this3 = this;
+      var _this4 = this;
       let keepElement = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
       return function* () {
         var _a, _b;
-        if (!_this3.processor) return;
-        _this3.log.debug('stopping processor', _this3.logContext);
-        (_a = _this3.processor.processedTrack) === null || _a === void 0 ? void 0 : _a.stop();
-        yield _this3.processor.destroy();
-        _this3.processor = undefined;
+        if (!_this4.processor) return;
+        _this4.log.debug('stopping processor', _this4.logContext);
+        (_a = _this4.processor.processedTrack) === null || _a === void 0 ? void 0 : _a.stop();
+        yield _this4.processor.destroy();
+        _this4.processor = undefined;
         if (!keepElement) {
-          (_b = _this3.processorElement) === null || _b === void 0 ? void 0 : _b.remove();
-          _this3.processorElement = undefined;
+          (_b = _this4.processorElement) === null || _b === void 0 ? void 0 : _b.remove();
+          _this4.processorElement = undefined;
         }
         // apply original track constraints in case the processor changed them
-        yield _this3._mediaStreamTrack.applyConstraints(_this3._constraints);
+        yield _this4._mediaStreamTrack.applyConstraints(_this4._constraints);
         // force re-setting of the mediaStreamTrack on the sender
-        yield _this3.setMediaStreamTrack(_this3._mediaStreamTrack, true);
-        _this3.emit(TrackEvent.TrackProcessorUpdate);
+        yield _this4.setMediaStreamTrack(_this4._mediaStreamTrack, true);
+        _this4.emit(TrackEvent.TrackProcessorUpdate);
       }();
     });
   }
@@ -14801,6 +15098,7 @@ class PCTransportManager {
     };
     this.state = PCTransportState.NEW;
     this.connectionLock = new Mutex();
+    this.remoteOfferLock = new Mutex();
   }
   get logContext() {
     var _a, _b;
@@ -14873,10 +15171,15 @@ class PCTransportManager {
         sdp: sd.sdp,
         signalingState: this.subscriber.getSignallingState().toString()
       }));
-      yield this.subscriber.setRemoteDescription(sd);
-      // answer the offer
-      const answer = yield this.subscriber.createAndSetAnswer();
-      return answer;
+      const unlock = yield this.remoteOfferLock.lock();
+      try {
+        yield this.subscriber.setRemoteDescription(sd);
+        // answer the offer
+        const answer = yield this.subscriber.createAndSetAnswer();
+        return answer;
+      } finally {
+        unlock();
+      }
     });
   }
   updateConfiguration(config, iceRestart) {
@@ -18209,83 +18512,218 @@ class LocalTrackPublication extends TrackPublication {
   }
 }
 
-var ConnectionQuality;
-(function (ConnectionQuality) {
-  ConnectionQuality["Excellent"] = "excellent";
-  ConnectionQuality["Good"] = "good";
-  ConnectionQuality["Poor"] = "poor";
-  /**
-   * Indicates that a participant has temporarily (or permanently) lost connection to LiveKit.
-   * For permanent disconnection a `ParticipantDisconnected` event will be emitted after a timeout
-   */
-  ConnectionQuality["Lost"] = "lost";
-  ConnectionQuality["Unknown"] = "unknown";
-})(ConnectionQuality || (ConnectionQuality = {}));
-function qualityFromProto(q) {
-  switch (q) {
-    case ConnectionQuality$1.EXCELLENT:
-      return ConnectionQuality.Excellent;
-    case ConnectionQuality$1.GOOD:
-      return ConnectionQuality.Good;
-    case ConnectionQuality$1.POOR:
-      return ConnectionQuality.Poor;
-    case ConnectionQuality$1.LOST:
-      return ConnectionQuality.Lost;
-    default:
-      return ConnectionQuality.Unknown;
+/** @internal */
+function extractProcessorsFromOptions(options) {
+  let audioProcessor;
+  let videoProcessor;
+  if (typeof options.audio === 'object' && options.audio.processor) {
+    audioProcessor = options.audio.processor;
+  }
+  if (typeof options.video === 'object' && options.video.processor) {
+    videoProcessor = options.video.processor;
   }
+  return {
+    audioProcessor,
+    videoProcessor
+  };
 }
-class Participant extends eventsExports.EventEmitter {
-  get logContext() {
+/**
+ * Creates a local video and audio track at the same time. When acquiring both
+ * audio and video tracks together, it'll display a single permission prompt to
+ * the user instead of two separate ones.
+ * @param options
+ */
+function createLocalTracks(options) {
+  return __awaiter(this, void 0, void 0, function* () {
     var _a, _b;
-    return Object.assign({}, (_b = (_a = this.loggerOptions) === null || _a === void 0 ? void 0 : _a.loggerContextCb) === null || _b === void 0 ? void 0 : _b.call(_a));
-  }
-  get isEncrypted() {
-    return this.trackPublications.size > 0 && Array.from(this.trackPublications.values()).every(tr => tr.isEncrypted);
-  }
-  get isAgent() {
-    var _a;
-    return ((_a = this.permissions) === null || _a === void 0 ? void 0 : _a.agent) || this.kind === ParticipantInfo_Kind.AGENT;
-  }
-  get kind() {
-    return this._kind;
-  }
-  /** participant attributes, similar to metadata, but as a key/value map */
-  get attributes() {
-    return Object.freeze(Object.assign({}, this._attributes));
-  }
-  /** @internal */
-  constructor(sid, identity, name, metadata, loggerOptions) {
-    let kind = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : ParticipantInfo_Kind.STANDARD;
-    var _a;
-    super();
-    /** audio level between 0-1.0, 1 being loudest, 0 being softest */
-    this.audioLevel = 0;
-    /** if participant is currently speaking */
-    this.isSpeaking = false;
-    this._connectionQuality = ConnectionQuality.Unknown;
-    this.log = livekitLogger;
-    this.log = getLogger((_a = loggerOptions === null || loggerOptions === void 0 ? void 0 : loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.Participant);
-    this.loggerOptions = loggerOptions;
-    this.setMaxListeners(100);
-    this.sid = sid;
-    this.identity = identity;
-    this.name = name;
-    this.metadata = metadata;
-    this.audioTrackPublications = new Map();
-    this.videoTrackPublications = new Map();
-    this.trackPublications = new Map();
-    this._kind = kind;
-    this._attributes = {};
-  }
-  getTrackPublications() {
-    return Array.from(this.trackPublications.values());
-  }
-  /**
-   * Finds the first track that matches the source filter, for example, getting
-   * the user's camera track with getTrackBySource(Track.Source.Camera).
-   */
-  getTrackPublication(source) {
+    // set default options to true
+    options !== null && options !== void 0 ? options : options = {};
+    (_a = options.audio) !== null && _a !== void 0 ? _a : options.audio = true;
+    (_b = options.video) !== null && _b !== void 0 ? _b : options.video = true;
+    const {
+      audioProcessor,
+      videoProcessor
+    } = extractProcessorsFromOptions(options);
+    const opts = mergeDefaultOptions(options, audioDefaults, videoDefaults);
+    const constraints = constraintsForOptions(opts);
+    // Keep a reference to the promise on DeviceManager and await it in getLocalDevices()
+    // works around iOS Safari Bug https://bugs.webkit.org/show_bug.cgi?id=179363
+    const mediaPromise = navigator.mediaDevices.getUserMedia(constraints);
+    if (options.audio) {
+      DeviceManager.userMediaPromiseMap.set('audioinput', mediaPromise);
+      mediaPromise.catch(() => DeviceManager.userMediaPromiseMap.delete('audioinput'));
+    }
+    if (options.video) {
+      DeviceManager.userMediaPromiseMap.set('videoinput', mediaPromise);
+      mediaPromise.catch(() => DeviceManager.userMediaPromiseMap.delete('videoinput'));
+    }
+    const stream = yield mediaPromise;
+    return Promise.all(stream.getTracks().map(mediaStreamTrack => __awaiter(this, void 0, void 0, function* () {
+      const isAudio = mediaStreamTrack.kind === 'audio';
+      isAudio ? opts.audio : opts.video;
+      let trackConstraints;
+      const conOrBool = isAudio ? constraints.audio : constraints.video;
+      if (typeof conOrBool !== 'boolean') {
+        trackConstraints = conOrBool;
+      }
+      // update the constraints with the device id the user gave permissions to in the permission prompt
+      // otherwise each track restart (e.g. mute - unmute) will try to initialize the device again -> causing additional permission prompts
+      if (trackConstraints) {
+        trackConstraints.deviceId = mediaStreamTrack.getSettings().deviceId;
+      } else {
+        trackConstraints = {
+          deviceId: mediaStreamTrack.getSettings().deviceId
+        };
+      }
+      const track = mediaTrackToLocalTrack(mediaStreamTrack, trackConstraints);
+      if (track.kind === Track.Kind.Video) {
+        track.source = Track.Source.Camera;
+      } else if (track.kind === Track.Kind.Audio) {
+        track.source = Track.Source.Microphone;
+      }
+      track.mediaStream = stream;
+      if (track instanceof LocalAudioTrack && audioProcessor) {
+        yield track.setProcessor(audioProcessor);
+      } else if (track instanceof LocalVideoTrack && videoProcessor) {
+        yield track.setProcessor(videoProcessor);
+      }
+      return track;
+    })));
+  });
+}
+/**
+ * Creates a [[LocalVideoTrack]] with getUserMedia()
+ * @param options
+ */
+function createLocalVideoTrack(options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const tracks = yield createLocalTracks({
+      audio: false,
+      video: options
+    });
+    return tracks[0];
+  });
+}
+function createLocalAudioTrack(options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const tracks = yield createLocalTracks({
+      audio: options,
+      video: false
+    });
+    return tracks[0];
+  });
+}
+/**
+ * Creates a screen capture tracks with getDisplayMedia().
+ * A LocalVideoTrack is always created and returned.
+ * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
+ */
+function createLocalScreenTracks(options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (options === undefined) {
+      options = {};
+    }
+    if (options.resolution === undefined && !isSafari17()) {
+      options.resolution = ScreenSharePresets.h1080fps30.resolution;
+    }
+    if (navigator.mediaDevices.getDisplayMedia === undefined) {
+      throw new DeviceUnsupportedError('getDisplayMedia not supported');
+    }
+    const constraints = screenCaptureToDisplayMediaStreamOptions(options);
+    const stream = yield navigator.mediaDevices.getDisplayMedia(constraints);
+    const tracks = stream.getVideoTracks();
+    if (tracks.length === 0) {
+      throw new TrackInvalidError('no video track found');
+    }
+    const screenVideo = new LocalVideoTrack(tracks[0], undefined, false);
+    screenVideo.source = Track.Source.ScreenShare;
+    const localTracks = [screenVideo];
+    if (stream.getAudioTracks().length > 0) {
+      const screenAudio = new LocalAudioTrack(stream.getAudioTracks()[0], undefined, false);
+      screenAudio.source = Track.Source.ScreenShareAudio;
+      localTracks.push(screenAudio);
+    }
+    return localTracks;
+  });
+}
+
+var ConnectionQuality;
+(function (ConnectionQuality) {
+  ConnectionQuality["Excellent"] = "excellent";
+  ConnectionQuality["Good"] = "good";
+  ConnectionQuality["Poor"] = "poor";
+  /**
+   * Indicates that a participant has temporarily (or permanently) lost connection to LiveKit.
+   * For permanent disconnection a `ParticipantDisconnected` event will be emitted after a timeout
+   */
+  ConnectionQuality["Lost"] = "lost";
+  ConnectionQuality["Unknown"] = "unknown";
+})(ConnectionQuality || (ConnectionQuality = {}));
+function qualityFromProto(q) {
+  switch (q) {
+    case ConnectionQuality$1.EXCELLENT:
+      return ConnectionQuality.Excellent;
+    case ConnectionQuality$1.GOOD:
+      return ConnectionQuality.Good;
+    case ConnectionQuality$1.POOR:
+      return ConnectionQuality.Poor;
+    case ConnectionQuality$1.LOST:
+      return ConnectionQuality.Lost;
+    default:
+      return ConnectionQuality.Unknown;
+  }
+}
+class Participant extends eventsExports.EventEmitter {
+  get logContext() {
+    var _a, _b;
+    return Object.assign({}, (_b = (_a = this.loggerOptions) === null || _a === void 0 ? void 0 : _a.loggerContextCb) === null || _b === void 0 ? void 0 : _b.call(_a));
+  }
+  get isEncrypted() {
+    return this.trackPublications.size > 0 && Array.from(this.trackPublications.values()).every(tr => tr.isEncrypted);
+  }
+  get isAgent() {
+    var _a;
+    return ((_a = this.permissions) === null || _a === void 0 ? void 0 : _a.agent) || this.kind === ParticipantInfo_Kind.AGENT;
+  }
+  get kind() {
+    return this._kind;
+  }
+  /** participant attributes, similar to metadata, but as a key/value map */
+  get attributes() {
+    return Object.freeze(Object.assign({}, this._attributes));
+  }
+  /** @internal */
+  constructor(sid, identity, name, metadata, loggerOptions) {
+    let kind = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : ParticipantInfo_Kind.STANDARD;
+    var _a;
+    super();
+    /** audio level between 0-1.0, 1 being loudest, 0 being softest */
+    this.audioLevel = 0;
+    /** if participant is currently speaking */
+    this.isSpeaking = false;
+    this._connectionQuality = ConnectionQuality.Unknown;
+    this.log = livekitLogger;
+    this.log = getLogger((_a = loggerOptions === null || loggerOptions === void 0 ? void 0 : loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.Participant);
+    this.loggerOptions = loggerOptions;
+    this.setMaxListeners(100);
+    this.sid = sid;
+    this.identity = identity;
+    this.name = name;
+    this.metadata = metadata;
+    this.audioTrackPublications = new Map();
+    this.videoTrackPublications = new Map();
+    this.trackPublications = new Map();
+    this._kind = kind;
+    this._attributes = {};
+  }
+  getTrackPublications() {
+    return Array.from(this.trackPublications.values());
+  }
+  /**
+   * Finds the first track that matches the source filter, for example, getting
+   * the user's camera track with getTrackBySource(Track.Source.Camera).
+   */
+  getTrackPublication(source) {
     for (const [, pub] of this.trackPublications) {
       if (pub.source === source) {
         return pub;
@@ -18632,7 +19070,14 @@ class LocalParticipant extends Participant {
           }
           if (!track.isMuted) {
             this.log.debug('track ended, attempting to use a different device', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)));
-            yield track.restartTrack();
+            if (track instanceof LocalAudioTrack) {
+              // fall back to default device if available
+              yield track.restartTrack({
+                deviceId: 'default'
+              });
+            } else {
+              yield track.restartTrack();
+            }
           }
         } catch (e) {
           this.log.warn("could not restart track, muting instead", Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)));
@@ -18821,6 +19266,9 @@ class LocalParticipant extends Participant {
         source,
         enabled
       }));
+      if (this.republishPromise) {
+        yield this.republishPromise;
+      }
       let track = this.getTrackPublication(source);
       if (enabled) {
         if (track) {
@@ -18828,11 +19276,14 @@ class LocalParticipant extends Participant {
         } else {
           let localTracks;
           if (this.pendingPublishing.has(source)) {
-            this.log.info('skipping duplicate published source', Object.assign(Object.assign({}, this.logContext), {
-              source
-            }));
-            // no-op it's already been requested
-            return;
+            const pendingTrack = yield this.waitForPendingPublicationOfSource(source);
+            if (!pendingTrack) {
+              this.log.info('skipping duplicate published source', Object.assign(Object.assign({}, this.logContext), {
+                source
+              }));
+            }
+            yield pendingTrack === null || pendingTrack === void 0 ? void 0 : pendingTrack.unmute();
+            return pendingTrack;
           }
           this.pendingPublishing.add(source);
           try {
@@ -18874,16 +19325,22 @@ class LocalParticipant extends Participant {
             this.pendingPublishing.delete(source);
           }
         }
-      } else if (track && track.track) {
-        // screenshare cannot be muted, unpublish instead
-        if (source === Track.Source.ScreenShare) {
-          track = yield this.unpublishTrack(track.track);
-          const screenAudioTrack = this.getTrackPublication(Track.Source.ScreenShareAudio);
-          if (screenAudioTrack && screenAudioTrack.track) {
-            this.unpublishTrack(screenAudioTrack.track);
+      } else {
+        if (!(track === null || track === void 0 ? void 0 : track.track)) {
+          // if there's no track available yet first wait for pending publishing promises of that source to see if it becomes available
+          track = yield this.waitForPendingPublicationOfSource(source);
+        }
+        if (track && track.track) {
+          // screenshare cannot be muted, unpublish instead
+          if (source === Track.Source.ScreenShare) {
+            track = yield this.unpublishTrack(track.track);
+            const screenAudioTrack = this.getTrackPublication(Track.Source.ScreenShareAudio);
+            if (screenAudioTrack && screenAudioTrack.track) {
+              this.unpublishTrack(screenAudioTrack.track);
+            }
+          } else {
+            yield track.mute();
           }
-        } else {
-          yield track.mute();
         }
       }
       return track;
@@ -18921,6 +19378,11 @@ class LocalParticipant extends Participant {
   createTracks(options) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, _b;
+      options !== null && options !== void 0 ? options : options = {};
+      const {
+        audioProcessor,
+        videoProcessor
+      } = extractProcessorsFromOptions(options);
       const mergedOptions = mergeDefaultOptions(options, (_a = this.roomOptions) === null || _a === void 0 ? void 0 : _a.audioCaptureDefaults, (_b = this.roomOptions) === null || _b === void 0 ? void 0 : _b.videoCaptureDefaults);
       const constraints = constraintsForOptions(mergedOptions);
       let stream;
@@ -18946,10 +19408,7 @@ class LocalParticipant extends Participant {
       }
       return Promise.all(stream.getTracks().map(mediaStreamTrack => __awaiter(this, void 0, void 0, function* () {
         const isAudio = mediaStreamTrack.kind === 'audio';
-        let trackOptions = isAudio ? mergedOptions.audio : mergedOptions.video;
-        if (typeof trackOptions === 'boolean' || !trackOptions) {
-          trackOptions = {};
-        }
+        isAudio ? mergedOptions.audio : mergedOptions.video;
         let trackConstraints;
         const conOrBool = isAudio ? constraints.audio : constraints.video;
         if (typeof conOrBool !== 'boolean') {
@@ -18966,12 +19425,10 @@ class LocalParticipant extends Participant {
           track.setAudioContext(this.audioContext);
         }
         track.mediaStream = stream;
-        if (trackOptions.processor) {
-          if (track instanceof LocalAudioTrack) {
-            yield track.setProcessor(trackOptions.processor);
-          } else {
-            yield track.setProcessor(trackOptions.processor);
-          }
+        if (track instanceof LocalAudioTrack && audioProcessor) {
+          yield track.setProcessor(audioProcessor);
+        } else if (track instanceof LocalVideoTrack && videoProcessor) {
+          yield track.setProcessor(videoProcessor);
         }
         return track;
       })));
@@ -19030,109 +19487,121 @@ class LocalParticipant extends Participant {
    */
   publishTrack(track, options) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c, _d;
-      if (track instanceof LocalAudioTrack) {
-        track.setAudioContext(this.audioContext);
-      }
-      yield (_a = this.reconnectFuture) === null || _a === void 0 ? void 0 : _a.promise;
-      if (track instanceof LocalTrack && this.pendingPublishPromises.has(track)) {
-        yield this.pendingPublishPromises.get(track);
-      }
-      let defaultConstraints;
-      if (track instanceof MediaStreamTrack) {
-        defaultConstraints = track.getConstraints();
-      } else {
-        // we want to access constraints directly as `track.mediaStreamTrack`
-        // might be pointing to a non-device track (e.g. processed track) already
-        defaultConstraints = track.constraints;
-        let deviceKind = undefined;
-        switch (track.source) {
-          case Track.Source.Microphone:
-            deviceKind = 'audioinput';
-            break;
-          case Track.Source.Camera:
-            deviceKind = 'videoinput';
+      return this.publishOrRepublishTrack(track, options);
+    });
+  }
+  publishOrRepublishTrack(track_1, options_1) {
+    return __awaiter(this, arguments, void 0, function (track, options) {
+      var _this2 = this;
+      let isRepublish = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      return function* () {
+        var _a, _b, _c, _d;
+        if (track instanceof LocalAudioTrack) {
+          track.setAudioContext(_this2.audioContext);
         }
-        if (deviceKind && this.activeDeviceMap.has(deviceKind)) {
-          defaultConstraints = Object.assign(Object.assign({}, defaultConstraints), {
-            deviceId: this.activeDeviceMap.get(deviceKind)
-          });
+        yield (_a = _this2.reconnectFuture) === null || _a === void 0 ? void 0 : _a.promise;
+        if (_this2.republishPromise && !isRepublish) {
+          yield _this2.republishPromise;
         }
-      }
-      // convert raw media track into audio or video track
-      if (track instanceof MediaStreamTrack) {
-        switch (track.kind) {
-          case 'audio':
-            track = new LocalAudioTrack(track, defaultConstraints, true, this.audioContext, {
-              loggerName: this.roomOptions.loggerName,
-              loggerContextCb: () => this.logContext
-            });
-            break;
-          case 'video':
-            track = new LocalVideoTrack(track, defaultConstraints, true, {
-              loggerName: this.roomOptions.loggerName,
-              loggerContextCb: () => this.logContext
+        if (track instanceof LocalTrack && _this2.pendingPublishPromises.has(track)) {
+          yield _this2.pendingPublishPromises.get(track);
+        }
+        let defaultConstraints;
+        if (track instanceof MediaStreamTrack) {
+          defaultConstraints = track.getConstraints();
+        } else {
+          // we want to access constraints directly as `track.mediaStreamTrack`
+          // might be pointing to a non-device track (e.g. processed track) already
+          defaultConstraints = track.constraints;
+          let deviceKind = undefined;
+          switch (track.source) {
+            case Track.Source.Microphone:
+              deviceKind = 'audioinput';
+              break;
+            case Track.Source.Camera:
+              deviceKind = 'videoinput';
+          }
+          if (deviceKind && _this2.activeDeviceMap.has(deviceKind)) {
+            defaultConstraints = Object.assign(Object.assign({}, defaultConstraints), {
+              deviceId: _this2.activeDeviceMap.get(deviceKind)
             });
-            break;
-          default:
-            throw new TrackInvalidError("unsupported MediaStreamTrack kind ".concat(track.kind));
+          }
         }
-      } else {
-        track.updateLoggerOptions({
-          loggerName: this.roomOptions.loggerName,
-          loggerContextCb: () => this.logContext
+        // convert raw media track into audio or video track
+        if (track instanceof MediaStreamTrack) {
+          switch (track.kind) {
+            case 'audio':
+              track = new LocalAudioTrack(track, defaultConstraints, true, _this2.audioContext, {
+                loggerName: _this2.roomOptions.loggerName,
+                loggerContextCb: () => _this2.logContext
+              });
+              break;
+            case 'video':
+              track = new LocalVideoTrack(track, defaultConstraints, true, {
+                loggerName: _this2.roomOptions.loggerName,
+                loggerContextCb: () => _this2.logContext
+              });
+              break;
+            default:
+              throw new TrackInvalidError("unsupported MediaStreamTrack kind ".concat(track.kind));
+          }
+        } else {
+          track.updateLoggerOptions({
+            loggerName: _this2.roomOptions.loggerName,
+            loggerContextCb: () => _this2.logContext
+          });
+        }
+        // is it already published? if so skip
+        let existingPublication;
+        _this2.trackPublications.forEach(publication => {
+          if (!publication.track) {
+            return;
+          }
+          if (publication.track === track) {
+            existingPublication = publication;
+          }
         });
-      }
-      // is it already published? if so skip
-      let existingPublication;
-      this.trackPublications.forEach(publication => {
-        if (!publication.track) {
-          return;
+        if (existingPublication) {
+          _this2.log.warn('track has already been published, skipping', Object.assign(Object.assign({}, _this2.logContext), getLogContextFromTrack(existingPublication)));
+          return existingPublication;
+        }
+        const isStereoInput = 'channelCount' in track.mediaStreamTrack.getSettings() &&
+        // @ts-ignore `channelCount` on getSettings() is currently only available for Safari, but is generally the best way to determine a stereo track https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackSettings/channelCount
+        track.mediaStreamTrack.getSettings().channelCount === 2 || track.mediaStreamTrack.getConstraints().channelCount === 2;
+        const isStereo = (_b = options === null || options === void 0 ? void 0 : options.forceStereo) !== null && _b !== void 0 ? _b : isStereoInput;
+        // disable dtx for stereo track if not enabled explicitly
+        if (isStereo) {
+          if (!options) {
+            options = {};
+          }
+          if (options.dtx === undefined) {
+            _this2.log.info("Opus DTX will be disabled for stereo tracks by default. Enable them explicitly to make it work.", Object.assign(Object.assign({}, _this2.logContext), getLogContextFromTrack(track)));
+          }
+          if (options.red === undefined) {
+            _this2.log.info("Opus RED will be disabled for stereo tracks by default. Enable them explicitly to make it work.");
+          }
+          (_c = options.dtx) !== null && _c !== void 0 ? _c : options.dtx = false;
+          (_d = options.red) !== null && _d !== void 0 ? _d : options.red = false;
         }
-        if (publication.track === track) {
-          existingPublication = publication;
+        const opts = Object.assign(Object.assign({}, _this2.roomOptions.publishDefaults), options);
+        if (!isE2EESimulcastSupported() && _this2.roomOptions.e2ee) {
+          _this2.log.info("End-to-end encryption is set up, simulcast publishing will be disabled on Safari versions and iOS browsers running iOS < v17.2", Object.assign({}, _this2.logContext));
+          opts.simulcast = false;
         }
-      });
-      if (existingPublication) {
-        this.log.warn('track has already been published, skipping', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(existingPublication)));
-        return existingPublication;
-      }
-      const isStereoInput = 'channelCount' in track.mediaStreamTrack.getSettings() &&
-      // @ts-ignore `channelCount` on getSettings() is currently only available for Safari, but is generally the best way to determine a stereo track https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackSettings/channelCount
-      track.mediaStreamTrack.getSettings().channelCount === 2 || track.mediaStreamTrack.getConstraints().channelCount === 2;
-      const isStereo = (_b = options === null || options === void 0 ? void 0 : options.forceStereo) !== null && _b !== void 0 ? _b : isStereoInput;
-      // disable dtx for stereo track if not enabled explicitly
-      if (isStereo) {
-        if (!options) {
-          options = {};
-        }
-        if (options.dtx === undefined) {
-          this.log.info("Opus DTX will be disabled for stereo tracks by default. Enable them explicitly to make it work.", Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)));
-        }
-        if (options.red === undefined) {
-          this.log.info("Opus RED will be disabled for stereo tracks by default. Enable them explicitly to make it work.");
-        }
-        (_c = options.dtx) !== null && _c !== void 0 ? _c : options.dtx = false;
-        (_d = options.red) !== null && _d !== void 0 ? _d : options.red = false;
-      }
-      const opts = Object.assign(Object.assign({}, this.roomOptions.publishDefaults), options);
-      if (!isE2EESimulcastSupported() && this.roomOptions.e2ee) {
-        this.log.info("End-to-end encryption is set up, simulcast publishing will be disabled on Safari versions and iOS browsers running iOS < v17.2", Object.assign({}, this.logContext));
-        opts.simulcast = false;
-      }
-      if (opts.source) {
-        track.source = opts.source;
-      }
-      const publishPromise = this.publish(track, opts, isStereo);
-      this.pendingPublishPromises.set(track, publishPromise);
-      try {
-        const publication = yield publishPromise;
-        return publication;
-      } catch (e) {
-        throw e;
-      } finally {
-        this.pendingPublishPromises.delete(track);
-      }
+        if (opts.source) {
+          track.source = opts.source;
+        }
+        const publishPromise = _this2.publish(track, opts, isStereo);
+        _this2.pendingPublishPromises.set(track, publishPromise);
+        try {
+          const publication = yield publishPromise;
+          return publication;
+        } catch (e) {
+          throw e;
+        } finally {
+          _this2.pendingPublishPromises.delete(track);
+        }
+      }();
     });
   }
   publish(track, opts, isStereo) {
@@ -19518,31 +19987,44 @@ class LocalParticipant extends Participant {
   }
   republishAllTracks(options_1) {
     return __awaiter(this, arguments, void 0, function (options) {
-      var _this2 = this;
+      var _this3 = this;
       let restartTracks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
       return function* () {
-        const localPubs = [];
-        _this2.trackPublications.forEach(pub => {
-          if (pub.track) {
-            if (options) {
-              pub.options = Object.assign(Object.assign({}, pub.options), options);
-            }
-            localPubs.push(pub);
-          }
-        });
-        yield Promise.all(localPubs.map(pub => __awaiter(_this2, void 0, void 0, function* () {
-          const track = pub.track;
-          yield this.unpublishTrack(track, false);
-          if (restartTracks && !track.isMuted && track.source !== Track.Source.ScreenShare && track.source !== Track.Source.ScreenShareAudio && (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) && !track.isUserProvided) {
-            // generally we need to restart the track before publishing, often a full reconnect
-            // is necessary because computer had gone to sleep.
-            this.log.debug('restarting existing track', Object.assign(Object.assign({}, this.logContext), {
-              track: pub.trackSid
-            }));
-            yield track.restartTrack();
+        if (_this3.republishPromise) {
+          yield _this3.republishPromise;
+        }
+        _this3.republishPromise = new Promise((resolve, reject) => __awaiter(_this3, void 0, void 0, function* () {
+          try {
+            const localPubs = [];
+            this.trackPublications.forEach(pub => {
+              if (pub.track) {
+                if (options) {
+                  pub.options = Object.assign(Object.assign({}, pub.options), options);
+                }
+                localPubs.push(pub);
+              }
+            });
+            yield Promise.all(localPubs.map(pub => __awaiter(this, void 0, void 0, function* () {
+              const track = pub.track;
+              yield this.unpublishTrack(track, false);
+              if (restartTracks && !track.isMuted && track.source !== Track.Source.ScreenShare && track.source !== Track.Source.ScreenShareAudio && (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) && !track.isUserProvided) {
+                // generally we need to restart the track before publishing, often a full reconnect
+                // is necessary because computer had gone to sleep.
+                this.log.debug('restarting existing track', Object.assign(Object.assign({}, this.logContext), {
+                  track: pub.trackSid
+                }));
+                yield track.restartTrack();
+              }
+              yield this.publishOrRepublishTrack(track, pub.options, true);
+            })));
+            resolve();
+          } catch (error) {
+            reject(error);
+          } finally {
+            this.republishPromise = undefined;
           }
-          yield this.publishTrack(track, pub.options);
-        })));
+        }));
+        yield _this3.republishPromise;
       }();
     });
   }
@@ -19555,7 +20037,7 @@ class LocalParticipant extends Participant {
    */
   publishData(data_1) {
     return __awaiter(this, arguments, void 0, function (data) {
-      var _this3 = this;
+      var _this4 = this;
       let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       return function* () {
         const kind = options.reliable ? DataPacket_Kind.RELIABLE : DataPacket_Kind.LOSSY;
@@ -19566,17 +20048,57 @@ class LocalParticipant extends Participant {
           value: {
             case: 'user',
             value: new UserPacket({
-              participantIdentity: _this3.identity,
+              participantIdentity: _this4.identity,
               payload: data,
               destinationIdentities,
               topic
             })
           }
         });
-        yield _this3.engine.sendDataPacket(packet, kind);
+        yield _this4.engine.sendDataPacket(packet, kind);
       }();
     });
   }
+  sendChatMessage(text) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const msg = {
+        id: crypto.randomUUID(),
+        message: text,
+        timestamp: Date.now()
+      };
+      const packet = new DataPacket({
+        value: {
+          case: 'chatMessage',
+          value: new ChatMessage(Object.assign(Object.assign({}, msg), {
+            timestamp: protoInt64.parse(msg.timestamp)
+          }))
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+      this.emit(ParticipantEvent.ChatMessage, msg);
+      return msg;
+    });
+  }
+  editChatMessage(editText, originalMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const msg = Object.assign(Object.assign({}, originalMessage), {
+        message: editText,
+        editTimestamp: Date.now()
+      });
+      const packet = new DataPacket({
+        value: {
+          case: 'chatMessage',
+          value: new ChatMessage(Object.assign(Object.assign({}, msg), {
+            timestamp: protoInt64.parse(msg.timestamp),
+            editTimestamp: protoInt64.parse(msg.editTimestamp)
+          }))
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+      this.emit(ParticipantEvent.ChatMessage, msg);
+      return msg;
+    });
+  }
   /**
    * Control who can subscribe to LocalParticipant's published tracks.
    *
@@ -19654,6 +20176,17 @@ class LocalParticipant extends Participant {
     });
     return publication;
   }
+  waitForPendingPublicationOfSource(source) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const publishPromiseEntry = Array.from(this.pendingPublishPromises.entries()).find(_ref3 => {
+        let [pendingTrack] = _ref3;
+        return pendingTrack.source === source;
+      });
+      if (publishPromiseEntry) {
+        return publishPromiseEntry[1];
+      }
+    });
+  }
 }
 
 class RemoteTrackPublication extends TrackPublication {
@@ -20724,6 +21257,8 @@ class Room extends eventsExports.EventEmitter {
         this.handleTranscription(participant, packet.value.value);
       } else if (packet.value.case === 'sipDtmf') {
         this.handleSipDtmf(participant, packet.value.value);
+      } else if (packet.value.case === 'chatMessage') {
+        this.handleChatMessage(participant, packet.value.value);
       }
     };
     this.handleUserPacket = (participant, userPacket, kind) => {
@@ -20746,6 +21281,10 @@ class Room extends eventsExports.EventEmitter {
       participant === null || participant === void 0 ? void 0 : participant.emit(ParticipantEvent.TranscriptionReceived, segments, publication);
       this.emit(RoomEvent.TranscriptionReceived, segments, participant, publication);
     };
+    this.handleChatMessage = (participant, chatMessage) => {
+      const msg = extractChatMessage(chatMessage);
+      this.emit(RoomEvent.ChatMessage, msg, participant);
+    };
     this.handleAudioPlaybackStarted = () => {
       if (this.canPlaybackAudio) {
         return;
@@ -20776,6 +21315,17 @@ class Room extends eventsExports.EventEmitter {
       }
     };
     this.handleDeviceChange = () => __awaiter(this, void 0, void 0, function* () {
+      // check for available devices, but don't request permissions in order to avoid prompts for kinds that haven't been used before
+      const availableDevices = yield DeviceManager.getInstance().getDevices(undefined, false);
+      // inputs are automatically handled via TrackEvent.Ended causing a TrackEvent.Restarted. Here we only need to worry about audiooutputs changing
+      const kinds = ['audiooutput'];
+      for (let kind of kinds) {
+        // switch to first available device if previously active device is not available any more
+        const devicesOfKind = availableDevices.filter(d => d.kind === kind);
+        if (devicesOfKind.length > 0 && !devicesOfKind.find(deviceInfo => deviceInfo.deviceId === this.getActiveDevice(kind))) {
+          yield this.switchActiveDevice(kind, devicesOfKind[0].deviceId);
+        }
+      }
       this.emit(RoomEvent.MediaDevicesChanged);
     });
     this.handleRoomUpdate = room => {
@@ -20820,9 +21370,10 @@ class Room extends eventsExports.EventEmitter {
       (_a = processor === null || processor === void 0 ? void 0 : processor.onPublish) === null || _a === void 0 ? void 0 : _a.call(processor, this);
     };
     this.onLocalTrackPublished = pub => __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d, _e, _f;
       (_a = pub.track) === null || _a === void 0 ? void 0 : _a.on(TrackEvent.TrackProcessorUpdate, this.onTrackProcessorUpdate);
-      (_d = (_c = (_b = pub.track) === null || _b === void 0 ? void 0 : _b.getProcessor()) === null || _c === void 0 ? void 0 : _c.onPublish) === null || _d === void 0 ? void 0 : _d.call(_c, this);
+      (_b = pub.track) === null || _b === void 0 ? void 0 : _b.on(TrackEvent.Restarted, this.onLocalTrackRestarted);
+      (_e = (_d = (_c = pub.track) === null || _c === void 0 ? void 0 : _c.getProcessor()) === null || _d === void 0 ? void 0 : _d.onPublish) === null || _e === void 0 ? void 0 : _e.call(_d, this);
       this.emit(RoomEvent.LocalTrackPublished, pub, this.localParticipant);
       if (pub.track instanceof LocalAudioTrack) {
         const trackIsSilent = yield pub.track.checkForSilence();
@@ -20830,7 +21381,7 @@ class Room extends eventsExports.EventEmitter {
           this.emit(RoomEvent.LocalAudioSilenceDetected, pub);
         }
       }
-      const deviceId = yield (_e = pub.track) === null || _e === void 0 ? void 0 : _e.getDeviceId();
+      const deviceId = yield (_f = pub.track) === null || _f === void 0 ? void 0 : _f.getDeviceId();
       const deviceKind = sourceToKind(pub.source);
       if (deviceKind && deviceId && deviceId !== this.localParticipant.activeDeviceMap.get(deviceKind)) {
         this.localParticipant.activeDeviceMap.set(deviceKind, deviceId);
@@ -20838,10 +21389,20 @@ class Room extends eventsExports.EventEmitter {
       }
     });
     this.onLocalTrackUnpublished = pub => {
-      var _a;
+      var _a, _b;
       (_a = pub.track) === null || _a === void 0 ? void 0 : _a.off(TrackEvent.TrackProcessorUpdate, this.onTrackProcessorUpdate);
+      (_b = pub.track) === null || _b === void 0 ? void 0 : _b.off(TrackEvent.Restarted, this.onLocalTrackRestarted);
       this.emit(RoomEvent.LocalTrackUnpublished, pub, this.localParticipant);
     };
+    this.onLocalTrackRestarted = track => __awaiter(this, void 0, void 0, function* () {
+      const deviceId = yield track.getDeviceId(false);
+      const deviceKind = sourceToKind(track.source);
+      if (deviceKind && deviceId && deviceId !== this.localParticipant.activeDeviceMap.get(deviceKind)) {
+        this.log.debug("local track restarted, setting ".concat(deviceKind, " ").concat(deviceId, " active"), this.logContext);
+        this.localParticipant.activeDeviceMap.set(deviceKind, deviceId);
+        this.emit(RoomEvent.ActiveDeviceChanged, deviceKind, deviceId);
+      }
+    });
     this.onLocalConnectionQualityChanged = quality => {
       this.emit(RoomEvent.ConnectionQualityChanged, quality, this.localParticipant);
     };
@@ -20851,6 +21412,9 @@ class Room extends eventsExports.EventEmitter {
     this.onLocalParticipantPermissionsChanged = prevPermissions => {
       this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, this.localParticipant);
     };
+    this.onLocalChatMessageSent = msg => {
+      this.emit(RoomEvent.ChatMessage, msg, this.localParticipant);
+    };
     this.setMaxListeners(100);
     this.remoteParticipants = new Map();
     this.sidToIdentity = new Map();
@@ -21025,9 +21589,8 @@ class Room extends eventsExports.EventEmitter {
   }
   /**
    * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
-   * In particular, it handles Chrome's unique behavior of creating `default`
-   * devices. When encountered, it'll be removed from the list of devices.
-   * The actual default device will be placed at top.
+   * In particular, it requests device permissions by default if needed
+   * and makes sure the returned device does not consist of dummy devices
    * @param kind
    * @returns a list of available local devices
    */
@@ -21240,15 +21803,15 @@ class Room extends eventsExports.EventEmitter {
       var _this3 = this;
       let exact = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       return function* () {
-        var _a, _b, _c;
-        var _d;
+        var _a, _b, _c, _d, _e, _f;
+        var _g;
         let deviceHasChanged = false;
         let success = true;
         const deviceConstraint = exact ? {
           exact: deviceId
         } : deviceId;
         if (kind === 'audioinput') {
-          const prevDeviceId = _this3.options.audioCaptureDefaults.deviceId;
+          const prevDeviceId = (_a = _this3.getActiveDevice(kind)) !== null && _a !== void 0 ? _a : _this3.options.audioCaptureDefaults.deviceId;
           _this3.options.audioCaptureDefaults.deviceId = deviceConstraint;
           deviceHasChanged = prevDeviceId !== deviceConstraint;
           const tracks = Array.from(_this3.localParticipant.audioTrackPublications.values()).filter(track => track.source === Track.Source.Microphone);
@@ -21262,7 +21825,7 @@ class Room extends eventsExports.EventEmitter {
             throw e;
           }
         } else if (kind === 'videoinput') {
-          const prevDeviceId = _this3.options.videoCaptureDefaults.deviceId;
+          const prevDeviceId = (_b = _this3.getActiveDevice(kind)) !== null && _b !== void 0 ? _b : _this3.options.videoCaptureDefaults.deviceId;
           _this3.options.videoCaptureDefaults.deviceId = deviceConstraint;
           deviceHasChanged = prevDeviceId !== deviceConstraint;
           const tracks = Array.from(_this3.localParticipant.videoTrackPublications.values()).filter(track => track.source === Track.Source.Camera);
@@ -21281,16 +21844,16 @@ class Room extends eventsExports.EventEmitter {
           }
           if (_this3.options.webAudioMix) {
             // setting `default` for web audio output doesn't work, so we need to normalize the id before
-            deviceId = (_a = yield DeviceManager.getInstance().normalizeDeviceId('audiooutput', deviceId)) !== null && _a !== void 0 ? _a : '';
+            deviceId = (_c = yield DeviceManager.getInstance().normalizeDeviceId('audiooutput', deviceId)) !== null && _c !== void 0 ? _c : '';
           }
-          (_b = (_d = _this3.options).audioOutput) !== null && _b !== void 0 ? _b : _d.audioOutput = {};
-          const prevDeviceId = _this3.options.audioOutput.deviceId;
+          (_d = (_g = _this3.options).audioOutput) !== null && _d !== void 0 ? _d : _g.audioOutput = {};
+          const prevDeviceId = (_e = _this3.getActiveDevice(kind)) !== null && _e !== void 0 ? _e : _this3.options.audioOutput.deviceId;
           _this3.options.audioOutput.deviceId = deviceId;
           deviceHasChanged = prevDeviceId !== deviceConstraint;
           try {
             if (_this3.options.webAudioMix) {
               // @ts-expect-error setSinkId is not yet in the typescript type of AudioContext
-              (_c = _this3.audioContext) === null || _c === void 0 ? void 0 : _c.setSinkId(deviceId);
+              (_f = _this3.audioContext) === null || _f === void 0 ? void 0 : _f.setSinkId(deviceId);
             }
             // also set audio output on all audio elements, even if webAudioMix is enabled in order to workaround echo cancellation not working on chrome with non-default output devices
             // see https://issues.chromium.org/issues/40252911#comment7
@@ -21311,7 +21874,7 @@ class Room extends eventsExports.EventEmitter {
     });
   }
   setupLocalParticipantEvents() {
-    this.localParticipant.on(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged).on(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged).on(ParticipantEvent.AttributesChanged, this.onLocalAttributesChanged).on(ParticipantEvent.TrackMuted, this.onLocalTrackMuted).on(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted).on(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished).on(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished).on(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged).on(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError).on(ParticipantEvent.AudioStreamAcquired, this.startAudio).on(ParticipantEvent.ParticipantPermissionsChanged, this.onLocalParticipantPermissionsChanged);
+    this.localParticipant.on(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged).on(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged).on(ParticipantEvent.AttributesChanged, this.onLocalAttributesChanged).on(ParticipantEvent.TrackMuted, this.onLocalTrackMuted).on(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted).on(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished).on(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished).on(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged).on(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError).on(ParticipantEvent.AudioStreamAcquired, this.startAudio).on(ParticipantEvent.ChatMessage, this.onLocalChatMessageSent).on(ParticipantEvent.ParticipantPermissionsChanged, this.onLocalParticipantPermissionsChanged);
   }
   recreateEngine() {
     var _a;
@@ -21405,7 +21968,7 @@ class Room extends eventsExports.EventEmitter {
           (_b = pub.track) === null || _b === void 0 ? void 0 : _b.stop();
         }
       });
-      this.localParticipant.off(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged).off(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged).off(ParticipantEvent.AttributesChanged, this.onLocalAttributesChanged).off(ParticipantEvent.TrackMuted, this.onLocalTrackMuted).off(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted).off(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished).off(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished).off(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged).off(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError).off(ParticipantEvent.AudioStreamAcquired, this.startAudio).off(ParticipantEvent.ParticipantPermissionsChanged, this.onLocalParticipantPermissionsChanged);
+      this.localParticipant.off(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged).off(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged).off(ParticipantEvent.AttributesChanged, this.onLocalAttributesChanged).off(ParticipantEvent.TrackMuted, this.onLocalTrackMuted).off(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted).off(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished).off(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished).off(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged).off(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError).off(ParticipantEvent.AudioStreamAcquired, this.startAudio).off(ParticipantEvent.ChatMessage, this.onLocalChatMessageSent).off(ParticipantEvent.ParticipantPermissionsChanged, this.onLocalParticipantPermissionsChanged);
       this.localParticipant.trackPublications.clear();
       this.localParticipant.videoTrackPublications.clear();
       this.localParticipant.audioTrackPublications.clear();
@@ -21851,7 +22414,7 @@ class Checker extends eventsExports.EventEmitter {
       if (this.room.state === ConnectionState.Connected) {
         return this.room;
       }
-      yield this.room.connect(this.url, this.token);
+      yield this.room.connect(this.url, this.token, this.connectOptions);
       return this.room;
     });
   }
@@ -21906,127 +22469,6 @@ class Checker extends eventsExports.EventEmitter {
   }
 }
 
-/**
- * Creates a local video and audio track at the same time. When acquiring both
- * audio and video tracks together, it'll display a single permission prompt to
- * the user instead of two separate ones.
- * @param options
- */
-function createLocalTracks(options) {
-  return __awaiter(this, void 0, void 0, function* () {
-    var _a, _b;
-    // set default options to true
-    options !== null && options !== void 0 ? options : options = {};
-    (_a = options.audio) !== null && _a !== void 0 ? _a : options.audio = true;
-    (_b = options.video) !== null && _b !== void 0 ? _b : options.video = true;
-    const opts = mergeDefaultOptions(options, audioDefaults, videoDefaults);
-    const constraints = constraintsForOptions(opts);
-    // Keep a reference to the promise on DeviceManager and await it in getLocalDevices()
-    // works around iOS Safari Bug https://bugs.webkit.org/show_bug.cgi?id=179363
-    const mediaPromise = navigator.mediaDevices.getUserMedia(constraints);
-    if (options.audio) {
-      DeviceManager.userMediaPromiseMap.set('audioinput', mediaPromise);
-      mediaPromise.catch(() => DeviceManager.userMediaPromiseMap.delete('audioinput'));
-    }
-    if (options.video) {
-      DeviceManager.userMediaPromiseMap.set('videoinput', mediaPromise);
-      mediaPromise.catch(() => DeviceManager.userMediaPromiseMap.delete('videoinput'));
-    }
-    const stream = yield mediaPromise;
-    return Promise.all(stream.getTracks().map(mediaStreamTrack => __awaiter(this, void 0, void 0, function* () {
-      const isAudio = mediaStreamTrack.kind === 'audio';
-      let trackOptions = isAudio ? options.audio : options.video;
-      if (typeof trackOptions === 'boolean' || !trackOptions) {
-        trackOptions = {};
-      }
-      let trackConstraints;
-      const conOrBool = isAudio ? constraints.audio : constraints.video;
-      if (typeof conOrBool !== 'boolean') {
-        trackConstraints = conOrBool;
-      }
-      // update the constraints with the device id the user gave permissions to in the permission prompt
-      // otherwise each track restart (e.g. mute - unmute) will try to initialize the device again -> causing additional permission prompts
-      if (trackConstraints) {
-        trackConstraints.deviceId = mediaStreamTrack.getSettings().deviceId;
-      } else {
-        trackConstraints = {
-          deviceId: mediaStreamTrack.getSettings().deviceId
-        };
-      }
-      const track = mediaTrackToLocalTrack(mediaStreamTrack, trackConstraints);
-      if (track.kind === Track.Kind.Video) {
-        track.source = Track.Source.Camera;
-      } else if (track.kind === Track.Kind.Audio) {
-        track.source = Track.Source.Microphone;
-      }
-      track.mediaStream = stream;
-      if (trackOptions.processor) {
-        if (track instanceof LocalAudioTrack) {
-          yield track.setProcessor(trackOptions.processor);
-        } else if (track instanceof LocalVideoTrack) {
-          yield track.setProcessor(trackOptions.processor);
-        }
-      }
-      return track;
-    })));
-  });
-}
-/**
- * Creates a [[LocalVideoTrack]] with getUserMedia()
- * @param options
- */
-function createLocalVideoTrack(options) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const tracks = yield createLocalTracks({
-      audio: false,
-      video: options
-    });
-    return tracks[0];
-  });
-}
-function createLocalAudioTrack(options) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const tracks = yield createLocalTracks({
-      audio: options,
-      video: false
-    });
-    return tracks[0];
-  });
-}
-/**
- * Creates a screen capture tracks with getDisplayMedia().
- * A LocalVideoTrack is always created and returned.
- * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
- */
-function createLocalScreenTracks(options) {
-  return __awaiter(this, void 0, void 0, function* () {
-    if (options === undefined) {
-      options = {};
-    }
-    if (options.resolution === undefined && !isSafari17()) {
-      options.resolution = ScreenSharePresets.h1080fps30.resolution;
-    }
-    if (navigator.mediaDevices.getDisplayMedia === undefined) {
-      throw new DeviceUnsupportedError('getDisplayMedia not supported');
-    }
-    const constraints = screenCaptureToDisplayMediaStreamOptions(options);
-    const stream = yield navigator.mediaDevices.getDisplayMedia(constraints);
-    const tracks = stream.getVideoTracks();
-    if (tracks.length === 0) {
-      throw new TrackInvalidError('no video track found');
-    }
-    const screenVideo = new LocalVideoTrack(tracks[0], undefined, false);
-    screenVideo.source = Track.Source.ScreenShare;
-    const localTracks = [screenVideo];
-    if (stream.getAudioTracks().length > 0) {
-      const screenAudio = new LocalAudioTrack(stream.getAudioTracks()[0], undefined, false);
-      screenAudio.source = Track.Source.ScreenShareAudio;
-      localTracks.push(screenAudio);
-    }
-    return localTracks;
-  });
-}
-
 class PublishAudioCheck extends Checker {
   get description() {
     return 'Can publish audio';
@@ -22435,5 +22877,5 @@ function isFacingModeValue(item) {
   return item === undefined || allowedValues.includes(item);
 }
 
-export { AudioPresets, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isScriptTransformSupported, isVideoFrame, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
+export { AudioPresets, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, extractProcessorsFromOptions, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isScriptTransformSupported, isVideoFrame, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
 //# sourceMappingURL=livekit-client.esm.mjs.map