genesys-cloud-streaming-client 19.4.1-develop.11 → 19.4.1-develop.13

package/dist/es/index.bundle.js

@@ -3096,7 +3096,7 @@ var INSPECT_MAX_BYTES = 50;
  * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
  * get the Object implementation, which is slower but behaves correctly.
  */
-Buffer$1.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined
+Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined
   ? global$1.TYPED_ARRAY_SUPPORT
   : true;
 
@@ -3106,7 +3106,7 @@ Buffer$1.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined
 kMaxLength();
 
 function kMaxLength () {
-  return Buffer$1.TYPED_ARRAY_SUPPORT
+  return Buffer.TYPED_ARRAY_SUPPORT
     ? 0x7fffffff
     : 0x3fffffff
 }
@@ -3115,14 +3115,14 @@ function createBuffer (that, length) {
   if (kMaxLength() < length) {
     throw new RangeError('Invalid typed array length')
   }
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     // Return an augmented `Uint8Array` instance, for best performance
     that = new Uint8Array(length);
-    that.__proto__ = Buffer$1.prototype;
+    that.__proto__ = Buffer.prototype;
   } else {
     // Fallback: Return an object instance of the Buffer class
     if (that === null) {
-      that = new Buffer$1(length);
+      that = new Buffer(length);
     }
     that.length = length;
   }
