@incodetech/core 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/OpenViduLogger-CQyDxBvM.esm.js

@@ -0,0 +1,803 @@
+import { t as __commonJS } from "./chunk-C_Yo44FK.esm.js";
+
+//#region ../../node_modules/.pnpm/jsnlog@2.30.0/node_modules/jsnlog/jsnlog.js
+var require_jsnlog = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/jsnlog@2.30.0/node_modules/jsnlog/jsnlog.js": ((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d$1, b$1) {
+				d$1.__proto__ = b$1;
+			} || function(d$1, b$1) {
+				for (var p in b$1) if (Object.prototype.hasOwnProperty.call(b$1, p)) d$1[p] = b$1[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	function JL(loggerName) {
+		if (!loggerName) return JL.__;
+		if (!Array.prototype.reduce) Array.prototype.reduce = function(callback, initialValue) {
+			var previousValue = initialValue;
+			for (var i = 0; i < this.length; i++) previousValue = callback(previousValue, this[i], i, this);
+			return previousValue;
+		};
+		var accumulatedLoggerName = "";
+		return ("." + loggerName).split(".").reduce(function(prev, curr, idx, arr) {
+			if (accumulatedLoggerName) accumulatedLoggerName += "." + curr;
+			else accumulatedLoggerName = curr;
+			var currentLogger = prev["__" + accumulatedLoggerName];
+			if (currentLogger === void 0) {
+				JL.Logger.prototype = prev;
+				currentLogger = new JL.Logger(accumulatedLoggerName);
+				prev["__" + accumulatedLoggerName] = currentLogger;
+			}
+			return currentLogger;
+		}, JL.__);
+	}
+	(function(JL$1) {
+		JL$1.requestId = "";
+		JL$1.entryId = 0;
+		JL$1._createXMLHttpRequest = function() {
+			return new XMLHttpRequest();
+		};
+		JL$1._getTime = function() {
+			return (/* @__PURE__ */ new Date()).getTime();
+		};
+		JL$1._console = console;
+		JL$1._appenderNames = [];
+		/**
+		Copies the value of a property from one object to the other.
+		This is used to copy property values as part of setOption for loggers and appenders.
+		
+		Because loggers inherit property values from their parents, it is important never to
+		create a property on a logger if the intent is to inherit from the parent.
+		
+		Copying rules:
+		1) if the from property is undefined (for example, not mentioned in a JSON object), the
+		to property is not affected at all.
+		2) if the from property is null, the to property is deleted (so the logger will inherit from
+		its parent).
+		3) Otherwise, the from property is copied to the to property.
+		*/
+		function copyProperty(propertyName, from, to) {
+			if (from[propertyName] === void 0) return;
+			if (from[propertyName] === null) {
+				delete to[propertyName];
+				return;
+			}
+			to[propertyName] = from[propertyName];
+		}
+		/**
+		Returns true if a log should go ahead.
+		Does not check level.
+		
+		@param filters
+		Filters that determine whether a log can go ahead.
+		*/
+		function allow(filters) {
+			if (!(JL$1.enabled == null)) {
+				if (!JL$1.enabled) return false;
+			}
+			try {
+				if (filters.userAgentRegex) {
+					if (!new RegExp(filters.userAgentRegex).test(navigator.userAgent)) return false;
+				}
+			} catch (e) {}
+			try {
+				if (filters.ipRegex && JL$1.clientIP) {
+					if (!new RegExp(filters.ipRegex).test(JL$1.clientIP)) return false;
+				}
+			} catch (e) {}
+			return true;
+		}
+		/**
+		Returns true if a log should go ahead, based on the message.
+		
+		@param filters
+		Filters that determine whether a log can go ahead.
+		
+		@param message
+		Message to be logged.
+		*/
+		function allowMessage(filters, message) {
+			try {
+				if (filters.disallow) {
+					if (new RegExp(filters.disallow).test(message)) return false;
+				}
+			} catch (e) {}
+			return true;
+		}
+		function stringifyLogObjectFunction(logObject) {
+			if (typeof logObject == "function") if (logObject instanceof RegExp) return logObject.toString();
+			else return logObject();
+			return logObject;
+		}
+		var StringifiedLogObject = function() {
+			function StringifiedLogObject$1(msg, meta, finalString) {
+				this.msg = msg;
+				this.meta = meta;
+				this.finalString = finalString;
+			}
+			return StringifiedLogObject$1;
+		}();
+		function stringifyLogObject(logObject) {
+			var actualLogObject = stringifyLogObjectFunction(logObject);
+			var finalString;
+			switch (typeof actualLogObject) {
+				case "string": return new StringifiedLogObject(actualLogObject, null, actualLogObject);
+				case "number":
+					finalString = actualLogObject.toString();
+					return new StringifiedLogObject(finalString, null, finalString);
+				case "boolean":
+					finalString = actualLogObject.toString();
+					return new StringifiedLogObject(finalString, null, finalString);
+				case "undefined": return new StringifiedLogObject("undefined", null, "undefined");
+				case "object": if (actualLogObject instanceof RegExp || actualLogObject instanceof String || actualLogObject instanceof Number || actualLogObject instanceof Boolean) {
+					finalString = actualLogObject.toString();
+					return new StringifiedLogObject(finalString, null, finalString);
+				} else {
+					if (typeof JL$1.serialize === "function") finalString = JL$1.serialize.call(this, actualLogObject);
+					else finalString = JSON.stringify(actualLogObject);
+					return new StringifiedLogObject("", actualLogObject, finalString);
+				}
+				default: return new StringifiedLogObject("unknown", null, "unknown");
+			}
+		}
+		function setOptions(options) {
+			copyProperty("enabled", options, this);
+			copyProperty("maxMessages", options, this);
+			copyProperty("defaultAjaxUrl", options, this);
+			copyProperty("clientIP", options, this);
+			copyProperty("requestId", options, this);
+			copyProperty("defaultBeforeSend", options, this);
+			copyProperty("serialize", options, this);
+			return this;
+		}
+		JL$1.setOptions = setOptions;
+		function getAllLevel() {
+			return -2147483648;
+		}
+		JL$1.getAllLevel = getAllLevel;
+		function getTraceLevel() {
+			return 1e3;
+		}
+		JL$1.getTraceLevel = getTraceLevel;
+		function getDebugLevel() {
+			return 2e3;
+		}
+		JL$1.getDebugLevel = getDebugLevel;
+		function getInfoLevel() {
+			return 3e3;
+		}
+		JL$1.getInfoLevel = getInfoLevel;
+		function getWarnLevel() {
+			return 4e3;
+		}
+		JL$1.getWarnLevel = getWarnLevel;
+		function getErrorLevel() {
+			return 5e3;
+		}
+		JL$1.getErrorLevel = getErrorLevel;
+		function getFatalLevel() {
+			return 6e3;
+		}
+		JL$1.getFatalLevel = getFatalLevel;
+		function getOffLevel() {
+			return 2147483647;
+		}
+		JL$1.getOffLevel = getOffLevel;
+		function levelToString(level) {
+			if (level <= 1e3) return "trace";
+			if (level <= 2e3) return "debug";
+			if (level <= 3e3) return "info";
+			if (level <= 4e3) return "warn";
+			if (level <= 5e3) return "error";
+			return "fatal";
+		}
+		var Exception = function() {
+			function Exception$1(data, inner) {
+				this.inner = inner;
+				this.name = "JL.Exception";
+				this.message = stringifyLogObject(data).finalString;
+			}
+			return Exception$1;
+		}();
+		JL$1.Exception = Exception;
+		Exception.prototype = /* @__PURE__ */ new Error();
+		var LogItem = function() {
+			function LogItem$1(l, m, n, t, u) {
+				this.l = l;
+				this.m = m;
+				this.n = n;
+				this.t = t;
+				this.u = u;
+			}
+			return LogItem$1;
+		}();
+		JL$1.LogItem = LogItem;
+		function newLogItem(levelNbr, message, loggerName) {
+			JL$1.entryId++;
+			return new LogItem(levelNbr, message, loggerName, JL$1._getTime(), JL$1.entryId);
+		}
+		function clearTimer(timer) {
+			if (timer.id) {
+				clearTimeout(timer.id);
+				timer.id = null;
+			}
+		}
+		function setTimer(timer, timeoutMs, callback) {
+			var that = this;
+			if (!timer.id) timer.id = setTimeout(function() {
+				callback.call(that);
+			}, timeoutMs);
+		}
+		var Appender = function() {
+			function Appender$1(appenderName, sendLogItems) {
+				this.appenderName = appenderName;
+				this.sendLogItems = sendLogItems;
+				this.level = JL$1.getTraceLevel();
+				this.sendWithBufferLevel = 2147483647;
+				this.storeInBufferLevel = -2147483648;
+				this.bufferSize = 0;
+				this.batchSize = 1;
+				this.maxBatchSize = 20;
+				this.batchTimeout = 2147483647;
+				this.sendTimeout = 5e3;
+				this.buffer = [];
+				this.batchBuffer = [];
+				this.batchTimeoutTimer = { id: null };
+				this.sendTimeoutTimer = { id: null };
+				this.nbrLogItemsSkipped = 0;
+				this.nbrLogItemsBeingSent = 0;
+				var emptyNameErrorMessage = "Trying to create an appender without a name or with an empty name";
+				if (appenderName == void 0) throw emptyNameErrorMessage;
+				if (JL$1._appenderNames.indexOf(appenderName) != -1) {
+					if (!appenderName) throw emptyNameErrorMessage;
+					throw "Multiple appenders use the same name " + appenderName;
+				}
+				JL$1._appenderNames.push(appenderName);
+			}
+			Appender$1.prototype.addLogItemsToBuffer = function(logItems) {
+				if (this.batchBuffer.length >= this.maxBatchSize) {
+					this.nbrLogItemsSkipped += logItems.length;
+					return;
+				}
+				if (!(JL$1.maxMessages == null)) {
+					if (JL$1.maxMessages < 1) return;
+					JL$1.maxMessages -= logItems.length;
+				}
+				this.batchBuffer = this.batchBuffer.concat(logItems);
+				var that = this;
+				setTimer(this.batchTimeoutTimer, this.batchTimeout, function() {
+					that.sendBatch.call(that);
+				});
+			};
+			Appender$1.prototype.batchBufferHasOverdueMessages = function() {
+				for (var i = 0; i < this.batchBuffer.length; i++) if (JL$1._getTime() - this.batchBuffer[i].t > this.batchTimeout) return true;
+				return false;
+			};
+			Appender$1.prototype.batchBufferHasStrandedMessage = function() {
+				return !(JL$1.maxMessages == null) && JL$1.maxMessages < 1 && this.batchBuffer.length > 0;
+			};
+			Appender$1.prototype.sendBatchIfComplete = function() {
+				if (this.batchBuffer.length >= this.batchSize || this.batchBufferHasOverdueMessages() || this.batchBufferHasStrandedMessage()) this.sendBatch();
+			};
+			Appender$1.prototype.onSendingEnded = function() {
+				clearTimer(this.sendTimeoutTimer);
+				this.nbrLogItemsBeingSent = 0;
+				this.sendBatchIfComplete();
+			};
+			Appender$1.prototype.setOptions = function(options) {
+				copyProperty("level", options, this);
+				copyProperty("ipRegex", options, this);
+				copyProperty("userAgentRegex", options, this);
+				copyProperty("disallow", options, this);
+				copyProperty("sendWithBufferLevel", options, this);
+				copyProperty("storeInBufferLevel", options, this);
+				copyProperty("bufferSize", options, this);
+				copyProperty("batchSize", options, this);
+				copyProperty("maxBatchSize", options, this);
+				copyProperty("batchTimeout", options, this);
+				copyProperty("sendTimeout", options, this);
+				if (this.bufferSize < this.buffer.length) this.buffer.length = this.bufferSize;
+				if (this.maxBatchSize < this.batchSize) throw new JL$1.Exception({
+					"message": "maxBatchSize cannot be smaller than batchSize",
+					"maxBatchSize": this.maxBatchSize,
+					"batchSize": this.batchSize
+				});
+				return this;
+			};
+			/**
+			Called by a logger to log a log item.
+			If in response to this call one or more log items need to be processed
+			(eg., sent to the server), this method calls this.sendLogItems
+			with an array with all items to be processed.
+			
+			Note that the name and parameters of this function must match those of the log function of
+			a Winston transport object, so that users can use these transports as appenders.
+			That is why there are many parameters that are not actually used by this function.
+			
+			level - string with the level ("trace", "debug", etc.) Only used by Winston transports.
+			msg - human readable message. Undefined if the log item is an object. Only used by Winston transports.
+			meta - log object. Always defined, because at least it contains the logger name. Only used by Winston transports.
+			callback - function that is called when the log item has been logged. Only used by Winston transports.
+			levelNbr - level as a number. Not used by Winston transports.
+			message - log item. If the user logged an object, this is the JSON string.  Not used by Winston transports.
+			loggerName: name of the logger.  Not used by Winston transports.
+			*/
+			Appender$1.prototype.log = function(level, msg, meta, callback, levelNbr, message, loggerName) {
+				var logItem;
+				if (!allow(this)) return;
+				if (!allowMessage(this, message)) return;
+				if (levelNbr < this.storeInBufferLevel) return;
+				logItem = newLogItem(levelNbr, message, loggerName);
+				if (levelNbr < this.level) {
+					if (this.bufferSize > 0) {
+						this.buffer.push(logItem);
+						if (this.buffer.length > this.bufferSize) this.buffer.shift();
+					}
+					return;
+				}
+				this.addLogItemsToBuffer([logItem]);
+				if (levelNbr >= this.sendWithBufferLevel) {
+					if (this.buffer.length) {
+						this.addLogItemsToBuffer(this.buffer);
+						this.buffer.length = 0;
+					}
+				}
+				this.sendBatchIfComplete();
+			};
+			Appender$1.prototype.sendBatch = function() {
+				if (this.nbrLogItemsBeingSent > 0) return;
+				clearTimer(this.batchTimeoutTimer);
+				if (this.batchBuffer.length == 0) return;
+				this.nbrLogItemsBeingSent = this.batchBuffer.length;
+				var that = this;
+				setTimer(this.sendTimeoutTimer, this.sendTimeout, function() {
+					that.onSendingEnded.call(that);
+				});
+				this.sendLogItems(this.batchBuffer, function() {
+					that.batchBuffer.splice(0, that.nbrLogItemsBeingSent);
+					if (that.nbrLogItemsSkipped > 0) {
+						that.batchBuffer.push(newLogItem(getWarnLevel(), "Lost " + that.nbrLogItemsSkipped + " messages. Either connection with the server was down or logging was disabled via the enabled option. Reduce lost messages by increasing the ajaxAppender option maxBatchSize.", that.appenderName));
+						that.nbrLogItemsSkipped = 0;
+					}
+					that.onSendingEnded.call(that);
+				});
+			};
+			return Appender$1;
+		}();
+		JL$1.Appender = Appender;
+		var AjaxAppender = function(_super) {
+			__extends(AjaxAppender$1, _super);
+			function AjaxAppender$1(appenderName) {
+				return _super.call(this, appenderName, AjaxAppender$1.prototype.sendLogItemsAjax) || this;
+			}
+			AjaxAppender$1.prototype.setOptions = function(options) {
+				copyProperty("url", options, this);
+				copyProperty("beforeSend", options, this);
+				_super.prototype.setOptions.call(this, options);
+				return this;
+			};
+			AjaxAppender$1.prototype.sendLogItemsAjax = function(logItems, successCallback) {
+				try {
+					if (!allow(this)) return;
+					if (this.xhr && this.xhr.readyState != 0 && this.xhr.readyState != 4) this.xhr.abort();
+					this.xhr = JL$1._createXMLHttpRequest();
+					var ajaxUrl = "/jsnlog.logger";
+					if (!(JL$1.defaultAjaxUrl == null)) ajaxUrl = JL$1.defaultAjaxUrl;
+					if (this.url) ajaxUrl = this.url;
+					this.xhr.open("POST", ajaxUrl);
+					this.xhr.setRequestHeader("Content-Type", "application/json");
+					this.xhr.setRequestHeader("JSNLog-RequestId", JL$1.requestId);
+					var that = this;
+					this.xhr.onreadystatechange = function() {
+						if (that.xhr.readyState == 4 && that.xhr.status >= 200 && that.xhr.status < 300) successCallback();
+					};
+					var json = {
+						r: JL$1.requestId,
+						lg: logItems
+					};
+					if (typeof this.beforeSend === "function") this.beforeSend.call(this, this.xhr, json);
+					else if (typeof JL$1.defaultBeforeSend === "function") JL$1.defaultBeforeSend.call(this, this.xhr, json);
+					var finalmsg = JSON.stringify(json);
+					this.xhr.send(finalmsg);
+				} catch (e) {}
+			};
+			return AjaxAppender$1;
+		}(Appender);
+		JL$1.AjaxAppender = AjaxAppender;
+		var ConsoleAppender = function(_super) {
+			__extends(ConsoleAppender$1, _super);
+			function ConsoleAppender$1(appenderName) {
+				return _super.call(this, appenderName, ConsoleAppender$1.prototype.sendLogItemsConsole) || this;
+			}
+			ConsoleAppender$1.prototype.clog = function(logEntry) {
+				JL$1._console.log(logEntry);
+			};
+			ConsoleAppender$1.prototype.cerror = function(logEntry) {
+				if (JL$1._console.error) JL$1._console.error(logEntry);
+				else this.clog(logEntry);
+			};
+			ConsoleAppender$1.prototype.cwarn = function(logEntry) {
+				if (JL$1._console.warn) JL$1._console.warn(logEntry);
+				else this.clog(logEntry);
+			};
+			ConsoleAppender$1.prototype.cinfo = function(logEntry) {
+				if (JL$1._console.info) JL$1._console.info(logEntry);
+				else this.clog(logEntry);
+			};
+			ConsoleAppender$1.prototype.cdebug = function(logEntry) {
+				if (JL$1._console.debug) JL$1._console.debug(logEntry);
+				else this.cinfo(logEntry);
+			};
+			ConsoleAppender$1.prototype.sendLogItemsConsole = function(logItems, successCallback) {
+				try {
+					if (!allow(this)) return;
+					if (!JL$1._console) return;
+					var i;
+					for (i = 0; i < logItems.length; ++i) {
+						var li = logItems[i];
+						var msg = li.n + ": " + li.m;
+						if (typeof window === "undefined") msg = new Date(li.t) + " | " + msg;
+						if (li.l <= JL$1.getDebugLevel()) this.cdebug(msg);
+						else if (li.l <= JL$1.getInfoLevel()) this.cinfo(msg);
+						else if (li.l <= JL$1.getWarnLevel()) this.cwarn(msg);
+						else this.cerror(msg);
+					}
+				} catch (e) {}
+				successCallback();
+			};
+			return ConsoleAppender$1;
+		}(Appender);
+		JL$1.ConsoleAppender = ConsoleAppender;
+		JL$1.Logger = function() {
+			function Logger(loggerName) {
+				this.loggerName = loggerName;
+				this.seenRegexes = [];
+			}
+			Logger.prototype.setOptions = function(options) {
+				copyProperty("level", options, this);
+				copyProperty("userAgentRegex", options, this);
+				copyProperty("disallow", options, this);
+				copyProperty("ipRegex", options, this);
+				copyProperty("appenders", options, this);
+				copyProperty("onceOnly", options, this);
+				this.seenRegexes = [];
+				return this;
+			};
+			Logger.prototype.buildExceptionObject = function(e) {
+				var excObject = {};
+				if (e.stack) excObject.stack = e.stack;
+				else excObject.e = e;
+				if (e.message) excObject.message = e.message;
+				if (e.name) excObject.name = e.name;
+				if (e.data) excObject.data = e.data;
+				if (e.inner) excObject.inner = this.buildExceptionObject(e.inner);
+				return excObject;
+			};
+			Logger.prototype.log = function(level, logObject, e) {
+				var i = 0;
+				var compositeMessage;
+				var excObject;
+				if (!this.appenders) return this;
+				if (level >= this.level && allow(this)) {
+					if (e) {
+						excObject = this.buildExceptionObject(e);
+						excObject.logData = stringifyLogObjectFunction(logObject);
+					} else excObject = logObject;
+					compositeMessage = stringifyLogObject(excObject);
+					if (allowMessage(this, compositeMessage.finalString)) {
+						if (this.onceOnly) {
+							i = this.onceOnly.length - 1;
+							while (i >= 0) {
+								if (new RegExp(this.onceOnly[i]).test(compositeMessage.finalString)) {
+									if (this.seenRegexes[i]) return this;
+									this.seenRegexes[i] = true;
+								}
+								i--;
+							}
+						}
+						compositeMessage.meta = compositeMessage.meta || {};
+						i = this.appenders.length - 1;
+						while (i >= 0) {
+							this.appenders[i].log(levelToString(level), compositeMessage.msg, compositeMessage.meta, function() {}, level, compositeMessage.finalString, this.loggerName);
+							i--;
+						}
+					}
+				}
+				return this;
+			};
+			Logger.prototype.trace = function(logObject) {
+				return this.log(getTraceLevel(), logObject);
+			};
+			Logger.prototype.debug = function(logObject) {
+				return this.log(getDebugLevel(), logObject);
+			};
+			Logger.prototype.info = function(logObject) {
+				return this.log(getInfoLevel(), logObject);
+			};
+			Logger.prototype.warn = function(logObject) {
+				return this.log(getWarnLevel(), logObject);
+			};
+			Logger.prototype.error = function(logObject) {
+				return this.log(getErrorLevel(), logObject);
+			};
+			Logger.prototype.fatal = function(logObject) {
+				return this.log(getFatalLevel(), logObject);
+			};
+			Logger.prototype.fatalException = function(logObject, e) {
+				return this.log(getFatalLevel(), logObject, e);
+			};
+			return Logger;
+		}();
+		function createAjaxAppender(appenderName) {
+			return new AjaxAppender(appenderName);
+		}
+		JL$1.createAjaxAppender = createAjaxAppender;
+		function createConsoleAppender(appenderName) {
+			return new ConsoleAppender(appenderName);
+		}
+		JL$1.createConsoleAppender = createConsoleAppender;
+		var defaultAppender;
+		if (typeof window !== "undefined") defaultAppender = new AjaxAppender("");
+		else defaultAppender = new ConsoleAppender("");
+		JL$1.__ = new JL$1.Logger("");
+		JL$1.__.setOptions({
+			level: JL$1.getDebugLevel(),
+			appenders: [defaultAppender]
+		});
+	})(JL || (JL = {}));
+	if (typeof exports !== "undefined") {
+		exports.__esModule = true;
+		exports.JL = JL;
+	}
+	var define;
+	if (typeof define == "function" && define.amd) define("jsnlog", [], function() {
+		return JL;
+	});
+	if (typeof __jsnlog_configure == "function") __jsnlog_configure(JL);
+	if (typeof window !== "undefined" && !window.onerror) window.onerror = function(errorMsg, url, lineNumber, column, errorObj) {
+		JL("onerrorLogger").fatalException({
+			"msg": "Uncaught Exception",
+			"errorMsg": errorMsg ? errorMsg.message || errorMsg : "",
+			"url": url,
+			"line number": lineNumber,
+			"column": column
+		}, errorObj);
+		return false;
+	};
+	if (typeof window !== "undefined" && !window.onunhandledrejection) window.onunhandledrejection = function(event) {
+		JL("onerrorLogger").fatalException({
+			"msg": "unhandledrejection",
+			"errorMsg": event.reason ? event.reason.message : event.message || null
+		}, event.reason);
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/openvidu-browser@2.32.1/node_modules/openvidu-browser/lib/OpenViduInternal/Logger/ConsoleLogger.js
+var require_ConsoleLogger = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/openvidu-browser@2.32.1/node_modules/openvidu-browser/lib/OpenViduInternal/Logger/ConsoleLogger.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ConsoleLogger = void 0;
+	var ConsoleLogger = class {
+		constructor(console$1) {
+			this.logger = console$1;
+			this.log = console$1.log, this.info = console$1.info, this.debug = console$1.debug, this.warn = console$1.warn, this.error = console$1.error;
+		}
+	};
+	exports.ConsoleLogger = ConsoleLogger;
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/openvidu-browser@2.32.1/node_modules/openvidu-browser/lib/OpenViduInternal/Logger/OpenViduLoggerConfiguration.js
+var require_OpenViduLoggerConfiguration = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/openvidu-browser@2.32.1/node_modules/openvidu-browser/lib/OpenViduInternal/Logger/OpenViduLoggerConfiguration.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.OpenViduLoggerConfiguration = void 0;
+	var OpenViduLoggerConfiguration;
+	(function(OpenViduLoggerConfiguration$1) {
+		OpenViduLoggerConfiguration$1["disabled"] = "disabled";
+		OpenViduLoggerConfiguration$1["debug"] = "debug";
+		OpenViduLoggerConfiguration$1["debug_app"] = "debug_app";
+	})(OpenViduLoggerConfiguration || (exports.OpenViduLoggerConfiguration = OpenViduLoggerConfiguration = {}));
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/openvidu-browser@2.32.1/node_modules/openvidu-browser/lib/OpenViduInternal/Logger/OpenViduLogger.js
+var require_OpenViduLogger = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/openvidu-browser@2.32.1/node_modules/openvidu-browser/lib/OpenViduInternal/Logger/OpenViduLogger.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.OpenViduLogger = void 0;
+	const jsnlog_1 = require_jsnlog();
+	const ConsoleLogger_1 = require_ConsoleLogger();
+	const OpenViduLoggerConfiguration_1 = require_OpenViduLoggerConfiguration();
+	var OpenViduLogger = class OpenViduLogger {
+		constructor() {
+			this.JSNLOG_URL = "/openvidu/elk/openvidu-browser-logs";
+			this.MAX_JSNLOG_BATCH_LOG_MESSAGES = 100;
+			this.MAX_MSECONDS_BATCH_MESSAGES = 5e3;
+			this.MAX_LENGTH_STRING_JSON = 1e3;
+			this.defaultConsoleLogger = new ConsoleLogger_1.ConsoleLogger(globalThis.console);
+			this.isProdMode = false;
+			this.isJSNLogSetup = false;
+		}
+		/**
+		* @hidden
+		*/
+		static configureJSNLog(openVidu, token) {
+			try {
+				if (globalThis["LOG_JSNLOG_RESULTS"] || this.instance && openVidu.isAtLeastPro && this.instance.isOpenViduBrowserLogsDebugActive(openVidu) && this.instance.canConfigureJSNLog(openVidu, this.instance)) {
+					if (openVidu.sendBrowserLogs === OpenViduLoggerConfiguration_1.OpenViduLoggerConfiguration.debug_app) this.instance.replaceWindowConsole();
+					this.instance.isJSNLogSetup = false;
+					this.instance.info("Configuring JSNLogs.");
+					const finalUserId = openVidu.finalUserId;
+					const sessionId = openVidu.session.sessionId;
+					const beforeSendCallback = (xhr) => {
+						const parentReadyStateFunction = xhr.onreadystatechange;
+						xhr.onreadystatechange = () => {
+							if (this.isInvalidResponse(xhr)) {
+								Object.defineProperty(xhr, "readyState", { value: 4 });
+								Object.defineProperty(xhr, "status", { value: 200 });
+								this.instance.disableLogger();
+							}
+							parentReadyStateFunction();
+						};
+						xhr.setRequestHeader("Authorization", "Basic " + btoa(`${finalUserId}%/%${sessionId}:` + token));
+						xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+						xhr.setRequestHeader("OV-Final-User-Id", finalUserId);
+						xhr.setRequestHeader("OV-Session-Id", sessionId);
+						xhr.setRequestHeader("OV-Token", token);
+					};
+					this.instance.currentAppender = jsnlog_1.JL.createAjaxAppender(`appender-${finalUserId}-${sessionId}`);
+					this.instance.currentAppender.setOptions({
+						beforeSend: beforeSendCallback,
+						maxBatchSize: 1e3,
+						batchSize: this.instance.MAX_JSNLOG_BATCH_LOG_MESSAGES,
+						batchTimeout: this.instance.MAX_MSECONDS_BATCH_MESSAGES
+					});
+					const logSerializer = (obj) => {
+						const getCircularReplacer = () => {
+							const seen = /* @__PURE__ */ new WeakSet();
+							return (key, value) => {
+								if (typeof value === "object" && value != null) {
+									if (seen.has(value) || globalThis.HTMLElement && value instanceof HTMLElement) return;
+									seen.add(value);
+								}
+								return value;
+							};
+						};
+						let stringifyJson = JSON.stringify(obj, getCircularReplacer());
+						if (stringifyJson.length > this.instance.MAX_LENGTH_STRING_JSON) stringifyJson = `${stringifyJson.substring(0, this.instance.MAX_LENGTH_STRING_JSON)}...`;
+						if (globalThis["LOG_JSNLOG_RESULTS"]) console.log(stringifyJson);
+						return stringifyJson;
+					};
+					jsnlog_1.JL.setOptions({
+						defaultAjaxUrl: openVidu.httpUri + this.instance.JSNLOG_URL,
+						serialize: logSerializer,
+						enabled: true
+					});
+					(0, jsnlog_1.JL)().setOptions({ appenders: [this.instance.currentAppender] });
+					this.instance.isJSNLogSetup = true;
+					this.instance.loggingSessionId = sessionId;
+					this.instance.info("JSNLog configured.");
+				}
+			} catch (e) {
+				console.error("Error configuring JSNLog: ");
+				console.error(e);
+				this.instance.disableLogger();
+			}
+		}
+		/**
+		* @hidden
+		*/
+		static getInstance() {
+			if (!OpenViduLogger.instance) OpenViduLogger.instance = new OpenViduLogger();
+			return OpenViduLogger.instance;
+		}
+		static isInvalidResponse(xhr) {
+			return xhr.status == 401 || xhr.status == 403 || xhr.status == 404 || xhr.status == 0;
+		}
+		canConfigureJSNLog(openVidu, logger) {
+			return openVidu.session.sessionId != logger.loggingSessionId;
+		}
+		isOpenViduBrowserLogsDebugActive(openVidu) {
+			return openVidu.sendBrowserLogs === OpenViduLoggerConfiguration_1.OpenViduLoggerConfiguration.debug || openVidu.sendBrowserLogs === OpenViduLoggerConfiguration_1.OpenViduLoggerConfiguration.debug_app;
+		}
+		getConsoleWithJSNLog() {
+			return (function(openViduLogger) {
+				return {
+					log: function(...args) {
+						openViduLogger.defaultConsoleLogger.log.apply(openViduLogger.defaultConsoleLogger.logger, arguments);
+						if (openViduLogger.isJSNLogSetup) (0, jsnlog_1.JL)().info(arguments);
+					},
+					info: function(...args) {
+						openViduLogger.defaultConsoleLogger.info.apply(openViduLogger.defaultConsoleLogger.logger, arguments);
+						if (openViduLogger.isJSNLogSetup) (0, jsnlog_1.JL)().info(arguments);
+					},
+					debug: function(...args) {
+						openViduLogger.defaultConsoleLogger.debug.apply(openViduLogger.defaultConsoleLogger.logger, arguments);
+					},
+					warn: function(...args) {
+						openViduLogger.defaultConsoleLogger.warn.apply(openViduLogger.defaultConsoleLogger.logger, arguments);
+						if (openViduLogger.isJSNLogSetup) (0, jsnlog_1.JL)().warn(arguments);
+					},
+					error: function(...args) {
+						openViduLogger.defaultConsoleLogger.error.apply(openViduLogger.defaultConsoleLogger.logger, arguments);
+						if (openViduLogger.isJSNLogSetup) (0, jsnlog_1.JL)().error(arguments);
+					}
+				};
+			})(this);
+		}
+		replaceWindowConsole() {
+			globalThis.console = this.defaultConsoleLogger.logger;
+			globalThis.console.log = this.getConsoleWithJSNLog().log;
+			globalThis.console.info = this.getConsoleWithJSNLog().info;
+			globalThis.console.debug = this.getConsoleWithJSNLog().debug;
+			globalThis.console.warn = this.getConsoleWithJSNLog().warn;
+			globalThis.console.error = this.getConsoleWithJSNLog().error;
+		}
+		disableLogger() {
+			jsnlog_1.JL.setOptions({ enabled: false });
+			this.isJSNLogSetup = false;
+			this.loggingSessionId = void 0;
+			this.currentAppender = void 0;
+			globalThis.console = this.defaultConsoleLogger.logger;
+			globalThis.console.log = this.defaultConsoleLogger.log;
+			globalThis.console.info = this.defaultConsoleLogger.info;
+			globalThis.console.debug = this.defaultConsoleLogger.debug;
+			globalThis.console.warn = this.defaultConsoleLogger.warn;
+			globalThis.console.error = this.defaultConsoleLogger.error;
+		}
+		/**
+		* @hidden
+		*/
+		log(...args) {
+			if (!this.isProdMode) this.defaultConsoleLogger.log.apply(this.defaultConsoleLogger.logger, arguments);
+			if (this.isJSNLogSetup) (0, jsnlog_1.JL)().info(arguments);
+		}
+		/**
+		* @hidden
+		*/
+		debug(...args) {
+			if (!this.isProdMode) this.defaultConsoleLogger.debug.apply(this.defaultConsoleLogger.logger, arguments);
+		}
+		/**
+		* @hidden
+		*/
+		info(...args) {
+			if (!this.isProdMode) this.defaultConsoleLogger.info.apply(this.defaultConsoleLogger.logger, arguments);
+			if (this.isJSNLogSetup) (0, jsnlog_1.JL)().info(arguments);
+		}
+		/**
+		* @hidden
+		*/
+		warn(...args) {
+			this.defaultConsoleLogger.warn.apply(this.defaultConsoleLogger.logger, arguments);
+			if (this.isJSNLogSetup) (0, jsnlog_1.JL)().warn(arguments);
+		}
+		/**
+		* @hidden
+		*/
+		error(...args) {
+			this.defaultConsoleLogger.error.apply(this.defaultConsoleLogger.logger, arguments);
+			if (this.isJSNLogSetup) (0, jsnlog_1.JL)().error(arguments);
+		}
+		/**
+		* @hidden
+		*/
+		flush() {
+			if (this.isJSNLogSetup && this.currentAppender != null) this.currentAppender.sendBatch();
+		}
+		enableProdMode() {
+			this.isProdMode = true;
+		}
+	};
+	exports.OpenViduLogger = OpenViduLogger;
+}) });
+
+//#endregion
+export { require_jsnlog as n, require_OpenViduLogger as t };