@cuekit-ai/react 1.3.1 → 1.3.3

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import {
   ConnectionState,
   GlobalStore,
-  Participant,
   ParticipantEvent,
   RoomEvent,
   Track,
   WEBRTC_BACKEND_SERVER_URL,
   __commonJS,
   __export,
+  __require,
   __toESM,
   _apiKey,
   _appId,
@@ -34,7 +34,7 @@ import {
   setServerUrl,
   setWebRTCCallbacks,
   setWebRTCConfig
-} from "./chunk-PLOG3DEN.mjs";
+} from "./chunk-ZGHSIEXZ.mjs";
 
 // node_modules/inline-style-parser/index.js
 var require_inline_style_parser = __commonJS({
@@ -366,6 +366,802 @@ var require_extend = __commonJS({
   }
 });
 
+// (disabled):crypto
+var require_crypto = __commonJS({
+  "(disabled):crypto"() {
+    "use strict";
+  }
+});
+
+// node_modules/crypto-js/core.js
+var require_core = __commonJS({
+  "node_modules/crypto-js/core.js"(exports, module) {
+    "use strict";
+    (function(root4, factory) {
+      if (typeof exports === "object") {
+        module.exports = exports = factory();
+      } else if (typeof define === "function" && define.amd) {
+        define([], factory);
+      } else {
+        root4.CryptoJS = factory();
+      }
+    })(exports, function() {
+      var CryptoJS = CryptoJS || function(Math2, undefined2) {
+        var crypto;
+        if (typeof window !== "undefined" && window.crypto) {
+          crypto = window.crypto;
+        }
+        if (typeof self !== "undefined" && self.crypto) {
+          crypto = self.crypto;
+        }
+        if (typeof globalThis !== "undefined" && globalThis.crypto) {
+          crypto = globalThis.crypto;
+        }
+        if (!crypto && typeof window !== "undefined" && window.msCrypto) {
+          crypto = window.msCrypto;
+        }
+        if (!crypto && typeof global !== "undefined" && global.crypto) {
+          crypto = global.crypto;
+        }
+        if (!crypto && typeof __require === "function") {
+          try {
+            crypto = require_crypto();
+          } catch (err) {
+          }
+        }
+        var cryptoSecureRandomInt = function() {
+          if (crypto) {
+            if (typeof crypto.getRandomValues === "function") {
+              try {
+                return crypto.getRandomValues(new Uint32Array(1))[0];
+              } catch (err) {
+              }
+            }
+            if (typeof crypto.randomBytes === "function") {
+              try {
+                return crypto.randomBytes(4).readInt32LE();
+              } catch (err) {
+              }
+            }
+          }
+          throw new Error("Native crypto module could not be used to get secure random number.");
+        };
+        var create2 = Object.create || /* @__PURE__ */ function() {
+          function F2() {
+          }
+          return function(obj) {
+            var subtype;
+            F2.prototype = obj;
+            subtype = new F2();
+            F2.prototype = null;
+            return subtype;
+          };
+        }();
+        var C = {};
+        var C_lib = C.lib = {};
+        var Base = C_lib.Base = /* @__PURE__ */ function() {
+          return {
+            /**
+             * Creates a new object that inherits from this object.
+             *
+             * @param {Object} overrides Properties to copy into the new object.
+             *
+             * @return {Object} The new object.
+             *
+             * @static
+             *
+             * @example
+             *
+             *     var MyType = CryptoJS.lib.Base.extend({
+             *         field: 'value',
+             *
+             *         method: function () {
+             *         }
+             *     });
+             */
+            extend: function(overrides) {
+              var subtype = create2(this);
+              if (overrides) {
+                subtype.mixIn(overrides);
+              }
+              if (!subtype.hasOwnProperty("init") || this.init === subtype.init) {
+                subtype.init = function() {
+                  subtype.$super.init.apply(this, arguments);
+                };
+              }
+              subtype.init.prototype = subtype;
+              subtype.$super = this;
+              return subtype;
+            },
+            /**
+             * Extends this object and runs the init method.
+             * Arguments to create() will be passed to init().
+             *
+             * @return {Object} The new object.
+             *
+             * @static
+             *
+             * @example
+             *
+             *     var instance = MyType.create();
+             */
+            create: function() {
+              var instance = this.extend();
+              instance.init.apply(instance, arguments);
+              return instance;
+            },
+            /**
+             * Initializes a newly created object.
+             * Override this method to add some logic when your objects are created.
+             *
+             * @example
+             *
+             *     var MyType = CryptoJS.lib.Base.extend({
+             *         init: function () {
+             *             // ...
+             *         }
+             *     });
+             */
+            init: function() {
+            },
+            /**
+             * Copies properties into this object.
+             *
+             * @param {Object} properties The properties to mix in.
+             *
+             * @example
+             *
+             *     MyType.mixIn({
+             *         field: 'value'
+             *     });
+             */
+            mixIn: function(properties) {
+              for (var propertyName in properties) {
+                if (properties.hasOwnProperty(propertyName)) {
+                  this[propertyName] = properties[propertyName];
+                }
+              }
+              if (properties.hasOwnProperty("toString")) {
+                this.toString = properties.toString;
+              }
+            },
+            /**
+             * Creates a copy of this object.
+             *
+             * @return {Object} The clone.
+             *
+             * @example
+             *
+             *     var clone = instance.clone();
+             */
+            clone: function() {
+              return this.init.prototype.extend(this);
+            }
+          };
+        }();
+        var WordArray = C_lib.WordArray = Base.extend({
+          /**
+           * Initializes a newly created word array.
+           *
+           * @param {Array} words (Optional) An array of 32-bit words.
+           * @param {number} sigBytes (Optional) The number of significant bytes in the words.
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.lib.WordArray.create();
+           *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
+           *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
+           */
+          init: function(words, sigBytes) {
+            words = this.words = words || [];
+            if (sigBytes != undefined2) {
+              this.sigBytes = sigBytes;
+            } else {
+              this.sigBytes = words.length * 4;
+            }
+          },
+          /**
+           * Converts this word array to a string.
+           *
+           * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+           *
+           * @return {string} The stringified word array.
+           *
+           * @example
+           *
+           *     var string = wordArray + '';
+           *     var string = wordArray.toString();
+           *     var string = wordArray.toString(CryptoJS.enc.Utf8);
+           */
+          toString: function(encoder) {
+            return (encoder || Hex).stringify(this);
+          },
+          /**
+           * Concatenates a word array to this word array.
+           *
+           * @param {WordArray} wordArray The word array to append.
+           *
+           * @return {WordArray} This word array.
+           *
+           * @example
+           *
+           *     wordArray1.concat(wordArray2);
+           */
+          concat: function(wordArray) {
+            var thisWords = this.words;
+            var thatWords = wordArray.words;
+            var thisSigBytes = this.sigBytes;
+            var thatSigBytes = wordArray.sigBytes;
+            this.clamp();
+            if (thisSigBytes % 4) {
+              for (var i2 = 0; i2 < thatSigBytes; i2++) {
+                var thatByte = thatWords[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
+                thisWords[thisSigBytes + i2 >>> 2] |= thatByte << 24 - (thisSigBytes + i2) % 4 * 8;
+              }
+            } else {
+              for (var j2 = 0; j2 < thatSigBytes; j2 += 4) {
+                thisWords[thisSigBytes + j2 >>> 2] = thatWords[j2 >>> 2];
+              }
+            }
+            this.sigBytes += thatSigBytes;
+            return this;
+          },
+          /**
+           * Removes insignificant bits.
+           *
+           * @example
+           *
+           *     wordArray.clamp();
+           */
+          clamp: function() {
+            var words = this.words;
+            var sigBytes = this.sigBytes;
+            words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
+            words.length = Math2.ceil(sigBytes / 4);
+          },
+          /**
+           * Creates a copy of this word array.
+           *
+           * @return {WordArray} The clone.
+           *
+           * @example
+           *
+           *     var clone = wordArray.clone();
+           */
+          clone: function() {
+            var clone = Base.clone.call(this);
+            clone.words = this.words.slice(0);
+            return clone;
+          },
+          /**
+           * Creates a word array filled with random bytes.
+           *
+           * @param {number} nBytes The number of random bytes to generate.
+           *
+           * @return {WordArray} The random word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.lib.WordArray.random(16);
+           */
+          random: function(nBytes) {
+            var words = [];
+            for (var i2 = 0; i2 < nBytes; i2 += 4) {
+              words.push(cryptoSecureRandomInt());
+            }
+            return new WordArray.init(words, nBytes);
+          }
+        });
+        var C_enc = C.enc = {};
+        var Hex = C_enc.Hex = {
+          /**
+           * Converts a word array to a hex string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The hex string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
+           */
+          stringify: function(wordArray) {
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+            var hexChars = [];
+            for (var i2 = 0; i2 < sigBytes; i2++) {
+              var bite = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
+              hexChars.push((bite >>> 4).toString(16));
+              hexChars.push((bite & 15).toString(16));
+            }
+            return hexChars.join("");
+          },
+          /**
+           * Converts a hex string to a word array.
+           *
+           * @param {string} hexStr The hex string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
+           */
+          parse: function(hexStr) {
+            var hexStrLength = hexStr.length;
+            var words = [];
+            for (var i2 = 0; i2 < hexStrLength; i2 += 2) {
+              words[i2 >>> 3] |= parseInt(hexStr.substr(i2, 2), 16) << 24 - i2 % 8 * 4;
+            }
+            return new WordArray.init(words, hexStrLength / 2);
+          }
+        };
+        var Latin1 = C_enc.Latin1 = {
+          /**
+           * Converts a word array to a Latin1 string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The Latin1 string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
+           */
+          stringify: function(wordArray) {
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+            var latin1Chars = [];
+            for (var i2 = 0; i2 < sigBytes; i2++) {
+              var bite = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
+              latin1Chars.push(String.fromCharCode(bite));
+            }
+            return latin1Chars.join("");
+          },
+          /**
+           * Converts a Latin1 string to a word array.
+           *
+           * @param {string} latin1Str The Latin1 string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
+           */
+          parse: function(latin1Str) {
+            var latin1StrLength = latin1Str.length;
+            var words = [];
+            for (var i2 = 0; i2 < latin1StrLength; i2++) {
+              words[i2 >>> 2] |= (latin1Str.charCodeAt(i2) & 255) << 24 - i2 % 4 * 8;
+            }
+            return new WordArray.init(words, latin1StrLength);
+          }
+        };
+        var Utf8 = C_enc.Utf8 = {
+          /**
+           * Converts a word array to a UTF-8 string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The UTF-8 string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
+           */
+          stringify: function(wordArray) {
+            try {
+              return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+            } catch (e2) {
+              throw new Error("Malformed UTF-8 data");
+            }
+          },
+          /**
+           * Converts a UTF-8 string to a word array.
+           *
+           * @param {string} utf8Str The UTF-8 string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
+           */
+          parse: function(utf8Str) {
+            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+          }
+        };
+        var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+          /**
+           * Resets this block algorithm's data buffer to its initial state.
+           *
+           * @example
+           *
+           *     bufferedBlockAlgorithm.reset();
+           */
+          reset: function() {
+            this._data = new WordArray.init();
+            this._nDataBytes = 0;
+          },
+          /**
+           * Adds new data to this block algorithm's buffer.
+           *
+           * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
+           *
+           * @example
+           *
+           *     bufferedBlockAlgorithm._append('data');
+           *     bufferedBlockAlgorithm._append(wordArray);
+           */
+          _append: function(data) {
+            if (typeof data == "string") {
+              data = Utf8.parse(data);
+            }
+            this._data.concat(data);
+            this._nDataBytes += data.sigBytes;
+          },
+          /**
+           * Processes available data blocks.
+           *
+           * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+           *
+           * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
+           *
+           * @return {WordArray} The processed data.
+           *
+           * @example
+           *
+           *     var processedData = bufferedBlockAlgorithm._process();
+           *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
+           */
+          _process: function(doFlush) {
+            var processedWords;
+            var data = this._data;
+            var dataWords = data.words;
+            var dataSigBytes = data.sigBytes;
+            var blockSize = this.blockSize;
+            var blockSizeBytes = blockSize * 4;
+            var nBlocksReady = dataSigBytes / blockSizeBytes;
+            if (doFlush) {
+              nBlocksReady = Math2.ceil(nBlocksReady);
+            } else {
+              nBlocksReady = Math2.max((nBlocksReady | 0) - this._minBufferSize, 0);
+            }
+            var nWordsReady = nBlocksReady * blockSize;
+            var nBytesReady = Math2.min(nWordsReady * 4, dataSigBytes);
+            if (nWordsReady) {
+              for (var offset = 0; offset < nWordsReady; offset += blockSize) {
+                this._doProcessBlock(dataWords, offset);
+              }
+              processedWords = dataWords.splice(0, nWordsReady);
+              data.sigBytes -= nBytesReady;
+            }
+            return new WordArray.init(processedWords, nBytesReady);
+          },
+          /**
+           * Creates a copy of this object.
+           *
+           * @return {Object} The clone.
+           *
+           * @example
+           *
+           *     var clone = bufferedBlockAlgorithm.clone();
+           */
+          clone: function() {
+            var clone = Base.clone.call(this);
+            clone._data = this._data.clone();
+            return clone;
+          },
+          _minBufferSize: 0
+        });
+        var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+          /**
+           * Configuration options.
+           */
+          cfg: Base.extend(),
+          /**
+           * Initializes a newly created hasher.
+           *
+           * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
+           *
+           * @example
+           *
+           *     var hasher = CryptoJS.algo.SHA256.create();
+           */
+          init: function(cfg) {
+            this.cfg = this.cfg.extend(cfg);
+            this.reset();
+          },
+          /**
+           * Resets this hasher to its initial state.
+           *
+           * @example
+           *
+           *     hasher.reset();
+           */
+          reset: function() {
+            BufferedBlockAlgorithm.reset.call(this);
+            this._doReset();
+          },
+          /**
+           * Updates this hasher with a message.
+           *
+           * @param {WordArray|string} messageUpdate The message to append.
+           *
+           * @return {Hasher} This hasher.
+           *
+           * @example
+           *
+           *     hasher.update('message');
+           *     hasher.update(wordArray);
+           */
+          update: function(messageUpdate) {
+            this._append(messageUpdate);
+            this._process();
+            return this;
+          },
+          /**
+           * Finalizes the hash computation.
+           * Note that the finalize operation is effectively a destructive, read-once operation.
+           *
+           * @param {WordArray|string} messageUpdate (Optional) A final message update.
+           *
+           * @return {WordArray} The hash.
+           *
+           * @example
+           *
+           *     var hash = hasher.finalize();
+           *     var hash = hasher.finalize('message');
+           *     var hash = hasher.finalize(wordArray);
+           */
+          finalize: function(messageUpdate) {
+            if (messageUpdate) {
+              this._append(messageUpdate);
+            }
+            var hash = this._doFinalize();
+            return hash;
+          },
+          blockSize: 512 / 32,
+          /**
+           * Creates a shortcut function to a hasher's object interface.
+           *
+           * @param {Hasher} hasher The hasher to create a helper for.
+           *
+           * @return {Function} The shortcut function.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
+           */
+          _createHelper: function(hasher) {
+            return function(message, cfg) {
+              return new hasher.init(cfg).finalize(message);
+            };
+          },
+          /**
+           * Creates a shortcut function to the HMAC's object interface.
+           *
+           * @param {Hasher} hasher The hasher to use in this HMAC helper.
+           *
+           * @return {Function} The shortcut function.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
+           */
+          _createHmacHelper: function(hasher) {
+            return function(message, key) {
+              return new C_algo.HMAC.init(hasher, key).finalize(message);
+            };
+          }
+        });
+        var C_algo = C.algo = {};
+        return C;
+      }(Math);
+      return CryptoJS;
+    });
+  }
+});
+
+// node_modules/crypto-js/md5.js
+var require_md5 = __commonJS({
+  "node_modules/crypto-js/md5.js"(exports, module) {
+    "use strict";
+    (function(root4, factory) {
+      if (typeof exports === "object") {
+        module.exports = exports = factory(require_core());
+      } else if (typeof define === "function" && define.amd) {
+        define(["./core"], factory);
+      } else {
+        factory(root4.CryptoJS);
+      }
+    })(exports, function(CryptoJS) {
+      (function(Math2) {
+        var C = CryptoJS;
+        var C_lib = C.lib;
+        var WordArray = C_lib.WordArray;
+        var Hasher = C_lib.Hasher;
+        var C_algo = C.algo;
+        var T = [];
+        (function() {
+          for (var i2 = 0; i2 < 64; i2++) {
+            T[i2] = Math2.abs(Math2.sin(i2 + 1)) * 4294967296 | 0;
+          }
+        })();
+        var MD52 = C_algo.MD5 = Hasher.extend({
+          _doReset: function() {
+            this._hash = new WordArray.init([
+              1732584193,
+              4023233417,
+              2562383102,
+              271733878
+            ]);
+          },
+          _doProcessBlock: function(M3, offset) {
+            for (var i2 = 0; i2 < 16; i2++) {
+              var offset_i = offset + i2;
+              var M_offset_i = M3[offset_i];
+              M3[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 16711935 | (M_offset_i << 24 | M_offset_i >>> 8) & 4278255360;
+            }
+            var H3 = this._hash.words;
+            var M_offset_0 = M3[offset + 0];
+            var M_offset_1 = M3[offset + 1];
+            var M_offset_2 = M3[offset + 2];
+            var M_offset_3 = M3[offset + 3];
+            var M_offset_4 = M3[offset + 4];
+            var M_offset_5 = M3[offset + 5];
+            var M_offset_6 = M3[offset + 6];
+            var M_offset_7 = M3[offset + 7];
+            var M_offset_8 = M3[offset + 8];
+            var M_offset_9 = M3[offset + 9];
+            var M_offset_10 = M3[offset + 10];
+            var M_offset_11 = M3[offset + 11];
+            var M_offset_12 = M3[offset + 12];
+            var M_offset_13 = M3[offset + 13];
+            var M_offset_14 = M3[offset + 14];
+            var M_offset_15 = M3[offset + 15];
+            var a = H3[0];
+            var b2 = H3[1];
+            var c = H3[2];
+            var d = H3[3];
+            a = FF(a, b2, c, d, M_offset_0, 7, T[0]);
+            d = FF(d, a, b2, c, M_offset_1, 12, T[1]);
+            c = FF(c, d, a, b2, M_offset_2, 17, T[2]);
+            b2 = FF(b2, c, d, a, M_offset_3, 22, T[3]);
+            a = FF(a, b2, c, d, M_offset_4, 7, T[4]);
+            d = FF(d, a, b2, c, M_offset_5, 12, T[5]);
+            c = FF(c, d, a, b2, M_offset_6, 17, T[6]);
+            b2 = FF(b2, c, d, a, M_offset_7, 22, T[7]);
+            a = FF(a, b2, c, d, M_offset_8, 7, T[8]);
+            d = FF(d, a, b2, c, M_offset_9, 12, T[9]);
+            c = FF(c, d, a, b2, M_offset_10, 17, T[10]);
+            b2 = FF(b2, c, d, a, M_offset_11, 22, T[11]);
+            a = FF(a, b2, c, d, M_offset_12, 7, T[12]);
+            d = FF(d, a, b2, c, M_offset_13, 12, T[13]);
+            c = FF(c, d, a, b2, M_offset_14, 17, T[14]);
+            b2 = FF(b2, c, d, a, M_offset_15, 22, T[15]);
+            a = GG(a, b2, c, d, M_offset_1, 5, T[16]);
+            d = GG(d, a, b2, c, M_offset_6, 9, T[17]);
+            c = GG(c, d, a, b2, M_offset_11, 14, T[18]);
+            b2 = GG(b2, c, d, a, M_offset_0, 20, T[19]);
+            a = GG(a, b2, c, d, M_offset_5, 5, T[20]);
+            d = GG(d, a, b2, c, M_offset_10, 9, T[21]);
+            c = GG(c, d, a, b2, M_offset_15, 14, T[22]);
+            b2 = GG(b2, c, d, a, M_offset_4, 20, T[23]);
+            a = GG(a, b2, c, d, M_offset_9, 5, T[24]);
+            d = GG(d, a, b2, c, M_offset_14, 9, T[25]);
+            c = GG(c, d, a, b2, M_offset_3, 14, T[26]);
+            b2 = GG(b2, c, d, a, M_offset_8, 20, T[27]);
+            a = GG(a, b2, c, d, M_offset_13, 5, T[28]);
+            d = GG(d, a, b2, c, M_offset_2, 9, T[29]);
+            c = GG(c, d, a, b2, M_offset_7, 14, T[30]);
+            b2 = GG(b2, c, d, a, M_offset_12, 20, T[31]);
+            a = HH(a, b2, c, d, M_offset_5, 4, T[32]);
+            d = HH(d, a, b2, c, M_offset_8, 11, T[33]);
+            c = HH(c, d, a, b2, M_offset_11, 16, T[34]);
+            b2 = HH(b2, c, d, a, M_offset_14, 23, T[35]);
+            a = HH(a, b2, c, d, M_offset_1, 4, T[36]);
+            d = HH(d, a, b2, c, M_offset_4, 11, T[37]);
+            c = HH(c, d, a, b2, M_offset_7, 16, T[38]);
+            b2 = HH(b2, c, d, a, M_offset_10, 23, T[39]);
+            a = HH(a, b2, c, d, M_offset_13, 4, T[40]);
+            d = HH(d, a, b2, c, M_offset_0, 11, T[41]);
+            c = HH(c, d, a, b2, M_offset_3, 16, T[42]);
+            b2 = HH(b2, c, d, a, M_offset_6, 23, T[43]);
+            a = HH(a, b2, c, d, M_offset_9, 4, T[44]);
+            d = HH(d, a, b2, c, M_offset_12, 11, T[45]);
+            c = HH(c, d, a, b2, M_offset_15, 16, T[46]);
+            b2 = HH(b2, c, d, a, M_offset_2, 23, T[47]);
+            a = II(a, b2, c, d, M_offset_0, 6, T[48]);
+            d = II(d, a, b2, c, M_offset_7, 10, T[49]);
+            c = II(c, d, a, b2, M_offset_14, 15, T[50]);
+            b2 = II(b2, c, d, a, M_offset_5, 21, T[51]);
+            a = II(a, b2, c, d, M_offset_12, 6, T[52]);
+            d = II(d, a, b2, c, M_offset_3, 10, T[53]);
+            c = II(c, d, a, b2, M_offset_10, 15, T[54]);
+            b2 = II(b2, c, d, a, M_offset_1, 21, T[55]);
+            a = II(a, b2, c, d, M_offset_8, 6, T[56]);
+            d = II(d, a, b2, c, M_offset_15, 10, T[57]);
+            c = II(c, d, a, b2, M_offset_6, 15, T[58]);
+            b2 = II(b2, c, d, a, M_offset_13, 21, T[59]);
+            a = II(a, b2, c, d, M_offset_4, 6, T[60]);
+            d = II(d, a, b2, c, M_offset_11, 10, T[61]);
+            c = II(c, d, a, b2, M_offset_2, 15, T[62]);
+            b2 = II(b2, c, d, a, M_offset_9, 21, T[63]);
+            H3[0] = H3[0] + a | 0;
+            H3[1] = H3[1] + b2 | 0;
+            H3[2] = H3[2] + c | 0;
+            H3[3] = H3[3] + d | 0;
+          },
+          _doFinalize: function() {
+            var data = this._data;
+            var dataWords = data.words;
+            var nBitsTotal = this._nDataBytes * 8;
+            var nBitsLeft = data.sigBytes * 8;
+            dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+            var nBitsTotalH = Math2.floor(nBitsTotal / 4294967296);
+            var nBitsTotalL = nBitsTotal;
+            dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 16711935 | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 4278255360;
+            dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 16711935 | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 4278255360;
+            data.sigBytes = (dataWords.length + 1) * 4;
+            this._process();
+            var hash = this._hash;
+            var H3 = hash.words;
+            for (var i2 = 0; i2 < 4; i2++) {
+              var H_i = H3[i2];
+              H3[i2] = (H_i << 8 | H_i >>> 24) & 16711935 | (H_i << 24 | H_i >>> 8) & 4278255360;
+            }
+            return hash;
+          },
+          clone: function() {
+            var clone = Hasher.clone.call(this);
+            clone._hash = this._hash.clone();
+            return clone;
+          }
+        });
+        function FF(a, b2, c, d, x, s, t) {
+          var n = a + (b2 & c | ~b2 & d) + x + t;
+          return (n << s | n >>> 32 - s) + b2;
+        }
+        function GG(a, b2, c, d, x, s, t) {
+          var n = a + (b2 & d | c & ~d) + x + t;
+          return (n << s | n >>> 32 - s) + b2;
+        }
+        function HH(a, b2, c, d, x, s, t) {
+          var n = a + (b2 ^ c ^ d) + x + t;
+          return (n << s | n >>> 32 - s) + b2;
+        }
+        function II(a, b2, c, d, x, s, t) {
+          var n = a + (c ^ (b2 | ~d)) + x + t;
+          return (n << s | n >>> 32 - s) + b2;
+        }
+        C.MD5 = Hasher._createHelper(MD52);
+        C.HmacMD5 = Hasher._createHmacHelper(MD52);
+      })(Math);
+      return CryptoJS.MD5;
+    });
+  }
+});
+
 // src/providers/cuekit-provider.tsx
 import React, { createContext, useContext, useEffect, useState } from "react";
 
@@ -473,16 +1269,10 @@ var CuekitProvider = ({
   useEffect(() => {
     if (apiKey) {
       try {
-        console.log("\u{1F3A4} CuekitProvider: Starting WebRTC initialization...", {
-          apiKey: apiKey.substring(0, 10) + "..."
-        });
         initWebRTC(apiKey);
-        console.log("\u{1F3A4} CuekitProvider: WebRTC initialized successfully");
       } catch (error) {
-        console.error("\u{1F3A4} CuekitProvider: Failed to initialize WebRTC:", error);
       }
     } else {
-      console.warn("\u{1F3A4} CuekitProvider: No API key provided, skipping WebRTC initialization");
     }
   }, [apiKey]);
   useEffect(() => {
@@ -492,18 +1282,14 @@ var CuekitProvider = ({
     };
   }, [navigationHandler]);
   useEffect(() => {
-    import("./webrtc-service-BHI4M7YJ.mjs").then(({ setWebRTCCallbacks: setWebRTCCallbacks2 }) => {
+    import("./webrtc-service-SDVOO4LS.mjs").then(({ setWebRTCCallbacks: setWebRTCCallbacks2 }) => {
       setWebRTCCallbacks2({
         onNavigationCommand: (command) => {
-          console.log("\u{1F9ED} Processing navigation command:", command);
           switch (command.type) {
             case "static_data_ready":
-              console.log("\u{1F4E6} Static data ready:", command.data);
               break;
             case "ai_intent":
-              console.log("\u{1F3AF} AI Intent:", command.text, "->", command.actionType);
               if (command.actionType === "navigate" && command.current_page) {
-                console.log(`\u{1F9ED} Navigating to: ${command.current_page}`);
                 if (navigationHandler) {
                   navigationHandler(command.current_page, {
                     intent: command.intent,
@@ -514,13 +1300,10 @@ var CuekitProvider = ({
               }
               break;
             case "user_speech_text":
-              console.log("\u{1F464} User said:", command.text);
               break;
             case "ai_speech_text":
-              console.log("\u{1F916} AI said:", command.text);
               break;
             default:
-              console.log("\u{1F50D} Unknown command type:", command.type);
           }
         },
         onConnectionStateChange: (state) => {
@@ -657,7 +1440,6 @@ var useWebRTC = (options) => {
       setIsConnected(true);
       return authData;
     } catch (err) {
-      console.error("Connection failed:", err);
       setError(err.message || "Failed to connect");
       setIsConnected(false);
     } finally {
@@ -742,7 +1524,7 @@ var useCuekit = (options) => {
   const [micState, setMicState] = useState3("idle");
   const [status, setStatus] = useState3("");
   const handleNavigationCommand = (event) => {
-    console.log(`\u{1F9E0} Processing event in useCuekit: ${event.type}`, event);
+    console.log(`\u2B07\uFE0F Received event from backend: ${event.type}`, event);
     switch (event.type) {
       case "user_speech_chunk":
       case "ai_speech_chunk": {
@@ -4625,9 +5407,9 @@ function factoryTitle(effects, ok3, nok, type, markerType, stringType) {
       return atBreak(code4);
     }
     effects.consume(code4);
-    return code4 === 92 ? escape : inside;
+    return code4 === 92 ? escape2 : inside;
   }
-  function escape(code4) {
+  function escape2(code4) {
     if (code4 === marker || code4 === 92) {
       effects.consume(code4);
       return inside;
@@ -13523,9 +14305,9 @@ var SunIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -13554,9 +14336,9 @@ var MoonIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -13577,9 +14359,9 @@ var CloseIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -13601,9 +14383,9 @@ var PhoneOffIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -16224,19 +17006,6 @@ var VoiceIntensityBars = ({
     return null;
   }
   let trackRef = null;
-  console.log("VoiceIntensityVisualizer Debug:", {
-    participants: participants.length,
-    localParticipant: !!localParticipant,
-    isActive
-  });
-  console.log(
-    "All participants:",
-    participants.map((p) => ({
-      identity: p.identity,
-      isLocal: p instanceof Participant,
-      hasAudio: p.getTrackPublication(Track.Source.Microphone)?.track !== void 0
-    }))
-  );
   let speakingParticipant = null;
   let highestAudioLevel = 0;
   participants.forEach((participant) => {
@@ -16249,15 +17018,8 @@ var VoiceIntensityBars = ({
   if (!speakingParticipant || highestAudioLevel === 0) {
     speakingParticipant = participants.find((p) => p.isSpeaking) || (participants.length > 0 ? participants[0] : null);
     if (speakingParticipant) {
-      console.log("Fallback to speaking status or first participant:", speakingParticipant.identity);
     }
   } else {
-    console.log(
-      "Using participant with highest audio level:",
-      speakingParticipant.identity,
-      "level:",
-      highestAudioLevel
-    );
   }
   if (speakingParticipant) {
     const audioTrack = speakingParticipant.getTrackPublication(Track.Source.Microphone);
@@ -16321,9 +17083,9 @@ var MicIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -16346,9 +17108,9 @@ var LoaderIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -16427,9 +17189,6 @@ var MicButton = ({
     onAISpeechEnd: (trackId) => handleAISpeech(false, trackId),
     appId
   });
-  useEffect10(() => {
-    console.log("\u{1F3A4} MicButton received messages:", JSON.stringify(messageManagerMessages, null, 2));
-  }, [messageManagerMessages]);
   useEffect10(() => {
     const checkTheme = () => {
       if (typeof document !== "undefined") {
@@ -16479,74 +17238,27 @@ var MicButton = ({
   }, [showBorderGlow]);
   const handleAISpeech = useCallback5(
     (isSpeaking, trackId) => {
-      console.log("\u{1F3A4} MicButton: ===== AI SPEECH EVENT START =====");
-      console.log("\u{1F3A4} MicButton: Event type:", isSpeaking ? "START" : "END");
-      console.log("\u{1F3A4} MicButton: Track ID:", trackId);
-      console.log("\u{1F3A4} MicButton: Current AI speaking state:", aiSpeakingRef.current);
-      console.log("\u{1F3A4} MicButton: Current active AI tracks:", Array.from(activeAITracksRef.current));
-      console.log("\u{1F3A4} MicButton: Current status:", status);
-      console.log("\u{1F3A4} MicButton: Current mic state:", micState);
-      console.log("\u{1F3A4} MicButton: Is listening:", isConnected);
-      console.log("\u{1F3A4} MicButton: Is connected:", isConnected);
       if (isSpeaking && trackId) {
-        console.log("\u{1F3A4} MicButton: ===== AI SPEECH START =====");
-        console.log("\u{1F3A4} MicButton: Adding track to active set:", trackId);
         activeAITracksRef.current.add(trackId);
         aiSpeakingRef.current = true;
-        console.log("\u{1F3A4} MicButton: After adding track:");
-        console.log("\u{1F3A4} MicButton: - Active tracks:", Array.from(activeAITracksRef.current));
-        console.log("\u{1F3A4} MicButton: - AI speaking state:", aiSpeakingRef.current);
-        console.log("\u{1F3A4} MicButton: - Status set to: AI is speaking...");
         if (aiSpeechTimeoutRef.current) {
-          console.log("\u{1F3A4} MicButton: Clearing existing AI speech timeout");
           clearTimeout(aiSpeechTimeoutRef.current);
         }
-        console.log(
-          "\u{1F3A4} MicButton: AI speech started, active tracks:",
-          Array.from(activeAITracksRef.current)
-        );
       } else if (!isSpeaking && trackId) {
-        console.log("\u{1F3A4} MicButton: ===== AI SPEECH END =====");
-        console.log("\u{1F3A4} MicButton: Removing track from active set:", trackId);
         activeAITracksRef.current.delete(trackId);
-        console.log("\u{1F3A4} MicButton: After removing track:");
-        console.log("\u{1F3A4} MicButton: - Active tracks:", Array.from(activeAITracksRef.current));
-        console.log("\u{1F3A4} MicButton: - Active tracks size:", activeAITracksRef.current.size);
         if (activeAITracksRef.current.size === 0) {
-          console.log("\u{1F3A4} MicButton: ===== ALL AI TRACKS ENDED =====");
-          console.log("\u{1F3A4} MicButton: No more active tracks, resetting AI speaking state");
           aiSpeakingRef.current = false;
-          console.log("\u{1F3A4} MicButton: After reset:");
-          console.log("\u{1F3A4} MicButton: - AI speaking state:", aiSpeakingRef.current);
-          console.log("\u{1F3A4} MicButton: - Status set to: Listening");
-          console.log("\u{1F3A4} MicButton: All AI tracks ended, voice recognition re-enabled");
         } else {
-          console.log("\u{1F3A4} MicButton: Still have active tracks, keeping AI speaking state");
-          console.log("\u{1F3A4} MicButton: Remaining tracks:", Array.from(activeAITracksRef.current));
         }
       } else if (!isSpeaking && !trackId) {
-        console.log("\u{1F3A4} MicButton: ===== MANUAL RESET =====");
-        console.log("\u{1F3A4} MicButton: Manual reset triggered");
         activeAITracksRef.current.clear();
         aiSpeakingRef.current = false;
-        console.log("\u{1F3A4} MicButton: After manual reset:");
-        console.log("\u{1F3A4} MicButton: - Active tracks cleared");
-        console.log("\u{1F3A4} MicButton: - AI speaking state:", aiSpeakingRef.current);
-        console.log("\u{1F3A4} MicButton: - Status set to: Listening");
-        console.log("\u{1F3A4} MicButton: AI speech manually reset");
       }
-      console.log("\u{1F3A4} MicButton: ===== AI SPEECH EVENT END =====");
-      console.log("\u{1F3A4} MicButton: Final state:");
-      console.log("\u{1F3A4} MicButton: - AI speaking:", aiSpeakingRef.current);
-      console.log("\u{1F3A4} MicButton: - Active tracks:", Array.from(activeAITracksRef.current));
-      console.log("\u{1F3A4} MicButton: - Status:", status);
-      console.log("\u{1F3A4} MicButton: ================================");
     },
     [status, micState, isConnected]
   );
   useEffect10(() => {
     if (audioContainerRef.current) {
-      console.log("\u{1F3A4} MicButton: Setting up audio container on mount");
       setAudioContainer(audioContainerRef);
     }
     return () => {
@@ -16574,49 +17286,33 @@ var MicButton = ({
   };
   useEffect10(() => {
     if (isConnected) {
-      console.log("\u{1F3A4} MicButton: WebRTC and SSE connections established - ready for commands");
     } else {
-      console.log("\u{1F3A4} MicButton: WebRTC not yet connected - ignoring speech");
     }
   }, [isConnected]);
   useEffect10(() => {
-    console.log("\u{1F3A4} MicButton: Auto-open check:", {
-      isConnected,
-      chatIsOpen: isChatOpen
-    });
     if (isConnected && !isChatOpen) {
-      console.log("\u{1F3A4} MicButton: Auto-opening chat popup");
       openChat();
     }
   }, [isConnected, isChatOpen, openChat]);
   useEffect10(() => {
     if (messageManagerMessages.length > 0 && !isChatOpen) {
-      console.log("\u{1F3A4} MicButton: Auto-opening chat popup due to messages");
       openChat();
     }
   }, [messageManagerMessages.length, isChatOpen, openChat]);
   const handleMicClick = useCallback5(() => {
     const shouldStop = micState === "listening" && isConnected;
     if (shouldStop) {
-      console.log("\u{1F3A4} MicButton: User wants to stop - closing everything");
       voiceDisconnect().then(() => {
-        console.log("\u{1F3A4} MicButton: Stopped and disconnected");
       }).catch((error) => {
-        console.error("\u{1F3A4} MicButton: Error during disconnect:", error);
       });
     } else {
-      console.log("\u{1F3A4} MicButton: User wants to start - connecting everything");
       voiceConnect(`user_${Date.now()}`, apiKey, appId).then(() => {
-        console.log("\u{1F3A4} MicButton: WebRTC and SSE connections started");
         if (showBorderGlow) setShowBodyGlow(true);
         openChat();
-        console.log("\u{1F3A4} MicButton: Started listening");
         setTimeout(() => {
-          console.log("\u{1F3A4} MicButton: Force opening chat popup after connection");
           openChat();
         }, 500);
       }).catch((error) => {
-        console.error("\u{1F3A4} MicButton: Failed to start connections:", error);
       });
     }
   }, [
@@ -16630,14 +17326,12 @@ var MicButton = ({
     showBorderGlow
   ]);
   const handleSendText = async (textToSend) => {
-    console.log("\u{1F3A4} MicButton: handleSendText called with:", textToSend);
     setMicState("thinking");
     if (showBorderGlow) setShowBodyGlow(true);
     if (!isChatOpen) {
       openChat();
     }
     if (isConnected) {
-      console.log("\u{1F3A4} MicButton: Sending via WebRTC");
       try {
         await sendUserCommand2(textToSend);
         setMicState("replying");
@@ -16646,27 +17340,21 @@ var MicButton = ({
           if (showBorderGlow) setShowBodyGlow(true);
         }, 1e3);
       } catch (error) {
-        console.error("\u{1F3A4} MicButton: Failed to send text:", error);
       } finally {
         setMicState("listening");
         if (showBorderGlow) setShowBodyGlow(true);
       }
     } else {
-      console.log("\u{1F3A4} MicButton: WebRTC not connected, cannot send message");
       setMicState("listening");
       if (showBorderGlow) setShowBodyGlow(true);
     }
-    console.log("\u{1F3A4} MicButton: Text sent via WebRTC");
   };
   const handleEndCall = async () => {
-    console.log("\u{1F3A4} MicButton: Ending call completely...");
     try {
       await voiceDisconnect();
       await voiceDisconnect();
       closeChat();
-      console.log("\u{1F3A4} MicButton: Call ended successfully");
     } catch (error) {
-      console.error("\u{1F3A4} MicButton: Error ending call:", error);
     }
   };
   const getIcon = () => {
@@ -16866,6 +17554,14 @@ var MicButton = ({
     /* @__PURE__ */ React11.createElement("span", { style: { fontSize: 12, fontWeight: 600, color: "hsl(var(--voice-text))" } }, "Open chat")
   ), /* @__PURE__ */ React11.createElement("div", { ref: audioContainerRef, style: { display: "none" } }), showBorderGlow && showBodyGlow && /* @__PURE__ */ React11.createElement(border_glow_default, { isActive: true }));
 };
+
+// src/utils/instrumentation.ts
+var import_md5 = __toESM(require_md5());
+function generateDynamicId(routePath, elementIdentifier) {
+  const combinedString = `${routePath}:${elementIdentifier}`;
+  const hash = (0, import_md5.default)(combinedString).toString();
+  return hash.substring(0, 8);
+}
 export {
   border_glow_default as BorderGlow,
   ChatPopup,
@@ -16876,6 +17572,7 @@ export {
   captureFullDOMStructure,
   configureWebRTCServer,
   executeAction,
+  generateDynamicId,
   getFullDOMStructure,
   getWebRTCServerConfig,
   initWebRTC,