@@ -3140,9 +3140,9 @@ function createBuffer (that, length) {
  * The `Uint8Array` prototype remains unmodified.
  */
 
-function Buffer$1 (arg, encodingOrOffset, length) {
-  if (!Buffer$1.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer$1)) {
-    return new Buffer$1(arg, encodingOrOffset, length)
+function Buffer (arg, encodingOrOffset, length) {
+  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
+    return new Buffer(arg, encodingOrOffset, length)
   }
 
   // Common case.
@@ -3157,11 +3157,11 @@ function Buffer$1 (arg, encodingOrOffset, length) {
   return from(this, arg, encodingOrOffset, length)
 }
 
-Buffer$1.poolSize = 8192; // not used by this implementation
+Buffer.poolSize = 8192; // not used by this implementation
 
 // TODO: Legacy, not needed anymore. Remove in next major version.
-Buffer$1._augment = function (arr) {
-  arr.__proto__ = Buffer$1.prototype;
+Buffer._augment = function (arr) {
+  arr.__proto__ = Buffer.prototype;
   return arr
 };
 
@@ -3189,13 +3189,13 @@ function from (that, value, encodingOrOffset, length) {
  * Buffer.from(buffer)
  * Buffer.from(arrayBuffer[, byteOffset[, length]])
  **/
-Buffer$1.from = function (value, encodingOrOffset, length) {
+Buffer.from = function (value, encodingOrOffset, length) {
   return from(null, value, encodingOrOffset, length)
 };
 
-if (Buffer$1.TYPED_ARRAY_SUPPORT) {
-  Buffer$1.prototype.__proto__ = Uint8Array.prototype;
-  Buffer$1.__proto__ = Uint8Array;
+if (Buffer.TYPED_ARRAY_SUPPORT) {
+  Buffer.prototype.__proto__ = Uint8Array.prototype;
+  Buffer.__proto__ = Uint8Array;
 }
 
 function assertSize (size) {
@@ -3226,14 +3226,14 @@ function alloc (that, size, fill, encoding) {
  * Creates a new filled Buffer instance.
  * alloc(size[, fill[, encoding]])
  **/
-Buffer$1.alloc = function (size, fill, encoding) {
+Buffer.alloc = function (size, fill, encoding) {
   return alloc(null, size, fill, encoding)
 };
 
 function allocUnsafe (that, size) {
   assertSize(size);
   that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
-  if (!Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (!Buffer.TYPED_ARRAY_SUPPORT) {
     for (var i = 0; i < size; ++i) {
       that[i] = 0;
     }
@@ -3244,13 +3244,13 @@ function allocUnsafe (that, size) {
 /**
  * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
  * */
-Buffer$1.allocUnsafe = function (size) {
+Buffer.allocUnsafe = function (size) {
   return allocUnsafe(null, size)
 };
 /**
  * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
  */
-Buffer$1.allocUnsafeSlow = function (size) {
+Buffer.allocUnsafeSlow = function (size) {
   return allocUnsafe(null, size)
 };
 
@@ -3259,7 +3259,7 @@ function fromString (that, string, encoding) {
     encoding = 'utf8';
   }
 
-  if (!Buffer$1.isEncoding(encoding)) {
+  if (!Buffer.isEncoding(encoding)) {
     throw new TypeError('"encoding" must be a valid string encoding')
   }
 
@@ -3306,10 +3306,10 @@ function fromArrayBuffer (that, array, byteOffset, length) {
     array = new Uint8Array(array, byteOffset, length);
   }
 
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     // Return an augmented `Uint8Array` instance, for best performance
     that = array;
-    that.__proto__ = Buffer$1.prototype;
+    that.__proto__ = Buffer.prototype;
   } else {
     // Fallback: Return an object instance of the Buffer class
     that = fromArrayLike(that, array);
@@ -3356,12 +3356,12 @@ function checked (length) {
   }
   return length | 0
 }
-Buffer$1.isBuffer = isBuffer;
+Buffer.isBuffer = isBuffer;
 function internalIsBuffer (b) {
   return !!(b != null && b._isBuffer)
 }
 
-Buffer$1.compare = function compare (a, b) {
+Buffer.compare = function compare (a, b) {
   if (!internalIsBuffer(a) || !internalIsBuffer(b)) {
     throw new TypeError('Arguments must be Buffers')
   }
@@ -3384,7 +3384,7 @@ Buffer$1.compare = function compare (a, b) {
   return 0
 };
 
-Buffer$1.isEncoding = function isEncoding (encoding) {
+Buffer.isEncoding = function isEncoding (encoding) {
   switch (String(encoding).toLowerCase()) {
     case 'hex':
     case 'utf8':
@@ -3403,13 +3403,13 @@ Buffer$1.isEncoding = function isEncoding (encoding) {
   }
 };
 
-Buffer$1.concat = function concat (list, length) {
+Buffer.concat = function concat (list, length) {
   if (!isArray(list)) {
     throw new TypeError('"list" argument must be an Array of Buffers')
   }
 
   if (list.length === 0) {
-    return Buffer$1.alloc(0)
+    return Buffer.alloc(0)
   }
 
   var i;
@@ -3420,7 +3420,7 @@ Buffer$1.concat = function concat (list, length) {
     }
   }
 
-  var buffer = Buffer$1.allocUnsafe(length);
+  var buffer = Buffer.allocUnsafe(length);
   var pos = 0;
   for (i = 0; i < list.length; ++i) {
     var buf = list[i];
@@ -3476,7 +3476,7 @@ function byteLength$1 (string, encoding) {
     }
   }
 }
-Buffer$1.byteLength = byteLength$1;
+Buffer.byteLength = byteLength$1;
 
 function slowToString (encoding, start, end) {
   var loweredCase = false;
@@ -3550,7 +3550,7 @@ function slowToString (encoding, start, end) {
 
 // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
 // Buffer instances.
-Buffer$1.prototype._isBuffer = true;
+Buffer.prototype._isBuffer = true;
 
 function swap (b, n, m) {
   var i = b[n];
@@ -3558,7 +3558,7 @@ function swap (b, n, m) {
   b[m] = i;
 }
 
-Buffer$1.prototype.swap16 = function swap16 () {
+Buffer.prototype.swap16 = function swap16 () {
   var len = this.length;
   if (len % 2 !== 0) {
     throw new RangeError('Buffer size must be a multiple of 16-bits')
@@ -3569,7 +3569,7 @@ Buffer$1.prototype.swap16 = function swap16 () {
   return this
 };
 
-Buffer$1.prototype.swap32 = function swap32 () {
+Buffer.prototype.swap32 = function swap32 () {
   var len = this.length;
   if (len % 4 !== 0) {
     throw new RangeError('Buffer size must be a multiple of 32-bits')
@@ -3581,7 +3581,7 @@ Buffer$1.prototype.swap32 = function swap32 () {
   return this
 };
 
-Buffer$1.prototype.swap64 = function swap64 () {
+Buffer.prototype.swap64 = function swap64 () {
   var len = this.length;
   if (len % 8 !== 0) {
     throw new RangeError('Buffer size must be a multiple of 64-bits')
@@ -3595,20 +3595,20 @@ Buffer$1.prototype.swap64 = function swap64 () {
   return this
 };
 
-Buffer$1.prototype.toString = function toString () {
+Buffer.prototype.toString = function toString () {
   var length = this.length | 0;
   if (length === 0) return ''
   if (arguments.length === 0) return utf8Slice(this, 0, length)
   return slowToString.apply(this, arguments)
 };
 
-Buffer$1.prototype.equals = function equals (b) {
+Buffer.prototype.equals = function equals (b) {
   if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer')
   if (this === b) return true
-  return Buffer$1.compare(this, b) === 0
+  return Buffer.compare(this, b) === 0
 };
 
-Buffer$1.prototype.inspect = function inspect () {
+Buffer.prototype.inspect = function inspect () {
   var str = '';
   var max = INSPECT_MAX_BYTES;
   if (this.length > 0) {
@@ -3618,7 +3618,7 @@ Buffer$1.prototype.inspect = function inspect () {
   return '<Buffer ' + str + '>'
 };
 
-Buffer$1.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
+Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
   if (!internalIsBuffer(target)) {
     throw new TypeError('Argument must be a Buffer')
   }
@@ -3717,7 +3717,7 @@ function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
 
   // Normalize val
   if (typeof val === 'string') {
-    val = Buffer$1.from(val, encoding);
+    val = Buffer.from(val, encoding);
   }
 
   // Finally, search either indexOf (if dir is true) or lastIndexOf
@@ -3729,7 +3729,7 @@ function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
     return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
   } else if (typeof val === 'number') {
     val = val & 0xFF; // Search for a byte value [0-255]
-    if (Buffer$1.TYPED_ARRAY_SUPPORT &&
+    if (Buffer.TYPED_ARRAY_SUPPORT &&
         typeof Uint8Array.prototype.indexOf === 'function') {
       if (dir) {
         return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
@@ -3799,15 +3799,15 @@ function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
   return -1
 }
 
-Buffer$1.prototype.includes = function includes (val, byteOffset, encoding) {
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
   return this.indexOf(val, byteOffset, encoding) !== -1
 };
 
-Buffer$1.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
   return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
 };
 
-Buffer$1.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
   return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
 };
 
@@ -3858,7 +3858,7 @@ function ucs2Write (buf, string, offset, length) {
   return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
 }
 
-Buffer$1.prototype.write = function write (string, offset, length, encoding) {
+Buffer.prototype.write = function write (string, offset, length, encoding) {
   // Buffer#write(string)
   if (offset === undefined) {
     encoding = 'utf8';
@@ -3930,7 +3930,7 @@ Buffer$1.prototype.write = function write (string, offset, length, encoding) {
   }
 };
 
-Buffer$1.prototype.toJSON = function toJSON () {
+Buffer.prototype.toJSON = function toJSON () {
   return {
     type: 'Buffer',
     data: Array.prototype.slice.call(this._arr || this, 0)
@@ -4083,7 +4083,7 @@ function utf16leSlice (buf, start, end) {
   return res
 }
 
-Buffer$1.prototype.slice = function slice (start, end) {
+Buffer.prototype.slice = function slice (start, end) {
   var len = this.length;
   start = ~~start;
   end = end === undefined ? len : ~~end;
@@ -4105,12 +4105,12 @@ Buffer$1.prototype.slice = function slice (start, end) {
   if (end < start) end = start;
 
   var newBuf;
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     newBuf = this.subarray(start, end);
-    newBuf.__proto__ = Buffer$1.prototype;
+    newBuf.__proto__ = Buffer.prototype;
   } else {
     var sliceLen = end - start;
-    newBuf = new Buffer$1(sliceLen, undefined);
+    newBuf = new Buffer(sliceLen, undefined);
     for (var i = 0; i < sliceLen; ++i) {
       newBuf[i] = this[i + start];
     }
@@ -4127,7 +4127,7 @@ function checkOffset (offset, ext, length) {
   if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
 }
 
-Buffer$1.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
   offset = offset | 0;
   byteLength = byteLength | 0;
   if (!noAssert) checkOffset(offset, byteLength, this.length);
@@ -4142,7 +4142,7 @@ Buffer$1.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAsser
   return val
 };
 
-Buffer$1.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
   offset = offset | 0;
   byteLength = byteLength | 0;
   if (!noAssert) {
@@ -4158,22 +4158,22 @@ Buffer$1.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAsser
   return val
 };
 
-Buffer$1.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 1, this.length);
   return this[offset]
 };
 
-Buffer$1.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 2, this.length);
   return this[offset] | (this[offset + 1] << 8)
 };
 
-Buffer$1.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 2, this.length);
   return (this[offset] << 8) | this[offset + 1]
 };
 
-Buffer$1.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 4, this.length);
 
   return ((this[offset]) |
@@ -4182,7 +4182,7 @@ Buffer$1.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
       (this[offset + 3] * 0x1000000)
 };
 
-Buffer$1.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 4, this.length);
 
   return (this[offset] * 0x1000000) +
@@ -4191,7 +4191,7 @@ Buffer$1.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
     this[offset + 3])
 };
 
-Buffer$1.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
   offset = offset | 0;
   byteLength = byteLength | 0;
   if (!noAssert) checkOffset(offset, byteLength, this.length);
@@ -4209,7 +4209,7 @@ Buffer$1.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert)
   return val
 };
 
-Buffer$1.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
   offset = offset | 0;
   byteLength = byteLength | 0;
   if (!noAssert) checkOffset(offset, byteLength, this.length);
@@ -4227,25 +4227,25 @@ Buffer$1.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert)
   return val
 };
 
-Buffer$1.prototype.readInt8 = function readInt8 (offset, noAssert) {
+Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 1, this.length);
   if (!(this[offset] & 0x80)) return (this[offset])
   return ((0xff - this[offset] + 1) * -1)
 };
 
-Buffer$1.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 2, this.length);
   var val = this[offset] | (this[offset + 1] << 8);
   return (val & 0x8000) ? val | 0xFFFF0000 : val
 };
 
-Buffer$1.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 2, this.length);
   var val = this[offset + 1] | (this[offset] << 8);
   return (val & 0x8000) ? val | 0xFFFF0000 : val
 };
 
-Buffer$1.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 4, this.length);
 
   return (this[offset]) |
@@ -4254,7 +4254,7 @@ Buffer$1.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
     (this[offset + 3] << 24)
 };
 
-Buffer$1.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 4, this.length);
 
   return (this[offset] << 24) |
@@ -4263,22 +4263,22 @@ Buffer$1.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
     (this[offset + 3])
 };
 
-Buffer$1.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 4, this.length);
   return read(this, offset, true, 23, 4)
 };
 
-Buffer$1.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 4, this.length);
   return read(this, offset, false, 23, 4)
 };
 
-Buffer$1.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 8, this.length);
   return read(this, offset, true, 52, 8)
 };
 
-Buffer$1.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
   if (!noAssert) checkOffset(offset, 8, this.length);
   return read(this, offset, false, 52, 8)
 };
@@ -4289,7 +4289,7 @@ function checkInt (buf, value, offset, ext, max, min) {
   if (offset + ext > buf.length) throw new RangeError('Index out of range')
 }
 
-Buffer$1.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
   value = +value;
   offset = offset | 0;
   byteLength = byteLength | 0;
@@ -4308,7 +4308,7 @@ Buffer$1.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength
   return offset + byteLength
 };
 
-Buffer$1.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
   value = +value;
   offset = offset | 0;
   byteLength = byteLength | 0;
@@ -4327,11 +4327,11 @@ Buffer$1.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength
   return offset + byteLength
 };
 
-Buffer$1.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
-  if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
+  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
   this[offset] = (value & 0xff);
   return offset + 1
 };
@@ -4344,11 +4344,11 @@ function objectWriteUInt16 (buf, value, offset, littleEndian) {
   }
 }
 
-Buffer$1.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     this[offset] = (value & 0xff);
     this[offset + 1] = (value >>> 8);
   } else {
@@ -4357,11 +4357,11 @@ Buffer$1.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAsse
   return offset + 2
 };
 
-Buffer$1.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     this[offset] = (value >>> 8);
     this[offset + 1] = (value & 0xff);
   } else {
@@ -4377,11 +4377,11 @@ function objectWriteUInt32 (buf, value, offset, littleEndian) {
   }
 }
 
-Buffer$1.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     this[offset + 3] = (value >>> 24);
     this[offset + 2] = (value >>> 16);
     this[offset + 1] = (value >>> 8);
@@ -4392,11 +4392,11 @@ Buffer$1.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAsse
   return offset + 4
 };
 
-Buffer$1.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     this[offset] = (value >>> 24);
     this[offset + 1] = (value >>> 16);
     this[offset + 2] = (value >>> 8);
@@ -4407,7 +4407,7 @@ Buffer$1.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAsse
   return offset + 4
 };
 
-Buffer$1.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) {
@@ -4430,7 +4430,7 @@ Buffer$1.prototype.writeIntLE = function writeIntLE (value, offset, byteLength,
   return offset + byteLength
 };
 
-Buffer$1.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) {
@@ -4453,21 +4453,21 @@ Buffer$1.prototype.writeIntBE = function writeIntBE (value, offset, byteLength,
   return offset + byteLength
 };
 
-Buffer$1.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
-  if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
+  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
   if (value < 0) value = 0xff + value + 1;
   this[offset] = (value & 0xff);
   return offset + 1
 };
 
-Buffer$1.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     this[offset] = (value & 0xff);
     this[offset + 1] = (value >>> 8);
   } else {
@@ -4476,11 +4476,11 @@ Buffer$1.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert
   return offset + 2
 };
 
-Buffer$1.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     this[offset] = (value >>> 8);
     this[offset + 1] = (value & 0xff);
   } else {
@@ -4489,11 +4489,11 @@ Buffer$1.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert
   return offset + 2
 };
 
-Buffer$1.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     this[offset] = (value & 0xff);
     this[offset + 1] = (value >>> 8);
     this[offset + 2] = (value >>> 16);
@@ -4504,12 +4504,12 @@ Buffer$1.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert
   return offset + 4
 };
 
-Buffer$1.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
   value = +value;
   offset = offset | 0;
   if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
   if (value < 0) value = 0xffffffff + value + 1;
-  if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+  if (Buffer.TYPED_ARRAY_SUPPORT) {
     this[offset] = (value >>> 24);
     this[offset + 1] = (value >>> 16);
     this[offset + 2] = (value >>> 8);
@@ -4533,11 +4533,11 @@ function writeFloat (buf, value, offset, littleEndian, noAssert) {
   return offset + 4
 }
 
-Buffer$1.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
   return writeFloat(this, value, offset, true, noAssert)
 };
 
-Buffer$1.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
   return writeFloat(this, value, offset, false, noAssert)
 };
 
