@stormstreaming/stormstreamer 0.9.0-beta.0

package/dist/amd/index.js

@@ -0,0 +1,3448 @@
+ /*
+ * StormStreaming JavaScript Streamer
+ * Copyright © 2021-2024 Web-Anatomy s.c. All rights reserved.
+ * contact@stormstreaming.com
+ * https://stormstreaming.com
+ *
+ * Version: 0.9.0-beta.0
+ * Version: 11/28/2024, 9:22:54 AM
+ *
+ * LEGAL NOTICE:
+ * This software is subject to the terms and conditions defined in
+ * separate license conditions ('LICENSE.txt')
+ *
+ */define(['exports'], (function (exports) { 'use strict';
+
+    class StormServerItem {
+      constructor(host, application, port = 443, isSSL = true) {
+        this.host = host;
+        this.application = application;
+        this.port = port;
+        this.isSSL = isSSL;
+        this.hasFaild = false;
+      }
+      getHost() {
+        return this.host;
+      }
+      getApplication() {
+        return this.application;
+      }
+      getPort() {
+        return this.port;
+      }
+      getIfSSL() {
+        return this.isSSL;
+      }
+      getIfFaild() {
+        return this.hasFaild;
+      }
+      setAsFaild(value) {
+        this.hasFaild = value;
+      }
+      getData() {
+        return {
+          serverURL: this.getHost(),
+          application: this.getHost(),
+          serverPort: this.getPort(),
+          isSSL: this.getIfSSL()
+        };
+      }
+      toString() {
+        return "host: " + this.host + " | application: " + this.application + " | port: " + this.port + " | isSSL: " + this.isSSL;
+      }
+    }
+
+    class StreamData {
+      constructor(streamConfig) {
+        this._serverList = new Array();
+        this._sourceList = new Array();
+        this._streamKey = null;
+        this.parse(streamConfig);
+      }
+      parse(streamConfig) {
+        var _a, _b, _c;
+        this._streamConfig = streamConfig;
+        if (!this._streamConfig) throw new Error("Stream configuration is missing. Please check stream config!");
+        if (this._streamConfig.serverList !== undefined && this._streamConfig.serverList !== null) {
+          if (this._streamConfig.serverList.length !== 0) {
+            for (let i = 0; i < this._streamConfig.serverList.length; i++) {
+              let host;
+              let application;
+              if (this._streamConfig.serverList[i].host != null) host = this._streamConfig.serverList[i].host;else throw new Error("Error while parsing server object (\"host\" field is missing). Please check player config!");
+              if (this._streamConfig.serverList[i].application != null) application = this._streamConfig.serverList[i].application;else throw new Error("Error while parsing server object (\"application\" field is missing). Please check player config!");
+              const port = (_a = this._streamConfig.serverList[i].port) !== null && _a !== void 0 ? _a : StreamData.DEFAULT_CONNECTION_PORT;
+              const isSSL = (_b = this._streamConfig.serverList[i].ssl) !== null && _b !== void 0 ? _b : StreamData.IS_SSL_BY_DEFAULT;
+              this._serverList.push(new StormServerItem(host, application, port, isSSL));
+            }
+          } else throw new Error("StormLibrary: Server list configuration is empty. Please check the config!");
+        } else throw new Error("StormLibrary: Server list configuration is missing. Please check the config!");
+        this._streamKey = (_c = this._streamConfig.streamKey) !== null && _c !== void 0 ? _c : this._streamKey;
+      }
+      getServerList() {
+        return this._serverList;
+      }
+      getSourceList() {
+        return this._sourceList;
+      }
+      get streamKey() {
+        return this._streamKey;
+      }
+      set streamKey(newValue) {
+        this._streamKey = newValue;
+      }
+      set serverList(serverList) {
+        this._serverList = serverList;
+      }
+      set sourceList(sourceList) {
+        this._sourceList = sourceList;
+      }
+      clearSourceList() {
+        this._sourceList = new Array();
+      }
+      clearServerList() {
+        this._serverList = new Array();
+      }
+      print(logger, force = false) {
+        if (StreamData.PRINT_ON_STARTUP || force) {
+          logger.info(this, "Server List:");
+          for (let i = 0; i < this._serverList.length; i++) {
+            logger.info(this, "=> [" + i + "] " + this._serverList[i].toString());
+          }
+          logger.info(this, "StreamKey: " + this._streamKey);
+        }
+      }
+    }
+    StreamData.PRINT_ON_STARTUP = true;
+    StreamData.DEFAULT_CONNECTION_PORT = 443;
+    StreamData.IS_SSL_BY_DEFAULT = true;
+
+    var ScalingType;
+    (function (ScalingType) {
+      ScalingType["FILL"] = "fill";
+      ScalingType["LETTER_BOX"] = "letterbox";
+      ScalingType["CROP"] = "crop";
+      ScalingType["ORIGINAL"] = "original";
+    })(ScalingType || (ScalingType = {}));
+
+    var SizeCalculationType;
+    (function (SizeCalculationType) {
+      SizeCalculationType["CLIENT_DIMENSIONS"] = "clientDimensions";
+      SizeCalculationType["BOUNDING_BOX"] = "boundingBox";
+      SizeCalculationType["FULL_BOX"] = "fullBox";
+    })(SizeCalculationType || (SizeCalculationType = {}));
+
+    class VideoData {
+      constructor(videoConfig) {
+        this._scalingMode = ScalingType.LETTER_BOX;
+        this._aspectRatio = "none";
+        this._videoWidthValue = 100;
+        this._isVideoWidthInPixels = false;
+        this._wasVideoWidthProvided = false;
+        this._videoHeightValue = 100;
+        this._isVideoHeightInPixels = false;
+        this._wasVideoHeightProvided = false;
+        this._resizeDebounce = 250;
+        this._parentSizeCalculationMethod = SizeCalculationType.CLIENT_DIMENSIONS;
+        this.parse(videoConfig);
+      }
+      parse(config) {
+        var _a, _b;
+        this.videoConfig = config;
+        if (this.videoConfig != null) {
+          if (this.videoConfig.aspectRatio != null) {
+            const aspectRatioRegexString = '^[0-9]*\\.?[0-9]+:[0-9]*\\.?[0-9]+$';
+            const aspectRatioRegex = new RegExp(aspectRatioRegexString);
+            let tempAspectRatio = this.videoConfig.aspectRatio;
+            if (aspectRatioRegex.test(tempAspectRatio)) {
+              this._aspectRatio = tempAspectRatio;
+            } else throw new Error("Parameter \"aspectRatio\" - must match \"number:number\" pattern ");
+            this._aspectRatio = this.videoConfig.aspectRatio;
+          }
+          if (this.videoConfig.scalingMode != null) {
+            let newScalingMode = this.videoConfig.scalingMode;
+            switch (newScalingMode.toLowerCase()) {
+              case "fill":
+                this._scalingMode = ScalingType.FILL;
+                break;
+              case "letterbox":
+                this._scalingMode = ScalingType.LETTER_BOX;
+                break;
+              case "crop":
+                this._scalingMode = ScalingType.CROP;
+                break;
+              case "original":
+                this._scalingMode = ScalingType.ORIGINAL;
+                break;
+              default:
+                throw new Error("Unknown video scaling mode. Please check player config!");
+            }
+          }
+          if (this.videoConfig.width !== undefined) {
+            if (this.videoConfig.width !== null) {
+              if (typeof this.videoConfig.width === "number") {
+                this._videoWidthValue = this.videoConfig.width;
+                this._isVideoWidthInPixels = true;
+              } else if (typeof this.videoConfig.width === "string") {
+                if (this.videoConfig.width.toLowerCase().endsWith('px')) {
+                  this._videoWidthValue = parseInt(this.videoConfig.width);
+                  this._isVideoWidthInPixels = true;
+                } else if (this.videoConfig.width.toLowerCase().endsWith('%')) {
+                  this._videoWidthValue = parseInt(this.videoConfig.width);
+                  this._isVideoWidthInPixels = false;
+                }
+              } else throw new Error("Unknown type for parameter \"width\" - it must be a number or a string! ");
+              this._wasVideoWidthProvided = true;
+            } else throw new Error("Parameter \"width\" cannot be empty");
+          }
+          if (this.videoConfig.height !== undefined) {
+            if (this.videoConfig.height !== null) {
+              if (typeof this.videoConfig.height === "number") {
+                this._videoHeightValue = this.videoConfig.height;
+                this._isVideoHeightInPixels = true;
+              } else if (typeof this.videoConfig.height === "string") {
+                if (this.videoConfig.height.toLowerCase().endsWith('px')) {
+                  this._videoHeightValue = parseInt(this.videoConfig.height);
+                  this._isVideoHeightInPixels = true;
+                } else if (this.videoConfig.height.toLowerCase().endsWith('%')) {
+                  this._videoHeightValue = parseInt(this.videoConfig.height);
+                  this._isVideoHeightInPixels = false;
+                }
+              } else throw new Error("Unknown type for parameter \"height\" - it must be a number or a string!");
+              this._wasVideoHeightProvided = true;
+            } else throw new Error("Parameter \"height\" cannot be empty");
+          }
+          if (this.videoConfig.sizeCalculationMethod !== undefined) {
+            if (this.videoConfig.sizeCalculationMethod !== null) {
+              switch (this.videoConfig.sizeCalculationMethod) {
+                case "clientDimensions":
+                  this._parentSizeCalculationMethod = SizeCalculationType.CLIENT_DIMENSIONS;
+                  break;
+                case "boundingBox":
+                  this._parentSizeCalculationMethod = SizeCalculationType.BOUNDING_BOX;
+                  break;
+                case "fullBox":
+                  this._parentSizeCalculationMethod = SizeCalculationType.FULL_BOX;
+                  break;
+              }
+            }
+          }
+          this._containerID = (_a = this.videoConfig.containerID) !== null && _a !== void 0 ? _a : null;
+          this._resizeDebounce = (_b = this.videoConfig.resizeDebounce) !== null && _b !== void 0 ? _b : this._resizeDebounce;
+        } else throw new Error("Missing video configuration. Please check player config!");
+      }
+      get scalingMode() {
+        return this._scalingMode;
+      }
+      get containerID() {
+        return this._containerID;
+      }
+      get videoWidthValue() {
+        return this._videoWidthValue;
+      }
+      get videoWidthInPixels() {
+        return this._isVideoWidthInPixels;
+      }
+      get videoWidthProvided() {
+        return this._wasVideoWidthProvided;
+      }
+      get videoHeightValue() {
+        return this._videoHeightValue;
+      }
+      get videoHeightInPixels() {
+        return this._isVideoHeightInPixels;
+      }
+      get videoHeightProvided() {
+        return this._wasVideoHeightProvided;
+      }
+      get aspectRatio() {
+        return this._aspectRatio;
+      }
+      get resizeDebounce() {
+        return this._resizeDebounce;
+      }
+      set resizeDebounce(newValue) {
+        this._resizeDebounce = newValue;
+      }
+      set videoWidthValue(newWidth) {
+        this._videoWidthValue = newWidth;
+      }
+      set videoWidthInPixels(value) {
+        this._isVideoWidthInPixels = value;
+      }
+      set videoHeightValue(newHeight) {
+        this._videoHeightValue = newHeight;
+      }
+      set videoHeightInPixels(value) {
+        this._isVideoHeightInPixels = value;
+      }
+      set containerID(newContainerID) {
+        this._containerID = newContainerID;
+      }
+      set scalingMode(newScalingMode) {
+        switch (newScalingMode.toLowerCase()) {
+          case "fill":
+            this._scalingMode = ScalingType.FILL;
+            break;
+          case "letterbox":
+            this._scalingMode = ScalingType.LETTER_BOX;
+            break;
+          case "crop":
+            this._scalingMode = ScalingType.CROP;
+            break;
+          case "original":
+            this._scalingMode = ScalingType.ORIGINAL;
+            break;
+          default:
+            throw new Error("Unknown video scaling mode. Please check player config!");
+        }
+      }
+      get parentSizeCalculationMethod() {
+        return this._parentSizeCalculationMethod;
+      }
+      print(logger) {
+        let scalingMode = "";
+        switch (this._scalingMode) {
+          case ScalingType.FILL:
+            scalingMode = "fill";
+            break;
+          case ScalingType.LETTER_BOX:
+            scalingMode = "letterbox";
+            break;
+          case ScalingType.CROP:
+            scalingMode = "crop";
+            break;
+          case ScalingType.ORIGINAL:
+            scalingMode = "original";
+            break;
+        }
+        logger.info(this, "VideoConfig :: containerID: " + this._containerID);
+        logger.info(this, "VideoConfig :: scalingMode: " + scalingMode);
+        logger.info(this, "VideoConfig :: width: " + this._videoWidthValue + (this._isVideoWidthInPixels ? "px" : "%") + (this._wasVideoWidthProvided ? " (provided)" : " (default)"));
+        logger.info(this, "VideoConfig :: height: " + this._videoHeightValue + (this._isVideoHeightInPixels ? "px" : "%") + (this._wasVideoHeightProvided ? " (provided)" : " (default)"));
+        logger.info(this, "VideoConfig :: aspectRatio: " + this._aspectRatio);
+      }
+    }
+
+    var LogType;
+    (function (LogType) {
+      LogType[LogType["TRACE"] = 0] = "TRACE";
+      LogType[LogType["INFO"] = 1] = "INFO";
+      LogType[LogType["SUCCESS"] = 2] = "SUCCESS";
+      LogType[LogType["WARNING"] = 3] = "WARNING";
+      LogType[LogType["ERROR"] = 4] = "ERROR";
+    })(LogType || (LogType = {}));
+
+    class DebugData {
+      constructor(debugConfig) {
+        this._consoleLogEnabled = false;
+        this._enabledConsoleTypes = [LogType.INFO, LogType.ERROR, LogType.SUCCESS, LogType.TRACE, LogType.WARNING];
+        this._consoleMonoColor = false;
+        this._containerLogEnabled = false;
+        this._enabledContainerTypes = [LogType.INFO, LogType.ERROR, LogType.SUCCESS, LogType.TRACE, LogType.WARNING];
+        this._containerLogMonoColor = false;
+        this.parse(debugConfig);
+      }
+      parse(debugConfig) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+        this._debugConfig = debugConfig;
+        if (this._debugConfig) {
+          this._consoleLogEnabled = (_c = (_b = (_a = this._debugConfig) === null || _a === void 0 ? void 0 : _a.console) === null || _b === void 0 ? void 0 : _b.enabled) !== null && _c !== void 0 ? _c : this._consoleLogEnabled;
+          this._consoleMonoColor = (_f = (_e = (_d = this._debugConfig) === null || _d === void 0 ? void 0 : _d.console) === null || _e === void 0 ? void 0 : _e.monoColor) !== null && _f !== void 0 ? _f : this._consoleMonoColor;
+          this._enabledConsoleTypes = (_j = this.parseLogTypes((_h = (_g = this._debugConfig) === null || _g === void 0 ? void 0 : _g.console) === null || _h === void 0 ? void 0 : _h.logTypes)) !== null && _j !== void 0 ? _j : this._enabledConsoleTypes;
+          this._containerLogEnabled = (_m = (_l = (_k = this._debugConfig) === null || _k === void 0 ? void 0 : _k.container) === null || _l === void 0 ? void 0 : _l.enabled) !== null && _m !== void 0 ? _m : this._containerLogEnabled;
+          this._containerLogMonoColor = (_q = (_p = (_o = this._debugConfig) === null || _o === void 0 ? void 0 : _o.container) === null || _p === void 0 ? void 0 : _p.monoColor) !== null && _q !== void 0 ? _q : this._containerLogMonoColor;
+          this._enabledContainerTypes = (_t = this.parseLogTypes((_s = (_r = this._debugConfig) === null || _r === void 0 ? void 0 : _r.container) === null || _s === void 0 ? void 0 : _s.logTypes)) !== null && _t !== void 0 ? _t : this._enabledContainerTypes;
+          this._containerID = (_w = (_v = (_u = this._debugConfig) === null || _u === void 0 ? void 0 : _u.container) === null || _v === void 0 ? void 0 : _v.containerID) !== null && _w !== void 0 ? _w : this._containerID;
+        }
+      }
+      parseLogTypes(logTypes) {
+        return logTypes === null || logTypes === void 0 ? void 0 : logTypes.map(type => {
+          switch (type.toLowerCase()) {
+            case 'info':
+              return LogType.INFO;
+            case 'error':
+              return LogType.ERROR;
+            case 'warning':
+              return LogType.WARNING;
+            case 'success':
+              return LogType.SUCCESS;
+            case 'trace':
+              return LogType.TRACE;
+            default:
+              throw new Error(`Unsupported log type: ${type}`);
+          }
+        });
+      }
+      get consoleLogEnabled() {
+        return this._consoleLogEnabled;
+      }
+      set consoleLogEnabled(newValue) {
+        this._consoleLogEnabled = newValue;
+      }
+      get enabledConsoleTypes() {
+        return this._enabledConsoleTypes;
+      }
+      set enabledConsoleTypes(newValue) {
+        this._enabledConsoleTypes = new Array();
+        for (let i = 0; i < newValue.length; i++) {
+          switch (newValue[i].toLowerCase()) {
+            case "info":
+              this._enabledConsoleTypes.push(LogType.INFO);
+              break;
+            case "error":
+              this._enabledConsoleTypes.push(LogType.ERROR);
+              break;
+            case "warning":
+              this._enabledConsoleTypes.push(LogType.WARNING);
+              break;
+            case "success":
+              this._enabledConsoleTypes.push(LogType.SUCCESS);
+              break;
+            case "trace":
+              this._enabledConsoleTypes.push(LogType.TRACE);
+              break;
+          }
+        }
+      }
+      get containerLogEnabled() {
+        return this._containerLogEnabled;
+      }
+      set containerLogEnabled(newValue) {
+        this._consoleLogEnabled = newValue;
+      }
+      get consoleLogMonoColor() {
+        return this._consoleMonoColor;
+      }
+      set consoleLogMonoColor(newValue) {
+        this._consoleMonoColor = newValue;
+      }
+      get enabledContainerTypes() {
+        return this._enabledContainerTypes;
+      }
+      set enabledContainerTypes(newValue) {
+        this._enabledContainerTypes = new Array();
+        for (let i = 0; i < newValue.length; i++) {
+          switch (newValue[i].toLowerCase()) {
+            case "info":
+              this._enabledContainerTypes.push(LogType.INFO);
+              break;
+            case "error":
+              this._enabledContainerTypes.push(LogType.ERROR);
+              break;
+            case "warning":
+              this._enabledContainerTypes.push(LogType.WARNING);
+              break;
+            case "success":
+              this._enabledContainerTypes.push(LogType.SUCCESS);
+              break;
+            case "trace":
+              this._enabledContainerTypes.push(LogType.TRACE);
+              break;
+          }
+        }
+      }
+      get containerID() {
+        return this._containerID;
+      }
+      set containerID(object) {
+        this._containerID = object;
+      }
+      get containerLogMonoColor() {
+        return this._containerLogMonoColor;
+      }
+      set containerLogMonoColor(newValue) {
+        this._containerLogMonoColor = newValue;
+      }
+      print(logger, force = false) {
+        if (DebugData.PRINT_ON_STARTUP || force) {
+          let consoleLogTypes = "";
+          for (let i = 0; i < this._enabledConsoleTypes.length; i++) {
+            switch (this._enabledConsoleTypes[i]) {
+              case LogType.TRACE:
+                consoleLogTypes += "TRACE, ";
+                break;
+              case LogType.SUCCESS:
+                consoleLogTypes += "SUCCESS, ";
+                break;
+              case LogType.WARNING:
+                consoleLogTypes += "WARNING, ";
+                break;
+              case LogType.INFO:
+                consoleLogTypes += "INFO, ";
+                break;
+              case LogType.ERROR:
+                consoleLogTypes += "ERROR, ";
+                break;
+            }
+          }
+          logger.info(this, "Console:: enabled: " + this._consoleLogEnabled);
+          logger.info(this, "Console:: logTypes: " + consoleLogTypes);
+          logger.info(this, "Console:: monoColor: " + this._consoleMonoColor);
+          let containerLogTypes = "";
+          for (let i = 0; i < this._enabledContainerTypes.length; i++) {
+            switch (this._enabledContainerTypes[i]) {
+              case LogType.TRACE:
+                containerLogTypes += "TRACE, ";
+                break;
+              case LogType.SUCCESS:
+                containerLogTypes += "SUCCESS, ";
+                break;
+              case LogType.WARNING:
+                containerLogTypes += "WARNING, ";
+                break;
+              case LogType.INFO:
+                containerLogTypes += "INFO, ";
+                break;
+              case LogType.ERROR:
+                containerLogTypes += "ERROR, ";
+                break;
+            }
+          }
+          logger.info(this, "Container:: enabled: " + this._containerLogEnabled);
+          logger.info(this, "Container:: logTypes: " + containerLogTypes);
+          logger.info(this, "Container:: containerID: " + this._containerID);
+          logger.info(this, "Container:: monoColor: " + this._consoleMonoColor);
+        }
+      }
+    }
+    DebugData.PRINT_ON_STARTUP = true;
+
+    class AudioData {
+      constructor(volumeConfig) {
+        this._startVolume = 100;
+        this._isMuted = false;
+        this.parse(volumeConfig);
+      }
+      parse(config) {
+        var _a, _b, _c, _d;
+        this._audioConfig = config;
+        if (this._audioConfig) {
+          this._startVolume = (_b = (_a = this._audioConfig) === null || _a === void 0 ? void 0 : _a.startVolume) !== null && _b !== void 0 ? _b : this._startVolume;
+          this._isMuted = (_d = (_c = this._audioConfig) === null || _c === void 0 ? void 0 : _c.muted) !== null && _d !== void 0 ? _d : this._isMuted;
+        }
+      }
+      get startVolume() {
+        return this._startVolume;
+      }
+      set startVolume(newValue) {
+        this._startVolume = newValue;
+      }
+      get muted() {
+        return this._isMuted;
+      }
+      set muted(newValue) {
+        this._isMuted = newValue;
+      }
+      print(logger, force = false) {
+        if (AudioData.PRINT_ON_STARTUP || force) logger.info(this, "Audio :: startVolume: " + this._startVolume + " | isMuted: " + this._isMuted);
+      }
+    }
+    AudioData.PRINT_ON_STARTUP = true;
+
+    class StorageData {
+      constructor(storageConfig) {
+        this._enabled = true;
+        this._prefix = "storm";
+        this.parse(storageConfig);
+      }
+      parse(config) {
+        var _a, _b, _c, _d;
+        this._storageConfig = config;
+        this._enabled = (_b = (_a = this._storageConfig) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : this._enabled;
+        this._prefix = (_d = (_c = this._storageConfig) === null || _c === void 0 ? void 0 : _c.prefix) !== null && _d !== void 0 ? _d : this._prefix;
+      }
+      get enabled() {
+        return this._enabled;
+      }
+      set enabled(newValue) {
+        this._enabled = newValue;
+      }
+      get prefix() {
+        return this._prefix;
+      }
+      set prefix(newValue) {
+        this._prefix = newValue;
+      }
+      print(logger, force = false) {
+        if (StorageData.PRINT_ON_STARTUP || force) logger.info(this, "Storage :: startVolume: " + this._enabled + " | prefix: " + this._prefix);
+      }
+    }
+    StorageData.PRINT_ON_STARTUP = true;
+
+    class SettingsData {
+      constructor(config) {
+        this._restartOnError = true;
+        this._reconnectTime = 1;
+        this._autoStart = false;
+        this._autoConnect = true;
+        this.startOnDOMReady = false;
+        this.iOSOnDomReadyFix = true;
+        this._restartOnFocus = true;
+        this.parse(config);
+      }
+      parse(config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        this._settingsConfig = config;
+        this._autoConnect = (_a = this._settingsConfig.autoConnect) !== null && _a !== void 0 ? _a : this._autoConnect;
+        this._autoStart = (_b = this._settingsConfig.autoStart) !== null && _b !== void 0 ? _b : this._autoStart;
+        this._restartOnFocus = (_c = this._settingsConfig.restartOnFocus) !== null && _c !== void 0 ? _c : this._restartOnFocus;
+        this._restartOnError = (_d = this._settingsConfig.restartOnError) !== null && _d !== void 0 ? _d : this._restartOnError;
+        this._reconnectTime = (_e = this._settingsConfig.reconnectTime) !== null && _e !== void 0 ? _e : this._reconnectTime;
+        this._videoData = new VideoData((_f = this._settingsConfig.video) !== null && _f !== void 0 ? _f : null);
+        this._audioData = new AudioData((_g = this._settingsConfig.audio) !== null && _g !== void 0 ? _g : null);
+        this._storageData = new StorageData((_h = this._settingsConfig.storage) !== null && _h !== void 0 ? _h : null);
+        this._debugData = new DebugData((_j = this._settingsConfig.debug) !== null && _j !== void 0 ? _j : null);
+      }
+      getAudioData() {
+        return this._audioData;
+      }
+      getVideoData() {
+        return this._videoData;
+      }
+      getStorageData() {
+        return this._storageData;
+      }
+      getIfRestartOnError() {
+        return this._restartOnError;
+      }
+      getReconnectTime() {
+        return this._reconnectTime;
+      }
+      get autoStart() {
+        return this._autoStart;
+      }
+      set autoStart(newValue) {
+        this._autoStart = newValue;
+      }
+      get autoConnect() {
+        return this._autoConnect;
+      }
+      get restartOnFocus() {
+        return this._restartOnFocus;
+      }
+      getDebugData() {
+        return this._debugData;
+      }
+      getIfStartOnDOMReadyEnabled() {
+        return this.startOnDOMReady;
+      }
+      getIfIOSOnDomStartFixEnabled() {
+        return this.iOSOnDomReadyFix;
+      }
+      print(logger, force = false) {
+        if (SettingsData.PRINT_ON_STARTUP || force) {
+          let enabledProtocols = "";
+          logger.info(this, "SettingsConfig :: autoConnect: " + this._autoConnect);
+          logger.info(this, "SettingsConfig :: autoStart: " + this._autoStart);
+          logger.info(this, "SettingsConfig :: restartOnError: " + this._restartOnError);
+          logger.info(this, "SettingsConfig :: reconnectTime: " + this._reconnectTime);
+          logger.info(this, "SettingsConfig :: enabledProtocols: " + enabledProtocols);
+          this._videoData.print(logger);
+          this._audioData.print(logger);
+          this._debugData.print(logger);
+          this._debugData.print(logger);
+        }
+      }
+    }
+    SettingsData.PRINT_ON_STARTUP = true;
+
+    class ConfigManager {
+      constructor(config) {
+        this.PRINT_ON_STARTUP = true;
+        this.demoMode = false;
+        this.parse(config);
+      }
+      parse(config) {
+        var _a, _b;
+        this.configTemplate = config;
+        if (this.configTemplate.stream == null) throw new Error("No stream field was provided. Please check your player config!");
+        this.streamData = new StreamData(this.configTemplate.stream);
+        this.settingsData = new SettingsData((_a = this.configTemplate.settings) !== null && _a !== void 0 ? _a : null);
+        this.demoMode = (_b = this.configTemplate.demoMode) !== null && _b !== void 0 ? _b : false;
+      }
+      getStreamData() {
+        return this.streamData;
+      }
+      getSettingsData() {
+        return this.settingsData;
+      }
+      getIfDemoMode() {
+        return this.demoMode;
+      }
+      print(logger, force = false) {
+        if (this.PRINT_ON_STARTUP || force) {
+          this.streamData.print(logger);
+          this.settingsData.print(logger);
+        }
+      }
+    }
+
+    class EventDispatcher {
+      constructor() {
+        this._isRemoved = false;
+        this._listeners = {};
+      }
+      addEventListener(eventName, listener, removable = true) {
+        if (!this._listeners[eventName]) this._listeners[eventName] = [];
+        let elementFound = false;
+        if (this._listeners[eventName] != undefined) {
+          if (this._listeners[eventName].length > 0) {
+            for (let i = 0; i < this._listeners[eventName].length; i++) {
+              let element = this._listeners[eventName][i];
+              if (element[1] == listener) {
+                elementFound = true;
+                break;
+              }
+            }
+          }
+        }
+        this._logger.success(this, "Registering a new event: " + eventName);
+        if (!elementFound) {
+          this._listeners[eventName].push([eventName, listener, removable]);
+          return true;
+        } else return false;
+      }
+      removeEventListener(eventName, listener) {
+        let elementFound = false;
+        if (this._listeners[eventName] != undefined) {
+          if (this._listeners[eventName].length > 0) {
+            for (let i = 0; i < this._listeners[eventName].length; i++) {
+              let element = this._listeners[eventName][i];
+              if (listener) {
+                if (element[1] == listener) {
+                  if (element[2] == true) {
+                    elementFound = true;
+                    this._listeners[eventName].splice(i, 1);
+                    break;
+                  } else break;
+                }
+              } else {
+                elementFound = true;
+                if (element[2] == true) {
+                  this._listeners[eventName].splice(i, 1);
+                }
+              }
+            }
+          }
+        }
+        this._logger.success(this, "Removing listener: " + eventName);
+        return elementFound;
+      }
+      removeAllEventListeners() {
+        this._logger.success(this, "Removing all listeners!");
+        for (const eventName in this._listeners) {
+          const typedEventName = eventName;
+          const branch = this._listeners[typedEventName];
+          if (branch && branch.length > 0) {
+            for (let i = branch.length - 1; i >= 0; i--) {
+              const element = branch[i];
+              if (element[2] === true) {
+                branch.splice(i, 1);
+              }
+            }
+          }
+        }
+      }
+      dispatchEvent(eventName, event) {
+        if (this._isRemoved) return;
+        if (this._listeners[eventName] != undefined) {
+          if (this._listeners[eventName].length > 0) {
+            for (let i = 0; i < this._listeners[eventName].length; i++) {
+              let element = this._listeners[eventName][i];
+              element[1].call(this, event);
+            }
+          }
+        }
+      }
+    }
+
+    class NumberUtilities {
+      static addLeadingZero(number) {
+        if (number < 10) {
+          return "0" + number;
+        } else {
+          return String(number);
+        }
+      }
+      static isNear(currentBuffer, target, targetMargin) {
+        return Math.abs(currentBuffer - target) <= targetMargin;
+      }
+      static generateUniqueString(length) {
+        let result = '';
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        const charactersLength = characters.length;
+        for (let i = 0; i < length; i++) {
+          result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        }
+        return result;
+      }
+    }
+    NumberUtilities.parseValue = value => {
+      if (typeof value === 'string') {
+        const isPixels = value.toLowerCase().endsWith('px');
+        const numericValue = parseInt(value, 10);
+        return {
+          value: numericValue,
+          isPixels: isPixels
+        };
+      } else {
+        return {
+          value: value,
+          isPixels: true
+        };
+      }
+    };
+
+    class Logger {
+      constructor(config, stormStreamer) {
+        this.colorOrder = ["red", "green", "blue", "orange", "black", "violet"];
+        this._logMemory = [];
+        this._streamerInstanceID = -1;
+        this._debugConfig = config;
+        this._stormStreamer = stormStreamer;
+        this._streamerInstanceID = this._stormStreamer.getStreamerID();
+        let colorID = this.colorOrder.length < stormStreamer.getStreamerID() ? this.colorOrder.length - 1 : stormStreamer.getStreamerID();
+        this._monoColor = this.colorOrder[colorID];
+      }
+      info(objectName, message) {
+        let output = this.logData(objectName, message);
+        if (this._debugConfig.consoleLogEnabled) {
+          if (this._debugConfig.enabledConsoleTypes.indexOf(LogType.INFO) >= 0) {
+            let consoleColor = this._debugConfig.consoleLogMonoColor ? this._monoColor : Logger.INFO_COLOR;
+            console.log('%c ' + output, 'color: ' + consoleColor);
+          }
+        }
+        if (this._debugConfig.containerLogEnabled) {
+          if (this._debugConfig.enabledContainerTypes.indexOf(LogType.INFO) >= 0) {
+            let containerColor = this._debugConfig.containerLogMonoColor ? this._monoColor : Logger.INFO_COLOR;
+            this.writeToContainer(output, containerColor);
+          }
+        }
+      }
+      warning(objectName, message) {
+        let output = this.logData(objectName, message);
+        if (this._debugConfig.consoleLogEnabled) {
+          if (this._debugConfig.enabledConsoleTypes.indexOf(LogType.WARNING) >= 0) {
+            let consoleColor = this._debugConfig.consoleLogMonoColor ? this._monoColor : Logger.WARNING_COLOR;
+            console.log('%c ' + output, 'color: ' + consoleColor);
+          }
+        }
+        if (this._debugConfig.containerLogEnabled) {
+          if (this._debugConfig.enabledContainerTypes.indexOf(LogType.WARNING) >= 0) {
+            let containerColor = this._debugConfig.containerLogMonoColor ? this._monoColor : Logger.WARNING_COLOR;
+            this.writeToContainer(output, containerColor);
+          }
+        }
+      }
+      error(objectName, message) {
+        let output = this.logData(objectName, message);
+        if (this._debugConfig.consoleLogEnabled) {
+          if (this._debugConfig.enabledConsoleTypes.indexOf(LogType.ERROR) >= 0) {
+            let consoleColor = this._debugConfig.consoleLogMonoColor ? this._monoColor : Logger.ERROR_COLOR;
+            console.log('%c ' + output, 'color: ' + consoleColor);
+          }
+        }
+        if (this._debugConfig.containerLogEnabled) {
+          if (this._debugConfig.enabledContainerTypes.indexOf(LogType.ERROR) >= 0) {
+            let containerColor = this._debugConfig.containerLogMonoColor ? this._monoColor : Logger.ERROR_COLOR;
+            this.writeToContainer(output, containerColor);
+          }
+        }
+      }
+      success(objectName, message) {
+        let output = this.logData(objectName, message);
+        if (this._debugConfig.consoleLogEnabled) {
+          if (this._debugConfig.enabledConsoleTypes.indexOf(LogType.SUCCESS) >= 0) {
+            let consoleColor = this._debugConfig.consoleLogMonoColor ? this._monoColor : Logger.SUCCESS_COLOR;
+            console.log('%c ' + output, 'color: ' + consoleColor);
+          }
+        }
+        if (this._debugConfig.containerLogEnabled) {
+          if (this._debugConfig.enabledContainerTypes.indexOf(LogType.SUCCESS) >= 0) {
+            let containerColor = this._debugConfig.containerLogMonoColor ? this._monoColor : Logger.SUCCESS_COLOR;
+            this.writeToContainer(output, containerColor);
+          }
+        }
+      }
+      trace(objectName, message) {
+        let output = this.logData(objectName, message);
+        if (this._debugConfig.consoleLogEnabled) {
+          if (this._debugConfig.enabledConsoleTypes.indexOf(LogType.TRACE) >= 0) {
+            let consoleColor = this._debugConfig.consoleLogMonoColor ? this._monoColor : Logger.TRACE_COLOR;
+            console.log('%c ' + output, 'color: ' + consoleColor);
+          }
+        }
+        if (this._debugConfig.containerLogEnabled) {
+          if (this._debugConfig.enabledContainerTypes.indexOf(LogType.TRACE) >= 0) {
+            let containerColor = this._debugConfig.containerLogMonoColor ? this._monoColor : Logger.TRACE_COLOR;
+            this.writeToContainer(output, containerColor);
+          }
+        }
+      }
+      logData(_objectName, message) {
+        let date = new Date();
+        let hour = NumberUtilities.addLeadingZero(date.getHours());
+        let minutes = NumberUtilities.addLeadingZero(date.getMinutes());
+        let seconds = NumberUtilities.addLeadingZero(date.getSeconds());
+        let label = String(this._streamerInstanceID);
+        if (this._streamerInstanceID >= 0) label += "|" + this._streamerInstanceID;
+        let finalString = "[Storm-ID:" + label + "] [" + hour + ":" + minutes + ":" + seconds + "] :: " + message;
+        this._logMemory.push(finalString);
+        return finalString;
+      }
+      writeToContainer(message, color) {
+        let containerName = this._debugConfig.containerID;
+        if (containerName) {
+          let container = document.getElementById(containerName);
+          let log = document.createElement('span');
+          log.innerText = message;
+          log.style.color = color;
+          container.appendChild(log);
+        }
+      }
+      setPlayerID(playerID) {
+        this._streamerInstanceID = playerID;
+      }
+      getAllLogs() {
+        return this._logMemory;
+      }
+    }
+    Logger.INFO_COLOR = "blue";
+    Logger.WARNING_COLOR = "orange";
+    Logger.ERROR_COLOR = "red";
+    Logger.SUCCESS_COLOR = "green";
+    Logger.TRACE_COLOR = "black";
+
+    class ClientUser {
+      constructor() {
+        this.bandwidthCapabilities = 0;
+      }
+      setBandwidthCapabilities(newCapabilities) {
+        this.bandwidthCapabilities = newCapabilities;
+      }
+      getBandwidthCapabilities() {
+        return this.bandwidthCapabilities;
+      }
+    }
+
+    class UserCapabilities {
+      static hasWebSocketsSupport() {
+        return window.WebSocket != null;
+      }
+      static isMobile() {
+        const mobileCheckString = "Mobile|mini|Fennec|Android|iP(ad|od|hone)";
+        const mobileCheckRegExp = new RegExp(mobileCheckString);
+        return mobileCheckRegExp.test(navigator.userAgent);
+      }
+      static isCookieEnabled() {
+        let cookieEnabled = navigator.cookieEnabled ? true : false;
+        if (typeof navigator.cookieEnabled == 'undefined' && !cookieEnabled) {
+          document.cookie = 'testcookie';
+          cookieEnabled = document.cookie.indexOf('testcookie') != -1 ? true : false;
+        }
+        return cookieEnabled;
+      }
+      static getOSVersion() {
+        let osVersion = "Unknown version";
+        let os = UserCapabilities.getOS();
+        if (os != null) {
+          const windowsCheckString = "Windows";
+          const windowsCheckRegExp = new RegExp(windowsCheckString);
+          if (windowsCheckRegExp.test(os)) {
+            const windowsExecString = "Windows (.*)";
+            const windowsExecRegExp = new RegExp(windowsExecString);
+            osVersion = windowsExecRegExp.exec(os)[1] != null ? windowsExecRegExp.exec(os)[1] : osVersion;
+            os = 'Windows';
+          }
+          switch (os) {
+            case 'Mac OS':
+            case 'Mac OS X':
+            case 'Android':
+              const versionExecString = "(?:Android|Mac OS|Mac OS X|MacPPC|MacIntel|Mac_PowerPC|Macintosh) ([\\.\\_\\d]+)";
+              const versionExecRegExp = new RegExp(versionExecString);
+              osVersion = versionExecRegExp.exec(navigator.userAgent)[1];
+              break;
+            case 'iOS':
+              const iOSExecString = "OS (\\d+)_(\\d+)_?(\\d+)?";
+              const iOSExecRegExp = new RegExp(iOSExecString);
+              osVersion = iOSExecRegExp.exec(navigator.userAgent);
+              osVersion = osVersion[1] + '.' + osVersion[2] + '.' + (osVersion[3] | 0);
+              break;
+          }
+        }
+        return osVersion;
+      }
+      static getBrowserName() {
+        return UserCapabilities.getFullBrowser().name;
+      }
+      static getBrowserVersion() {
+        return UserCapabilities.getFullBrowser().version;
+      }
+      static getFullBrowser() {
+        let nAgt = navigator.userAgent;
+        let browser = navigator.appName;
+        let version = '' + parseFloat(navigator.appVersion);
+        let majorVersion = parseInt(navigator.appVersion, 10);
+        let nameOffset, verOffset, ix;
+        if ((verOffset = nAgt.indexOf('Opera')) != -1) {
+          browser = 'Opera';
+          version = nAgt.substring(verOffset + 6);
+          if ((verOffset = nAgt.indexOf('Version')) != -1) {
+            version = nAgt.substring(verOffset + 8);
+          }
+        } else if ((verOffset = nAgt.indexOf('MSIE')) != -1) {
+          browser = 'Microsoft Internet Explorer';
+          version = nAgt.substring(verOffset + 5);
+        } else if (browser == 'Netscape' && nAgt.indexOf('Trident/') != -1) {
+          browser = 'Microsoft Internet Explorer';
+          version = nAgt.substring(verOffset + 5);
+          if ((verOffset = nAgt.indexOf('rv:')) != -1) {
+            version = nAgt.substring(verOffset + 3);
+          }
+        } else if ((verOffset = nAgt.indexOf('Chrome')) != -1) {
+          browser = 'Chrome';
+          if (nAgt.indexOf("FBAV") > -1 || nAgt.indexOf("FBAN") > -1) browser = 'Facebook';
+          if (nAgt.indexOf("OPR") > -1) browser = 'Opera';
+          if (nAgt.indexOf("SamsungBrowser") > -1) browser = 'Samsung';
+          version = nAgt.substring(verOffset + 7);
+        } else if ((verOffset = nAgt.indexOf('Safari')) != -1) {
+          browser = 'Safari';
+          version = nAgt.substring(verOffset + 7);
+          if ((verOffset = nAgt.indexOf('Version')) != -1) {
+            version = nAgt.substring(verOffset + 8);
+          }
+          if (nAgt.indexOf('CriOS') != -1) {
+            browser = 'Chrome';
+          }
+          if (nAgt.indexOf('FxiOS') != -1) {
+            browser = "Firefox";
+          }
+        } else if ((verOffset = nAgt.indexOf('Firefox')) != -1) {
+          browser = 'Firefox';
+          version = nAgt.substring(verOffset + 8);
+        } else if ((nameOffset = nAgt.lastIndexOf(' ') + 1) < (verOffset = nAgt.lastIndexOf('/'))) {
+          browser = nAgt.substring(nameOffset, verOffset);
+          version = nAgt.substring(verOffset + 1);
+          if (browser.toLowerCase() == browser.toUpperCase()) {
+            browser = navigator.appName;
+          }
+        }
+        if ((ix = version.indexOf(';')) != -1) version = version.substring(0, ix);
+        if ((ix = version.indexOf(' ')) != -1) version = version.substring(0, ix);
+        if ((ix = version.indexOf(')')) != -1) version = version.substring(0, ix);
+        majorVersion = parseInt('' + version, 10);
+        if (isNaN(majorVersion)) {
+          version = '' + parseFloat(navigator.appVersion);
+          majorVersion = parseInt(navigator.appVersion, 10);
+        }
+        return {
+          "name": browser,
+          "fullVersion": version,
+          "version": majorVersion
+        };
+      }
+      static getOS() {
+        let os = "Unknown OS";
+        let oscodes = [{
+          "os": 'Windows 10',
+          "code": "(Windows 10.0|Windows NT 10.0)"
+        }, {
+          "os": 'Windows 8.1',
+          "code": "(Windows 8.1|Windows NT 6.3)"
+        }, {
+          "os": 'Windows 8',
+          "code": "(Windows 8|Windows NT 6.2)"
+        }, {
+          "os": 'Windows 7',
+          "code": "(Windows 7|Windows NT 6.1)"
+        }, {
+          "os": 'Windows Vista',
+          "code": "Windows NT 6.0"
+        }, {
+          "os": 'Windows Server 2003',
+          "code": "Windows NT 5.2"
+        }, {
+          "os": 'Windows XP',
+          "code": "(Windows NT 5.1|Windows XP)"
+        }, {
+          "os": 'Windows 2000',
+          "code": "(Windows NT 5.0|Windows 2000)"
+        }, {
+          "os": 'Windows ME',
+          "code": "(Win 9x 4.90|Windows ME)"
+        }, {
+          "os": 'Windows 98',
+          "code": "(Windows 98|Win98)"
+        }, {
+          "os": 'Windows 95',
+          "code": "(Windows 95|Win95|Windows_95)"
+        }, {
+          "os": 'Windows NT 4.0',
+          "code": "(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)"
+        }, {
+          "os": 'Windows CE',
+          "code": "Windows CE"
+        }, {
+          "os": 'Windows 3.11',
+          "code": "Win16"
+        }, {
+          "os": 'Android',
+          "code": "Android"
+        }, {
+          "os": 'Open BSD',
+          "code": "OpenBSD"
+        }, {
+          "os": 'Sun OS',
+          "code": "SunOS"
+        }, {
+          "os": 'Chrome OS',
+          "code": "CrOS"
+        }, {
+          "os": 'Linux',
+          "code": "(Linux|X11(?!.*CrOS))"
+        }, {
+          "os": 'iOS',
+          "code": "(iPhone|iPad|iPod)"
+        }, {
+          "os": 'Mac OS X',
+          "code": "Mac OS X"
+        }, {
+          "os": 'Mac OS',
+          "code": "(Mac OS|MacPPC|MacIntel|Mac_PowerPC|Macintosh)"
+        }, {
+          "os": 'QNX',
+          "code": "QNX"
+        }, {
+          "os": 'UNIX',
+          "code": "UNIX"
+        }, {
+          "os": 'BeOS',
+          "code": "BeOS"
+        }, {
+          "os": 'OS/2',
+          "code": "OS\\/2"
+        }, {
+          "os": 'Search Bot',
+          "code": "(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\\/Teoma|ia_archiver)"
+        }];
+        for (var id in oscodes) {
+          var cs = oscodes[id];
+          var re = new RegExp(cs.code);
+          if (re.test(navigator.userAgent)) {
+            os = cs.os;
+            break;
+          }
+        }
+        return os;
+      }
+      static hasWebRTCSupport() {
+        let isSupported = false;
+        try {
+          let webrtc = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia || window.RTCPeerConnection;
+          isSupported = true;
+        } catch (error) {
+          isSupported = false;
+        }
+        return isSupported;
+      }
+      static hasHLSSupport(videoObject) {
+        if (videoObject !== null) {
+          return Boolean(videoObject.canPlayType('application/vnd.apple.mpegURL') || videoObject.canPlayType('audio/mpegurl'));
+        } else return false;
+      }
+      static hasMSESupport() {
+        const mediaSource = window.MediaSource = window.MediaSource || window.WebKitMediaSource;
+        window.SourceBuffer = window.SourceBuffer || window.WebKitSourceBuffer;
+        return mediaSource && typeof mediaSource.isTypeSupported === 'function';
+      }
+      static hasMMSSupport() {
+        return window.ManagedMediaSource;
+      }
+      static isSSL() {
+        if (location.protocol === 'https:') return true;else return false;
+      }
+    }
+
+    class StorageManager {
+      constructor(main) {
+        var _a, _b, _c, _d, _e, _f;
+        this.LOG_ACTIVITY = false;
+        this.isEnabled = true;
+        this.prefix = "";
+        this.logger = main.getLogger();
+        this.isEnabled = (_c = (_b = (_a = main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getSettingsData()) === null || _b === void 0 ? void 0 : _b.getStorageData().enabled) !== null && _c !== void 0 ? _c : this.isEnabled;
+        this.prefix = (_f = (_e = (_d = main.getConfigManager()) === null || _d === void 0 ? void 0 : _d.getSettingsData()) === null || _e === void 0 ? void 0 : _e.getStorageData().prefix) !== null && _f !== void 0 ? _f : this.prefix;
+        if (this.LOG_ACTIVITY) this.logger.info(this, "Creating new StorageManager");
+      }
+      saveField(name, value) {
+        if (this.isEnabled == true) {
+          if (this.LOG_ACTIVITY) this.logger.info(this, "Saving data: " + name + " | " + value);
+          localStorage.setItem(this.prefix + name, value);
+        }
+      }
+      getField(name) {
+        if (this.isEnabled == true) {
+          const value = localStorage.getItem(this.prefix + name);
+          if (this.LOG_ACTIVITY) this.logger.info(this, "Grabbing data: " + name + " | " + value);
+          return value;
+        } else return null;
+      }
+    }
+
+    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    }
+
+    /**
+     * lodash (Custom Build) <https://lodash.com/>
+     * Build: `lodash modularize exports="npm" -o ./`
+     * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+     * Released under MIT license <https://lodash.com/license>
+     * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+     * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+     */
+
+    /** Used as the `TypeError` message for "Functions" methods. */
+    var FUNC_ERROR_TEXT = 'Expected a function';
+
+    /** Used as references for various `Number` constants. */
+    var NAN = 0 / 0;
+
+    /** `Object#toString` result references. */
+    var symbolTag = '[object Symbol]';
+
+    /** Used to match leading and trailing whitespace. */
+    var reTrim = /^\s+|\s+$/g;
+
+    /** Used to detect bad signed hexadecimal string values. */
+    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+    /** Used to detect binary string values. */
+    var reIsBinary = /^0b[01]+$/i;
+
+    /** Used to detect octal string values. */
+    var reIsOctal = /^0o[0-7]+$/i;
+
+    /** Built-in method references without a dependency on `root`. */
+    var freeParseInt = parseInt;
+
+    /** Detect free variable `global` from Node.js. */
+    var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+    /** Detect free variable `self`. */
+    var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+    /** Used as a reference to the global object. */
+    var root = freeGlobal || freeSelf || Function('return this')();
+
+    /** Used for built-in method references. */
+    var objectProto = Object.prototype;
+
+    /**
+     * Used to resolve the
+     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+     * of values.
+     */
+    var objectToString = objectProto.toString;
+
+    /* Built-in method references for those with the same name as other `lodash` methods. */
+    var nativeMax = Math.max,
+        nativeMin = Math.min;
+
+    /**
+     * Gets the timestamp of the number of milliseconds that have elapsed since
+     * the Unix epoch (1 January 1970 00:00:00 UTC).
+     *
+     * @static
+     * @memberOf _
+     * @since 2.4.0
+     * @category Date
+     * @returns {number} Returns the timestamp.
+     * @example
+     *
+     * _.defer(function(stamp) {
+     *   console.log(_.now() - stamp);
+     * }, _.now());
+     * // => Logs the number of milliseconds it took for the deferred invocation.
+     */
+    var now = function() {
+      return root.Date.now();
+    };
+
+    /**
+     * Creates a debounced function that delays invoking `func` until after `wait`
+     * milliseconds have elapsed since the last time the debounced function was
+     * invoked. The debounced function comes with a `cancel` method to cancel
+     * delayed `func` invocations and a `flush` method to immediately invoke them.
+     * Provide `options` to indicate whether `func` should be invoked on the
+     * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+     * with the last arguments provided to the debounced function. Subsequent
+     * calls to the debounced function return the result of the last `func`
+     * invocation.
+     *
+     * **Note:** If `leading` and `trailing` options are `true`, `func` is
+     * invoked on the trailing edge of the timeout only if the debounced function
+     * is invoked more than once during the `wait` timeout.
+     *
+     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+     * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+     *
+     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+     * for details over the differences between `_.debounce` and `_.throttle`.
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Function
+     * @param {Function} func The function to debounce.
+     * @param {number} [wait=0] The number of milliseconds to delay.
+     * @param {Object} [options={}] The options object.
+     * @param {boolean} [options.leading=false]
+     *  Specify invoking on the leading edge of the timeout.
+     * @param {number} [options.maxWait]
+     *  The maximum time `func` is allowed to be delayed before it's invoked.
+     * @param {boolean} [options.trailing=true]
+     *  Specify invoking on the trailing edge of the timeout.
+     * @returns {Function} Returns the new debounced function.
+     * @example
+     *
+     * // Avoid costly calculations while the window size is in flux.
+     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+     *
+     * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+     * jQuery(element).on('click', _.debounce(sendMail, 300, {
+     *   'leading': true,
+     *   'trailing': false
+     * }));
+     *
+     * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+     * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+     * var source = new EventSource('/stream');
+     * jQuery(source).on('message', debounced);
+     *
+     * // Cancel the trailing debounced invocation.
+     * jQuery(window).on('popstate', debounced.cancel);
+     */
+    function debounce(func, wait, options) {
+      var lastArgs,
+          lastThis,
+          maxWait,
+          result,
+          timerId,
+          lastCallTime,
+          lastInvokeTime = 0,
+          leading = false,
+          maxing = false,
+          trailing = true;
+
+      if (typeof func != 'function') {
+        throw new TypeError(FUNC_ERROR_TEXT);
+      }
+      wait = toNumber(wait) || 0;
+      if (isObject(options)) {
+        leading = !!options.leading;
+        maxing = 'maxWait' in options;
+        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+        trailing = 'trailing' in options ? !!options.trailing : trailing;
+      }
+
+      function invokeFunc(time) {
+        var args = lastArgs,
+            thisArg = lastThis;
+
+        lastArgs = lastThis = undefined;
+        lastInvokeTime = time;
+        result = func.apply(thisArg, args);
+        return result;
+      }
+
+      function leadingEdge(time) {
+        // Reset any `maxWait` timer.
+        lastInvokeTime = time;
+        // Start the timer for the trailing edge.
+        timerId = setTimeout(timerExpired, wait);
+        // Invoke the leading edge.
+        return leading ? invokeFunc(time) : result;
+      }
+
+      function remainingWait(time) {
+        var timeSinceLastCall = time - lastCallTime,
+            timeSinceLastInvoke = time - lastInvokeTime,
+            result = wait - timeSinceLastCall;
+
+        return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
+      }
+
+      function shouldInvoke(time) {
+        var timeSinceLastCall = time - lastCallTime,
+            timeSinceLastInvoke = time - lastInvokeTime;
+
+        // Either this is the first call, activity has stopped and we're at the
+        // trailing edge, the system time has gone backwards and we're treating
+        // it as the trailing edge, or we've hit the `maxWait` limit.
+        return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
+          (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
+      }
+
+      function timerExpired() {
+        var time = now();
+        if (shouldInvoke(time)) {
+          return trailingEdge(time);
+        }
+        // Restart the timer.
+        timerId = setTimeout(timerExpired, remainingWait(time));
+      }
+
+      function trailingEdge(time) {
+        timerId = undefined;
+
+        // Only invoke if we have `lastArgs` which means `func` has been
+        // debounced at least once.
+        if (trailing && lastArgs) {
+          return invokeFunc(time);
+        }
+        lastArgs = lastThis = undefined;
+        return result;
+      }
+
+      function cancel() {
+        if (timerId !== undefined) {
+          clearTimeout(timerId);
+        }
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = undefined;
+      }
+
+      function flush() {
+        return timerId === undefined ? result : trailingEdge(now());
+      }
+
+      function debounced() {
+        var time = now(),
+            isInvoking = shouldInvoke(time);
+
+        lastArgs = arguments;
+        lastThis = this;
+        lastCallTime = time;
+
+        if (isInvoking) {
+          if (timerId === undefined) {
+            return leadingEdge(lastCallTime);
+          }
+          if (maxing) {
+            // Handle invocations in a tight loop.
+            timerId = setTimeout(timerExpired, wait);
+            return invokeFunc(lastCallTime);
+          }
+        }
+        if (timerId === undefined) {
+          timerId = setTimeout(timerExpired, wait);
+        }
+        return result;
+      }
+      debounced.cancel = cancel;
+      debounced.flush = flush;
+      return debounced;
+    }
+
+    /**
+     * Checks if `value` is the
+     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+     *
+     * @static
+     * @memberOf _
+     * @since 0.1.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+     * @example
+     *
+     * _.isObject({});
+     * // => true
+     *
+     * _.isObject([1, 2, 3]);
+     * // => true
+     *
+     * _.isObject(_.noop);
+     * // => true
+     *
+     * _.isObject(null);
+     * // => false
+     */
+    function isObject(value) {
+      var type = typeof value;
+      return !!value && (type == 'object' || type == 'function');
+    }
+
+    /**
+     * Checks if `value` is object-like. A value is object-like if it's not `null`
+     * and has a `typeof` result of "object".
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+     * @example
+     *
+     * _.isObjectLike({});
+     * // => true
+     *
+     * _.isObjectLike([1, 2, 3]);
+     * // => true
+     *
+     * _.isObjectLike(_.noop);
+     * // => false
+     *
+     * _.isObjectLike(null);
+     * // => false
+     */
+    function isObjectLike(value) {
+      return !!value && typeof value == 'object';
+    }
+
+    /**
+     * Checks if `value` is classified as a `Symbol` primitive or object.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+     * @example
+     *
+     * _.isSymbol(Symbol.iterator);
+     * // => true
+     *
+     * _.isSymbol('abc');
+     * // => false
+     */
+    function isSymbol(value) {
+      return typeof value == 'symbol' ||
+        (isObjectLike(value) && objectToString.call(value) == symbolTag);
+    }
+
+    /**
+     * Converts `value` to a number.
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to process.
+     * @returns {number} Returns the number.
+     * @example
+     *
+     * _.toNumber(3.2);
+     * // => 3.2
+     *
+     * _.toNumber(Number.MIN_VALUE);
+     * // => 5e-324
+     *
+     * _.toNumber(Infinity);
+     * // => Infinity
+     *
+     * _.toNumber('3.2');
+     * // => 3.2
+     */
+    function toNumber(value) {
+      if (typeof value == 'number') {
+        return value;
+      }
+      if (isSymbol(value)) {
+        return NAN;
+      }
+      if (isObject(value)) {
+        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+        value = isObject(other) ? (other + '') : other;
+      }
+      if (typeof value != 'string') {
+        return value === 0 ? value : +value;
+      }
+      value = value.replace(reTrim, '');
+      var isBinary = reIsBinary.test(value);
+      return (isBinary || reIsOctal.test(value))
+        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+        : (reIsBadHex.test(value) ? NAN : +value);
+    }
+
+    var lodash_debounce = debounce;
+
+    var debounce$1 = /*@__PURE__*/getDefaultExportFromCjs(lodash_debounce);
+
+    class ScreenElement {
+      constructor(main) {
+        var _a, _b, _c, _d, _e, _f;
+        this.LOG_ACTIVITY = true;
+        this._volume = 100;
+        this._isMuted = false;
+        this._isMutedByBrowser = false;
+        this.onForceMute = () => {
+          this._isMuted = true;
+          this._isMutedByBrowser = true;
+          this.dispatchVolumeEvent();
+        };
+        this._main = main;
+        this._logger = main.getLogger();
+        this._videoElement = document.createElement('video');
+        this._main.addEventListener("playbackForceMute", this.onForceMute, false);
+        let startVolume = (_b = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getSettingsData().getAudioData().startVolume) !== null && _b !== void 0 ? _b : 100;
+        let isMuted = (_d = (_c = this._main.getConfigManager()) === null || _c === void 0 ? void 0 : _c.getSettingsData().getAudioData().muted) !== null && _d !== void 0 ? _d : false;
+        if (((_e = this._main.getStorageManager()) === null || _e === void 0 ? void 0 : _e.getField("volume")) != null) startVolume = Number(this._main.getStorageManager().getField("volume"));
+        if (((_f = this._main.getStorageManager()) === null || _f === void 0 ? void 0 : _f.getField("muted")) != null) {
+          const savedValue = this._main.getStorageManager().getField("muted") == "true";
+          if (savedValue) {
+            isMuted = true;
+            this._isMutedByBrowser = true;
+          }
+        }
+        this._volume = startVolume;
+        this._isMuted = isMuted;
+        if (this.LOG_ACTIVITY) this._logger.info(this, "VideoElement :: Start Volume: " + this._volume + " | Muted: " + this._isMuted);
+        this._videoElement.volume = this._volume / 100;
+        this._videoElement.muted = this._isMuted;
+        this._videoElement.setAttribute('playsinline', 'playsinline');
+        this._videoElement.setAttribute('webkit-playsinline', 'webkit-playsinline');
+        this._main.dispatchEvent("videoElementCreate", {
+          ref: this._main,
+          videoElement: this._videoElement
+        });
+        this.initialize();
+      }
+      initialize() {
+        this._videoElement.onload = function (event) {};
+        this._videoElement.onstalled = event => {
+          this._logger.info(this, "VideoElement :: onstalled");
+        };
+        this._videoElement.onerror = event => {
+          this._logger.info(this, "VideoElement :: onerror :: " + JSON.stringify(event));
+        };
+        this._videoElement.onvolumechange = () => {
+          this.dispatchVolumeEvent();
+        };
+        this._videoElement.onpause = () => {};
+        this._videoElement.ontimeupdate = function (event) {};
+        this._videoElement.onended = event => {
+          this._logger.info(this, "VideoElement :: onended");
+        };
+        this._videoElement.onplay = () => {};
+      }
+      setVolume(value) {
+        if (this._isMuted && value > 0) this.setMuted(false);
+        this._volume = value;
+        this._videoElement.volume = value / 100;
+        this._main.getStorageManager().saveField("volume", String(value));
+        if (value == 0) this.setMuted(true);
+      }
+      getVolume() {
+        return this._volume;
+      }
+      setMuted(isMuted) {
+        this._isMuted = isMuted;
+        this._videoElement.muted = isMuted;
+        this._isMutedByBrowser = false;
+        this._main.getStorageManager().saveField("muted", String(isMuted));
+        if (this.getVolume() == 0 && !isMuted) this.setVolume(100);
+      }
+      getIfMuted() {
+        return this._isMuted;
+      }
+      dispatchVolumeEvent() {
+        const action = !this._isMutedByBrowser ? "user" : "browser";
+        const eventObj = {
+          volume: this._volume,
+          isMuted: this._isMuted,
+          type: action
+        };
+        if (this.LOG_ACTIVITY) this._logger.info(this, "ScreenElement :: Event: onVolumeChange: " + JSON.stringify(eventObj));
+        this._main.dispatchEvent("volumeChange", {
+          ref: this._main,
+          volume: this._volume,
+          muted: this._isMuted,
+          invokedBy: action
+        });
+      }
+      getVideoElement() {
+        return this._videoElement;
+      }
+    }
+
+    class DomUtilities {
+      static calculateDimensionsWithMargins(element) {
+        const style = window.getComputedStyle(element);
+        const rect = element.getBoundingClientRect();
+        const paddingLeft = parseFloat(style.paddingLeft);
+        const paddingRight = parseFloat(style.paddingRight);
+        const paddingTop = parseFloat(style.paddingTop);
+        const paddingBottom = parseFloat(style.paddingBottom);
+        const borderLeft = parseFloat(style.borderLeftWidth);
+        const borderRight = parseFloat(style.borderRightWidth);
+        const borderTop = parseFloat(style.borderTopWidth);
+        const borderBottom = parseFloat(style.borderBottomWidth);
+        const width = rect.width - paddingLeft - paddingRight - borderLeft - borderRight;
+        const height = rect.height - paddingTop - paddingBottom - borderTop - borderBottom;
+        return {
+          width,
+          height
+        };
+      }
+    }
+
+    class StageController {
+      constructor(main) {
+        this._containerWidth = 0;
+        this._tempContainerWidth = 0;
+        this._containerHeight = 0;
+        this._tempContainerHeight = 0;
+        this._videoWidth = 0;
+        this._videoHeight = 0;
+        this._scalingMode = ScalingType.FILL;
+        this.isInFullScreenMode = false;
+        this._autoResizeEnabled = true;
+        this.onFullScreenChange = () => {
+          if (document.fullscreenElement == null) {
+            this.isInFullScreenMode = false;
+            this._logger.info(this, "The library has exited FullScreen mode!");
+            this._main.dispatchEvent("fullScreenExit", {
+              ref: this._main
+            });
+          } else {
+            this.isInFullScreenMode = true;
+            this._logger.info(this, "The library has entered FullScreen mode!");
+            this._main.dispatchEvent("fullScreenEnter", {
+              ref: this._main
+            });
+          }
+        };
+        this.onResize = () => {
+          if (this._parentElement != null) {
+            const calcMethod = this._main.getConfigManager().getSettingsData().getVideoData().parentSizeCalculationMethod;
+            this._videoContainer.style.display = "none";
+            switch (calcMethod) {
+              case SizeCalculationType.CLIENT_DIMENSIONS:
+                this._tempContainerWidth = this._parentElement.clientWidth;
+                this._tempContainerHeight = this._parentElement.clientHeight;
+                break;
+              case SizeCalculationType.BOUNDING_BOX:
+                this._tempContainerWidth = this._parentElement.getBoundingClientRect().width;
+                this._tempContainerHeight = this._parentElement.getBoundingClientRect().height;
+                break;
+              case SizeCalculationType.FULL_BOX:
+                this._tempContainerWidth = DomUtilities.calculateDimensionsWithMargins(this._parentElement).width;
+                this._tempContainerHeight = DomUtilities.calculateDimensionsWithMargins(this._parentElement).height;
+                break;
+            }
+            this._logger.info(this, "onResize called: " + this._tempContainerWidth + "x" + this._tempContainerHeight + " (" + calcMethod + ")");
+            this.resizeVideoContainer();
+            this.scaleVideo();
+            this._videoContainer.style.display = "block";
+            this._main.dispatchEvent("resizeUpdate", {
+              ref: this._main,
+              width: this._tempContainerWidth,
+              height: this._tempContainerHeight
+            });
+          }
+        };
+        this._main = main;
+        this._logger = main.getLogger();
+        this._logger.info(this, "Creating new StageController");
+        this.initialize();
+      }
+      initialize() {
+        var _a, _b, _c, _d, _e, _f;
+        const containerID = (_d = (_c = (_b = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getSettingsData()) === null || _b === void 0 ? void 0 : _b.getVideoData()) === null || _c === void 0 ? void 0 : _c.containerID) !== null && _d !== void 0 ? _d : null;
+        this._scalingMode = (_f = (_e = this._main.getConfigManager()) === null || _e === void 0 ? void 0 : _e.getSettingsData().getVideoData().scalingMode) !== null && _f !== void 0 ? _f : ScalingType.FILL;
+        this._videoContainer = document.createElement('div');
+        this._videoContainer.setAttribute("id", "stormLibrary_" + this._main.getStreamerID());
+        this._videoContainer.style.overflow = "hidden";
+        this._videoContainer.style.position = "relative";
+        this._videoContainer.classList.add("stormLibrary");
+        this._screenElement = new ScreenElement(this._main);
+        this._videoContainer.appendChild(this._screenElement.getVideoElement());
+        const debounceValue = this._main.getConfigManager().getSettingsData().getVideoData().resizeDebounce;
+        if (debounceValue > 0) {
+          this._resizeObserver = new ResizeObserver(debounce$1(() => () => {
+            if (this._autoResizeEnabled) this.onResize();
+          }, debounceValue, {
+            leading: false,
+            trailing: true
+          }));
+        } else {
+          this._resizeObserver = new ResizeObserver(() => {
+            if (this._autoResizeEnabled) this.onResize();
+          });
+        }
+        document.addEventListener('fullscreenchange', this.onFullScreenChange, false);
+        document.addEventListener('webkitfullscreenchange', this.onFullScreenChange, false);
+        document.addEventListener('mozfullscreenchange', this.onFullScreenChange, false);
+        document.addEventListener('webkitendfullscreen', this.onFullScreenChange, false);
+        this._screenElement.getVideoElement().addEventListener('webkitendfullscreen', this.onFullScreenChange, false);
+        if (containerID) {
+          this.attachToParent(containerID);
+        } else this._logger.warning(this, `Could not create HTMLObject for the library - "containerID" was not provided`);
+      }
+      attachToParent(container) {
+        let result = false;
+        let tempParentElement = null;
+        if (typeof container === "string") {
+          this._logger.info(this, "Attaching container to ID: " + container);
+          tempParentElement = document.getElementById(container);
+        } else if (container instanceof HTMLElement) {
+          this._logger.info(this, "Attaching container to HTMLElement: " + container);
+          tempParentElement = container;
+        }
+        if (tempParentElement === this._parentElement) {
+          this._logger.warning(this, "attachToParent :: container is the same");
+          return false;
+        }
+        if (tempParentElement && this._videoContainer) {
+          this._parentElement = tempParentElement;
+          this._parentElement.appendChild(this._videoContainer);
+          this._resizeObserver.observe(this._parentElement);
+          this._parentElement.addEventListener("transitionend", () => {
+            this.onResize();
+          });
+          this._main.dispatchEvent("containerChange", {
+            ref: this._main,
+            container: this._parentElement
+          });
+          this.onResize();
+          result = true;
+        } else {
+          this._logger.warning(this, "attachToParent :: container was not found");
+        }
+        return result;
+      }
+      detachFromParent() {
+        let result = false;
+        if (this._parentElement != null && this._videoContainer != null) {
+          this._logger.info(this, "Detaching from parent: " + this._videoContainer);
+          this._parentElement.removeChild(this._videoContainer);
+          if (this._resizeObserver) {
+            this._resizeObserver.unobserve(this._parentElement);
+            this._resizeObserver.disconnect();
+          }
+          if (this._autoResizeEnabled) this._parentElement.removeEventListener("transitionend", this.onResize);
+          this._main.dispatchEvent("containerChange", {
+            ref: this._main,
+            container: null
+          });
+          result = true;
+        } else {
+          this._logger.info(this, "Failed detaching from parent!");
+        }
+        this._parentElement = null;
+        return result;
+      }
+      resizeVideoContainer() {
+        const isWidthInPX = this._main.getConfigManager().getSettingsData().getVideoData().videoWidthInPixels;
+        const isHeightInPX = this._main.getConfigManager().getSettingsData().getVideoData().videoHeightInPixels;
+        const videoWidthVal = this._main.getConfigManager().getSettingsData().getVideoData().videoWidthValue;
+        const videoHeightVal = this._main.getConfigManager().getSettingsData().getVideoData().videoHeightValue;
+        const aspectRatio = this._main.getConfigManager().getSettingsData().getVideoData().aspectRatio;
+        let finalVideoWidth = 0;
+        let finalVideoHeight = 0;
+        let aspectWRatio = Number(aspectRatio.split(":")[0]);
+        let aspectHRatio = Number(aspectRatio.split(":")[1]);
+        if (aspectRatio == "none") {
+          if (isWidthInPX) {
+            finalVideoWidth = videoWidthVal;
+          } else {
+            if (this._parentElement != null) finalVideoWidth = this._tempContainerWidth * videoWidthVal / 100;
+          }
+          if (isHeightInPX) {
+            finalVideoHeight = videoHeightVal;
+          } else {
+            if (this._parentElement != null) {
+              finalVideoHeight = this._tempContainerHeight * videoHeightVal / 100;
+              if (finalVideoHeight == 0 && this._videoHeight != 0 && this._videoWidth != 0) finalVideoHeight = this._videoHeight * finalVideoWidth / this._videoWidth;
+            }
+          }
+        } else {
+          if (isWidthInPX) {
+            finalVideoWidth = videoWidthVal;
+          } else {
+            if (this._parentElement != null) finalVideoWidth = this._tempContainerWidth * videoWidthVal / 100;
+          }
+          finalVideoHeight = finalVideoWidth * aspectHRatio / aspectWRatio;
+        }
+        this._containerWidth = Math.ceil(finalVideoWidth);
+        this._containerHeight = Math.ceil(finalVideoHeight);
+        this._videoWidth = this._containerWidth;
+        this._videoHeight = this._containerHeight;
+        if (this._videoContainer !== null) {
+          this._videoContainer.style.width = this._containerWidth + "px";
+          this._videoContainer.style.height = this._containerHeight + "px";
+        }
+      }
+      scaleVideo() {
+        if (this._screenElement !== null) {
+          let videoX = 0;
+          let videoY = 0;
+          let videoWidth = 0;
+          let videoHeight = 0;
+          switch (this._scalingMode) {
+            case ScalingType.FILL:
+              {
+                videoWidth = this._containerWidth;
+                videoHeight = this._containerHeight;
+              }
+              break;
+            case ScalingType.CROP:
+              {
+                videoWidth = this._containerWidth;
+                videoHeight = this._videoHeight * this._containerWidth / this._videoWidth;
+                if (videoHeight >= this._containerHeight) {
+                  videoX = 0;
+                  videoY = (videoHeight - this._containerHeight) / 2 * -1;
+                } else {
+                  videoHeight = this._containerHeight;
+                  videoWidth = this._videoWidth * this._containerHeight / this._videoHeight;
+                  videoY = 0;
+                  videoX = (videoWidth - this._containerWidth) / 2 * -1;
+                }
+              }
+              break;
+            case ScalingType.LETTER_BOX:
+              {
+                videoWidth = this._containerWidth;
+                videoHeight = this._videoHeight * this._containerWidth / this._videoWidth;
+                if (videoHeight <= this._containerHeight) {
+                  videoX = 0;
+                  videoY = (videoHeight - this._containerHeight) / 2 * -1;
+                  if (videoHeight > this._containerHeight) {
+                    videoHeight = this._containerHeight;
+                    videoWidth = this._videoWidth * this._containerHeight / this._videoHeight;
+                    videoY = 0;
+                    videoX = (videoWidth - this._containerWidth) / 2 * -1;
+                  }
+                } else {
+                  videoHeight = this._containerHeight;
+                  videoWidth = this._videoWidth * this._containerHeight / this._videoHeight;
+                  videoY = 0;
+                  videoX = (videoWidth - this._containerWidth) / 2 * -1;
+                }
+              }
+              break;
+            case ScalingType.ORIGINAL:
+              {
+                videoWidth = this._videoWidth;
+                videoHeight = this._videoHeight;
+                videoX = (this._videoWidth - this._containerWidth) / -2;
+                videoY = (this._videoHeight - this._containerHeight) / -2;
+                break;
+              }
+          }
+          this._screenElement.getVideoElement().style.left = Math.floor(videoX) + "px";
+          this._screenElement.getVideoElement().style.top = Math.floor(videoY) + "px";
+          this._screenElement.getVideoElement().style.width = Math.ceil(videoWidth) + "px";
+          this._screenElement.getVideoElement().style.height = Math.ceil(videoHeight) + "px";
+          this._screenElement.getVideoElement().style.position = "absolute";
+          this._screenElement.getVideoElement().style.objectFit = "fill";
+        }
+      }
+      enterFullScreen() {
+        var _a, _b, _c;
+        if ((_a = this._screenElement) === null || _a === void 0 ? void 0 : _a.getVideoElement().webkitEnterFullScreen) {
+          (_b = this._screenElement) === null || _b === void 0 ? void 0 : _b.getVideoElement().webkitEnterFullScreen();
+        } else {
+          (_c = this._screenElement) === null || _c === void 0 ? void 0 : _c.getVideoElement().requestFullscreen();
+        }
+      }
+      exitFullScreen() {
+        var _a;
+        if ((_a = this._screenElement) === null || _a === void 0 ? void 0 : _a.getVideoElement().webkitExitFullscreen) {
+          document.webkitExitFullscreen();
+        } else {
+          document.exitFullscreen();
+        }
+      }
+      isFullScreenMode() {
+        return this.isInFullScreenMode;
+      }
+      setDimension(key, value) {
+        const dimensionKey = key === 'width' ? 'videoWidth' : 'videoHeight';
+        let valueInPixels;
+        let numericValue;
+        if (typeof value === "number") {
+          numericValue = value;
+          valueInPixels = true;
+        } else if (typeof value === "string") {
+          numericValue = parseInt(value);
+          valueInPixels = value.toLowerCase().endsWith('px');
+        } else {
+          throw new Error(`Unknown value for parameter "${key}" - it must be a number or a string!`);
+        }
+        this._main.getConfigManager().getSettingsData().getVideoData()[`${dimensionKey}Value`] = numericValue;
+        this._main.getConfigManager().getSettingsData().getVideoData()[`${dimensionKey}InPixels`] = valueInPixels;
+        this.resizeVideoContainer();
+        this.scaleVideo();
+      }
+      setSize(width, height) {
+        this.setDimension('width', width);
+        this.setDimension('height', height);
+      }
+      setWidth(width) {
+        this.setDimension('width', width);
+      }
+      setHeight(height) {
+        this.setDimension('height', height);
+      }
+      getParentElement() {
+        return this._parentElement;
+      }
+      setScalingMode(newMode) {
+        switch (newMode.toLowerCase()) {
+          case "fill":
+            this._scalingMode = ScalingType.FILL;
+            break;
+          case "crop":
+            this._scalingMode = ScalingType.CROP;
+            break;
+          case "letterbox":
+            this._scalingMode = ScalingType.LETTER_BOX;
+            break;
+          case "original":
+            this._scalingMode = ScalingType.ORIGINAL;
+            break;
+        }
+        this.scaleVideo();
+      }
+      getContainerWidth() {
+        return this._containerWidth;
+      }
+      getContainerHeight() {
+        return this._containerHeight;
+      }
+      getScalingModeAsString() {
+        let scalingName = "";
+        switch (this._scalingMode) {
+          case ScalingType.FILL:
+            scalingName = "fill";
+            break;
+          case ScalingType.CROP:
+            scalingName = "crop";
+            break;
+          case ScalingType.LETTER_BOX:
+            scalingName = "letterbox";
+            break;
+          case ScalingType.ORIGINAL:
+            scalingName = "original";
+            break;
+        }
+        return scalingName;
+      }
+      getScalingMode() {
+        return this._scalingMode;
+      }
+      getScreenElement() {
+        return this._screenElement;
+      }
+      getContainer() {
+        return this._videoContainer;
+      }
+      destroy() {
+        this.detachFromParent();
+      }
+    }
+    StageController.LOG_ACTIVITY = true;
+
+    class MungeSDP {
+      constructor() {}
+      addAudio(sdpStr, audioLine) {
+        const sdpLines = sdpStr.split(/\r\n/);
+        let sdpSection = '';
+        let sdpStrRet = '';
+        let done = false;
+        for (const sdpLine of sdpLines) {
+          if (sdpLine.length <= 0) continue;
+          if (sdpLine.indexOf('m=audio') === 0) {
+            sdpSection = 'audio';
+          } else if (sdpLine.indexOf('m=video') === 0) {
+            sdpSection = 'video';
+          }
+          sdpStrRet += sdpLine;
+          sdpStrRet += '\r\n';
+          if (sdpSection === 'audio') {
+            if ('a=rtcp-mux'.localeCompare(sdpLine) === 0 && !done) {
+              sdpStrRet += audioLine;
+              done = true;
+            }
+          }
+        }
+        return sdpStrRet;
+      }
+      addVideo(sdpStr, videoLine) {
+        const sdpLines = sdpStr.split(/\r\n/);
+        let sdpStrRet = '';
+        let done = false;
+        let rtcpSize = false;
+        for (const sdpLine of sdpLines) {
+          if (sdpLine.length <= 0) continue;
+          if (sdpLine.includes("a=rtcp-rsize")) {
+            rtcpSize = true;
+          }
+          if (sdpLine.includes("a=rtcp-mux")) ;
+        }
+        let foundMVideo = false;
+        for (const sdpLine of sdpLines) {
+          if (sdpLine.startsWith("m=video")) {
+            foundMVideo = true;
+          }
+          sdpStrRet += sdpLine;
+          sdpStrRet += '\r\n';
+          if (foundMVideo) {
+            if ('a=rtcp-rsize'.localeCompare(sdpLine) === 0 && !done && rtcpSize) {
+              sdpStrRet += videoLine;
+              done = true;
+            }
+            if ('a=rtcp-mux'.localeCompare(sdpLine) === 0 && done && !rtcpSize) {
+              sdpStrRet += videoLine;
+              done = true;
+            }
+            if ('a=rtcp-mux'.localeCompare(sdpLine) === 0 && !done && !rtcpSize) {
+              done = true;
+            }
+          }
+        }
+        return sdpStrRet;
+      }
+      deliverCheckLine(profile, type) {
+        for (const line in MungeSDP.SDPOutput) {
+          const lineInUse = MungeSDP.SDPOutput[line];
+          if (lineInUse.includes(profile)) {
+            if (profile.includes("VP9") || profile.includes("VP8")) {
+              let output = "";
+              const outputs = lineInUse.split(/\r\n/);
+              for (const transport of outputs) {
+                output += transport;
+                output += "\r\n";
+              }
+              if (type.includes("audio")) {
+                MungeSDP.audioIndex = parseInt(line);
+              }
+              if (type.includes("video")) {
+                MungeSDP.videoIndex = parseInt(line);
+              }
+              return output;
+            }
+            if (type.includes("audio")) {
+              MungeSDP.audioIndex = parseInt(line);
+            }
+            if (type.includes("video")) {
+              MungeSDP.videoIndex = parseInt(line);
+            }
+            return lineInUse;
+          }
+        }
+        return '';
+      }
+      checkLine(line) {
+        if (line.startsWith("a=rtpmap") || line.startsWith("a=rtcp-fb") || line.startsWith("a=fmtp")) {
+          const res = line.split(":");
+          if (res.length > 1) {
+            const number = res[1].split(" ");
+            if (!isNaN(parseInt(number[0]))) {
+              if (!number[1].startsWith("http") && !number[1].startsWith("ur")) {
+                let currentString = MungeSDP.SDPOutput[number[0]];
+                if (!currentString) {
+                  currentString = "";
+                }
+                currentString += line + "\r\n";
+                MungeSDP.SDPOutput[number[0]] = currentString;
+                return false;
+              }
+            }
+          }
+        }
+        return true;
+      }
+      getrtpMapID(line) {
+        const findid = new RegExp('a=rtpmap:(\\d+) (\\w+)/(\\d+)');
+        const found = line.match(findid);
+        return found && found.length >= 3 ? found : null;
+      }
+      mungeSDPPublish(sdpStr, mungeData) {
+        MungeSDP.SDPOutput = {};
+        MungeSDP.videoChoice = "42e01f";
+        MungeSDP.audioChoice = "opus";
+        MungeSDP.videoIndex = -1;
+        MungeSDP.audioIndex = -1;
+        const sdpLines = sdpStr.split(/\r\n/);
+        let sdpSection = 'header';
+        let hitMID = false;
+        let sdpStrRet = '';
+        if (mungeData.videoCodec != null && mungeData.videoCodec !== '') MungeSDP.videoChoice = mungeData.videoCodec;
+        if (mungeData.audioCodec != null && mungeData.audioCodec !== '') MungeSDP.audioChoice = mungeData.audioCodec;
+        for (const sdpLine of sdpLines) {
+          if (sdpLine.length <= 0) continue;
+          const doneCheck = this.checkLine(sdpLine);
+          if (!doneCheck) continue;
+          sdpStrRet += sdpLine;
+          sdpStrRet += '\r\n';
+        }
+        sdpStrRet = this.addAudio(sdpStrRet, this.deliverCheckLine(MungeSDP.audioChoice, "audio"));
+        sdpStrRet = this.addVideo(sdpStrRet, this.deliverCheckLine(MungeSDP.videoChoice, "video"));
+        const newSdpLines = sdpStrRet.split(/\r\n/);
+        sdpStrRet = '';
+        for (const sdpLine of newSdpLines) {
+          if (sdpLine.length <= 0) continue;
+          let audioMLines;
+          if (sdpLine.indexOf("m=audio") === 0 && MungeSDP.audioIndex !== -1) {
+            audioMLines = sdpLine.split(" ");
+            sdpStrRet += audioMLines[0] + " " + audioMLines[1] + " " + audioMLines[2] + " " + MungeSDP.audioIndex + "\r\n";
+            sdpSection = 'audio';
+            hitMID = false;
+            continue;
+          }
+          if (sdpLine.indexOf("m=video") === 0 && MungeSDP.videoIndex !== -1) {
+            audioMLines = sdpLine.split(" ");
+            sdpStrRet += audioMLines[0] + " " + audioMLines[1] + " " + audioMLines[2] + " " + MungeSDP.videoIndex + "\r\n";
+            sdpSection = 'video';
+            hitMID = false;
+            continue;
+          }
+          sdpStrRet += sdpLine;
+          if (sdpLine.indexOf("a=rtpmap") === 0) {
+            sdpSection = 'bandwidth';
+            hitMID = false;
+          }
+          if (UserCapabilities.getBrowserName().toLowerCase() === 'chrome' || UserCapabilities.getBrowserName().toLowerCase() === 'safari') {
+            if (sdpLine.indexOf("a=mid:") === 0 || sdpLine.indexOf("a=rtpmap") === 0) {
+              if (!hitMID) {
+                if ('audio'.localeCompare(sdpSection) === 0) {
+                  if (mungeData.audioBitrate !== undefined && mungeData.audioBitrate !== '') {
+                    sdpStrRet += '\r\nb=CT:' + mungeData.audioBitrate;
+                    sdpStrRet += '\r\nb=AS:' + mungeData.audioBitrate;
+                  }
+                  hitMID = true;
+                } else if ('video'.localeCompare(sdpSection) === 0) {
+                  if (mungeData.videoBitrate !== undefined && mungeData.videoBitrate !== '') {
+                    sdpStrRet += '\r\nb=CT:' + mungeData.videoBitrate;
+                    sdpStrRet += '\r\nb=AS:' + mungeData.videoBitrate;
+                    if (mungeData.videoFrameRate !== undefined) {
+                      sdpStrRet += '\r\na=framerate:' + mungeData.videoFrameRate;
+                    }
+                  }
+                  hitMID = true;
+                } else if (UserCapabilities.getBrowserName().toLowerCase() === 'chrome' && 'bandwidth'.localeCompare(sdpSection) === 0) {
+                  const rtpmapID = this.getrtpMapID(sdpLine);
+                  if (rtpmapID !== null) {
+                    const match = rtpmapID[2].toLowerCase();
+                    if ('vp9'.localeCompare(match) === 0 || 'vp8'.localeCompare(match) === 0 || 'h264'.localeCompare(match) === 0 || 'red'.localeCompare(match) === 0 || 'ulpfec'.localeCompare(match) === 0 || 'rtx'.localeCompare(match) === 0) {
+                      if (mungeData.videoBitrate !== undefined) {
+                        sdpStrRet += '\r\na=fmtp:' + rtpmapID[1] + ' x-google-min-bitrate=' + mungeData.videoBitrate + ';x-google-max-bitrate=' + mungeData.videoBitrate;
+                      }
+                    }
+                    if ('opus'.localeCompare(match) === 0 || 'isac'.localeCompare(match) === 0 || 'g722'.localeCompare(match) === 0 || 'pcmu'.localeCompare(match) === 0 || 'pcma'.localeCompare(match) === 0 || 'cn'.localeCompare(match) === 0) {
+                      if (mungeData.audioBitrate !== undefined) {
+                        sdpStrRet += '\r\na=fmtp:' + rtpmapID[1] + ' x-google-min-bitrate=' + mungeData.audioBitrate + ';x-google-max-bitrate=' + mungeData.audioBitrate;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          if (UserCapabilities.getBrowserName().toLowerCase() === 'firefox') {
+            if (sdpLine.indexOf("c=IN") === 0) {
+              if ('audio'.localeCompare(sdpSection) === 0) {
+                if (mungeData.audioBitrate !== '') {
+                  if (typeof mungeData.audioBitrate === "string") {
+                    const audioBitrate = parseInt(mungeData.audioBitrate);
+                    const audioBitrateTIAS = audioBitrate * 1000 * 0.95 - 50 * 40 * 8;
+                    sdpStrRet += "\r\nb=TIAS:" + audioBitrateTIAS + "\r\n";
+                    sdpStrRet += "b=AS:" + audioBitrate + "\r\n";
+                    sdpStrRet += "b=CT:" + audioBitrate + "\r\n";
+                  }
+                }
+                continue;
+              }
+              if ('video'.localeCompare(sdpSection) === 0) {
+                if (mungeData.videoBitrate !== '') {
+                  if (typeof mungeData.videoBitrate === "string") {
+                    const videoBitrate = parseInt(mungeData.videoBitrate);
+                    const videoBitrateTIAS = videoBitrate * 1000 * 0.95 - 50 * 40 * 8;
+                    sdpStrRet += "\r\nb=TIAS:" + videoBitrateTIAS * 1000 + "\r\n";
+                    sdpStrRet += "b=AS:" + videoBitrate + "\r\n";
+                    sdpStrRet += "b=CT:" + videoBitrate + "\r\n";
+                  }
+                }
+                continue;
+              }
+            }
+          }
+          sdpStrRet += '\r\n';
+        }
+        return sdpStrRet;
+      }
+      mungeSDPPlay(sdpStr) {
+        const sdpLines = sdpStr.split(/\r\n/);
+        let sdpStrRet = '';
+        for (const sdpLine of sdpLines) {
+          if (sdpLine.length === 0) continue;
+          if (sdpLine.includes("profile-level-id")) {
+            let profileLevelId = sdpLine.substr(sdpLine.indexOf("profile-level-id") + 17, 6);
+            let profile = Number('0x' + profileLevelId.substr(0, 2));
+            let constraint = Number('0x' + profileLevelId.substr(2, 2));
+            let level = Number('0x' + profileLevelId.substr(4, 2));
+            if (profile > 0x42) {
+              profile = 0x42;
+              constraint = 0xE0;
+              level = 0x1F;
+            }
+            if (constraint === 0x00) {
+              constraint = 0xE0;
+            }
+            const newProfileLevelId = ("00" + profile.toString(16)).slice(-2).toLowerCase() + ("00" + constraint.toString(16)).slice(-2).toLowerCase() + ("00" + level.toString(16)).slice(-2).toLowerCase();
+            sdpStrRet += sdpLine.replace(profileLevelId, newProfileLevelId);
+          } else {
+            sdpStrRet += sdpLine;
+          }
+          sdpStrRet += '\r\n';
+        }
+        return sdpStrRet;
+      }
+    }
+    MungeSDP.SDPOutput = {};
+
+    var InputType;
+    (function (InputType) {
+      InputType[InputType["VIDEO_INPUT"] = 0] = "VIDEO_INPUT";
+      InputType[InputType["AUDIO_INPUT"] = 1] = "AUDIO_INPUT";
+    })(InputType || (InputType = {}));
+
+    class InputDevice {
+      constructor(inputDevice, number) {
+        this._groupID = "";
+        this._isSelected = false;
+        if (inputDevice !== undefined && inputDevice !== null) {
+          if (inputDevice.deviceId !== undefined && inputDevice.deviceId !== null) this._id = inputDevice.deviceId;else throw new Error("no deviceID");
+          if (inputDevice.kind !== undefined && inputDevice.kind !== null) {
+            switch (inputDevice.kind) {
+              case "videoinput":
+                this._inputType = InputType.VIDEO_INPUT;
+                break;
+              case "audioinput":
+                this._inputType = InputType.AUDIO_INPUT;
+                break;
+              default:
+                throw new Error("incorrect kind");
+            }
+          } else throw new Error("no device kind");
+          if (inputDevice.label !== null && inputDevice.label !== "") {
+            this._label = this.cleanLabel(inputDevice.label);
+          } else this._label = this._inputType == InputType.VIDEO_INPUT ? "Camera " + number : "Microphone " + number;
+          if (inputDevice.groupId !== undefined && inputDevice.groupId !== null) this._groupID = inputDevice.groupId;
+        } else throw new Error("no input device");
+      }
+      cleanLabel(label) {
+        return label;
+      }
+      getLabel() {
+        return this._label;
+      }
+      getID() {
+        return this._id;
+      }
+      getGroupID() {
+        return this._groupID;
+      }
+      getIfSelected() {
+        return this._isSelected;
+      }
+      setSelected(isSelected) {
+        this._isSelected = isSelected;
+      }
+    }
+
+    class InputDeviceList {
+      constructor() {
+        this._internalList = new Array();
+      }
+      push(item) {
+        let alreadyExists = false;
+        if (this._internalList.length > 0) {
+          for (let i = 0; i < this._internalList.length; i++) {
+            if (this._internalList[i].getGroupID() !== "") {
+              if (this._internalList[i].getGroupID() == item.getGroupID()) {
+                alreadyExists = true;
+                this._internalList[i] = item;
+              }
+            }
+          }
+          if (alreadyExists == false) return this._internalList.push(item);else return this._internalList.length;
+        } else return this._internalList.push(item);
+      }
+      get(id) {
+        return this._internalList[id];
+      }
+      getSize() {
+        return this._internalList.length;
+      }
+      getArray() {
+        return this._internalList;
+      }
+    }
+
+    exports.PublishState = void 0;
+    (function (PublishState) {
+      PublishState["NOT_INITIALIZED"] = "NOT_INITIALIZED";
+      PublishState["INITIALIZED"] = "INITIALIZED";
+      PublishState["CONNECTING"] = "CONNECTING";
+      PublishState["PUBLISHED"] = "PUBLISHED";
+      PublishState["UNPUBLISHED"] = "UNPUBLISHED";
+      PublishState["STOPPED"] = "STOPPED";
+      PublishState["UNKNOWN"] = "UNKNOWN";
+      PublishState["ERROR"] = "ERROR";
+    })(exports.PublishState || (exports.PublishState = {}));
+
+    class SoundMeter {
+      constructor(main) {
+        this._instant = 0.0;
+        this._slow = 0.0;
+        this.clip = 0.0;
+        this._main = main;
+      }
+      attach(stream) {
+        this._stream = stream;
+        this.audioContext = new AudioContext();
+        this.microphone = this.audioContext.createMediaStreamSource(stream);
+        this.processor = this.audioContext.createScriptProcessor(2048, 1, 1);
+        this.microphone.connect(this.processor);
+        this.processor.connect(this.audioContext.destination);
+        this.processor.onaudioprocess = event => {
+          this.onAudioProcess(event);
+        };
+      }
+      detach() {
+        if (this.microphone !== null) this.microphone.disconnect();
+        if (this.processor !== null) this.processor.disconnect();
+      }
+      clear() {
+        this._instant = 0;
+        this._slow = 0;
+        this.clip = 0;
+      }
+      onAudioProcess(event) {
+        const input = event.inputBuffer.getChannelData(0);
+        let i;
+        let sum = 0.0;
+        let clipcount = 0;
+        for (i = 0; i < input.length; ++i) {
+          sum += input[i] * input[i];
+          if (Math.abs(input[i]) > 0.99) {
+            clipcount += 1;
+          }
+        }
+        this._instant = Math.sqrt(sum / input.length);
+        this._slow = 0.05 * this._instant + 0.95 * this._slow;
+        this.clip = clipcount / input.length;
+        console.log("sound", this._instant, this._slow);
+        this._main.dispatchEvent("soundMeter", {
+          ref: this._main,
+          high: this._instant,
+          low: this._slow
+        });
+      }
+    }
+
+    class PlaybackController {
+      constructor(main) {
+        this._isWindowActive = true;
+        this._peerConnectionConfig = {
+          'iceServers': []
+        };
+        this._isMicrophoneMuted = false;
+        this._constraints = {
+          video: {
+            width: {
+              min: "640",
+              ideal: "1024",
+              max: "1024"
+            },
+            height: {
+              min: "360",
+              ideal: "576",
+              max: "576"
+            },
+            frameRate: {
+              min: 24,
+              ideal: 30,
+              max: 30
+            }
+          },
+          audio: true
+        };
+        this._publishState = exports.PublishState.NOT_INITIALIZED;
+        this.onServerDisconnect = () => {};
+        this.onServerConnect = () => {
+          this._peerConnection = new RTCPeerConnection(this._peerConnectionConfig);
+          this._peerConnection.onicecandidate = event => {
+            this.onIceCandidate(event);
+          };
+          this._peerConnection.onconnectionstatechange = event => {
+            this.onConnectionStateChange(event);
+          };
+          this._peerConnection.onnegotiationneeded = event => {
+            this._peerConnection.createOffer(description => {
+              this.onDescriptionSuccess(description);
+            }, error => {
+              this.onDescriptionError(error);
+            }).catch(reason => {
+              console.log(reason);
+            });
+          };
+          let localTracks = this._stream.getTracks();
+          for (let localTrack in localTracks) {
+            this._peerConnection.addTrack(localTracks[localTrack], this._stream);
+          }
+        };
+        this.onDescriptionSuccess = description => {
+          var _a, _b, _c;
+          const streamInfo = {
+            applicationName: (_b = (_a = this._main.getNetworkController()) === null || _a === void 0 ? void 0 : _a.getConnection().getCurrentServer()) === null || _b === void 0 ? void 0 : _b.getApplication(),
+            streamName: (_c = this._main.getConfigManager()) === null || _c === void 0 ? void 0 : _c.getStreamData().streamKey,
+            sessionId: "[empty]"
+          };
+          description.sdp = this._mungeSDP.mungeSDPPublish(description.sdp, {
+            audioBitrate: "64",
+            videoBitrate: "1500",
+            videoFrameRate: 30,
+            videoCodec: "42e01f",
+            audioCodec: "opus"
+          });
+          this._peerConnection.setLocalDescription(description).then(() => {
+            var _a;
+            (_a = this._main.getNetworkController()) === null || _a === void 0 ? void 0 : _a.sendMessage('{"direction":"publish", "command":"sendOffer", "streamInfo":' + JSON.stringify(streamInfo) + ', "sdp":' + JSON.stringify(description) + '}');
+          }).catch(error => {
+            console.log(error);
+          });
+        };
+        this.visibilityChange = () => {
+          if (document.visibilityState === 'hidden') {
+            this.onWindowBlur();
+          } else if (document.visibilityState === 'visible') {
+            this.onWindowFocus();
+          }
+        };
+        this.onWindowBlur = () => {
+          if (this._isWindowActive) {
+            this._logger.warning(this, "Player window is no longer in focus!");
+          }
+          this._isWindowActive = false;
+        };
+        this.onWindowFocus = () => {
+          if (!this._isWindowActive) {
+            this._logger.info(this, "Player window is focused again!");
+          }
+          this._isWindowActive = true;
+        };
+        this._main = main;
+        this._logger = main.getLogger();
+        this._logger.info(this, "Creating new PlaybackController");
+        this._mungeSDP = new MungeSDP();
+        this._soundMeter = new SoundMeter(this._main);
+        this.initialize();
+      }
+      initialize() {
+        var _a, _b, _c;
+        this._main.addEventListener("serverConnect", this.onServerConnect, false);
+        this._main.addEventListener("serverDisconnect", this.onServerDisconnect, false);
+        document.addEventListener("visibilitychange", this.visibilityChange);
+        window.addEventListener("blur", this.onWindowBlur);
+        window.addEventListener("focus", this.onWindowFocus);
+        if ((_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getSettingsData().autoConnect) {
+          this._logger.info(this, "Initializing NetworkController (autoConnect is true)");
+          (_b = this._main.getNetworkController()) === null || _b === void 0 ? void 0 : _b.initialize();
+        } else this._logger.warning(this, "Warning - autoConnect is set to false, switching to standby mode!");
+        if (((_c = this._main.getConfigManager()) === null || _c === void 0 ? void 0 : _c.getStreamData().streamKey) != null) this.startWebRTC();
+      }
+      startWebRTC() {
+        try {
+          if (navigator.mediaDevices.getUserMedia) {
+            navigator.mediaDevices.getUserMedia(this._constraints).then(stream => {
+              this.onUserMediaSuccess(stream);
+            }).catch(error => {
+              this.onUserMediaError(error);
+            });
+          } else {
+            this._logger.error(this, "WebRTCStreamer :: Browser does not support WebRTC");
+            this._main.dispatchEvent("compatibilityError", {
+              ref: this._main,
+              message: "WebRTC is not supported"
+            });
+          }
+        } catch (error) {
+          this.onUserMediaError(error);
+        }
+      }
+      publish(streamKey) {
+        if (this._publishState == exports.PublishState.PUBLISHED) this.closeStream();
+        this._main.getConfigManager().getStreamData().streamKey = streamKey;
+        this.startWebRTC();
+      }
+      unpublish() {
+        this.closeStream();
+      }
+      onUserMediaSuccess(stream) {
+        var _a;
+        this._logger.success(this, "WebRTCStreamer :: WebRTC UserMedia successfully retrieved");
+        this._stream = stream;
+        this._soundMeter.attach(this._stream);
+        this.setPublishState(exports.PublishState.INITIALIZED);
+        if (this._cameraList == null || this._microphoneList == null) this.grabDevices();
+        const videoElement = this._main.getStageController().getScreenElement().getVideoElement();
+        videoElement.srcObject = stream;
+        videoElement.autoplay = true;
+        videoElement.playsInline = true;
+        (_a = this._main.getNetworkController()) === null || _a === void 0 ? void 0 : _a.start();
+      }
+      onUserMediaError(error) {
+        switch (error.message) {
+          case "Permission denied":
+            this._logger.warning(this, "WebRTCStreamer :: No permission to access camera & microphone");
+            this._main.dispatchEvent("inputDeviceDenied", {
+              ref: this._main
+            });
+            break;
+          case "The request is not allowed by the user agent or the platform in the current context, possibly because the user denied permission.":
+            this._logger.warning(this, "WebRTCStreamer :: No permission to access camera & microphone");
+            this._main.dispatchEvent("inputDeviceDenied", {
+              ref: this._main
+            });
+            break;
+          case "The request is not allowed by the user agent or the platform in the current context.":
+            this._logger.warning(this, "WebRTCStreamer :: No permission to access camera & microphone");
+            this._main.dispatchEvent("inputDeviceDenied", {
+              ref: this._main
+            });
+            break;
+          case "The object can not be found here.":
+            this._logger.warning(this, "WebRTCStreamer :: Could not access camera or microphone");
+            this._main.dispatchEvent("inputDeviceError", {
+              ref: this._main
+            });
+            break;
+          case "Requested device not found":
+            this._logger.warning(this, "WebRTCStreamer :: Could not access camera or microphone");
+            this._main.dispatchEvent("inputDeviceError", {
+              ref: this._main
+            });
+            break;
+          default:
+            this._logger.warning(this, "WebRTCStreamer :: Unsupported onUserMediaError: " + error.message);
+            break;
+        }
+      }
+      onSocketMessage(data) {
+        let msgJSON = JSON.parse(data);
+        let msgStatus = Number(msgJSON["status"]);
+        switch (msgStatus) {
+          case 200:
+            let sdpData = msgJSON['sdp'];
+            if (sdpData !== undefined) {
+              this._peerConnection.setRemoteDescription(new RTCSessionDescription(sdpData), () => {}, () => {});
+            }
+            let iceCandidates = msgJSON['iceCandidates'];
+            if (iceCandidates !== undefined) {
+              for (let index in iceCandidates) {
+                this._peerConnection.addIceCandidate(new RTCIceCandidate(iceCandidates[index]));
+              }
+            }
+            break;
+          case 503:
+            this._main.dispatchEvent("streamKeyInUse", {
+              ref: this._main,
+              streamKey: this._main.getConfigManager().getStreamData().streamKey
+            });
+            this.setPublishState(exports.PublishState.ERROR);
+            break;
+        }
+      }
+      onConnectionStateChange(event) {
+        if (event !== null) {
+          switch (event.currentTarget.connectionState) {
+            case "connecting":
+              this._logger.info(this, "WebRTCStreamer :: Event: onStreamerConnecting");
+              this.setPublishState(exports.PublishState.CONNECTING);
+              break;
+            case "connected":
+              this._logger.info(this, "WebRTCStreamer :: Event: onStreamerConnected");
+              this.setPublishState(exports.PublishState.PUBLISHED);
+              if (this._isMicrophoneMuted == true) this.muteMicrophone(false);
+              break;
+            case "disconnected":
+              this._logger.info(this, "WebRTCStreamer :: Event: onStreamerDisconnected");
+              this.setPublishState(exports.PublishState.UNPUBLISHED);
+              break;
+            case "failed":
+              this._logger.info(this, "WebRTCStreamer :: Event: onPlayerFailed");
+              this.setPublishState(exports.PublishState.ERROR);
+              break;
+            default:
+              this._logger.info(this, "WebRTCStreamer :: Unsupported onConnectionStateChange: " + event.currentTarget.connectionState);
+              break;
+          }
+        }
+      }
+      grabDevices() {
+        navigator.mediaDevices.enumerateDevices().then(devices => {
+          this._cameraList = new InputDeviceList();
+          this._microphoneList = new InputDeviceList();
+          for (let i = 0; i < devices.length; i++) {
+            try {
+              if (devices[i].kind === 'videoinput') {
+                let device = new InputDevice(devices[i], i);
+                this._cameraList.push(device);
+              } else if (devices[i].kind === 'audioinput') {
+                let device = new InputDevice(devices[i], i);
+                this._microphoneList.push(device);
+              }
+            } catch (error) {
+              this._logger.error(this, "WebRTCStreamer :: Input Device Error: " + error);
+            }
+          }
+          if (this._cameraList.getSize() == 0) {
+            this._main.dispatchEvent("noCameraFound", {
+              ref: this._main
+            });
+          } else if (this._microphoneList.getSize() == 0) {
+            this._main.dispatchEvent("noCameraFound", {
+              ref: this._main
+            });
+          } else {
+            this._logger.info(this, "Camera list:");
+            for (let i = 0; i < this._cameraList.getSize(); i++) this._logger.info(this, "=> [" + i + "] InputDevice: " + this._cameraList.get(i).getLabel());
+            this._logger.info(this, "Microphone list:");
+            for (let k = 0; k < this._microphoneList.getSize(); k++) this._logger.info(this, "=> [" + k + "] InputDevice: " + this._microphoneList.get(k).getLabel());
+            this._selectedCamera = this.pickCamera();
+            this._selectedMicrophone = this.pickMicrophone();
+          }
+        }).catch(() => {
+          this._main.dispatchEvent("inputDeviceError", {
+            ref: this._main
+          });
+        });
+      }
+      selectCamera(cameraID) {
+        var _a;
+        for (let i = 0; i < this._cameraList.getSize(); i++) {
+          if (this._cameraList.get(i).getID() == cameraID) {
+            this._selectedCamera = this._cameraList.get(i);
+            (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.saveField("cameraID", this._selectedCamera.getID());
+            break;
+          }
+        }
+        this.closeStream();
+        this._constraints.video.deviceId = this._selectedCamera.getID();
+        this.startWebRTC();
+      }
+      selectMicrophone(micID) {
+        var _a;
+        for (let i = 0; i < this._microphoneList.getSize(); i++) {
+          if (this._microphoneList.get(i).getID() == micID) {
+            this._selectedMicrophone = this._microphoneList.get(i);
+            (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.saveField("microphoneID", this._selectedMicrophone.getID());
+            break;
+          }
+        }
+        this.closeStream();
+        this._constraints.audio = {
+          deviceId: this._selectedMicrophone.getID()
+        };
+        this.startWebRTC();
+      }
+      pickCamera() {
+        var _a, _b;
+        for (let i = 0; i < this._cameraList.getSize(); i++) this._cameraList.get(i).setSelected(false);
+        let savedCameraID = (_b = (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.getField("cameraID")) !== null && _b !== void 0 ? _b : null;
+        if (this._selectedCamera == null || savedCameraID == null) this._selectedCamera = this._cameraList.get(0);else this.selectCamera(savedCameraID);
+        this._selectedCamera.setSelected(true);
+        this._main.dispatchEvent("deviceListUpdate", {
+          ref: this._main,
+          cameraList: this._cameraList.getArray(),
+          microphoneList: this._microphoneList.getArray()
+        });
+        return this._selectedCamera;
+      }
+      pickMicrophone() {
+        var _a, _b;
+        for (let i = 0; i < this._microphoneList.getSize(); i++) this._microphoneList.get(i).setSelected(false);
+        let savedMicID = (_b = (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.getField("microphoneID")) !== null && _b !== void 0 ? _b : null;
+        if (this._selectedMicrophone == null || savedMicID == null) this._selectedMicrophone = this._microphoneList.get(0);else this.selectMicrophone(savedMicID);
+        this._selectedMicrophone.setSelected(true);
+        this._main.dispatchEvent("deviceListUpdate", {
+          ref: this._main,
+          cameraList: this._cameraList.getArray(),
+          microphoneList: this._microphoneList.getArray()
+        });
+        return this._selectedMicrophone;
+      }
+      muteMicrophone(microphoneState) {
+        if (this._publishState == exports.PublishState.PUBLISHED) {
+          if (this._stream !== null) {
+            if (microphoneState) {
+              this._logger.success(this, "WebRTCStreamer :: Unmuting microphone");
+            } else {
+              this._logger.success(this, "WebRTCStreamer :: Muting microphone");
+            }
+            for (let i = 0; i < this._stream.getAudioTracks().length; i++) this._stream.getAudioTracks()[i].enabled = microphoneState;
+            this._isMicrophoneMuted = !microphoneState;
+          } else {
+            this._logger.warning(this, "WebRTCStreamer :: Stream object not present!");
+          }
+        } else {
+          this._logger.warning(this, "WebRTCStreamer :: Not ready to change microphone");
+        }
+      }
+      onDescriptionError(error) {
+        this._logger.info(this, "WebRTCStreamer :: onDescriptionError: " + JSON.stringify(error));
+      }
+      onIceCandidate(event) {
+        if (event.candidate !== null) ;
+      }
+      closeStream() {
+        if (this._stream) {
+          this._stream.getTracks().forEach(function (track) {
+            track.stop();
+          });
+        }
+        this._soundMeter.detach();
+        if (this._peerConnection !== undefined && this._peerConnection !== null) this._peerConnection.close();
+        this.setPublishState(exports.PublishState.UNPUBLISHED);
+      }
+      getCurrentCamera() {
+        return this._selectedCamera;
+      }
+      getCurrentMicrophone() {
+        return this._selectedMicrophone;
+      }
+      setPublishState(newState) {
+        this._publishState = newState;
+        this._main.dispatchEvent("publishStateChange", {
+          ref: this._main,
+          state: this._publishState
+        });
+      }
+      getCameraList() {
+        return this._cameraList.getArray();
+      }
+      getMicrophoneList() {
+        return this._microphoneList.getArray();
+      }
+      getPlayer() {
+        return this._selectedPlayer;
+      }
+      destroy() {
+        var _a;
+        this.closeStream();
+        (_a = this._selectedPlayer) === null || _a === void 0 ? void 0 : _a.clear();
+        this._selectedPlayer = null;
+        this._main.removeEventListener("serverConnect", this.onServerConnect);
+        document.removeEventListener("visibilitychange", this.visibilityChange);
+        window.removeEventListener("blur", this.onWindowBlur);
+        window.removeEventListener("focus", this.onWindowFocus);
+      }
+    }
+
+    var ConnectionState;
+    (function (ConnectionState) {
+      ConnectionState[ConnectionState["NOT_INITIALIZED"] = 0] = "NOT_INITIALIZED";
+      ConnectionState[ConnectionState["STARTED"] = 1] = "STARTED";
+      ConnectionState[ConnectionState["CONNECTING"] = 2] = "CONNECTING";
+      ConnectionState[ConnectionState["CONNECTED"] = 3] = "CONNECTED";
+      ConnectionState[ConnectionState["CLOSED"] = 4] = "CLOSED";
+      ConnectionState[ConnectionState["FAILED"] = 5] = "FAILED";
+    })(ConnectionState || (ConnectionState = {}));
+
+    class AbstractSocket {
+      constructor() {
+        this.CONNECTION_TIMEOUT = 5;
+        this.isBinary = true;
+        this._connectionState = ConnectionState.NOT_INITIALIZED;
+        this._messageCount = 0;
+        this._disconnectedByUser = false;
+        this._isConnected = false;
+        this._sequenceNumber = -1;
+      }
+      startConnection() {
+        this._disconnectedByUser = false;
+        this._messageCount = 0;
+        this._isConnected = false;
+        this._disconnectedByUser = false;
+        this._connectionState = ConnectionState.CONNECTING;
+        this.socket = new WebSocket(this.socketURL);
+        if (this.isBinary) this.socket.binaryType = "arraybuffer";
+        this.socket.onopen = event => {
+          clearTimeout(this._connectionTimeout);
+          this._sequenceNumber++;
+          this._connectionState = ConnectionState.CONNECTED;
+          this.onSocketOpen(event);
+        };
+        this.socket.onmessage = event => {
+          this._messageCount++;
+          this.onSocketMessage(event);
+        };
+        this.socket.onclose = event => {
+          clearTimeout(this._connectionTimeout);
+          if (this._connectionState == ConnectionState.CONNECTED) {
+            this._connectionState = ConnectionState.CLOSED;
+            this.onSocketClose(event);
+          } else {
+            this._connectionState = ConnectionState.FAILED;
+          }
+        };
+        this.socket.onerror = event => {
+          clearTimeout(this._connectionTimeout);
+          if (this._connectionState == ConnectionState.CONNECTING) this.onSocketError(event);
+          if (this._connectionState == ConnectionState.CONNECTED) {
+            try {
+              this.socket.close();
+            } catch (error) {}
+          }
+        };
+        this._connectionTimeout = setTimeout(() => {
+          try {
+            this.socket.close();
+          } catch (error) {}
+          if (this._connectionState == ConnectionState.CONNECTING) {
+            this._connectionState = ConnectionState.FAILED;
+            this.onSocketError(new ErrorEvent("connectionTimeout"));
+          }
+        }, this.CONNECTION_TIMEOUT * 1000);
+      }
+      onSocketOpen(event) {}
+      onSocketClose(event) {}
+      onSocketMessage(event) {}
+      onSocketError(event) {}
+      onError(error) {}
+      sendData(data) {
+        if (this._connectionState == ConnectionState.CONNECTED) {
+          if (this.socket !== null) {
+            if (data !== undefined && data !== null) {
+              this.socket.send(data);
+              return;
+            } else this.onError("no data to send");
+          }
+        }
+        this.onError("socket not connected");
+      }
+      getConnectionState() {
+        return this._connectionState;
+      }
+      disconnect(byUser = true) {
+        this._isConnected = false;
+        this._connectionState = ConnectionState.CLOSED;
+        if (byUser) {
+          this._logger.warning(this, "Disconnected by user");
+          this._disconnectedByUser = byUser;
+        }
+        if (this.socket != null) {
+          this.socket.onopen = null;
+          this.socket.onmessage = null;
+          this.socket.onclose = null;
+          this.socket.onerror = null;
+          this.socket.close();
+        }
+      }
+      destroy() {
+        if (this.socket !== undefined && this.socket !== null) {
+          this.socket.onopen = null;
+          this.socket.onmessage = null;
+          this.socket.onclose = null;
+          this.socket.onerror = null;
+          this.socket.close();
+        }
+        this._connectionState = ConnectionState.CLOSED;
+      }
+      getSocketURL() {
+        return this.socketURL;
+      }
+    }
+
+    class WowzaConnection extends AbstractSocket {
+      constructor(main, networkController) {
+        super();
+        this._logger = main.getLogger();
+        this._main = main;
+        this._networkController = networkController;
+        this.initialize();
+      }
+      initialize() {
+        this._logger.info(this, "Starting new connection with a storm server");
+        this.pickServerFromList(this._main.getConfigManager().getStreamData().getServerList());
+        if (this._currServer != null) {
+          this.socketURL = this.createURL(this._currServer);
+          this._logger.info(this, `Starting WebSocket connection with: ${this.socketURL}`);
+          this._main.dispatchEvent("serverConnectionInitiate", {
+            ref: this._main,
+            serverURL: this.socketURL
+          });
+          if (this._main.getConfigManager().getIfDemoMode()) {
+            this._logger.warning(this, "Player is in demo mode, and will not connect with a server!");
+            this._main.dispatchEvent("authorizationComplete", {
+              ref: this._main
+            });
+            return;
+          }
+          this.startConnection();
+        } else this._logger.error(this, "Connection with the server could not be initialized!");
+      }
+      onSocketOpen(event) {
+        this._logger.success(this, `Connection with the server has been established!`);
+        this._main.dispatchEvent("serverConnect", {
+          ref: this._main,
+          serverURL: this.socketURL,
+          sequenceNum: this._sequenceNumber
+        });
+        this._isConnected = true;
+      }
+      onSocketError(event) {
+        this._isConnected = false;
+        if (!this._disconnectedByUser) {
+          this._logger.error(this, `Connection with the server failed`);
+          this._main.dispatchEvent("serverConnectionError", {
+            ref: this._main,
+            serverURL: this.socketURL,
+            restart: this._main.getConfigManager().getSettingsData().getIfRestartOnError(),
+            sequenceNum: this._sequenceNumber
+          });
+          if (this._isConnected == false) {
+            this._currServer.setAsFaild(true);
+            this.initiateReconnect();
+          }
+        }
+      }
+      onSocketClose(event) {
+        this._isConnected = false;
+        if (!this._disconnectedByUser) {
+          this._logger.error(this, `Connection with the server has been closed`);
+          this._main.dispatchEvent("serverDisconnect", {
+            ref: this._main,
+            serverURL: this.socketURL,
+            restart: this._main.getConfigManager().getSettingsData().getIfRestartOnError(),
+            sequenceNum: this._sequenceNumber
+          });
+          this.initiateReconnect();
+        } else this._logger.warning(this, `Force disconnect from server!`);
+      }
+      onSocketMessage(event) {
+        this._networkController.onMessage(event);
+      }
+      createURL(serverItem) {
+        let url = "";
+        url += serverItem.getIfSSL() ? "wss://" : "ws://";
+        url += serverItem.getHost();
+        url += ":" + serverItem.getPort();
+        url += "/webrtc-session.json";
+        return url;
+      }
+      initiateReconnect() {
+        const shouldReconnect = this._main.getConfigManager().getSettingsData().getIfRestartOnError();
+        const reconnectTime = this._main.getConfigManager().getSettingsData().getReconnectTime();
+        if (this._disconnectedByUser) {
+          return;
+        }
+        if (shouldReconnect) {
+          if (this._reconnectTimer != null) clearTimeout(this._reconnectTimer);
+          this._reconnectTimer = setTimeout(() => {
+            this.pickServerFromList(this._main.getConfigManager().getStreamData().getServerList());
+            if (this._currServer != null) {
+              this._logger.info(this, `Will reconnect to the server in ${reconnectTime} seconds...`);
+              this.socketURL = this.createURL(this._currServer);
+              this._logger.info(this, `Starting WebSocket connection with: ${this.socketURL}`);
+              this._main.dispatchEvent("serverConnectionInitiate", {
+                ref: this._main,
+                serverURL: this.socketURL
+              });
+              this.startConnection();
+            }
+          }, reconnectTime * 1000);
+        }
+      }
+      pickServerFromList(serverList) {
+        let server = null;
+        for (let i = 0; i < serverList.length; i++) {
+          if (!serverList[i].getIfFaild()) {
+            server = serverList[i];
+            break;
+          }
+        }
+        if (server == null) {
+          this._logger.error(this, "All connections failed!");
+          this._main.dispatchEvent("allConnectionsFailed", {
+            ref: this._main,
+            mode: "none"
+          });
+          this._currServer = null;
+          return;
+        } else {
+          this._currServer = server;
+        }
+      }
+      isConnectionActive() {
+        return this._isConnected;
+      }
+      getCurrentServer() {
+        return this._currServer;
+      }
+      destroy() {
+        super.destroy();
+        if (this._reconnectTimer != null) clearTimeout(this._reconnectTimer);
+      }
+    }
+
+    class NetworkController {
+      constructor(main) {
+        this._currentStreamKey = "none";
+        this._lastState = "";
+        this.onServerConnect = () => {};
+        this.onServerDisconnect = () => {
+          this._lastState = "none";
+        };
+        this.onMessage = event => {
+          var _a;
+          (_a = this._main.getPlaybackController()) === null || _a === void 0 ? void 0 : _a.onSocketMessage(event.data);
+        };
+        this._main = main;
+        this._logger = main.getLogger();
+        this._main.addEventListener("serverConnect", this.onServerConnect, false);
+        this._main.addEventListener("serverDisconnect", this.onServerDisconnect, false);
+      }
+      initialize() {
+        if (this._connection != null) {
+          if (this._connection.getConnectionState() == ConnectionState.CONNECTING || this._connection.getConnectionState() == ConnectionState.CONNECTED) {
+            this._logger.info(this, "Connection is alive, not doing anything!");
+          } else {
+            this._logger.info(this, "Connection is dead, restarting!");
+            this._connection.startConnection();
+          }
+        }
+      }
+      start() {
+        this._connection = new WowzaConnection(this._main, this);
+      }
+      stop() {
+        this._connection.disconnect(true);
+        this._lastState = "";
+      }
+      sendMessage(message) {
+        if (this._connection.isConnectionActive()) {
+          this._connection.sendData(message);
+        }
+      }
+      getConnection() {
+        return this._connection;
+      }
+      getCurrentStreamKey() {
+        return this._currentStreamKey;
+      }
+    }
+
+    class StormStreamer extends EventDispatcher {
+      constructor(streamConfig, autoInitialize = false) {
+        super();
+        this.DEV_MODE = true;
+        this.STREAMER_VERSION = "0.9.0-beta.0";
+        this.COMPILE_DATE = "11/28/2024, 9:22:53 AM";
+        this.STREAMER_BRANCH = "Experimental";
+        this.STREAMER_PROTOCOL_VERSION = 1;
+        this._initialized = false;
+        if (typeof window === 'undefined' || !window.document || !window.document.createElement) {
+          console.error(`StormLibrary Creation Error - No "window" element in the provided context!`);
+          return;
+        }
+        if (this.DEV_MODE && !('StormStreamerArray' in window)) {
+          window.StormStreamerArray = [];
+        }
+        window.StormStreamerArray.push(this);
+        this._streamerID = StormStreamer.NEXT_STREAMER_ID++;
+        if (streamConfig == null) return;
+        this.setStreamConfig(streamConfig);
+        if (autoInitialize) this.initialize();
+      }
+      initialize() {
+        if (this._isRemoved) return;
+        if (this._configManager == null) throw Error("Stream Config was not provided for this library! A properly configured object must be provided through the constructor or via the setConfig method before using the initialize() method.");
+        this._storageManager = new StorageManager(this);
+        this._stageController = new StageController(this);
+        this._networkController = new NetworkController(this);
+        this._playbackController = new PlaybackController(this);
+        this._clientUser = new ClientUser();
+        this._initialized = true;
+        this.dispatchEvent("streamerReady", {
+          ref: this
+        });
+      }
+      setStreamConfig(streamConfig) {
+        if (this._isRemoved) return;
+        const copiedStreamConfig = JSON.parse(JSON.stringify(streamConfig));
+        if (this._configManager == null) {
+          this._configManager = new ConfigManager(copiedStreamConfig);
+          this._logger = new Logger(this._configManager.getSettingsData().getDebugData(), this);
+          this._logger.info(this, "StreamerID: " + this._streamerID);
+          this._logger.info(this, "Version: " + this.STREAMER_VERSION + " | Compile Date: " + this.COMPILE_DATE + " | Branch: " + this.STREAMER_BRANCH);
+          this._logger.info(this, "UserCapabilities :: Browser: " + UserCapabilities.getBrowserName() + " " + UserCapabilities.getBrowserVersion());
+          this._logger.info(this, "UserCapabilities :: Operating System: " + UserCapabilities.getOS() + " " + UserCapabilities.getOSVersion());
+          this._logger.info(this, "UserCapabilities :: isMobile: " + UserCapabilities.isMobile());
+          this._logger.info(this, "UserCapabilities :: hasMSESupport: " + UserCapabilities.hasMSESupport());
+          this._logger.info(this, "UserCapabilities :: hasWebSocketSupport: " + UserCapabilities.hasWebSocketsSupport());
+          this._logger.info(this, "UserCapabilities :: hasWebRTCSupport: " + UserCapabilities.hasWebRTCSupport());
+          this._configManager.print(this._logger);
+        } else {
+          this._logger.info(this, "StreamConfig has been overwritten, dispatching streamConfigChanged!");
+          this._configManager = new ConfigManager(copiedStreamConfig);
+          this._configManager.print(this._logger);
+          this.dispatchEvent("streamConfigChange", {
+            ref: this,
+            newConfig: this._configManager
+          });
+        }
+      }
+      stop() {}
+      isConnected() {
+        var _a, _b;
+        return (_b = (_a = this._networkController) === null || _a === void 0 ? void 0 : _a.getConnection().isConnectionActive()) !== null && _b !== void 0 ? _b : false;
+      }
+      attachToContainer(container) {
+        var _a, _b;
+        let result = false;
+        if (this._initialized) return (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.attachToParent(container)) !== null && _b !== void 0 ? _b : false;
+        return result;
+      }
+      detachFromContainer() {
+        var _a, _b;
+        let result = false;
+        if (this._initialized) return (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.detachFromParent()) !== null && _b !== void 0 ? _b : false;
+        return result;
+      }
+      getContainer() {
+        var _a, _b;
+        return (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getParentElement()) !== null && _b !== void 0 ? _b : null;
+      }
+      mute() {
+        if (this._stageController != null) {
+          if (this._stageController.getScreenElement() != null) {
+            this._stageController.getScreenElement().setMuted(true);
+            return;
+          }
+        }
+        this._configManager.getSettingsData().getAudioData().muted = true;
+      }
+      unmute() {
+        if (this._stageController != null) {
+          if (this._stageController.getScreenElement() != null) {
+            this._stageController.getScreenElement().setMuted(false);
+            return;
+          }
+        }
+        this._configManager.getSettingsData().getAudioData().muted = false;
+      }
+      isMute() {
+        var _a, _b, _c, _d;
+        return (_d = (_c = (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getIfMuted()) !== null && _c !== void 0 ? _c : this._configManager.getSettingsData().getAudioData().muted) !== null && _d !== void 0 ? _d : false;
+      }
+      toggleMute() {
+        const isMuted = this.isMute();
+        if (isMuted) {
+          this.unmute();
+        } else {
+          this.mute();
+        }
+        return !isMuted;
+      }
+      setVolume(newVolume) {
+        var _a, _b;
+        if (((_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.setVolume(newVolume)) !== undefined) {
+          return;
+        }
+        this._configManager.getSettingsData().getAudioData().startVolume = newVolume;
+      }
+      getVolume() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getVolume()) !== null && _c !== void 0 ? _c : this._configManager.getSettingsData().getAudioData().startVolume;
+      }
+      getCameraList() {
+        var _a, _b;
+        return (_b = (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.getCameraList()) !== null && _b !== void 0 ? _b : null;
+      }
+      getMicrophoneList() {
+        var _a, _b;
+        return (_b = (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.getMicrophoneList()) !== null && _b !== void 0 ? _b : null;
+      }
+      setCamera(cameraID) {
+        var _a;
+        (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.selectCamera(cameraID);
+      }
+      setMicrophone(microphoneID) {
+        var _a;
+        (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.selectMicrophone(microphoneID);
+      }
+      getCurrentCamera() {
+        return this._playbackController.getCurrentCamera();
+      }
+      getCurrentMicrophone() {
+        return this._playbackController.getCurrentMicrophone();
+      }
+      muteMicrophone(microphoneState) {
+        var _a;
+        (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.muteMicrophone(microphoneState);
+      }
+      publish(streamKey) {
+        var _a;
+        (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.publish(streamKey);
+      }
+      unpublish() {
+        var _a;
+        (_a = this._playbackController) === null || _a === void 0 ? void 0 : _a.unpublish();
+      }
+      setSize(width, height) {
+        if (this._initialized) this._stageController.setSize(width, height);else {
+          const parsedWidth = NumberUtilities.parseValue(width);
+          const parsedHeight = NumberUtilities.parseValue(height);
+          this._configManager.getSettingsData().getVideoData().videoWidthValue = parsedWidth.value;
+          this._configManager.getSettingsData().getVideoData().videoWidthInPixels = parsedWidth.isPixels;
+          this._configManager.getSettingsData().getVideoData().videoHeightValue = parsedHeight.value;
+          this._configManager.getSettingsData().getVideoData().videoHeightInPixels = parsedHeight.isPixels;
+        }
+      }
+      setWidth(width) {
+        if (this._initialized) this._stageController.setWidth(width);else {
+          const parsedWidth = NumberUtilities.parseValue(width);
+          this._configManager.getSettingsData().getVideoData().videoWidthValue = parsedWidth.value;
+          this._configManager.getSettingsData().getVideoData().videoWidthInPixels = parsedWidth.isPixels;
+        }
+      }
+      setHeight(height) {
+        if (this._initialized) this._stageController.setHeight(height);else {
+          const parsedHeight = NumberUtilities.parseValue(height);
+          this._configManager.getSettingsData().getVideoData().videoHeightValue = parsedHeight.value;
+          this._configManager.getSettingsData().getVideoData().videoHeightInPixels = parsedHeight.isPixels;
+        }
+      }
+      getWidth() {
+        if (this._initialized) return this._stageController.getContainerWidth();else {
+          if (this._configManager.getSettingsData().getVideoData().videoWidthInPixels) return this._configManager.getSettingsData().getVideoData().videoWidthValue;
+        }
+        return 0;
+      }
+      getHeight() {
+        if (this._initialized) return this._stageController.getContainerHeight();else {
+          if (this._configManager.getSettingsData().getVideoData().videoHeightInPixels) return this._configManager.getSettingsData().getVideoData().videoHeightValue;
+        }
+        return 0;
+      }
+      setScalingMode(newMode) {
+        if (this._stageController) {
+          this._stageController.setScalingMode(newMode);
+        } else {
+          this._configManager.getSettingsData().getVideoData().scalingMode = newMode;
+        }
+      }
+      getScalingMode() {
+        if (this._stageController) {
+          return this._stageController.getScalingMode();
+        } else {
+          return this._configManager.getSettingsData().getVideoData().scalingMode;
+        }
+      }
+      updateToSize() {
+        if (this._initialized) {
+          this._stageController.onResize();
+        }
+      }
+      makeScreenshot() {
+        let canvas = document.createElement('canvas');
+        let context = canvas.getContext('2d');
+        return new Promise(resolve => {
+          if (this._stageController != null) {
+            canvas.width = this._stageController.getScreenElement().getVideoElement().videoWidth;
+            canvas.height = this._stageController.getScreenElement().getVideoElement().videoHeight;
+            let element = this._stageController.getScreenElement().getVideoElement();
+            if (context) {
+              context.drawImage(element, 0, 0, canvas.width, canvas.height);
+              canvas.toBlob(blob => {
+                resolve(blob);
+              }, 'image/png');
+            } else {
+              resolve(null);
+            }
+          } else {
+            resolve(null);
+          }
+        });
+      }
+      enterFullScreen() {
+        if (this._initialized && this._stageController) this._stageController.enterFullScreen();
+      }
+      exitFullScreen() {
+        if (this._initialized && this._stageController) this._stageController.exitFullScreen();
+      }
+      isFullScreenMode() {
+        if (this._initialized && this._stageController) return this._stageController.isFullScreenMode();
+        return false;
+      }
+      getStreamerID() {
+        return this._streamerID;
+      }
+      getLogger() {
+        return this._logger;
+      }
+      getConfigManager() {
+        return this._configManager;
+      }
+      getNetworkController() {
+        return this._networkController;
+      }
+      getPlaybackController() {
+        return this._playbackController;
+      }
+      getStageController() {
+        return this._stageController;
+      }
+      getVideoElement() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getVideoElement()) !== null && _c !== void 0 ? _c : null;
+      }
+      isInitialized() {
+        return this._initialized;
+      }
+      getVersion() {
+        return this.STREAMER_VERSION;
+      }
+      getBranch() {
+        return this.STREAMER_BRANCH;
+      }
+      getStorageManager() {
+        return this._storageManager;
+      }
+      dispatchEvent(eventName, event) {
+        super.dispatchEvent(eventName, event);
+      }
+      destroy() {
+        var _a, _b, _c;
+        this._logger.warning(this, "Destroying library instance, bye, bye!");
+        this._initialized = false;
+        this._isRemoved = true;
+        (_a = this._networkController) === null || _a === void 0 ? void 0 : _a.getConnection().destroy();
+        (_b = this._stageController) === null || _b === void 0 ? void 0 : _b.destroy();
+        (_c = this._playbackController) === null || _c === void 0 ? void 0 : _c.destroy();
+        this.removeAllEventListeners();
+      }
+    }
+    StormStreamer.NEXT_STREAMER_ID = 0;
+
+    function create(config) {
+      return new StormStreamer(config);
+    }
+
+    exports.StormStreamer = StormStreamer;
+    exports.create = create;
+
+}));