@@ -4549,16 +4549,16 @@ function writeDouble (buf, value, offset, littleEndian, noAssert) {
   return offset + 8
 }
 
-Buffer$1.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
   return writeDouble(this, value, offset, true, noAssert)
 };
 
-Buffer$1.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
   return writeDouble(this, value, offset, false, noAssert)
 };
 
 // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
-Buffer$1.prototype.copy = function copy (target, targetStart, start, end) {
+Buffer.prototype.copy = function copy (target, targetStart, start, end) {
   if (!start) start = 0;
   if (!end && end !== 0) end = this.length;
   if (targetStart >= target.length) targetStart = target.length;
@@ -4590,7 +4590,7 @@ Buffer$1.prototype.copy = function copy (target, targetStart, start, end) {
     for (i = len - 1; i >= 0; --i) {
       target[i + targetStart] = this[i + start];
     }
-  } else if (len < 1000 || !Buffer$1.TYPED_ARRAY_SUPPORT) {
+  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
     // ascending copy from start
     for (i = 0; i < len; ++i) {
       target[i + targetStart] = this[i + start];
@@ -4610,7 +4610,7 @@ Buffer$1.prototype.copy = function copy (target, targetStart, start, end) {
 //    buffer.fill(number[, offset[, end]])
 //    buffer.fill(buffer[, offset[, end]])
 //    buffer.fill(string[, offset[, end]][, encoding])
-Buffer$1.prototype.fill = function fill (val, start, end, encoding) {
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
   // Handle string cases:
   if (typeof val === 'string') {
     if (typeof start === 'string') {
@@ -4630,7 +4630,7 @@ Buffer$1.prototype.fill = function fill (val, start, end, encoding) {
     if (encoding !== undefined && typeof encoding !== 'string') {
       throw new TypeError('encoding must be a string')
     }
-    if (typeof encoding === 'string' && !Buffer$1.isEncoding(encoding)) {
+    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
       throw new TypeError('Unknown encoding: ' + encoding)
     }
   } else if (typeof val === 'number') {
@@ -4659,7 +4659,7 @@ Buffer$1.prototype.fill = function fill (val, start, end, encoding) {
   } else {
     var bytes = internalIsBuffer(val)
       ? val
-      : utf8ToBytes(new Buffer$1(val, encoding).toString());
+      : utf8ToBytes(new Buffer(val, encoding).toString());
     var len = bytes.length;
     for (i = 0; i < end - start; ++i) {
       this[i + start] = bytes[i % len];
@@ -5067,7 +5067,7 @@ function toFormData$1(obj, formData, options) {
     }
 
     if (utils$1.isArrayBuffer(value) || utils$1.isTypedArray(value)) {
-      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer$1.from(value);
+      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
     }
 
     return value;
@@ -10997,7 +10997,7 @@ class LogUploader {
         while (queueItem = this.sendQueue.shift()) {
             promises.push(this.postLogsToEndpointInstantly(queueItem.requestParams, { saveOnFailure: true }));
         }
-        /* don't want this to be async because this is called from the window 'unload' event */
+        /* don't want this to be async because this is called from the document 'visibilitychange' event */
         return promises;
     }
     resetSendQueue() {
@@ -11161,7 +11161,11 @@ class ServerLogger {
         this.isInitialized = true;
         this.debounceLogUploadTime = logger.config.uploadDebounceTime || DEFAULT_UPLOAD_DEBOUNCE;
         this.logUploader = getOrCreateLogUploader(logger.config.url, logger.config.debugMode, logger.config.useUniqueLogUploader, logger.config.customHeaders);
-        window.addEventListener('unload', this.sendAllLogsInstantly.bind(this));
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden') {
+                this.sendAllLogsInstantly();
+            }
+        });
         /* when we stop server logging, we need to clear everything out */
         this.logger.on('onStop', (_reason) => {
             this.debug('`onStop` received. Clearing logBuffer and sendQueue', {
@@ -11240,7 +11244,7 @@ class ServerLogger {
         this.sendLogsToServer();
     }
     sendAllLogsInstantly() {
-        /* don't want this to be async because this is called from the window 'unload' event */
+        /* don't want this to be async because this is called from the document 'visibilitychange' event */
         /* this will send any queued up requests */
         return this.logUploader.sendEntireQueue()
             .concat(
@@ -11554,7 +11558,7 @@ class Logger extends EventEmitter {
     }
 }
 /* eslint-disable @typescript-eslint/naming-convention */
-Logger.VERSION = '4.2.17';
+Logger.VERSION = '4.2.18';
 
 /* istanbul ignore file */
 if (!commonjsGlobal) {
@@ -11651,6 +11655,7 @@ var SessionTypes;
     SessionTypes["collaborateVideo"] = "collaborateVideo";
     SessionTypes["acdScreenShare"] = "screenShare";
     SessionTypes["screenRecording"] = "screenRecording";
+    SessionTypes["liveScreenMonitoring"] = "liveScreenMonitoring";
     SessionTypes["unknown"] = "unknown";
 })(SessionTypes || (SessionTypes = {}));
 
@@ -11722,6 +11727,9 @@ const isAcdJid = function (jid) {
 const isScreenRecordingJid = function (jid) {
     return jid.startsWith('screenrecording-') && !isSoftphoneJid(jid);
 };
+const isLiveScreenMonitoringJid = function (jid) {
+    return jid.startsWith('livemonitor-') && !isSoftphoneJid(jid);
+};
 const isSoftphoneJid = function (jid) {
     if (!jid) {
         return false;
@@ -12176,6 +12184,7 @@ class Notifications {
         return this.xmppUnsubscribe(topic);
     }
     bulkSubscribe(topics, options = { replace: false, force: false }, priorities = {}) {
+        var _a;
         return __awaiter$4(this, void 0, void 0, function* () {
             this.setTopicPriorities(priorities);
             let toSubscribe = mergeAndDedup(topics, []);
@@ -12192,29 +12201,38 @@ class Notifications {
             if (response && response.data && 'entities' in response.data && Array.isArray(response.data.entities)) {
                 topicResponseEntities = response.data.entities;
             }
-            const topicResponsesById = {};
+            const result = {};
             for (const topicEntity of topicResponseEntities) {
-                topicResponsesById[topicEntity.id] = topicEntity;
+                const { id, state, rejectionReason } = topicEntity;
+                result[id] = { topic: id, state, rejectionReason };
+                // If response entity is a combined topic ID like "a.b?c&d" include individualized topic IDs
+                // as keys in the map. This could either point to the same result as the combined topic ID
+                // or to a specific result for that individual topic if backend provides a specific result.
+                // Example: caller asked to subscribe "a.b?c&d" but user lacks permission for topic "a.b.d"
+                // In this case, API response will include "a.b?c&d" as success along with "a.b.d" as failure.
+                if (id.includes('?')) {
+                    for (const individualTopic of splitIntoIndividualTopics(id)) {
+                        const hasIndividualTopicResult = result.hasOwnProperty(individualTopic);
+                        // Only use the combined topic result for this individual topic ID if there isn't already
+                        // a result for the individual topic itself. Exact topic result takes precedence.
+                        if (!hasIndividualTopicResult) {
+                            result[individualTopic] = result[id];
+                        }
+                    }
+                }
             }
-            const result = {};
             if (options.replace) {
                 this.bulkSubscriptions = {};
             }
             topics.forEach(topic => {
                 this.bulkSubscriptions[topic] = true;
-                if (this.enablePartialBulkResubscribe) {
-                    if (topic in topicResponsesById) {
-                        const { state, rejectionReason } = topicResponsesById[topic];
-                        result[topic] = { topic, state, rejectionReason };
-                    }
-                    else {
-                        result[topic] = { topic, state: 'Unknown' };
-                    }
-                }
-                else {
-                    result[topic] = { topic, state: 'Permitted' };
-                }
             });
+            // Add a fallback result for any topic in the toSubscribe list that isn't already in result.
+            // With partial bulk resubscribe enabled missing result means "Unknown" state but when not
+            // enabled the fallback is "Permitted" for backward compatibility (success response means OK).
+            for (const topic of toSubscribe) {
+                (_a = result[topic]) !== null && _a !== void 0 ? _a : (result[topic] = { topic, state: this.enablePartialBulkResubscribe ? 'Unknown' : 'Permitted' });
+            }
             return result;
         });
     }
@@ -18743,135 +18761,150 @@ util$2.inherits = function inherits(ctor, superCtor) {
 
 var BufferList = {};
 
-var Buffer = buffer.Buffer;
-function copyBuffer(src, target, offset) {
-    src.copy(target, offset);
-}
-BufferList.BufferList = class BufferList {
-    constructor() {
-        this.head = null;
-        this.tail = null;
-        this.length = 0;
-    }
-    push(v) {
-        var entry = { data: v, next: null };
-        if (this.length > 0)
-            this.tail.next = entry;
-        else
-            this.head = entry;
-        this.tail = entry;
-        ++this.length;
-    }
-    unshift(v) {
-        var entry = { data: v, next: this.head };
-        if (this.length === 0)
-            this.tail = entry;
-        this.head = entry;
-        ++this.length;
-    }
-    shift() {
-        if (this.length === 0)
-            return;
-        var ret = this.head.data;
-        if (this.length === 1)
-            this.head = this.tail = null;
-        else
-            this.head = this.head.next;
-        --this.length;
-        return ret;
-    }
-    clear() {
-        this.head = this.tail = null;
-        this.length = 0;
-    }
-    join(s) {
-        if (this.length === 0)
-            return '';
-        var p = this.head;
-        var ret = '' + p.data;
-        while ((p = p.next)) {
-            ret += s + p.data;
-        }
-        return ret;
-    }
-    concat(n) {
-        if (this.length === 0)
-            return Buffer.alloc(0);
-        if (this.length === 1)
-            return this.head.data;
-        var ret = Buffer.allocUnsafe(n >>> 0);
-        var p = this.head;
-        var i = 0;
-        while (p) {
-            copyBuffer(p.data, ret, i);
-            i += p.data.length;
-            p = p.next;
-        }
-        return ret;
-    }
-};
+var hasRequiredBufferList;
 
-/*<replacement>*/
-var pna = process$1;
-/*</replacement>*/
-// undocumented cb() API, needed for core, not for public API
-function destroy(err, cb) {
-    var _this = this;
-    var readableDestroyed = this._readableState && this._readableState.destroyed;
-    var writableDestroyed = this._writableState && this._writableState.destroyed;
-    if (readableDestroyed || writableDestroyed) {
-        if (cb) {
-            cb(err);
-        }
-        else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
-            pna.nextTick(emitErrorNT, this, err);
-        }
-        return this;
-    }
-    // we set destroyed to true before firing error callbacks in order
-    // to make it re-entrance safe in case destroy() is called within callbacks
-    if (this._readableState) {
-        this._readableState.destroyed = true;
-    }
-    // if this is a duplex stream mark the writable part as destroyed as well
-    if (this._writableState) {
-        this._writableState.destroyed = true;
-    }
-    this._destroy(err || null, function (err) {
-        if (!cb && err) {
-            pna.nextTick(emitErrorNT, _this, err);
-            if (_this._writableState) {
-                _this._writableState.errorEmitted = true;
-            }
-        }
-        else if (cb) {
-            cb(err);
-        }
-    });
-    return this;
-}
-function undestroy() {
-    if (this._readableState) {
-        this._readableState.destroyed = false;
-        this._readableState.reading = false;
-        this._readableState.ended = false;
-        this._readableState.endEmitted = false;
-    }
-    if (this._writableState) {
-        this._writableState.destroyed = false;
-        this._writableState.ended = false;
-        this._writableState.ending = false;
-        this._writableState.finished = false;
-        this._writableState.errorEmitted = false;
-    }
+function requireBufferList () {
+	if (hasRequiredBufferList) return BufferList;
+	hasRequiredBufferList = 1;
+	var Buffer = buffer.Buffer;
+	function copyBuffer(src, target, offset) {
+	    src.copy(target, offset);
+	}
+	BufferList.BufferList = class BufferList {
+	    constructor() {
+	        this.head = null;
+	        this.tail = null;
+	        this.length = 0;
+	    }
+	    push(v) {
+	        var entry = { data: v, next: null };
+	        if (this.length > 0)
+	            this.tail.next = entry;
+	        else
+	            this.head = entry;
+	        this.tail = entry;
+	        ++this.length;
+	    }
+	    unshift(v) {
+	        var entry = { data: v, next: this.head };
+	        if (this.length === 0)
+	            this.tail = entry;
+	        this.head = entry;
+	        ++this.length;
+	    }
+	    shift() {
+	        if (this.length === 0)
+	            return;
+	        var ret = this.head.data;
+	        if (this.length === 1)
+	            this.head = this.tail = null;
+	        else
+	            this.head = this.head.next;
+	        --this.length;
+	        return ret;
+	    }
+	    clear() {
+	        this.head = this.tail = null;
+	        this.length = 0;
+	    }
+	    join(s) {
+	        if (this.length === 0)
+	            return '';
+	        var p = this.head;
+	        var ret = '' + p.data;
+	        while ((p = p.next)) {
+	            ret += s + p.data;
+	        }
+	        return ret;
+	    }
+	    concat(n) {
+	        if (this.length === 0)
+	            return Buffer.alloc(0);
+	        if (this.length === 1)
+	            return this.head.data;
+	        var ret = Buffer.allocUnsafe(n >>> 0);
+	        var p = this.head;
+	        var i = 0;
+	        while (p) {
+	            copyBuffer(p.data, ret, i);
+	            i += p.data.length;
+	            p = p.next;
+	        }
+	        return ret;
+	    }
+	};
+	return BufferList;
 }
-function emitErrorNT(self, err) {
-    self.emit('error', err);
+
+var destroy_1;
+var hasRequiredDestroy;
+
+function requireDestroy () {
+	if (hasRequiredDestroy) return destroy_1;
+	hasRequiredDestroy = 1;
+	/*<replacement>*/
+	var pna = process$1;
+	/*</replacement>*/
+	// undocumented cb() API, needed for core, not for public API
+	function destroy(err, cb) {
+	    var _this = this;
+	    var readableDestroyed = this._readableState && this._readableState.destroyed;
+	    var writableDestroyed = this._writableState && this._writableState.destroyed;
+	    if (readableDestroyed || writableDestroyed) {
+	        if (cb) {
+	            cb(err);
+	        }
+	        else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
+	            pna.nextTick(emitErrorNT, this, err);
+	        }
+	        return this;
+	    }
+	    // we set destroyed to true before firing error callbacks in order
+	    // to make it re-entrance safe in case destroy() is called within callbacks
+	    if (this._readableState) {
+	        this._readableState.destroyed = true;
+	    }
+	    // if this is a duplex stream mark the writable part as destroyed as well
+	    if (this._writableState) {
+	        this._writableState.destroyed = true;
+	    }
+	    this._destroy(err || null, function (err) {
+	        if (!cb && err) {
+	            pna.nextTick(emitErrorNT, _this, err);
+	            if (_this._writableState) {
+	                _this._writableState.errorEmitted = true;
+	            }
+	        }
+	        else if (cb) {
+	            cb(err);
+	        }
+	    });
+	    return this;
+	}
+	function undestroy() {
+	    if (this._readableState) {
+	        this._readableState.destroyed = false;
+	        this._readableState.reading = false;
+	        this._readableState.ended = false;
+	        this._readableState.endEmitted = false;
+	    }
+	    if (this._writableState) {
+	        this._writableState.destroyed = false;
+	        this._writableState.ended = false;
+	        this._writableState.ending = false;
+	        this._writableState.finished = false;
+	        this._writableState.errorEmitted = false;
+	    }
+	}
+	function emitErrorNT(self, err) {
+	    self.emit('error', err);
+	}
+	destroy_1 = {
+	    destroy: destroy,
+	    undestroy: undestroy
+	};
+	return destroy_1;
 }
-var destroy_1 = {
-    destroy: destroy,
-    undestroy: undestroy
-};
 
 var _stream_writable;
 var hasRequired_stream_writable;
@@ -18917,7 +18950,7 @@ function require_stream_writable () {
 	    return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 	}
 	/*</replacement>*/
-	var destroyImpl = destroy_1;
+	var destroyImpl = requireDestroy();
 	util.inherits(Writable, Stream);
 	function nop() { }
 	function WritableState(options, stream) {
@@ -19921,8 +19954,8 @@ function require_stream_readable () {
 	/*<replacement>*/
 	var debug = function () { };
 	/*</replacement>*/
-	var BufferList$1 = BufferList.BufferList;
-	var destroyImpl = destroy_1;
+	var BufferList = requireBufferList().BufferList;
+	var destroyImpl = requireDestroy();
 	var StringDecoder;
 	util.inherits(Readable, Stream);
 	var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
@@ -19972,7 +20005,7 @@ function require_stream_readable () {
 	    // A linked list is used to store data chunks instead of an array because the
 	    // linked list can remove elements from the beginning faster than
 	    // array.shift()
-	    this.buffer = new BufferList$1();
+	    this.buffer = new BufferList();
 	    this.length = 0;
 	    this.pipes = null;
 	    this.pipesCount = 0;
@@ -35915,6 +35948,9 @@ class WebrtcExtension extends EventEmitter {
         else if (isScreenRecordingJid(jid)) {
             return SessionTypes.screenRecording;
         }
+        else if (isLiveScreenMonitoringJid(jid)) {
+            return SessionTypes.liveScreenMonitoring;
+        }
         else if (isSoftphoneJid(jid)) {
             return SessionTypes.softphone;
         }