@stormstreaming/stormstreamer 0.9.2-beta.2 → 0.9.3-beta.0

package/dist/amd/index.js

@@ -4,8 +4,8 @@
  * contact@stormstreaming.com
  * https://stormstreaming.com
  *
- * Version: 0.9.2-beta.2
- * Version: 3/6/2025, 2:53:17 PM
+ * Version: 0.9.3-beta.0
+ * Version: 3/8/2025, 11:51:36 PM
  *
  * LEGAL NOTICE:
  * This software is subject to the terms and conditions defined in
@@ -45,7 +45,18 @@
         return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
+    /**
+     * Class stores information related to storm servers
+     */
     class StormServerItem {
+      /**
+       * Constructor
+       *
+       * @param host server URL e.g. "cdn-e001.stormstreaming.com"
+       * @param applicationName e.g. "live
+       * @param port usually 443
+       * @param isSSL whenever connection should be stablished via SSL (true by default)
+       */
       constructor(host, application, port = 443, isSSL = true) {
         this.host = host;
         this.application = application;
@@ -53,24 +64,46 @@
         this.isSSL = isSSL;
         this.hasFaild = false;
       }
+      /**
+       * Returns server URL
+       */
       getHost() {
         return this.host;
       }
+      /**
+       * Returns server application
+       */
       getApplication() {
         return this.application;
       }
+      /**
+       * Returns port number
+       */
       getPort() {
         return this.port;
       }
+      /**
+       * Returns whenever connection should be established via SSL
+       */
       getIfSSL() {
         return this.isSSL;
       }
+      /**
+       * Returns whenever connection faild while trying to connect
+       */
       getIfFaild() {
         return this.hasFaild;
       }
+      /**
+       * Marks this server as faild, prevent it from being used anymore
+       * @param value
+       */
       setAsFaild(value) {
         this.hasFaild = value;
       }
+      /**
+       * Returns data from this object
+       */
       getData() {
         return {
           serverURL: this.getHost(),
@@ -84,13 +117,29 @@
       }
     }
 
+    /**
+     * Class contains streaming data
+     */
     class StreamData {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constructor
+       * @param streamConfig
+       */
       constructor(streamConfig) {
         this._serverList = new Array();
         this._sourceList = new Array();
         this._streamKey = null;
         this.parse(streamConfig);
       }
+      //------------------------------------------------------------------------//
+      // MAIN METHODS
+      //------------------------------------------------------------------------//
+      /**
+       * Parses provided config
+       */
       parse(streamConfig) {
         var _a, _b, _c;
         this._streamConfig = streamConfig;
@@ -110,30 +159,68 @@
         } 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;
       }
+      //------------------------------------------------------------------------//
+      // GETS & SETS
+      //------------------------------------------------------------------------//
+      /**
+       * Returns list of all provided servers
+       */
       getServerList() {
         return this._serverList;
       }
+      /**
+       * Returns list of all video sources
+       */
       getSourceList() {
         return this._sourceList;
       }
+      /**
+       * Returns group name;
+       */
       get streamKey() {
         return this._streamKey;
       }
+      /**
+       * Returns group name;
+       */
       set streamKey(newValue) {
         this._streamKey = newValue;
       }
+      /**
+       * Allows to push server list to the config
+       * @param serverList
+       */
       set serverList(serverList) {
         this._serverList = serverList;
       }
+      /**
+       * Allows to push source list to the config
+       * @param sourceList
+       */
       set sourceList(sourceList) {
         this._sourceList = sourceList;
       }
+      //------------------------------------------------------------------------//
+      // OTHER
+      //------------------------------------------------------------------------//
+      /**
+       * Removes all sources
+       */
       clearSourceList() {
         this._sourceList = new Array();
       }
+      /**
+       * Removes all SERVERS
+       */
       clearServerList() {
         this._serverList = new Array();
       }
+      /**
+       * Prints current settings.
+       *
+       * @param logger reference to logger
+       * @param force if printing is disabled, this parameter can overwrite it
+       */
       print(logger, force = false) {
         if (StreamData.PRINT_ON_STARTUP || force) {
           logger.info(this, "Server List:");
@@ -144,10 +231,26 @@
         }
       }
     }
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     StreamData.PRINT_ON_STARTUP = true;
+    /**
+     * Default storm port (usually 443)
+     * @private
+     */
     StreamData.DEFAULT_CONNECTION_PORT = 443;
+    /**
+     * Whenever all connection to strom should be made via SSL
+     * @private
+     */
     StreamData.IS_SSL_BY_DEFAULT = true;
 
+    /**
+     * Different types of video scaling mechanisms
+     */
     var ScalingType;
     (function (ScalingType) {
       ScalingType["FILL"] = "fill";
@@ -156,6 +259,9 @@
       ScalingType["ORIGINAL"] = "original";
     })(ScalingType || (ScalingType = {}));
 
+    /**
+     * Different types of security methods for player
+     */
     var SizeCalculationType;
     (function (SizeCalculationType) {
       SizeCalculationType["CLIENT_DIMENSIONS"] = "clientDimensions";
@@ -163,20 +269,77 @@
       SizeCalculationType["FULL_BOX"] = "fullBox";
     })(SizeCalculationType || (SizeCalculationType = {}));
 
+    /**
+     * Class contains settings for video object
+     */
     class VideoData {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constructor
+       *
+       * @param videoConfig video config object
+       */
       constructor(videoConfig) {
+        /**
+         * Selected scaling mode
+         * @private
+         */
         this._scalingMode = ScalingType.LETTER_BOX;
+        /**
+         * Aspect ratio saved as a string (two numbers with : in between)
+         * @private
+         */
         this._aspectRatio = "none";
+        /**
+         * Initial video container width
+         * @private
+         */
         this._videoWidthValue = 100;
+        /**
+         * Whenever width is in pixels
+         * @private
+         */
         this._isVideoWidthInPixels = false;
+        /**
+         * Whenever width was provided
+         * @private
+         */
         this._wasVideoWidthProvided = false;
+        /**
+         * Initial video container height;
+         * @private
+         */
         this._videoHeightValue = 100;
+        /**
+         * Whenever height is in pixels
+         * @private
+         */
         this._isVideoHeightInPixels = false;
+        /**
+         * Whenever height was provided
+         * @private
+         */
         this._wasVideoHeightProvided = false;
+        /**
+         * Resize debounce parameter
+         * @private
+         */
         this._resizeDebounce = 250;
+        /**
+         * Method used for calculating parent size;
+         * @private
+         */
         this._parentSizeCalculationMethod = SizeCalculationType.CLIENT_DIMENSIONS;
         this.parse(videoConfig);
       }
+      //------------------------------------------------------------------------//
+      // MAIN METHODS
+      //------------------------------------------------------------------------//
+      /**
+       * Parses provided config
+       */
       parse(config) {
         var _a, _b;
         this.videoConfig = config;
@@ -262,30 +425,60 @@
           this._resizeDebounce = (_b = this.videoConfig.resizeDebounce) !== null && _b !== void 0 ? _b : this._resizeDebounce;
         } else throw new Error("Missing video configuration. Please check player config!");
       }
+      //------------------------------------------------------------------------//
+      // GETS & SETS
+      //------------------------------------------------------------------------//
+      /**
+       * Returns selected scaling mode
+       */
       get scalingMode() {
         return this._scalingMode;
       }
+      /**
+       * Returns ID of the main video container
+       */
       get containerID() {
         return this._containerID;
       }
+      /**
+       * Returns video screen initial width
+       */
       get videoWidthValue() {
         return this._videoWidthValue;
       }
+      /**
+       * Returns whenever screen width was provided in pixels
+       */
       get videoWidthInPixels() {
         return this._isVideoWidthInPixels;
       }
+      /**
+       * Returns whenever screen width was provided in pixels
+       */
       get videoWidthProvided() {
         return this._wasVideoWidthProvided;
       }
+      /**
+       * Returns video container initial width
+       */
       get videoHeightValue() {
         return this._videoHeightValue;
       }
+      /**
+       * Returns video container initial width
+       */
       get videoHeightInPixels() {
         return this._isVideoHeightInPixels;
       }
+      /**
+       * Returns whenever screen width was provided in pixels
+       */
       get videoHeightProvided() {
         return this._wasVideoHeightProvided;
       }
+      /**
+       * Returns aspect ratio;
+       */
       get aspectRatio() {
         return this._aspectRatio;
       }
@@ -295,21 +488,45 @@
       set resizeDebounce(newValue) {
         this._resizeDebounce = newValue;
       }
+      /**
+       * Sets new width to the player config
+       * @param newWidth
+       */
       set videoWidthValue(newWidth) {
         this._videoWidthValue = newWidth;
       }
+      /**
+       * Sets new width to the player config
+       * @param newWidth
+       */
       set videoWidthInPixels(value) {
         this._isVideoWidthInPixels = value;
       }
+      /**
+       * Sets new height to the player config
+       * @param newHeight
+       */
       set videoHeightValue(newHeight) {
         this._videoHeightValue = newHeight;
       }
+      /**
+       * Sets new width to the player config
+       * @param newWidth
+       */
       set videoHeightInPixels(value) {
         this._isVideoHeightInPixels = value;
       }
+      /**
+       * Sets new containerID for the player
+       * @param newContainerID
+       */
       set containerID(newContainerID) {
         this._containerID = newContainerID;
       }
+      /**
+       * Sets new scaling mode
+       * @param newScalingMode
+       */
       set scalingMode(newScalingMode) {
         switch (newScalingMode.toLowerCase()) {
           case "fill":
@@ -331,6 +548,14 @@
       get parentSizeCalculationMethod() {
         return this._parentSizeCalculationMethod;
       }
+      //------------------------------------------------------------------------//
+      // OTHER
+      //------------------------------------------------------------------------//
+      /**
+       * Prints current settings
+       *
+       * @param logger
+       */
       print(logger) {
         let scalingMode = "";
         switch (this._scalingMode) {
@@ -355,6 +580,9 @@
       }
     }
 
+    /**
+     * Contains all log types
+     */
     var LogType;
     (function (LogType) {
       LogType[LogType["TRACE"] = 0] = "TRACE";
@@ -364,18 +592,61 @@
       LogType[LogType["ERROR"] = 4] = "ERROR";
     })(LogType || (LogType = {}));
 
+    /**
+     * This class represents "debug" section of an original player config. If any field/value is missing in the config,
+     * default values defined within this class will be used instead.
+     */
     class DebugData {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Creates debug object based on parameters from config object
+       *
+       * @param debugConfig
+       */
       constructor(debugConfig) {
+        /**
+         * Decides whenever log will be outputted in browser console
+         * @private
+         */
         this._consoleLogEnabled = false;
+        /**
+         * List of enabled console log types (order doesn't matter)
+         * @private
+         */
         this._enabledConsoleTypes = [LogType.INFO, LogType.ERROR, LogType.SUCCESS, LogType.TRACE, LogType.WARNING];
+        /**
+         * If true, different types of logs for console will have the same color, but each player will have
+         * its own color (easier to debug with multiple players)
+         *
+         * @private
+         */
         this._consoleMonoColor = false;
+        /**
+         * List of enabled console log types (order doesn't matter)
+         * @private
+         */
         this._containerLogEnabled = false;
+        /**
+         *
+         * @private
+         */
         this._enabledContainerTypes = [LogType.INFO, LogType.ERROR, LogType.SUCCESS, LogType.TRACE, LogType.WARNING];
+        /**
+         * If true, different types of logs for container will have the same color, but each player will have
+         * its own color (easier to debug with multiple players)
+         *
+         * @private
+         */
         this._containerLogMonoColor = false;
         this._stageController = true;
         this._streamerController = true;
         this.parse(debugConfig);
       }
+      /**
+       * Parses provided config
+       */
       parse(debugConfig) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
         this._debugConfig = debugConfig;
@@ -409,15 +680,32 @@
           }
         });
       }
+      //------------------------------------------------------------------------//
+      // GETS & SETS
+      //------------------------------------------------------------------------//
+      /**
+       * Returns whenever logs from debug will be pushed to browser console. False by default.
+       */
       get consoleLogEnabled() {
         return this._consoleLogEnabled;
       }
+      /**
+       * Sets console logging on/off
+       * @param newValue
+       */
       set consoleLogEnabled(newValue) {
         this._consoleLogEnabled = newValue;
       }
+      /**
+       * Returns all enabled types of logs for console logging
+       */
       get enabledConsoleTypes() {
         return this._enabledConsoleTypes;
       }
+      /**
+       * Sets console log types
+       * @param newValue
+       */
       set enabledConsoleTypes(newValue) {
         this._enabledConsoleTypes = new Array();
         for (let i = 0; i < newValue.length; i++) {
@@ -440,21 +728,42 @@
           }
         }
       }
+      /**
+       * Returns whenever logs from debug will be pushed to a cointainer. False by default.
+       */
       get containerLogEnabled() {
         return this._containerLogEnabled;
       }
+      /**
+       * Sets container debugging on/off
+       * @param newValue
+       */
       set containerLogEnabled(newValue) {
         this._consoleLogEnabled = newValue;
       }
+      /**
+       * Retruns true if all console outputs will have the same color (depending on playerID)
+       */
       get consoleLogMonoColor() {
         return this._consoleMonoColor;
       }
+      /**
+       * Sets console logging to monocolor
+       * @param newValue
+       */
       set consoleLogMonoColor(newValue) {
         this._consoleMonoColor = newValue;
       }
+      /**
+       * Returns all enabled types of logs for container logging
+       */
       get enabledContainerTypes() {
         return this._enabledContainerTypes;
       }
+      /**
+       * Sets console log types
+       * @param newValue
+       */
       set enabledContainerTypes(newValue) {
         this._enabledContainerTypes = new Array();
         for (let i = 0; i < newValue.length; i++) {
@@ -477,15 +786,29 @@
           }
         }
       }
+      /**
+       * Return a reference to a object where logs will be pushed as text. Null by default.
+       */
       get containerID() {
         return this._containerID;
       }
+      /**
+       * Sets container for logging
+       * @param object
+       */
       set containerID(object) {
         this._containerID = object;
       }
+      /**
+       * Retruns true if all container outputs will have the same color (depending on playerID)
+       */
       get containerLogMonoColor() {
         return this._containerLogMonoColor;
       }
+      /**
+       * Sets container logging to monocolor
+       * @param newValue
+       */
       set containerLogMonoColor(newValue) {
         this._containerLogMonoColor = newValue;
       }
@@ -495,6 +818,14 @@
       get streamerControllerDebug() {
         return this._streamerController;
       }
+      //------------------------------------------------------------------------//
+      // OTHER
+      //------------------------------------------------------------------------//
+      /**
+       * Prints current settings
+       *
+       * @param logger
+       */
       print(logger, force = false) {
         if (DebugData.PRINT_ON_STARTUP || force) {
           let consoleLogTypes = "";
@@ -547,14 +878,43 @@
         }
       }
     }
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     DebugData.PRINT_ON_STARTUP = true;
 
+    /**
+     * Class contains all parameters related to volume
+     */
     class AudioData {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constructor
+       * @param volumeConfig
+       */
       constructor(volumeConfig) {
+        /**
+         * Default value for volume
+         * @private
+         */
         this._startVolume = 100;
+        /**
+         * Whenever video is muted
+         * @private
+         */
         this._isMuted = false;
         this.parse(volumeConfig);
       }
+      //------------------------------------------------------------------------//
+      // MAIN METHODS
+      //------------------------------------------------------------------------//
+      /**
+       * Parses provided config
+       */
       parse(config) {
         var _a, _b, _c, _d;
         this._audioConfig = config;
@@ -563,67 +923,203 @@
           this._isMuted = (_d = (_c = this._audioConfig) === null || _c === void 0 ? void 0 : _c.muted) !== null && _d !== void 0 ? _d : this._isMuted;
         }
       }
+      //------------------------------------------------------------------------//
+      // GETS & SETS
+      //------------------------------------------------------------------------//
+      /**
+       * Returns player start volume
+       */
       get startVolume() {
         return this._startVolume;
       }
+      /**
+       * Sets start volume for the player (by default it's 100)
+       * @param newValue
+       */
       set startVolume(newValue) {
         this._startVolume = newValue;
       }
+      /**
+       * Returns whenever library should be muted on start
+       */
       get muted() {
         return this._isMuted;
       }
+      /**
+       * Sets whenever library should be muted or not
+       * @param newValue
+       */
       set muted(newValue) {
         this._isMuted = newValue;
       }
+      //------------------------------------------------------------------------//
+      // OTHER
+      //------------------------------------------------------------------------//
+      /**
+       * Prints current settings
+       *
+       * @param logger
+       */
       print(logger, force = false) {
         if (AudioData.PRINT_ON_STARTUP || force) logger.info(this, "Audio :: startVolume: " + this._startVolume + " | isMuted: " + this._isMuted);
       }
     }
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     AudioData.PRINT_ON_STARTUP = true;
 
+    /**
+     * Class contains all parameters related to volume
+     */
     class StorageData {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constructor
+       * @param storageConfig
+       */
       constructor(storageConfig) {
+        /**
+         * Whenever storage is enabled or not (true by default)
+         * @private
+         */
         this._enabled = true;
+        /**
+         * Prefix for loading and saving settings
+         * @private
+         */
         this._prefix = "storm";
         this.parse(storageConfig);
       }
+      //------------------------------------------------------------------------//
+      // MAIN METHODS
+      //------------------------------------------------------------------------//
+      /**
+       * Parses provided config
+       */
       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;
       }
+      //------------------------------------------------------------------------//
+      // GETS & SETS
+      //------------------------------------------------------------------------//
+      /**
+       * Returns if storage is enabled
+       */
       get enabled() {
         return this._enabled;
       }
+      /**
+       * Sets new value for enabled
+       * @param newValue
+       */
       set enabled(newValue) {
         this._enabled = newValue;
       }
+      /**
+       * Returns storage prefix
+       */
       get prefix() {
         return this._prefix;
       }
+      /**
+       * Sets storage prefix
+       * @param newValue
+       */
       set prefix(newValue) {
         this._prefix = newValue;
       }
+      //------------------------------------------------------------------------//
+      // OTHER
+      //------------------------------------------------------------------------//
+      /**
+       * Prints current settings
+       *
+       * @param logger
+       */
       print(logger, force = false) {
         if (StorageData.PRINT_ON_STARTUP || force) logger.info(this, "Storage :: startVolume: " + this._enabled + " | prefix: " + this._prefix);
       }
     }
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     StorageData.PRINT_ON_STARTUP = true;
 
+    /**
+     * Store all settings related to player behavior
+     */
     class SettingsData {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constructor
+       * @param config
+       */
       constructor(config) {
+        /**
+         * Whenver player should try reconnecting upon its error
+         * @private
+         */
         this._restartOnError = true;
+        /**
+         * Number of seconds between player reconnects
+         * @private
+         */
         this._reconnectTime = 1;
+        /**
+         * Decides whenver player will automatically start playing content
+         * @private
+         */
         this._autoStart = false;
+        /**
+         * Decides whenver player will automatically connect to a server
+         * @private
+         */
         this._autoConnect = true;
+        /**
+         * Start player only when DOM is ready
+         *
+         * @private
+         */
         this.startOnDOMReady = false;
+        /**
+         * Starts video playback on iOS only once DOM is ready
+         *
+         * @private
+         *
+         */
         this.iOSOnDomReadyFix = true;
+        /**
+         * Decides whenever player will restart on focus/blur
+         * @private
+         */
         this._restartOnFocus = true;
+        /**
+         * Whenever streamer should preselect some camera and microphone if no was selected prior
+         * @private
+         */
         this._preselectDevices = true;
         this._cancelPublishOnError = true;
         this.parse(config);
       }
+      //------------------------------------------------------------------------//
+      // MAIN METHODS
+      //------------------------------------------------------------------------//
+      /**
+       * Parses provided config
+       * @param config
+       */
       parse(config) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         this._settingsConfig = config;
@@ -639,33 +1135,67 @@
         this._storageData = new StorageData((_k = this._settingsConfig.storage) !== null && _k !== void 0 ? _k : null);
         this._debugData = new DebugData((_l = this._settingsConfig.debug) !== null && _l !== void 0 ? _l : null);
       }
+      //------------------------------------------------------------------------//
+      // GETS & SETS
+      //------------------------------------------------------------------------//
+      /**
+       * Returns Volume Config
+       */
       getAudioData() {
         return this._audioData;
       }
+      /**
+       * Returns Video Config
+       */
       getVideoData() {
         return this._videoData;
       }
+      /**
+       * Returns Storage Data
+       */
       getStorageData() {
         return this._storageData;
       }
+      /**
+       * Returns if player should reset connection after error
+       */
       getIfRestartOnError() {
         return this._restartOnError;
       }
+      /**
+       * Returns time (in ms) when player should attempt new connection after error
+       */
       getReconnectTime() {
         return this._reconnectTime;
       }
+      /**
+       * Returns true whenever autostart is activated
+       */
       get autoStart() {
         return this._autoStart;
       }
+      /**
+       * Sets autostart value
+       * @param newValue
+       */
       set autoStart(newValue) {
         this._autoStart = newValue;
       }
+      /**
+       * Returns true/false whenever library is set to auto-connect with a Storm server
+       */
       get autoConnect() {
         return this._autoConnect;
       }
+      /**
+       * Returns true whenever library should restart the connection on document focus/blur
+       */
       get restartOnFocus() {
         return this._restartOnFocus;
       }
+      /**
+       * Returns Debug Config
+       */
       getDebugData() {
         return this._debugData;
       }
@@ -675,12 +1205,26 @@
       getIfCancelPublishOnError() {
         return this._cancelPublishOnError;
       }
+      /**
+       * Returns whenever player should start only after DOM has been initialized
+       */
       getIfStartOnDOMReadyEnabled() {
         return this.startOnDOMReady;
       }
+      /**
+       * Returns whenever player (ios mode) should start only after DOM has been initialized
+       */
       getIfIOSOnDomStartFixEnabled() {
         return this.iOSOnDomReadyFix;
       }
+      //------------------------------------------------------------------------//
+      // OTHER
+      //------------------------------------------------------------------------//
+      /**
+       * Prints current settings
+       *
+       * @param logger
+       */
       print(logger, force = false) {
         if (SettingsData.PRINT_ON_STARTUP || force) {
           let enabledProtocols = "";
@@ -696,14 +1240,45 @@
         }
       }
     }
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     SettingsData.PRINT_ON_STARTUP = true;
 
+    /**
+     * Class responsible for parsing config object.
+     */
     class ConfigManager {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constuctor
+       * @param config config object
+       */
       constructor(config) {
+        /**
+         * Decides whenever player will print this config data on startup
+         *
+         * @private
+         */
         this.PRINT_ON_STARTUP = true;
+        /**
+         * Whenver we're in demo mode
+         * @private
+         */
         this.demoMode = false;
         this.parse(config);
       }
+      //------------------------------------------------------------------------//
+      // MAIN METHODS
+      //------------------------------------------------------------------------//
+      /**
+       * Parses config objects into smaller chunkes related to their kind.
+       * @private
+       */
       parse(config) {
         var _a, _b;
         this.configTemplate = config;
@@ -712,15 +1287,36 @@
         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;
       }
+      //------------------------------------------------------------------------//
+      // GETS & SETS
+      //------------------------------------------------------------------------//
+      /**
+       * Returns the part of the config with player stream data (what to play)
+       */
       getStreamData() {
         return this.streamData;
       }
+      /**
+       * Returns the part of the config with player settings
+       */
       getSettingsData() {
         return this.settingsData;
       }
+      /**
+       * Returns true/false whenever we're in demo mode or not
+       */
       getIfDemoMode() {
         return this.demoMode;
       }
+      //------------------------------------------------------------------------//
+      // OTHER
+      //------------------------------------------------------------------------//
+      /**
+       * Prints current settings.
+       *
+       * @param logger reference to logger
+       * @param force if printing is disabled, this parameter can overwrite it
+       */
       print(logger, force = false) {
         if (this.PRINT_ON_STARTUP || force) {
           this.streamData.print(logger);
@@ -729,11 +1325,29 @@
       }
     }
 
+    /**
+     * General class for event-listeners
+     */
     class EventDispatcher {
       constructor() {
+        /**
+         * Whenever instance of this class has been removed
+         * @protected
+         */
         this._isRemoved = false;
+        /**
+         * An array storing all the listeners
+         * @private
+         */
         this._listeners = {};
-      }
+        // nothing
+      }
+      /**
+       * Method registers event listener with the object
+       * @param eventName name of an event (as a string)
+       * @param listener a reference to a method
+       * @param removable whenever this listener can be removed or not
+       */
       addEventListener(eventName, listener, removable = true) {
         if (!this._listeners[eventName]) this._listeners[eventName] = [];
         let elementFound = false;
@@ -754,6 +1368,11 @@
           return true;
         } else return false;
       }
+      /**
+       * Method removes a listener from this object based on event name and used method
+       * @param eventName name of an event (as a string)
+       * @param listenera reference to a method (optional)
+       */
       removeEventListener(eventName, listener) {
         let elementFound = false;
         if (this._listeners[eventName] != undefined) {
@@ -780,6 +1399,9 @@
         this._logger.success(this, "Removing listener: " + eventName);
         return elementFound;
       }
+      /**
+       * Method removes all event listeners
+       */
       removeAllEventListeners() {
         this._logger.success(this, "Removing all listeners!");
         for (const eventName in this._listeners) {
@@ -795,6 +1417,11 @@
           }
         }
       }
+      /**
+       * Method dispatches an event of a given eventName
+       * @param eventName
+       * @param event
+       */
       dispatchEvent(eventName, event) {
         if (this._isRemoved) return;
         if (this._listeners[eventName] != undefined) {
@@ -805,10 +1432,18 @@
             }
           }
         }
+        //console.log('%c⏵ Event: '+eventName+' was dispatched: '+count+' times', 'background: yellow; color: black;');
       }
     }
 
+    /**
+     * Class responsible for operations on numbers
+     */
     class NumberUtilities {
+      /**
+       * Adds leading "zero" before the number and returns it as a string. Example: "1" -> "01"
+       * @param number
+       */
       static addLeadingZero(number) {
         if (number < 10) {
           return "0" + number;
@@ -846,9 +1481,27 @@
     };
 
     class Logger {
+      /**
+       * Constructor
+       *
+       * @param config object containing settings for logger
+       * @param stormLibrary reference to main class
+       */
       constructor(config, stormStreamer) {
+        /**
+         * List of colors used for monoColor option
+         * @private
+         */
         this.colorOrder = ["red", "green", "blue", "orange", "black", "violet"];
+        /**
+         * Stores all loges within this array
+         * @private
+         */
         this._logMemory = [];
+        /**
+         * Main name of the instance
+         * @private
+         */
         this._streamerInstanceID = -1;
         this._debugConfig = config;
         this._stormStreamer = stormStreamer;
@@ -856,6 +1509,12 @@
         let colorID = this.colorOrder.length < stormStreamer.getStreamerID() ? this.colorOrder.length - 1 : stormStreamer.getStreamerID();
         this._monoColor = this.colorOrder[colorID];
       }
+      /**
+       * Creates new "info" type log
+       *
+       * @param objectName object that called the log
+       * @param message log message
+       */
       info(objectName, message) {
         let output = this.logData(objectName, message);
         if (this._debugConfig.consoleLogEnabled) {
@@ -871,6 +1530,12 @@
           }
         }
       }
+      /**
+       * Creates new "warning" type log
+       *
+       * @param objectName object that called the log
+       * @param message log message
+       */
       warning(objectName, message) {
         let output = this.logData(objectName, message);
         if (this._debugConfig.consoleLogEnabled) {
@@ -899,10 +1564,16 @@
         const id = this._stormStreamer.getStreamerID();
         const keyCaps = id >= 0 && id < EMOJI_MAP.length ? EMOJI_MAP[id] : `[${id}]`;
         const color = COLOR_SCHEMES[scheme];
-        if (!color) return;
+        if (!color) return; // Early return if invalid scheme
         const style = `background: black; color: ${color}; border: 1px solid ${color}; padding: 5px 5px 5px 0px`;
         console.log(`%c 🎦️${keyCaps} ${text}`, style);
       }
+      /**
+       * Creates new "error" type log
+       *
+       * @param objectName object that called the log
+       * @param message log message
+       */
       error(objectName, message) {
         let output = this.logData(objectName, message);
         if (this._debugConfig.consoleLogEnabled) {
@@ -918,6 +1589,12 @@
           }
         }
       }
+      /**
+       * Creates new "success" type log
+       *
+       * @param objectName object that called the log
+       * @param message log message
+       */
       success(objectName, message) {
         let output = this.logData(objectName, message);
         if (this._debugConfig.consoleLogEnabled) {
@@ -933,6 +1610,12 @@
           }
         }
       }
+      /**
+       * Creates new "trace" type log
+       *
+       * @param objectName object that called the log
+       * @param message log message
+       */
       trace(objectName, message) {
         let output = this.logData(objectName, message);
         if (this._debugConfig.consoleLogEnabled) {
@@ -948,6 +1631,12 @@
           }
         }
       }
+      /**
+       * Prepares console message and formats its text
+       * @param _objectName object that called the log
+       * @param message log message
+       * @private
+       */
       logData(_objectName, message) {
         let date = new Date();
         let hour = NumberUtilities.addLeadingZero(date.getHours());
@@ -959,6 +1648,13 @@
         this._logMemory.push(finalString);
         return finalString;
       }
+      /**
+       * Writes log to a DOM container
+       *
+       * @param message the message
+       * @param color of the log
+       * @private
+       */
       writeToContainer(message, color) {
         let containerName = this._debugConfig.containerID;
         if (containerName) {
@@ -969,28 +1665,67 @@
           container.appendChild(log);
         }
       }
+      /**
+       * Sets player id
+       * @param playerID
+       */
       setPlayerID(playerID) {
         this._streamerInstanceID = playerID;
       }
+      /**
+       * Returns all logs
+       */
       getAllLogs() {
         return this._logMemory;
       }
     }
+    /**
+     * Defines what color an info log would be outputted (can be either a color name or #hex)
+     * @private
+     */
     Logger.INFO_COLOR = "blue";
+    /**
+     * Defines what color a warning log would be outputted (can be either a color name or #hex)
+     * @private
+     */
     Logger.WARNING_COLOR = "orange";
+    /**
+     * Defines what color an error log would be outputted (can be either a color name or #hex)
+     * @private
+     */
     Logger.ERROR_COLOR = "red";
+    /**
+     * Defines what color a success log would be outputted (can be either a color name or #hex)
+     * @private
+     */
     Logger.SUCCESS_COLOR = "green";
+    /**
+     * Defines what color a success log would be outputted (can be either a color name or #hex)
+     * @private
+     */
     Logger.TRACE_COLOR = "black";
 
+    /**
+     * Class for detecting user device, browser, etc.
+     */
     class UserCapabilities {
+      /**
+       * Returns true or false depending on availability of WebSockets
+       */
       static hasWebSocketsSupport() {
         return window.WebSocket != null;
       }
+      /**
+       * Returns true if user is using a mobile browser
+       */
       static isMobile() {
         const mobileCheckString = "Mobile|mini|Fennec|Android|iP(ad|od|hone)";
         const mobileCheckRegExp = new RegExp(mobileCheckString);
         return mobileCheckRegExp.test(navigator.userAgent);
       }
+      /**
+       * Returns true if cookies are enabled for this browser/device
+       */
       static isCookieEnabled() {
         let cookieEnabled = navigator.cookieEnabled ? true : false;
         if (typeof navigator.cookieEnabled == 'undefined' && !cookieEnabled) {
@@ -999,6 +1734,9 @@
         }
         return cookieEnabled;
       }
+      /**
+       * Returns an OS Version
+       */
       static getOSVersion() {
         let osVersion = "Unknown version";
         let os = UserCapabilities.getOS();
@@ -1008,7 +1746,9 @@
           if (windowsCheckRegExp.test(os)) {
             const windowsExecString = "Windows (.*)";
             const windowsExecRegExp = new RegExp(windowsExecString);
+            // @ts-ignore
             osVersion = windowsExecRegExp.exec(os)[1] != null ? windowsExecRegExp.exec(os)[1] : osVersion;
+            // @ts-ignore
             os = 'Windows';
           }
           switch (os) {
@@ -1017,37 +1757,53 @@
             case 'Android':
               const versionExecString = "(?:Android|Mac OS|Mac OS X|MacPPC|MacIntel|Mac_PowerPC|Macintosh) ([\\.\\_\\d]+)";
               const versionExecRegExp = new RegExp(versionExecString);
+              // @ts-ignore
               osVersion = versionExecRegExp.exec(navigator.userAgent)[1];
               break;
             case 'iOS':
               const iOSExecString = "OS (\\d+)_(\\d+)_?(\\d+)?";
               const iOSExecRegExp = new RegExp(iOSExecString);
+              // @ts-ignore
               osVersion = iOSExecRegExp.exec(navigator.userAgent);
+              // @ts-ignore
               osVersion = osVersion[1] + '.' + osVersion[2] + '.' + (osVersion[3] | 0);
               break;
           }
         }
         return osVersion;
       }
+      /**
+       * Returns a browser name
+       */
       static getBrowserName() {
         return UserCapabilities.getFullBrowser().name;
       }
+      /**
+       * Returns a browser version
+       */
       static getBrowserVersion() {
         return UserCapabilities.getFullBrowser().version;
       }
+      /**
+       * Returns a full browser name
+       */
       static getFullBrowser() {
+        //browser
         let nAgt = navigator.userAgent;
         let browser = navigator.appName;
         let version = '' + parseFloat(navigator.appVersion);
         let majorVersion = parseInt(navigator.appVersion, 10);
         let nameOffset, verOffset, ix;
+        // Opera
         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) {
+        }
+        // MSIE
+        else if ((verOffset = nAgt.indexOf('MSIE')) != -1) {
           browser = 'Microsoft Internet Explorer';
           version = nAgt.substring(verOffset + 5);
         } else if (browser == 'Netscape' && nAgt.indexOf('Trident/') != -1) {
@@ -1056,34 +1812,50 @@
           if ((verOffset = nAgt.indexOf('rv:')) != -1) {
             version = nAgt.substring(verOffset + 3);
           }
-        } else if ((verOffset = nAgt.indexOf('Chrome')) != -1) {
+        }
+        // Chrome
+        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) {
+        }
+        // Safari
+        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);
           }
+          // Chrome on iPad identifies itself as Safari. Actual results do not match what Google claims
+          //  at: https://developers.google.com/chrome/mobile/docs/user-agent?hl=ja
+          //  No mention of chrome in the user agent string. However it does mention CriOS, which presumably
+          //  can be keyed on to detect it.
           if (nAgt.indexOf('CriOS') != -1) {
+            //Chrome on iPad spoofing Safari...correct it.
             browser = 'Chrome';
+            //Don't believe there is a way to grab the accurate version number, so leaving that for now.
           }
+
           if (nAgt.indexOf('FxiOS') != -1) {
             browser = "Firefox";
           }
-        } else if ((verOffset = nAgt.indexOf('Firefox')) != -1) {
+        }
+        // Firefox
+        else if ((verOffset = nAgt.indexOf('Firefox')) != -1) {
           browser = 'Firefox';
           version = nAgt.substring(verOffset + 8);
-        } else if ((nameOffset = nAgt.lastIndexOf(' ') + 1) < (verOffset = nAgt.lastIndexOf('/'))) {
+        }
+        // Other browsers
+        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;
           }
         }
+        // trim the version string
         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);
@@ -1098,6 +1870,9 @@
           "version": majorVersion
         };
       }
+      /**
+       * Returns Operating System name
+       */
       static getOS() {
         let os = "Unknown OS";
         let oscodes = [{
@@ -1192,9 +1967,15 @@
         }
         return os;
       }
+      /**
+       * Returns true whenever device supports WebRTC
+       */
       static hasWebRTCSupport() {
+        //if(this.getBrowserName() == "Facebook" && this.getOS() == "Android")
+        //return false;
         let isSupported = false;
         try {
+          // @ts-ignore
           let webrtc = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia || window.RTCPeerConnection;
           isSupported = true;
         } catch (error) {
@@ -1202,47 +1983,99 @@
         }
         return isSupported;
       }
+      /**
+       * Checks whenever player support "out-of-box" HLS (mobile browsers mostly do)
+       * @param videoObject html element video
+       */
       static hasHLSSupport(videoObject) {
+        //if(this.getBrowserName() == "Facebook" && this.getOS() == "Android")
+        //return false;
         if (videoObject !== null) {
           return Boolean(videoObject.canPlayType('application/vnd.apple.mpegURL') || videoObject.canPlayType('audio/mpegurl'));
         } else return false;
       }
+      /**
+       * Returns true or false depending on availability of Media Source Extensions (MSE)
+       */
       static hasMSESupport() {
+        // @ts-ignore
         const mediaSource = window.MediaSource = window.MediaSource || window.WebKitMediaSource;
+        // @ts-ignore
         window.SourceBuffer = window.SourceBuffer || window.WebKitSourceBuffer;
         return mediaSource && typeof mediaSource.isTypeSupported === 'function';
       }
+      /**
+       * Returns true or false depending on availability of Managed Media Source Extensions (MMS).
+       * This API is MacOS / iOS only.
+       */
       static hasMMSSupport() {
+        // @ts-ignore
         return window.ManagedMediaSource;
       }
+      /**
+       * Returns true whenever user is connected via HTTPS
+       */
       static isSSL() {
         if (location.protocol === 'https:') return true;else return false;
       }
     }
 
+    /**
+     * Saves and retrieve data from localStorage.
+     */
     class StorageManager {
+      /**
+       * Constructor
+       * @param main
+       * @param prefix
+       */
       constructor(main) {
         var _a, _b, _c, _d, _e, _f;
+        /**
+         * Decides whenever logs are being generated by this class
+         * @private
+         */
         this.LOG_ACTIVITY = false;
+        /**
+         * Whenever saving cookies is enabled at all
+         * @private
+         */
         this.isEnabled = true;
+        /**
+         * Prefix for multiple instances
+         * @private
+         */
         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");
       }
+      /**
+       * Saves data a a cookie
+       * @param name name of a field
+       * @param value value of a field
+       */
       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);
         }
       }
+      /**
+       * Removes a field from localStorage
+       * @param name the name of the field to remove
+       */
       removeField(name) {
         if (this.isEnabled) {
           if (this.LOG_ACTIVITY) this.logger.info(this, "Removing data: " + name);
           localStorage.removeItem(this.prefix + name);
         }
       }
+      /**
+       * Retrieves field from cookie
+       * @param name cookie name
+       */
       getField(name) {
         if (this.isEnabled == true) {
           const value = localStorage.getItem(this.prefix + name);
@@ -1638,13 +2471,38 @@
 
     var debounce$1 = /*@__PURE__*/getDefaultExportFromCjs(lodash_debounce);
 
+    /**
+     * Class controls the VideoElement itself
+     */
     class ScreenElement {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
       constructor(main) {
         var _a, _b, _c, _d, _e, _f;
+        /**
+         * Decides whenever logs are being generated by this class
+         * @private
+         */
         this.LOG_ACTIVITY = true;
+        /**
+         * Current volume level
+         * @private
+         */
         this._volume = 100;
+        /**
+         * Whenever video is muted
+         * @private
+         */
         this._isMuted = false;
+        /**
+         * Whenever video is muted by a browser
+         * @private
+         */
         this._isMutedByBrowser = false;
+        /**
+         * Called whenever browser stops playback
+         */
         this.onForceMute = () => {
           this._isMuted = true;
           this._isMutedByBrowser = true;
@@ -1677,18 +2535,33 @@
         });
         this.initialize();
       }
+      //------------------------------------------------------------------------//
+      // MAIN METHODS
+      //------------------------------------------------------------------------//
+      /**
+       * Initializes and pre-configures main video object
+       */
       initialize() {
-        this._videoElement.onload = function (event) {};
+        this._videoElement.onload = function (event) {
+          //console.log('videoElement.onload', event);
+        };
         this._videoElement.onstalled = event => {
           this._logger.info(this, "VideoElement :: onstalled");
         };
         this._videoElement.onerror = event => {
           this._logger.info(this, "VideoElement :: onerror :: " + JSON.stringify(event));
         };
+        /**
+         * Fires whenever something changes video object volume
+         * @param event
+         */
+        // @ts-ignore
         this._videoElement.onvolumechange = () => {
           this.dispatchVolumeEvent();
         };
-        this._videoElement.onpause = () => {};
+        this._videoElement.onpause = () => {
+          // nothing
+        };
         this._videoElement.addEventListener('loadedmetadata', () => {
           this._main.dispatchEvent("metadata", {
             ref: this._main,
@@ -1696,12 +2569,33 @@
             videoHeight: this._videoElement.videoHeight
           });
         });
-        this._videoElement.ontimeupdate = function (event) {};
+        /**
+         * Updates every second,
+         * @param event
+         */
+        this._videoElement.ontimeupdate = function (event) {
+          /*
+          let newWidth: number = self.videoElement.videoWidth;
+          let newHeight: number = self.videoElement.videoHeight;
+           if (newWidth != 0 && newHeight != 0) {
+              if (newWidth !== self.videoWidth || newHeight !== self.videoHeight) {
+                  self.videoWidth = newWidth;
+                  self.videoHeight = newHeight;
+                  self.scaleVideo();
+              }
+          }
+           */
+        };
+        // @ts-ignore
         this._videoElement.onended = event => {
           this._logger.info(this, "VideoElement :: onended");
         };
         this._videoElement.onplay = () => {};
       }
+      /**
+       * Sets new volume for playback. It'll also try to store value in a browser memory
+       * @param value
+       */
       setVolume(value) {
         if (this._isMuted && value > 0) this.setMuted(false);
         this._volume = value;
@@ -1712,6 +2606,10 @@
       getVolume() {
         return this._volume;
       }
+      /**
+       * Allows to apply mute to a video element
+       * @param isMuted
+       */
       setMuted(isMuted) {
         this._isMuted = isMuted;
         this._videoElement.muted = isMuted;
@@ -1719,9 +2617,15 @@
         this._main.getStorageManager().saveField("muted", String(isMuted));
         if (this.getVolume() == 0 && !isMuted) this.setVolume(100);
       }
+      /**
+       * Returns true/false whenever video is muted or not
+       */
       getIfMuted() {
         return this._isMuted;
       }
+      /**
+       * Dispatches event informing about volume chan
+       */
       dispatchVolumeEvent() {
         const action = !this._isMutedByBrowser ? "user" : "browser";
         const eventObj = {
@@ -1737,12 +2641,22 @@
           invokedBy: action
         });
       }
+      /**
+       * Return VideoElement
+       */
       getVideoElement() {
         return this._videoElement;
       }
     }
 
+    /**
+     * Class responsible for operations on numbers
+     */
     class DomUtilities {
+      /**
+       * Calculates element dimensions including margins
+       * @param element
+       */
       static calculateDimensionsWithMargins(element) {
         const style = window.getComputedStyle(element);
         const rect = element.getBoundingClientRect();
@@ -1763,20 +2677,73 @@
       }
     }
 
+    /**
+     * Class controls all visual elements of the player
+     */
     class StageController {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
       constructor(main) {
+        /**
+         * Video width
+         * @private
+         */
         this._containerWidth = 0;
+        /**
+         * Temp container width
+         * @private
+         */
         this._tempContainerWidth = 0;
+        /**
+         * Video height
+         * @private
+         */
         this._containerHeight = 0;
+        /**
+         * Temp container height
+         * @private
+         */
         this._tempContainerHeight = 0;
+        /**
+         * Video width (initally 0, after "onmetadata" event is updated to match the real one
+         * @private
+         */
         this._videoWidth = 0;
+        /**
+         * Video width (initally 0, after "onmetadata" event is updated to match the real one
+         * @private
+         */
         this._videoHeight = 0;
+        /**
+         * Current scaling type
+         * @private
+         */
         this._scalingMode = ScalingType.FILL;
+        /**
+         * If in fullscreen mode
+         * @private
+         */
         this.isInFullScreenMode = false;
+        /**
+         * Whenever we are resizing atm.
+         * @private
+         */
         this._isResizing = false;
+        /**
+         * Deco
+         * @private
+         */
         this._autoResizeEnabled = true;
+        /**
+         * Parameter holds original overflow style
+         * @private
+         */
         this._parentOriginalOverflow = '';
         this._debug = false;
+        //------------------------------------------------------------------------//
+        // FULLSCREEN
+        //------------------------------------------------------------------------//
         this.onFullScreenChange = () => {
           if (document.fullscreenElement == null) {
             this.isInFullScreenMode = false;
@@ -1797,16 +2764,22 @@
         this._logger.info(this, "Creating new StageController");
         this.initialize();
       }
+      //------------------------------------------------------------------------//
+      // MAIN METHODS
+      //------------------------------------------------------------------------//
       initialize() {
         var _a, _b, _c, _d, _e, _f, _g, _h;
+        // prepare data
         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._debug = (_h = (_g = this._main.getConfigManager()) === null || _g === void 0 ? void 0 : _g.getSettingsData().getDebugData().stageControllerDebug) !== null && _h !== void 0 ? _h : this._debug;
+        // pre-configuration for videoContainer
         this._videoContainer = document.createElement('div');
         this._videoContainer.setAttribute("id", "stormStreamer_" + this._main.getStreamerID());
         this._videoContainer.style.overflow = "hidden";
         this._videoContainer.style.position = "relative";
         this._videoContainer.classList.add("stormStreamer");
+        // pre-configuration for videoElement
         this._screenElement = new ScreenElement(this._main);
         this._videoContainer.appendChild(this._screenElement.getVideoElement());
         const debounceValue = this._main.getConfigManager().getSettingsData().getVideoData().resizeDebounce;
@@ -1836,9 +2809,16 @@
           this.attachToParent(containerID);
         } else this._logger.warning(this, `Could not create HTMLObject for the library - "containerID" was not provided`);
       }
+      /**
+       * Method attaches element to a parent container
+       *
+       * @param container
+       */
       attachToParent(container) {
-        let result = false;
+        // preparing elements
+        let result = false; // To indicate the success of the operation
         let tempParentElement = null;
+        // Check if container is either an ID string or an HTMLElement instance
         if (typeof container === "string") {
           this._logger.info(this, "Attaching container to ID: " + container);
           tempParentElement = document.getElementById(container);
@@ -1846,11 +2826,13 @@
           this._logger.info(this, "Attaching container to HTMLElement: " + container);
           tempParentElement = container;
         }
+        // Check if the new container is not the same as the old one
         if (tempParentElement === this._parentElement) {
           if (this._debug) this._logger.decoratedLog("Attaching Failed (container is the same)", "dark-pink");
           this._logger.warning(this, "attachToParent :: container is the same");
           return false;
         }
+        // If a valid container is found and _videoContainer exists, append it
         if (tempParentElement && this._videoContainer) {
           if (this._debug) this._logger.decoratedLog("Attach To Parent: " + container + " (success)", "dark-pink");
           this._parentElement = tempParentElement;
@@ -1864,13 +2846,16 @@
             container: this._parentElement
           });
           this.handleResize();
-          result = true;
+          result = true; // Operation successful
         } else {
           if (this._debug) this._logger.decoratedLog("Attach To Parent: " + container + " (failure - container not found)", "dark-pink");
           this._logger.warning(this, "attachToParent :: container \"" + container + "\"+ was not found");
         }
-        return result;
+        return result; // Return the result of the operation
       }
+      /**
+       * Detaches the library from a parent container
+       */
       detachFromParent() {
         if (this._debug) this._logger.decoratedLog("Detach From Parent", "dark-pink");
         let result = false;
@@ -1898,7 +2883,9 @@
         this._isResizing = true;
         this._parentOriginalOverflow = this._parentElement.style.overflow;
         this._parentElement.style.overflow = 'hidden';
+        // Używamy requestAnimationFrame aby dać przeglądarce czas na zastosowanie overflow
         requestAnimationFrame(() => {
+          // Obliczamy nowe wymiary
           this.calculateNewDimensions();
           this._parentElement.style.overflow = this._parentOriginalOverflow;
           this._isResizing = false;
@@ -1933,6 +2920,10 @@
         this.resizeVideoContainer();
         this.scaleVideo();
       }
+      /**
+       * Method resizes video container
+       * @private
+       */
       resizeVideoContainer() {
         const isWidthInPX = this._main.getConfigManager().getSettingsData().getVideoData().videoWidthInPixels;
         const isHeightInPX = this._main.getConfigManager().getSettingsData().getVideoData().videoHeightInPixels;
@@ -1979,12 +2970,14 @@
           let videoWidth = 0;
           let videoHeight = 0;
           switch (this._scalingMode) {
+            //--- FILL, covers 100% of width & height
             case ScalingType.FILL:
               {
                 videoWidth = this._containerWidth;
                 videoHeight = this._containerHeight;
               }
               break;
+            //--- CROP
             case ScalingType.CROP:
               {
                 videoWidth = this._containerWidth;
@@ -2000,8 +2993,10 @@
                 }
               }
               break;
+            //--- LETTER BOX
             case ScalingType.LETTER_BOX:
               {
+                // jeżeli szerokość
                 videoWidth = this._containerWidth;
                 videoHeight = this._videoHeight * this._containerWidth / this._videoWidth;
                 if (videoHeight <= this._containerHeight) {
@@ -2021,6 +3016,7 @@
                 }
               }
               break;
+            //--- ORIGINAL
             case ScalingType.ORIGINAL:
               {
                 videoWidth = this._videoWidth;
@@ -2040,7 +3036,9 @@
       }
       enterFullScreen() {
         var _a, _b, _c;
+        // @ts-ignore
         if ((_a = this._screenElement) === null || _a === void 0 ? void 0 : _a.getVideoElement().webkitEnterFullScreen) {
+          // @ts-ignore
           (_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();
@@ -2048,7 +3046,9 @@
       }
       exitFullScreen() {
         var _a;
+        // @ts-ignore
         if ((_a = this._screenElement) === null || _a === void 0 ? void 0 : _a.getVideoElement().webkitExitFullscreen) {
+          // @ts-ignore
           document.webkitExitFullscreen();
         } else {
           document.exitFullscreen();
@@ -2057,6 +3057,9 @@
       isFullScreenMode() {
         return this.isInFullScreenMode;
       }
+      //------------------------------------------------------------------------//
+      // SETS & GETS
+      //------------------------------------------------------------------------//
       setDimension(key, value) {
         const dimensionKey = key === 'width' ? 'videoWidth' : 'videoHeight';
         let valueInPixels;
@@ -2138,10 +3141,17 @@
       getContainer() {
         return this._videoContainer;
       }
+      //------------------------------------------------------------------------//
+      // CLEANUP
+      //------------------------------------------------------------------------//
       destroy() {
         this.detachFromParent();
       }
     }
+    /**
+     * Decides whenever logs are being generated by this class
+     * @private
+     */
     StageController.LOG_ACTIVITY = true;
 
     class MungeSDP {
@@ -2265,7 +3275,9 @@
         MungeSDP.audioChoice = mungeData.audioCodec || "opus";
         MungeSDP.videoIndex = -1;
         MungeSDP.audioIndex = -1;
+        // Zapewniamy, że frame rate jest w odpowiednim zakresie
         const frameRate = mungeData.videoFrameRate ? Math.min(Math.max(mungeData.videoFrameRate, 1), 60) : 30;
+        // Pierwszy przebieg - zbieranie informacji o kodekach
         const sdpLines = sdpStr.split(/\r\n/);
         let sdpStrRet = '';
         for (const sdpLine of sdpLines) {
@@ -2274,23 +3286,26 @@
           if (!doneCheck) continue;
           sdpStrRet += sdpLine + '\r\n';
         }
+        // Dodaj linie audio i video
         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 = '';
         let sdpSection = 'header';
         let hitMID = false;
+        // Dodajemy parametry frame rate dla każdego kodeka video
         const addFrameRateParameters = payloadType => {
           let params = '';
           params += `\r\na=rtcp-fb:${payloadType} ccm fir`;
           params += `\r\na=rtcp-fb:${payloadType} nack`;
           params += `\r\na=rtcp-fb:${payloadType} nack pli`;
-          params += `\r\na=rtcp-fb:${payloadType} goog-remb`;
+          params += `\r\na=rtcp-fb:${payloadType} goog-remb`; // Dodajemy wsparcie dla REMB
           params += `\r\na=fmtp:${payloadType} max-fr=${frameRate};max-fps=${frameRate}`;
           return params;
         };
         for (const sdpLine of newSdpLines) {
           if (sdpLine.length <= 0) continue;
+          // Sekcja audio
           if (sdpLine.indexOf("m=audio") === 0 && MungeSDP.audioIndex !== -1) {
             const audioMLines = sdpLine.split(" ");
             sdpStrRet += `${audioMLines[0]} ${audioMLines[1]} ${audioMLines[2]} ${MungeSDP.audioIndex}\r\n`;
@@ -2298,21 +3313,25 @@
             hitMID = false;
             continue;
           }
+          // Sekcja video - tutaj dodajemy podstawowe parametry frame rate
           if (sdpLine.indexOf("m=video") === 0 && MungeSDP.videoIndex !== -1) {
             const videoMLines = sdpLine.split(" ");
             sdpStrRet += `${videoMLines[0]} ${videoMLines[1]} ${videoMLines[2]} ${MungeSDP.videoIndex}\r\n`;
-            sdpStrRet += `a=framerate:${frameRate}\r\n`;
-            sdpStrRet += `a=x-google-max-framerate:${frameRate}\r\n`;
-            sdpStrRet += `a=max-fr:${frameRate}\r\n`;
+            // Dodajemy kompleksowe parametry frame rate
+            sdpStrRet += `a=framerate:${frameRate}\r\n`; // Standardowy parametr
+            sdpStrRet += `a=x-google-max-framerate:${frameRate}\r\n`; // Chrome
+            sdpStrRet += `a=max-fr:${frameRate}\r\n`; // Dodatkowy parametr
             sdpSection = 'video';
             hitMID = false;
             continue;
           }
           sdpStrRet += sdpLine;
+          // Obsługa rtpmap i parametrów kodeków
           if (sdpLine.indexOf("a=rtpmap") === 0) {
             const rtpmapID = this.getrtpMapID(sdpLine);
             if (rtpmapID !== null) {
               const codecName = rtpmapID[2].toLowerCase();
+              // Parametry dla kodeków video
               if (codecName === 'vp9' || codecName === 'vp8' || codecName === 'h264') {
                 sdpStrRet += addFrameRateParameters(rtpmapID[1]);
               }
@@ -2320,6 +3339,7 @@
             sdpSection = 'bandwidth';
             hitMID = false;
           }
+          // Obsługa specyficzna dla przeglądarek
           const browser = UserCapabilities.getBrowserName().toLowerCase();
           if (browser === 'chrome' || browser === 'safari') {
             if (sdpLine.indexOf("a=mid:") === 0 || sdpLine.indexOf("a=rtpmap") === 0) {
@@ -2332,6 +3352,7 @@
                   sdpStrRet += `\r\na=x-google-max-framerate:${frameRate}`;
                   hitMID = true;
                 }
+                // Dodatkowe parametry dla Chrome
                 if (browser === 'chrome' && sdpSection === 'bandwidth') {
                   const rtpmapID = this.getrtpMapID(sdpLine);
                   if (rtpmapID !== null) {
@@ -2489,8 +3510,9 @@
         this._analyser = null;
         this._microphone = null;
         this._lastEventTime = 0;
-        this.THROTTLE_INTERVAL = 100;
+        this.THROTTLE_INTERVAL = 100; // ms between updates
         this._isMonitoring = false;
+        // Moving average variables for smoothing
         this._instant = 0.0;
         this._slow = 0.0;
         this._main = main;
@@ -2500,23 +3522,30 @@
           console.warn('SoundMeter: Attempted to attach stream without audio tracks');
           return;
         }
+        // Ensure clean state before attaching
         this.detach();
         try {
           this._audioContext = new AudioContext();
+          // Create and configure nodes
           this._microphone = this._audioContext.createMediaStreamSource(stream);
           this._analyser = this._audioContext.createAnalyser();
           this._analyser.fftSize = 2048;
           this._analyser.smoothingTimeConstant = 0.3;
+          // Connect nodes
           this._microphone.connect(this._analyser);
+          // Start monitoring
           this.startMonitoring();
         } catch (error) {
           console.error('SoundMeter: Error during attach:', error);
-          this.detach();
+          this.detach(); // Cleanup on error
         }
       }
+
       detach() {
         var _a, _b;
+        // Stop monitoring first
         this._isMonitoring = false;
+        // Disconnect and cleanup nodes in reverse order
         if (this._microphone) {
           try {
             this._microphone.disconnect();
@@ -2556,7 +3585,9 @@
           if (!this._analyser || !this._isMonitoring) return;
           const now = Date.now();
           try {
+            // Read time-domain data
             this._analyser.getFloatTimeDomainData(dataArray);
+            // Calculate levels
             let sum = 0.0;
             let clipcount = 0;
             for (let i = 0; i < dataArray.length; ++i) {
@@ -2566,8 +3597,10 @@
                 clipcount += 1;
               }
             }
+            // Update metrics
             this._instant = Math.sqrt(sum / dataArray.length);
             this._slow = 0.05 * this._instant + 0.95 * this._slow;
+            // Throttle event dispatch
             if (now - this._lastEventTime >= this.THROTTLE_INTERVAL) {
               this._lastEventTime = now;
               this._main.dispatchEvent("soundMeter", {
@@ -2581,8 +3614,10 @@
             this._isMonitoring = false;
             return;
           }
+          // Schedule next analysis
           requestAnimationFrame(analyze);
         };
+        // Start analysis loop
         requestAnimationFrame(analyze);
       }
     }
@@ -2607,6 +3642,9 @@
       DeviceState["STOPPED"] = "STOPPED";
     })(exports.DeviceState || (exports.DeviceState = {}));
 
+    /**
+     * Different connection states
+     */
     var ConnectionState;
     (function (ConnectionState) {
       ConnectionState[ConnectionState["NOT_INITIALIZED"] = 0] = "NOT_INITIALIZED";
@@ -2617,16 +3655,56 @@
       ConnectionState[ConnectionState["FAILED"] = 5] = "FAILED";
     })(ConnectionState || (ConnectionState = {}));
 
+    /**
+     * Base for all classes that use WebSocksts
+     */
+    /**
+     * Abstract socket connection
+     */
     class AbstractSocket {
       constructor() {
+        /**
+         * Connection timeout
+         * @protected
+         */
         this.CONNECTION_TIMEOUT = 5;
+        /**
+         * Whenever it is binary data or not
+         * @protected
+         */
         this.isBinary = true;
+        /**
+         * Current state of the connection
+         * @private
+         */
         this._connectionState = ConnectionState.NOT_INITIALIZED;
+        /**
+         * Number of messages that arrived
+         * @private
+         */
         this._messageCount = 0;
+        /**
+         * Was disconnected by user?
+         * @protected
+         */
         this._disconnectedByUser = false;
+        /**
+         * Whenever we're connected to a server or not
+         * @private
+         */
         this._isConnected = false;
+        /**
+         * Counts connections
+         * @protected
+         */
         this._sequenceNumber = -1;
       }
+      /**
+       * Creates and starts new socket connection
+       *
+       * @param socketURL
+       * @private
+       */
       startConnection() {
         this._disconnectedByUser = false;
         this._messageCount = 0;
@@ -2660,24 +3738,61 @@
           if (this._connectionState == ConnectionState.CONNECTED) {
             try {
               this.socket.close();
-            } catch (error) {}
+            } catch (error) {
+              //
+            }
           }
         };
         this._connectionTimeout = setTimeout(() => {
           try {
             this.socket.close();
-          } catch (error) {}
+          } 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) {}
+      /**
+       * Method is called once connection with the server is established
+       * @param event
+       */
+      onSocketOpen(event) {
+        // nothing, for extension only
+      }
+      /**
+       * Method is called once connection with the server is closed (
+       *
+       * @param event
+       */
+      onSocketClose(event) {
+        // nothing, for extension only
+      }
+      /**
+       * Method is called whenever a new message from socket arrives
+       * @private
+       */
+      onSocketMessage(event) {
+        // nothing, for extension only
+      }
+      /**
+       * Method is called whenever an error on socket occures
+       *
+       * @param event
+       * @private
+       */
+      onSocketError(event) {
+        // nothing, for extension only
+      }
+      onError(error) {
+        // nothing, for extension only
+      }
+      /**
+       * Sends data via socket
+       * @param data
+       */
       sendData(data) {
         if (this._connectionState == ConnectionState.CONNECTED) {
           if (this.socket !== null) {
@@ -2689,9 +3804,15 @@
         }
         this.onError("socket not connected");
       }
+      /**
+       * Returns player state e.g. NOT_INITIALIZED, STARTED, CONNECTED, ENDED
+       */
       getConnectionState() {
         return this._connectionState;
       }
+      /**
+       * Rozłacza z serwerem
+       */
       disconnect(byUser = true) {
         this._isConnected = false;
         this._connectionState = ConnectionState.CLOSED;
@@ -2707,6 +3828,11 @@
           this.socket.close();
         }
       }
+      /**
+       * Destroys connection
+       *
+       * @protected
+       */
       destroy() {
         if (this.socket !== undefined && this.socket !== null) {
           this.socket.onopen = null;
@@ -2717,6 +3843,10 @@
         }
         this._connectionState = ConnectionState.CLOSED;
       }
+      /**
+       * Returns currenly used socketURL
+       * @protected
+       */
       getSocketURL() {
         return this.socketURL;
       }
@@ -2790,7 +3920,18 @@
       }
     }
 
+    /**
+     * Main class for communicating with Storm Streaming Server
+     */
     class WowzaStatusConnection extends AbstractSocket {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constructor
+       * @param main
+       * @constructor
+       */
       constructor(main, server) {
         super();
         this._logger = main.getLogger();
@@ -2806,6 +3947,14 @@
           this.startConnection();
         } else this._logger.error(this, "Connection with the server could not be initialized!");
       }
+      //------------------------------------------------------------------------//
+      // BASE EVENTS
+      //------------------------------------------------------------------------//
+      /**
+       * On server connection opened;
+       * @param event
+       * @protected
+       */
       onSocketOpen(event) {
         this._logger.success(this, `Connection with the server has been established!`);
         this._main.dispatchEvent("statusServerConnect", {
@@ -2815,6 +3964,11 @@
         });
         this._isConnected = true;
       }
+      /**
+       * On server connection error
+       * @param event
+       * @protected
+       */
       onSocketError(event) {
         this._isConnected = false;
         if (!this._disconnectedByUser) {
@@ -2827,6 +3981,11 @@
           });
         }
       }
+      /**
+       * On server connection closed
+       * @param event
+       * @protected
+       */
       onSocketClose(event) {
         this._isConnected = false;
         if (!this._disconnectedByUser) {
@@ -2840,6 +3999,10 @@
           this.initiateReconnect();
         } else this._logger.warning(this, `Force disconnect from server!`);
       }
+      /**
+       * Method is called whenever a new message from socket arrives
+       * @private
+       */
       onSocketMessage(event) {
         if (typeof event.data == "string") {
           let msgJSON = JSON.parse(event.data);
@@ -2864,6 +4027,10 @@
           }
         }
       }
+      /**
+       * Initiates reconnection procedure
+       * @private
+       */
       initiateReconnect() {
         const shouldReconnect = this._main.getConfigManager().getSettingsData().getIfRestartOnError();
         const reconnectTime = this._main.getConfigManager().getSettingsData().getReconnectTime();
@@ -2884,6 +4051,14 @@
           }, reconnectTime * 1000);
         }
       }
+      //------------------------------------------------------------------------//
+      // BASE METHODS
+      //------------------------------------------------------------------------//
+      /**
+       * Creates new URL for WebSockets based on serverItem object
+       * @param serverItem
+       * @private
+       */
       createURL(serverItem) {
         let url = "";
         url += serverItem.getIfSSL() ? "wss://" : "ws://";
@@ -2892,12 +4067,18 @@
         url += "/statuschecker";
         return url;
       }
+      /**
+       * Returns true/false depending if a connection with a server is active
+       */
       isConnectionActive() {
         return this._isConnected;
       }
       getCurrentServer() {
         return this._currServer;
       }
+      /**
+       * Destroys object and clean-ups everything that is needed
+       */
       destroy() {
         super.destroy();
       }
@@ -2943,16 +4124,51 @@
       }
     }
 
+    /**
+     * This class (instance) is responsible to controlling video playback. It's the central point of the whole project, where
+     * all components are being managed.
+     */
     class StreamerController {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constructor - requires properly configured config object
+       * @param config
+       */
       constructor(main) {
         var _a, _b, _c;
+        /**
+         * Whenever current window is active or not
+         * @private
+         */
         this._isWindowActive = true;
+        /**
+         * Default configuration for ICE-Servers
+         * @private
+         */
         this._peerConnectionConfig = {
           'iceServers': []
         };
+        /**
+         * Whenever microphone is currenly muted
+         * @private
+         */
         this._isMicrophoneMuted = false;
+        /**
+         * Desired microphone state that should be applied when stream becomes available
+         * @private
+         */
         this._pendingMicrophoneState = null;
+        /**
+         * Whenever we have cheched for permissions
+         * @private
+         */
         this._permissionChecked = false;
+        /**
+         * A default set of permissions
+         * @private
+         */
         this._constraints = {
           video: {
             width: {
@@ -2973,17 +4189,45 @@
           },
           audio: true
         };
+        /**
+         * Current count for restart, _restartTimerMaxCount is the max number
+         * @private
+         */
         this._restartTimerCount = 0;
+        /**
+         * max
+         * @private
+         */
         this._restartTimerMaxCount = 5;
+        /**
+         * Current streamer state
+         * @protected
+         */
         this._publishState = exports.PublishState.NOT_INITIALIZED;
         this._publishTime = 0;
+        /**
+         * General state for streamer
+         * @protected
+         */
         this._inputDeviceState = exports.InputDevicesState.NOT_INITIALIZED;
+        /**
+         * Current Camera state
+         * @protected
+         */
         this._cameraState = exports.DeviceState.NOT_INITIALIZED;
+        /**
+         * Current Microphone state
+         * @protected
+         */
         this._microphoneState = exports.DeviceState.NOT_INITIALIZED;
         this._publishTimer = 0;
         this._currentOrientation = ((_a = window.screen.orientation) === null || _a === void 0 ? void 0 : _a.type) || '';
         this._statusTimer = null;
         this._debug = false;
+        /**
+         * Handles device state changes and initiates publishing if appropriate
+         * @private
+         */
         this.onDeviceStateChange = event => {
           var _a;
           const usedStreamKey = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey;
@@ -2991,15 +4235,21 @@
             this.publish(usedStreamKey);
           }
         };
+        /**
+         * This method is responsible for handing orientation changes for mobile devices
+         */
         this.handleOrientationChange = () => __awaiter(this, void 0, void 0, function* () {
           var _d, _e;
+          // Dajemy chwilę na ustabilizowanie się orientacji
           yield new Promise(resolve => setTimeout(resolve, 500));
           const newOrientation = ((_d = window.screen.orientation) === null || _d === void 0 ? void 0 : _d.type) || '';
           if (this._currentOrientation !== newOrientation) {
             this._logger.info(this, `Orientation changed from ${this._currentOrientation} to ${newOrientation}`);
             this._currentOrientation = newOrientation;
+            // Zapamiętaj aktualny stream key i stan publikacji
             const streamKey = (_e = this._main.getConfigManager()) === null || _e === void 0 ? void 0 : _e.getStreamData().streamKey;
             this._publishState === exports.PublishState.PUBLISHED;
+            // Zamknij istniejące połączenie i stream
             this.closeWebRTCConnection();
             if (this._stream) {
               this._stream.getTracks().forEach(track => {
@@ -3007,8 +4257,10 @@
               });
               this._stream = null;
             }
+            // Rozpocznij wszystko od nowa
             try {
               yield this.startCamera();
+              // Jeśli stream był opublikowany, publikujemy ponownie
               if (streamKey) {
                 this.publish(streamKey);
               }
@@ -3019,6 +4271,9 @@
           }
         });
         this.onServerDisconnect = () => {};
+        /**
+         * Method for handling a situation when a given streamKey is already in use.
+         */
         this.onStreamKeyTaken = () => {
           if (this._restartTimer != null) {
             clearInterval(this._restartTimer);
@@ -3053,17 +4308,26 @@
             }
           }, 1000);
         };
+        //------------------------------------------------------------------------//
+        // NETWORK AND RTC
+        //------------------------------------------------------------------------//
+        /**
+         * Method fires once a connection with wowza is established. It's the main connection where we exchange
+         * ice-candidates and SDP. We'll start setting up peer connections.
+         */
         this.onServerConnect = () => {
           if (this._peerConnection) {
             this.closeWebRTCConnection();
           }
           this._peerConnection = new RTCPeerConnection(this._peerConnectionConfig);
+          // Najpierw dodaj tracki
           if (this._stream) {
             let localTracks = this._stream.getTracks();
             for (let localTrack in localTracks) {
               this._peerConnection.addTrack(localTracks[localTrack], this._stream);
             }
           }
+          // Potem dodaj event handlery
           this._peerConnection.onicecandidate = event => {
             this.onIceCandidate(event);
           };
@@ -3083,6 +4347,9 @@
           });
           this.createStatusConnection();
         };
+        /**
+         * Method fires once a status connection is established. We'll set an interval for monitoring stream status.
+         */
         this.onStatusServerConnect = () => {
           const usedStreamKey = this._main.getConfigManager().getStreamData().streamKey;
           if (this._statusTimer == null) {
@@ -3095,13 +4362,20 @@
         };
         this.requestStatusData = () => {
           var _a;
-          const usedStreamKey = this._main.getConfigManager().getStreamData().streamKey;
-          (_a = this._statusConnection) === null || _a === void 0 ? void 0 : _a.sendData('{"packetID":"STREAM_STATUS", "streamKey": "' + usedStreamKey + '"}');
+          (_a = this._statusConnection) === null || _a === void 0 ? void 0 : _a.sendData('{"packetID":"STREAM_STATUS", "streamKey": "' + this._fullStreamName + '"}');
         };
+        /**
+         * If for some reason the status connection is disconnected we have to clean the interval
+         */
         this.onStatusServerDisconnect = () => {
           if (this._statusTimer != null) clearInterval(this._statusTimer);
           this._statusTimer = null;
         };
+        /**
+         * This event fires whenever "STREAM_STATUS_RESPONSE" packet form status connection reports stream status along some stream data. This gives
+         * us an insight into whenever our stream is ok (works) or not.
+         * @param event
+         */
         this.onStreamStatsUpdate = event => {
           const update = event.streamStatus;
           if (this._publishState == exports.PublishState.PUBLISHED && update.publishState != exports.PublishState.PUBLISHED) this.setPublishState(exports.PublishState.UNPUBLISHED);
@@ -3109,9 +4383,10 @@
         };
         this.onDescriptionSuccess = description => {
           var _a, _b, _c;
+          this._fullStreamName = ((_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey) + "_" + new Date().getTime();
           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,
+            applicationName: (_c = (_b = this._main.getNetworkController()) === null || _b === void 0 ? void 0 : _b.getConnection().getCurrentServer()) === null || _c === void 0 ? void 0 : _c.getApplication(),
+            streamName: this._fullStreamName,
             sessionId: "[empty]"
           };
           description.sdp = this._mungeSDP.mungeSDPPublish(description.sdp, {
@@ -3127,9 +4402,16 @@
               (_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.onWebRTCError(error, self);
             });
           }
         };
+        //------------------------------------------------------------------------//
+        // BLUR & FOCUS
+        //------------------------------------------------------------------------//
+        /**
+         * Methods handles visibility change events
+         */
         this.visibilityChange = () => {
           if (document.visibilityState === 'hidden') {
             this.onWindowBlur();
@@ -3137,12 +4419,18 @@
             this.onWindowFocus();
           }
         };
+        /**
+         * Reacts to browser changing visibility of the document (or blur)
+         */
         this.onWindowBlur = () => {
           if (this._isWindowActive) {
             this._logger.warning(this, "Player window is no longer in focus!");
           }
           this._isWindowActive = false;
         };
+        /**
+         * Reacts to browser changing visibility of the document (or focus)
+         */
         this.onWindowFocus = () => {
           if (!this._isWindowActive) {
             this._logger.info(this, "Player window is focused again!");
@@ -3154,8 +4442,18 @@
         this._mungeSDP = new MungeSDP();
         this._soundMeter = new SoundMeter(this._main);
         this._debug = (_c = (_b = this._main.getConfigManager()) === null || _b === void 0 ? void 0 : _b.getSettingsData().getDebugData().streamerControllerDebug) !== null && _c !== void 0 ? _c : this._debug;
+        // Start initialization process
         this.initialize();
       }
+      //------------------------------------------------------------------------//
+      // MAIN METHODS
+      //------------------------------------------------------------------------//
+      /**
+       * Initializes the PlaybackController by setting up event listeners and device handling
+       * This method orchestrates the initialization process by first checking device availability
+       * and permissions, then setting up necessary event listeners and configurations
+       * @private
+       */
       initialize() {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
@@ -3177,6 +4475,10 @@
           }
         });
       }
+      /**
+       * Sets up core event listeners for the controller
+       * @private
+       */
       setupEventListeners() {
         this._main.addEventListener("serverConnect", this.onServerConnect, false);
         this._main.addEventListener("serverDisconnect", this.onServerDisconnect, false);
@@ -3189,14 +4491,21 @@
         window.addEventListener("blur", this.onWindowBlur);
         window.addEventListener("focus", this.onWindowFocus);
       }
+      /**
+       * Initializes media devices by checking permissions and setting up initial device lists
+       * @private
+       */
       initializeDevices() {
         return __awaiter(this, void 0, void 0, function* () {
           try {
+            // Request initial device permissions
             const stream = yield navigator.mediaDevices.getUserMedia({
               video: true,
               audio: true
             });
+            // Stop the test stream
             stream.getTracks().forEach(track => track.stop());
+            // Initialize device lists
             yield this.grabDevices();
           } catch (error) {
             this._logger.error(this, "Error initializing devices: " + JSON.stringify(error));
@@ -3204,6 +4513,10 @@
           }
         });
       }
+      /**
+       * Initializes the media stream if a camera or microphone is selected
+       * @private
+       */
       initializeStream() {
         if (this._selectedCamera || this._selectedMicrophone) {
           this.startCamera();
@@ -3243,8 +4556,12 @@
           }
         });
       }
+      /**
+       * Handles successful camera stream initialization
+       */
       onCameraStreamSuccess(stream) {
         this._logger.success(this, "Camera stream successfully retrieved");
+        // Get actual stream dimensions
         const videoTrack = stream.getVideoTracks()[0];
         const audioTrack = stream.getAudioTracks()[0];
         const streamData = new PublishMetadata();
@@ -3252,6 +4569,7 @@
           const settings = videoTrack.getSettings();
           let width = settings.width;
           let height = settings.height;
+          // Na urządzeniach mobilnych potrzebujemy skorygować wymiary
           const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
           if (isMobile) {
             if (width > height && window.innerWidth < window.innerHeight || width < height && window.innerWidth > window.innerHeight) {
@@ -3261,10 +4579,12 @@
           streamData.streamWidth = width;
           streamData.streamHeight = height;
           streamData.videoTrackPresent = true;
+          // Obliczanie proporcji i konwersja na string
           const gcd = (a, b) => b ? gcd(b, a % b) : a;
           const divisor = gcd(width, height);
           const widthRatio = width / divisor;
           const heightRatio = height / divisor;
+          // Sprawdzamy typowe proporcje z pewną tolerancją
           const ratio = width / height;
           let aspectRatioString = `${widthRatio}:${heightRatio}`;
           if (Math.abs(ratio - 16 / 9) < 0.1) {
@@ -3278,6 +4598,7 @@
         }
         streamData.audioTrackPresent = !!audioTrack;
         this._logger.info(this, `Publish MetaData :: Resolution: ${streamData.streamWidth}x${streamData.streamHeight} | ` + `Aspect ratio: ${streamData.aspectRatio}, ` + `Video track: ${streamData.videoTrackPresent} | Audio track: ${streamData.audioTrackPresent}`);
+        // Dispatch event with stream data
         this._main.dispatchEvent("publishMetadataUpdate", {
           ref: this._main,
           metadata: streamData
@@ -3304,6 +4625,9 @@
         videoElement.muted = true;
         this.setPublishState(exports.PublishState.INITIALIZED);
       }
+      /**
+       * Initializes WebRTC connection
+       */
       initializeWebRTC() {
         var _a;
         if (!this._stream) {
@@ -3318,6 +4642,12 @@
           (_a = this._main.getNetworkController()) === null || _a === void 0 ? void 0 : _a.start();
         }
       }
+      /**
+       * Modified publish method to handle both camera and WebRTC
+       *
+       * @param streamKey - klucz streamu
+       * @returns {boolean} - true jeśli udało się rozpocząć publikowanie
+       */
       publish(streamKey) {
         if (this._statusTimer != null) clearInterval(this._statusTimer);
         if (this._main.getConfigManager().getStreamData().streamKey == streamKey && this._publishState == exports.PublishState.CONNECTED) {
@@ -3357,21 +4687,40 @@
         });
         this.closeStream();
       }
+      /**
+       * This method
+       * @private
+       */
       setupOrientationListener() {
+        // Sprawdzamy czy urządzenie wspiera event orientationchange
         if (window.screen && window.screen.orientation) {
           window.screen.orientation.addEventListener('change', this.handleOrientationChange);
         } else {
+          // Fallback dla starszych urządzeń
           window.addEventListener('orientationchange', this.handleOrientationChange);
         }
       }
+      //------------------------------------------------------------------------//
+      // USER MEDIA
+      //------------------------------------------------------------------------//
+      /**
+       * Error on trying to grab video stream (it usually means that browser does not support WebRTC streaming)
+       *
+       * @param error
+       */
       onUserMediaError(error) {
         return __awaiter(this, void 0, void 0, function* () {
           yield this.grabDevices();
+          // Dodatkowa obsługa specyficznych błędów getUserMedia, jeśli potrzebna
           if (error.name === "OverconstrainedError") {
             this._logger.warning(this, "Device constraints not satisfied");
           }
         });
       }
+      /**
+       * This method is used for checking individual access to output devices
+       * @private
+       */
       checkIndividualDeviceAccess() {
         return __awaiter(this, void 0, void 0, function* () {
           const results = {
@@ -3384,27 +4733,35 @@
               available: false
             }
           };
+          // Sprawdzamy fizyczną dostępność urządzeń
           try {
             const devices = yield navigator.mediaDevices.enumerateDevices();
             results.camera.available = devices.some(device => device.kind === 'videoinput');
             results.microphone.available = devices.some(device => device.kind === 'audioinput');
+            // Sprawdzamy czy mamy etykiety urządzeń - ich brak może oznaczać brak uprawnień
             const hasLabels = devices.some(device => device.label !== '');
             if (!hasLabels) {
+              // Jeśli nie mamy etykiet, wymuszamy pytanie o uprawnienia
               try {
                 const stream = yield navigator.mediaDevices.getUserMedia({
                   video: results.camera.available,
                   audio: results.microphone.available
                 });
+                // Jeśli udało się uzyskać strumień, mamy uprawnienia
                 results.camera.allowed = stream.getVideoTracks().length > 0;
                 results.microphone.allowed = stream.getAudioTracks().length > 0;
+                // Zatrzymujemy strumień testowy
                 stream.getTracks().forEach(track => track.stop());
+                // Aktualizujemy listę urządzeń po uzyskaniu uprawnień
                 yield this.grabDevices();
               } catch (error) {
                 console.error('Error requesting permissions:', error);
+                // Nie udało się uzyskać uprawnień
                 results.camera.allowed = false;
                 results.microphone.allowed = false;
               }
             } else {
+              // Jeśli mamy etykiety, prawdopodobnie mamy już uprawnienia
               results.camera.allowed = devices.some(device => device.kind === 'videoinput' && device.label !== '');
               results.microphone.allowed = devices.some(device => device.kind === 'audioinput' && device.label !== '');
             }
@@ -3418,15 +4775,25 @@
           return results;
         });
       }
+      //------------------------------------------------------------------------//
+      // SOCKETS & SDP
+      //------------------------------------------------------------------------//
+      /**
+       * This method handles basic SDP/ICE-Candidate exchange with a Wowza Server
+       *
+       * @param data
+       */
       onSocketMessage(data) {
         var _a;
         let msgJSON = JSON.parse(data);
         let msgStatus = Number(msgJSON["status"]);
         switch (msgStatus) {
           case 200:
+            // OK
             this._logger.info(this, "SDP Exchange Successful");
             let sdpData = msgJSON['sdp'];
             if (sdpData !== undefined) {
+              // @ts-ignore
               this._peerConnection.setRemoteDescription(new RTCSessionDescription(sdpData), () => {}, () => {});
             }
             let iceCandidates = msgJSON['iceCandidates'];
@@ -3437,6 +4804,7 @@
             }
             break;
           case 503:
+            // NOT OK
             this._logger.error(this, "StreamKey already use");
             const usedStreamKey = (_a = this._main.getConfigManager().getStreamData().streamKey) !== null && _a !== void 0 ? _a : "unknown";
             this._main.dispatchEvent("streamKeyInUse", {
@@ -3447,6 +4815,16 @@
             break;
         }
       }
+      //------------------------------------------------------------------------//
+      // EVENTS
+      //------------------------------------------------------------------------//
+      /**
+       * Recives events related to peerConnection (change of state)
+       *
+       * @param event event with its data
+       * @param thisRef reference to player classonConnectionStateChange
+       * @private
+       */
       onConnectionStateChange(event) {
         this._logger.info(this, "Connection State Change: " + JSON.stringify(event));
         if (event !== null) {
@@ -3474,12 +4852,20 @@
           }
         }
       }
+      //------------------------------------------------------------------------//
+      // DEVICES
+      //------------------------------------------------------------------------//
+      /**
+       * Returns list od devices (cameras, microphones) available for user's device
+       */
       grabDevices() {
         return __awaiter(this, void 0, void 0, function* () {
           try {
             const deviceAccess = yield this.checkIndividualDeviceAccess();
             this._cameraList = new InputDeviceList();
             this._microphoneList = new InputDeviceList();
+            // Wysyłamy eventy tylko jeśli nie sprawdzaliśmy wcześniej uprawnień
+            // lub jeśli zmienił się stan uprawnień (resetowana flaga)
             if (!this._permissionChecked) {
               if (!deviceAccess.camera.allowed) {
                 this._main.dispatchEvent("cameraAccessDenied", {
@@ -3508,6 +4894,7 @@
                 this.setInputDeviceState(exports.InputDevicesState.INVALID);
               }
             }
+            // Wypełnianie list dostępnymi urządzeniami
             const devices = yield navigator.mediaDevices.enumerateDevices();
             for (const device of devices) {
               if (device.deviceId && device.label) {
@@ -3521,6 +4908,7 @@
               }
             }
             try {
+              // Aktualizacja wybranych urządzeń
               if (deviceAccess.camera.allowed) {
                 this._selectedCamera = this.pickCamera();
               }
@@ -3531,6 +4919,7 @@
               this.setInputDeviceState(exports.InputDevicesState.INVALID);
               this._logger.error(this, "Errror on grab devices: " + JSON.stringify(error));
             }
+            // Zawsze wysyłamy aktualizację list urządzeń
             this._main.dispatchEvent("deviceListUpdate", {
               ref: this._main,
               cameraList: this._cameraList.getArray(),
@@ -3552,6 +4941,10 @@
           }
         });
       }
+      /**
+       * Selects camera based on camera device ID;
+       * @param cameraID
+       */
       selectCamera(cameraID) {
         var _a, _b;
         for (let i = 0; i < this._cameraList.getSize(); i++) {
@@ -3560,6 +4953,7 @@
         this._selectedCamera = null;
         this.setInputDeviceState(exports.InputDevicesState.UPDATING);
         this.setCameraState(exports.DeviceState.NOT_INITIALIZED);
+        // Zapamiętaj aktualny stream key i stan publikacji
         const streamKey = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey;
         const wasPublished = this._publishState === exports.PublishState.CONNECTED;
         for (let i = 0; i < this._cameraList.getSize(); i++) {
@@ -3577,8 +4971,11 @@
         });
         this.stopCameraStream();
         if (this._selectedCamera != null) {
+          // Update constraints with new device
           this._constraints.video.deviceId = this._selectedCamera.id;
+          // Restart camera stream
           this.startCamera().then(() => {
+            // Jeśli stream był opublikowany, publikujemy ponownie
             this.setCameraState(exports.DeviceState.ENABLED);
             if (this._cameraState == exports.DeviceState.ENABLED && this._microphoneState == exports.DeviceState.ENABLED) this.setInputDeviceState(exports.InputDevicesState.READY);else this.setInputDeviceState(exports.InputDevicesState.INVALID);
             if (wasPublished && streamKey) {
@@ -3589,6 +4986,10 @@
           this.setInputDeviceState(exports.InputDevicesState.INVALID);
         }
       }
+      /**
+       * Method tries to select (change) microphone based on its system ID
+       * @param micID
+       */
       selectMicrophone(micID) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
@@ -3599,8 +5000,10 @@
           this.setInputDeviceState(exports.InputDevicesState.UPDATING);
           this.setMicrophoneState(exports.DeviceState.NOT_INITIALIZED);
           this._logger.info(this, "Selecting microphone: " + micID);
+          // Zapamiętaj aktualny stream key i stan publikacji
           const streamKey = (_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData().streamKey;
           const wasPublished = this._publishState === exports.PublishState.CONNECTED;
+          // Znajdź i zapisz wybrany mikrofon
           for (let i = 0; i < this._microphoneList.getSize(); i++) {
             if (this._microphoneList.get(i).id == micID) {
               this._selectedMicrophone = this._microphoneList.get(i);
@@ -3609,13 +5012,17 @@
               break;
             }
           }
+          // Zawsze wysyłamy aktualizację list urządzeń
           this._main.dispatchEvent("deviceListUpdate", {
             ref: this._main,
             cameraList: this._cameraList.getArray(),
             microphoneList: this._microphoneList.getArray()
           });
+          // Odłącz SoundMeter przed zmianą strumienia
           this._soundMeter.detach();
+          // Zamknij istniejące połączenie WebRTC
           this.closeWebRTCConnection();
+          // Zatrzymaj obecny strumień
           if (this._stream) {
             this._stream.getTracks().forEach(track => {
               track.stop();
@@ -3623,6 +5030,7 @@
             this._stream = null;
           }
           try {
+            // Rozpocznij wszystko od nowa
             yield this.startCamera();
             this.setMicrophoneState(exports.DeviceState.ENABLED);
             if (this._cameraState == exports.DeviceState.ENABLED && this._microphoneState == exports.DeviceState.ENABLED) {
@@ -3630,6 +5038,7 @@
             } else {
               this.setInputDeviceState(exports.InputDevicesState.INVALID);
             }
+            // Jeśli stream był opublikowany, publikujemy ponownie
             if (wasPublished && streamKey) {
               this.publish(streamKey);
             }
@@ -3642,6 +5051,11 @@
           }
         });
       }
+      /**
+       * This method tries to start a camera.
+       *
+       * @private
+       */
       startCamera() {
         return __awaiter(this, void 0, void 0, function* () {
           if (this._stream) {
@@ -3690,24 +5104,37 @@
           }
         });
       }
+      /**
+       * Updates WebRTC connection with new stream
+       */
       updateWebRTCStream() {
         if (!this._peerConnection || !this._stream) {
           return;
         }
+        // Remove all existing tracks from the peer connection
         const senders = this._peerConnection.getSenders();
         senders.forEach(sender => {
           if (this._peerConnection) this._peerConnection.removeTrack(sender);
         });
+        // Add new tracks
         this._stream.getTracks().forEach(track => {
           if (this._stream != null && this._peerConnection) {
             this._peerConnection.addTrack(track, this._stream);
           }
         });
       }
+      /**
+       * Modified closeStream to handle both camera and WebRTC completely
+       */
       closeStream() {
         if (this._peerConnection !== undefined && this._peerConnection !== null) this._peerConnection.close();
         this.setPublishState(exports.PublishState.UNPUBLISHED);
       }
+      /**
+       * This method selects a camera based on previous uses or saved IDs
+       *
+       * @private
+       */
       pickCamera() {
         var _a, _b, _c, _d, _e, _f;
         for (let i = 0; i < this._cameraList.getSize(); i++) {
@@ -3716,12 +5143,14 @@
         let savedCameraID = (_b = (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.getField("cameraID")) !== null && _b !== void 0 ? _b : null;
         if (this._cameraList.getSize() > 0) {
           if (savedCameraID) {
+            // Szukamy zapisanej kamery
             let found = false;
             for (let i = 0; i < this._cameraList.getSize(); i++) {
               if (this._cameraList.get(i).id === savedCameraID) {
                 this._selectedCamera = this._cameraList.get(i);
                 this._selectedCamera.isSelected = true;
                 this.setCameraState(exports.DeviceState.ENABLED);
+                // Ustaw deviceId w constraints
                 found = true;
                 this._constraints.video.deviceId = this._selectedCamera.id;
                 break;
@@ -3741,6 +5170,7 @@
               return null;
             }
           }
+          // Jeśli nie znaleziono zapisanej kamery, używamy pierwszej
           if (!this._selectedCamera) {
             this._main.dispatchEvent("savedCameraNotFound", {
               ref: this._main,
@@ -3770,6 +5200,11 @@
         });
         return this._selectedCamera;
       }
+      /**
+       * This method selects a microphone based on previous uses or saved IDs
+       *
+       * @private
+       */
       pickMicrophone() {
         var _a, _b, _c, _d, _e, _f;
         for (let i = 0; i < this._microphoneList.getSize(); i++) {
@@ -3827,32 +5262,51 @@
         }
         return this._selectedMicrophone;
       }
+      /**
+       * Cleans all saved cameras and microphones IDs.
+       */
       clearSavedDevices() {
         var _a, _b;
         (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.removeField("cameraID");
         (_b = this._main.getStorageManager()) === null || _b === void 0 ? void 0 : _b.removeField("microphoneID");
       }
+      /**
+       * Messes up camera's and microphone's id (for testing only)
+       */
       messSavedDevices() {
         var _a, _b;
         (_a = this._main.getStorageManager()) === null || _a === void 0 ? void 0 : _a.saveField("cameraID", "a");
         (_b = this._main.getStorageManager()) === null || _b === void 0 ? void 0 : _b.saveField("microphoneID", "b");
       }
+      /**
+       * Handles microphone muting state
+       * @param microphoneState true to unmute, false to mute
+       */
       muteMicrophone(shouldMute) {
         if (this._isMicrophoneMuted === shouldMute) {
+          // State hasn't changed, no need to do anything
           return;
         }
         this._isMicrophoneMuted = shouldMute;
         if (this._stream) {
-          this.applyMicrophoneState(!shouldMute);
+          this.applyMicrophoneState(!shouldMute); // Odwracamy wartość dla track.enabled
         } else {
-          this._pendingMicrophoneState = !shouldMute;
+          // Store the desired state to be applied when stream becomes available
+          this._pendingMicrophoneState = !shouldMute; // Odwracamy wartość dla przyszłego track.enabled
           this._logger.info(this, `WebRTCStreamer :: Stream not yet available, storing microphone state (muted: ${shouldMute})`);
         }
+        // Always dispatch the event to keep UI in sync
         this._main.dispatchEvent("microphoneStateChange", {
           ref: this._main,
           isMuted: this._isMicrophoneMuted
         });
       }
+      /**
+       * Applies the microphone state to the actual stream tracks
+       *
+       * @param enabled true to enable tracks, false to disable
+       * @private
+       */
       applyMicrophoneState(enabled) {
         if (!this._stream) {
           this._logger.warning(this, "WebRTCStreamer :: Cannot apply microphone state - stream not available");
@@ -3866,6 +5320,13 @@
           this._logger.warning(this, "WebRTCStreamer :: No audio tracks found in stream");
         }
       }
+      /**
+       * This methods is a final check whenever we're ready to publish a stream
+       *
+       * @param requireVideo - whenever video track is required
+       * @param requireAudio - whenever audio track is required
+       * @returns {boolean} true if stream is ready for publishing
+       */
       isStreamReady(requireVideo = true, requireAudio = true) {
         if (!this._stream) {
           return false;
@@ -3888,6 +5349,9 @@
       onIceCandidate(event) {
         if (event.candidate !== null) ;
       }
+      //------------------------------------------------------------------------//
+      // SETS & GETS
+      //------------------------------------------------------------------------//
       createStatusConnection() {
         var _a, _b, _c;
         const serverItem = (_c = (_b = (_a = this._main) === null || _a === void 0 ? void 0 : _a.getNetworkController()) === null || _b === void 0 ? void 0 : _b.getConnection()) === null || _c === void 0 ? void 0 : _c.getCurrentServer();
@@ -3922,6 +5386,7 @@
       getPublishTime() {
         return this._publishState == exports.PublishState.PUBLISHED ? this._publishTime : 0;
       }
+      // DEVICE STATE
       setInputDeviceState(newState) {
         if (this._inputDeviceState == newState) return;
         this._inputDeviceState = newState;
@@ -3935,6 +5400,7 @@
       getInputDeviceState() {
         return this._inputDeviceState;
       }
+      // CAMERA STATE
       setCameraState(newState) {
         if (this._cameraState == newState) return;
         this._cameraState = newState;
@@ -3944,9 +5410,10 @@
           selectedCamera: this._selectedCamera
         });
       }
-      getCamerState() {
+      getCameraState() {
         return this._cameraState;
       }
+      // MICROPHONE STATE
       setMicrophoneState(newState) {
         if (this._microphoneState == newState) return;
         this._microphoneState = newState;
@@ -3968,6 +5435,13 @@
       getPublishState() {
         return this._publishState;
       }
+      //------------------------------------------------------------------------//
+      // DESTROY & DELETE
+      //------------------------------------------------------------------------//
+      /**
+       * Method used to stop camera from streaming
+       * @private
+       */
       stopCameraStream() {
         var _a, _b;
         if (this._stream) {
@@ -3980,66 +5454,112 @@
           this._stream = null;
         }
       }
+      /**
+       * Method stops streaming for all streams
+       * @private
+       */
       forceStopAllStreams() {
         var _a, _b;
-        if (this._peerConnection) {
+        // 1. First, detach the sound meter
+        if (this._soundMeter) {
+          this._soundMeter.detach();
+        }
+        // 2. Stop the main stream if it exists
+        if (this._stream) {
           try {
-            const senders = this._peerConnection.getSenders();
-            senders.forEach(sender => {
-              var _a;
+            const tracks = this._stream.getTracks();
+            this._logger.info(this, `Stopping ${tracks.length} tracks from main stream`);
+            tracks.forEach(track => {
               try {
-                if (sender.track) {
-                  sender.track.enabled = false;
-                  sender.track.stop();
-                  (_a = this._peerConnection) === null || _a === void 0 ? void 0 : _a.removeTrack(sender);
-                }
+                track.enabled = false;
+                track.stop();
+                this._logger.info(this, `Stopped ${track.kind} track: ${track.id}`);
               } catch (e) {
-                console.error('Error stopping sender track:', e);
+                this._logger.error(this, `Error stopping ${track.kind} track: ${e}`);
               }
             });
-            this._peerConnection.close();
-            this._peerConnection = null;
+            this._stream = null;
           } catch (e) {
-            console.error('Error closing peer connection:', e);
+            this._logger.error(this, 'Error stopping main stream');
           }
         }
+        // 3. Clean up video element
         try {
           const videoElement = (_b = (_a = this._main.getStageController()) === null || _a === void 0 ? void 0 : _a.getScreenElement()) === null || _b === void 0 ? void 0 : _b.getVideoElement();
           if (videoElement && videoElement.srcObject instanceof MediaStream) {
             const videoTracks = videoElement.srcObject.getTracks();
-            videoTracks.forEach(track => {
-              try {
-                track.enabled = false;
-                track.stop();
-              } catch (e) {
-                console.error('Error stopping video element track:', e);
-              }
-            });
+            if (videoTracks.length > 0) {
+              this._logger.info(this, `Stopping ${videoTracks.length} tracks from video element`);
+              videoTracks.forEach(track => {
+                try {
+                  track.enabled = false;
+                  track.stop();
+                } catch (e) {
+                  this._logger.error(this, `Error stopping video element track: ${e}`);
+                }
+              });
+            }
             videoElement.srcObject = null;
             videoElement.removeAttribute('src');
             videoElement.load();
           }
         } catch (e) {
-          console.error('Error cleaning video element:', e);
+          this._logger.error(this, 'Error cleaning video element');
         }
-        if (this._stream) {
+        // 4. Handle RTCPeerConnection last, with proper state checking
+        if (this._peerConnection) {
           try {
-            const tracks = this._stream.getTracks();
-            tracks.forEach(track => {
-              try {
-                track.enabled = false;
-                track.stop();
-              } catch (e) {
-                console.error(`Error stopping ${track.kind} track:`, e);
-              }
-            });
-            this._stream = null;
+            // Only try to remove tracks if the connection isn't already closed
+            if (this._peerConnection.signalingState !== 'closed') {
+              const senders = this._peerConnection.getSenders();
+              this._logger.info(this, `Cleaning up ${senders.length} senders from peer connection`);
+              senders.forEach(sender => {
+                try {
+                  if (sender.track) {
+                    sender.track.enabled = false;
+                    sender.track.stop();
+                    // Only try to remove the track if connection is still open
+                    if (this._peerConnection && this._peerConnection.signalingState !== 'closed') {
+                      this._peerConnection.removeTrack(sender);
+                    }
+                  }
+                } catch (e) {
+                  this._logger.error(this, `Error stopping sender track: ${e}`);
+                }
+              });
+            }
+            // Now close the peer connection
+            this._peerConnection.close();
+            this._peerConnection = null;
           } catch (e) {
-            console.error('Error stopping main stream:', e);
+            this._logger.error(this, 'Error closing peer connection');
           }
         }
+        // 5. Ensure we properly null out our device references
+        this._selectedCamera = null;
+        this._selectedMicrophone = null;
+        // 6. Make a final check for any active tracks at the global level
+        try {
+          const allTracks = [];
+          // Try to find any tracks that might still be active by querying devices
+          navigator.mediaDevices.getUserMedia({
+            audio: false,
+            video: false
+          }).then(() => {
+            // This is just to trigger a device check
+            this._logger.info(this, "Performed final device check");
+          }).catch(() => {
+            // Ignore errors from this check
+          });
+        } catch (e) {
+          // Ignore errors from final check
+        }
       }
+      /**
+       * Stops all streaming operations and cleans up resources
+       */
       stop() {
+        // Stop status connection and clear timer
         if (this._statusConnection) {
           this._statusConnection.destroy();
           this._statusConnection = null;
@@ -4049,12 +5569,16 @@
           this._statusTimer = null;
         }
         this._main.getConfigManager().getStreamData().streamKey = null;
+        // Close WebRTC connection
         this.closeWebRTCConnection();
+        // Stop all media streams
         this.stopCameraStream();
+        // Reset states
         this.setPublishState(exports.PublishState.STOPPED);
         this.setInputDeviceState(exports.InputDevicesState.STOPPED);
         this.setCameraState(exports.DeviceState.STOPPED);
         this.setMicrophoneState(exports.DeviceState.STOPPED);
+        // Clear restart timer if exists
         if (this._restartTimer) {
           clearInterval(this._restartTimer);
           this._restartTimer = null;
@@ -4062,19 +5586,26 @@
         this._restartTimerCount = 0;
         clearTimeout(this._publishTimer);
       }
+      /**
+       * Reinitializes the streaming setup
+       */
       start() {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
           try {
+            // Reset states
             this._publishState = exports.PublishState.NOT_INITIALIZED;
             this._inputDeviceState = exports.InputDevicesState.NOT_INITIALIZED;
             this._cameraState = exports.DeviceState.NOT_INITIALIZED;
             this._microphoneState = exports.DeviceState.NOT_INITIALIZED;
+            // Reinitialize devices and stream
             yield this.initializeDevices();
             yield this.startCamera();
+            // If autoConnect is enabled, initialize network
             if ((_a = this._main.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getSettingsData().autoConnect) {
               (_b = this._main.getNetworkController()) === null || _b === void 0 ? void 0 : _b.initialize();
             }
+            // Reinitialize status connection if needed
             if ((_c = this._main.getConfigManager()) === null || _c === void 0 ? void 0 : _c.getStreamData().streamKey) {
               this.createStatusConnection();
             }
@@ -4085,38 +5616,76 @@
           }
         });
       }
+      /**
+       * Method used for destroying everything (one-time use)
+       */
       destroy() {
+        // Stop any ongoing timers and intervals first
+        if (this._statusTimer != null) {
+          clearInterval(this._statusTimer);
+          this._statusTimer = null;
+        }
+        if (this._restartTimer != null) {
+          clearInterval(this._restartTimer);
+          this._restartTimer = null;
+        }
+        clearTimeout(this._publishTimer);
+        // Remove orientation change listeners
         if (window.screen && window.screen.orientation) {
           window.screen.orientation.removeEventListener('change', this.handleOrientationChange);
         } else {
           window.removeEventListener('orientationchange', this.handleOrientationChange);
         }
-        this.forceStopAllStreams();
-        if (this._soundMeter) {
-          this._soundMeter.detach();
-        }
-        clearTimeout(this._publishTimer);
-        this._pendingMicrophoneState = null;
-        this._cameraList = new InputDeviceList();
-        this._microphoneList = new InputDeviceList();
-        this._permissionChecked = false;
-        this._isWindowActive = false;
-        this._isMicrophoneMuted = false;
+        // Remove other event listeners
         try {
           this._main.removeEventListener("serverConnect", this.onServerConnect);
           this._main.removeEventListener("serverDisconnect", this.onServerDisconnect);
+          this._main.removeEventListener("streamKeyInUse", this.onStreamKeyTaken);
+          this._main.removeEventListener("statusServerConnect", this.onStatusServerConnect);
+          this._main.removeEventListener("statusServerDisconnect", this.onStatusServerDisconnect);
+          this._main.removeEventListener("streamStatusUpdate", this.onStreamStatsUpdate);
+          this._main.removeEventListener("deviceStateChange", this.onDeviceStateChange);
           document.removeEventListener("visibilitychange", this.visibilityChange);
           window.removeEventListener("blur", this.onWindowBlur);
           window.removeEventListener("focus", this.onWindowFocus);
         } catch (e) {
-          console.error('Error removing event listeners:', e);
+          this._logger.error(this, 'Error removing event listeners');
         }
+        // Make sure we destroy the status connection
+        if (this._statusConnection) {
+          this._statusConnection.destroy();
+          this._statusConnection = null;
+        }
+        // Stop all media streams and clean up the WebRTC connection
+        this.forceStopAllStreams();
+        // Reset all state variables
+        this._pendingMicrophoneState = null;
+        this._cameraList = new InputDeviceList();
+        this._microphoneList = new InputDeviceList();
+        this._permissionChecked = false;
+        this._isWindowActive = false;
+        this._isMicrophoneMuted = false;
         this._publishState = exports.PublishState.NOT_INITIALIZED;
-        if (this._restartTimer != null) clearInterval(this._restartTimer);
+        this._inputDeviceState = exports.InputDevicesState.NOT_INITIALIZED;
+        this._cameraState = exports.DeviceState.NOT_INITIALIZED;
+        this._microphoneState = exports.DeviceState.NOT_INITIALIZED;
+        // Log completion
+        this._logger.success(this, "StreamerController successfully destroyed and all resources released");
       }
     }
 
+    /**
+     * Main class for communicating with Storm Streaming Server
+     */
     class WowzaConnection extends AbstractSocket {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constructor
+       * @param main
+       * @constructor
+       */
       constructor(main, networkController) {
         super();
         this._logger = main.getLogger();
@@ -4144,6 +5713,14 @@
           this.startConnection();
         } else this._logger.error(this, "Connection with the server could not be initialized!");
       }
+      //------------------------------------------------------------------------//
+      // BASE EVENTS
+      //------------------------------------------------------------------------//
+      /**
+       * On server connection opened;
+       * @param event
+       * @protected
+       */
       onSocketOpen(event) {
         this._logger.success(this, `Connection with the server has been established!`);
         this._main.dispatchEvent("serverConnect", {
@@ -4153,6 +5730,11 @@
         });
         this._isConnected = true;
       }
+      /**
+       * On server connection error
+       * @param event
+       * @protected
+       */
       onSocketError(event) {
         this._isConnected = false;
         if (!this._disconnectedByUser) {
@@ -4169,6 +5751,11 @@
           }
         }
       }
+      /**
+       * On server connection closed
+       * @param event
+       * @protected
+       */
       onSocketClose(event) {
         this._isConnected = false;
         if (!this._disconnectedByUser) {
@@ -4182,9 +5769,21 @@
           this.initiateReconnect();
         } else this._logger.warning(this, `Force disconnect from server!`);
       }
+      /**
+       * Method is called whenever a new message from socket arrives
+       * @private
+       */
       onSocketMessage(event) {
         this._networkController.onMessage(event);
       }
+      //------------------------------------------------------------------------//
+      // BASE METHODS
+      //------------------------------------------------------------------------//
+      /**
+       * Creates new URL for WebSockets based on serverItem object
+       * @param serverItem
+       * @private
+       */
       createURL(serverItem) {
         let url = "";
         url += serverItem.getIfSSL() ? "wss://" : "ws://";
@@ -4193,6 +5792,10 @@
         url += "/webrtc-session.json";
         return url;
       }
+      /**
+       * Initiates reconnection procedure
+       * @private
+       */
       initiateReconnect() {
         const shouldReconnect = this._main.getConfigManager().getSettingsData().getIfRestartOnError();
         const reconnectTime = this._main.getConfigManager().getSettingsData().getReconnectTime();
@@ -4216,6 +5819,11 @@
           }, reconnectTime * 1000);
         }
       }
+      /**
+       * Picks new server from this list of available ones
+       * @param serverList
+       * @private
+       */
       pickServerFromList(serverList) {
         let server = null;
         for (let i = 0; i < serverList.length; i++) {
@@ -4236,23 +5844,52 @@
           this._currServer = server;
         }
       }
+      /**
+       * Returns true/false depending if a connection with a server is active
+       */
       isConnectionActive() {
         return this._isConnected;
       }
       getCurrentServer() {
         return this._currServer;
       }
+      /**
+       * Destroys object and clean-ups everything that is needed
+       */
       destroy() {
         super.destroy();
         if (this._reconnectTimer != null) clearTimeout(this._reconnectTimer);
       }
     }
 
+    /**
+     * Main class for managing socket connections (only one per instance) and parsing packets.
+     */
     class NetworkController {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constructor
+       * @param main reference to the main class
+       */
       constructor(main) {
+        /**
+         * Current streamKey
+         * @private
+         */
         this._currentStreamKey = "none";
+        /**
+         * Last state
+         * @private
+         */
         this._lastState = "";
-        this.onServerConnect = () => {};
+        //------------------------------------------------------------------------//
+        // CONNECTION-RELATED METHODS
+        //------------------------------------------------------------------------//
+        this.onServerConnect = () => {
+          // nothing
+        };
         this.onServerDisconnect = () => {
           this._lastState = "none";
         };
@@ -4265,6 +5902,9 @@
         this._main.addEventListener("serverConnect", this.onServerConnect, false);
         this._main.addEventListener("serverDisconnect", this.onServerDisconnect, false);
       }
+      //------------------------------------------------------------------------//
+      // MAIN METHODS
+      //------------------------------------------------------------------------//
       initialize() {
         if (this._connection != null) {
           if (this._connection.getConnectionState() == ConnectionState.CONNECTING || this._connection.getConnectionState() == ConnectionState.CONNECTED) {
@@ -4287,9 +5927,18 @@
           this._connection.sendData(message);
         }
       }
+      //------------------------------------------------------------------------//
+      // SETS & GETS
+      //------------------------------------------------------------------------//
+      /**
+       * Returns current SocketConnection object
+       */
       getConnection() {
         return this._connection;
       }
+      /**
+       * Returns streamKey that is currently being used
+       */
       getCurrentStreamKey() {
         return this._currentStreamKey;
       }
@@ -4356,18 +6005,22 @@
         this._lastTimestamp = null;
         this._isTimemarkLine = false;
         this._borderWidth = 1;
+        // Validate input arrays
         if (colors.length !== valueRanges.length + 1) {
           throw new Error(`Colors array must have exactly ${valueRanges.length + 1} elements (one more than valueRanges)`);
         }
+        // Validate that valueRanges are in ascending order
         for (let i = 1; i < valueRanges.length; i++) {
           if (valueRanges[i] <= valueRanges[i - 1]) {
             throw new Error('ValueRanges must be in ascending order');
           }
         }
+        // Validate colors format
         const hexColorRegex = /^#[0-9A-Fa-f]{6}$/;
         if (!colors.every(color => hexColorRegex.test(color))) {
           throw new Error('All colors must be in valid hex format (e.g., #FF0000)');
         }
+        // Find container
         let container;
         if (typeof containerIdOrElement === 'string') {
           const foundElement = document.getElementById(containerIdOrElement);
@@ -4378,13 +6031,17 @@
         } else {
           container = containerIdOrElement;
         }
+        // Get container dimensions
         const containerRect = container.getBoundingClientRect();
         this._width = Math.floor(containerRect.width);
         this._height = Math.floor(containerRect.height);
+        // Calculate effective dimensions (accounting for border)
         this._effectiveWidth = this._width - this._borderWidth * 2;
         this._effectiveHeight = this._height - this._borderWidth * 2;
+        // Create canvas element
         this._canvas = document.createElement('canvas');
         container.appendChild(this._canvas);
+        // Get context
         const context = this._canvas.getContext('2d', {
           willReadFrequently: true
         });
@@ -4392,13 +6049,16 @@
           throw new Error('Failed to get canvas context');
         }
         this._ctx = context;
-        this._valueRanges = [0, ...valueRanges];
+        this._valueRanges = [0, ...valueRanges]; // Add 0 at the beginning
         this._colors = colors;
         this._lineWidth = lineWidth;
+        // Set canvas size
         this._canvas.width = this._width;
         this._canvas.height = this._height;
+        // Set canvas style to ensure it displays at the correct size
         this._canvas.style.width = `${this._width}px`;
         this._canvas.style.height = `${this._height}px`;
+        // Initial background and border
         this.clear();
       }
       drawBorder() {
@@ -4407,12 +6067,15 @@
         this._ctx.strokeRect(this._borderWidth / 2, this._borderWidth / 2, this._width - this._borderWidth, this._height - this._borderWidth);
       }
       clear() {
+        // Clear entire canvas
         this._ctx.clearRect(0, 0, this._width, this._height);
+        // Fill background within border
         this._ctx.fillStyle = this._colors[0];
         this._ctx.fillRect(this._borderWidth, this._borderWidth, this._effectiveWidth, this._effectiveHeight);
+        // Draw border
         this.drawBorder();
         this._isFullyDrawn = false;
-        this._currentX = this._borderWidth;
+        this._currentX = this._borderWidth; // Start after left border
         this._lastTimestamp = null;
         this._isTimemarkLine = false;
       }
@@ -4425,6 +6088,7 @@
             };
           }
         }
+        // If value is greater than the last range
         return {
           lowerIndex: this._valueRanges.length - 2,
           upperIndex: this._valueRanges.length - 1
@@ -4434,10 +6098,14 @@
         return (value - lowerBound) / (upperBound - lowerBound);
       }
       shiftCanvasLeft(shiftAmount) {
+        // Get the content within the borders
         const imageData = this._ctx.getImageData(this._borderWidth + shiftAmount, this._borderWidth, this._effectiveWidth - shiftAmount, this._effectiveHeight);
+        // Clear the area within borders
         this._ctx.fillStyle = this._colors[0];
         this._ctx.fillRect(this._borderWidth, this._borderWidth, this._effectiveWidth, this._effectiveHeight);
+        // Draw shifted content
         this._ctx.putImageData(imageData, this._borderWidth, this._borderWidth);
+        // Redraw border as it might have been affected
         this.drawBorder();
       }
       applyOverlayEffect(baseColor, overlayOpacity = 0.5) {
@@ -4502,15 +6170,18 @@
           lowerColor = this.applyOverlayEffect(lowerColor, 0.3);
           upperColor = this.applyOverlayEffect(upperColor, 0.3);
         }
+        // Calculate heights accounting for borders
         const upperHeight = Math.round(this._effectiveHeight * ratio);
         const lowerHeight = this._effectiveHeight - upperHeight;
+        // Draw lower part
         this._ctx.fillStyle = lowerColor;
         this._ctx.fillRect(x, this._height - this._borderWidth - lowerHeight, width, lowerHeight);
+        // Draw upper part
         this._ctx.fillStyle = upperColor;
         this._ctx.fillRect(x, this._borderWidth, width, upperHeight);
       }
       clearGraph() {
-        this._currentX = this._borderWidth;
+        this._currentX = this._borderWidth; // Reset to after left border
         this._isFullyDrawn = false;
         this._lastTimestamp = null;
         this._isTimemarkLine = false;
@@ -4536,8 +6207,10 @@
       start() {
         if (this._graph != null) stop();
         const valueRanges = [1000000, 2000000, 3000000, 5000000, 6000000, 7000000];
-        const colors = ['#000000', '#0a3980', '#2793dd', '#3bc39c', '#c3df3e', '#f89539', '#f83f3f'];
-        this._graph = new GraphDrawer(this._object, valueRanges, colors);
+        const colors = ['#000000', '#0a3980', '#2793dd', '#3bc39c', '#c3df3e', '#f89539', '#f83f3f' // MaxBuffer - End
+        ];
+
+        this._graph = new GraphDrawer(this._object, valueRanges, colors, 5);
         this._main.addEventListener("streamStatusUpdate", this.onStreamStatsUpdate);
         return this;
       }
@@ -4562,8 +6235,10 @@
       start() {
         if (this._graph != null) stop();
         const valueRanges = [25, 26, 27, 28, 29, 30];
-        const colors = ['#000000', '#0a3980', '#2793dd', '#3bc39c', '#c3df3e', '#f89539', '#f83f3f'];
-        this._graph = new GraphDrawer(this._object, valueRanges, colors);
+        const colors = ['#000000', '#0a3980', '#2793dd', '#3bc39c', '#c3df3e', '#f89539', '#f83f3f' // MaxBuffer - End
+        ];
+
+        this._graph = new GraphDrawer(this._object, valueRanges, colors, 5);
         this._main.addEventListener("streamStatusUpdate", this.onStreamStatsUpdate);
         return this;
       }
@@ -4575,19 +6250,85 @@
       }
     }
 
+    class MicrophoneGraph {
+      constructor(main, container) {
+        this.onStreamStatsUpdate = event => {
+          var _a;
+          (_a = this._graph) === null || _a === void 0 ? void 0 : _a.addEntry(event.high * 500);
+          console.log(event.high * 200);
+        };
+        this._main = main;
+        this._object = container;
+        this._main.addGraph(this);
+      }
+      start() {
+        if (this._graph != null) stop();
+        const valueRanges = [0, 20, 40, 60, 80, 100];
+        const colors = ['#000000', '#0a3980', '#2793dd', '#3bc39c', '#c3df3e', '#f89539', '#f83f3f' // MaxBuffer - End
+        ];
+
+        this._graph = new GraphDrawer(this._object, valueRanges, colors, 2);
+        this._main.addEventListener("soundMeter", this.onStreamStatsUpdate);
+        return this;
+      }
+      stop() {
+        this._main.removeEventListener("soundMeter", this.onStreamStatsUpdate);
+        if (this._graph != null) this._graph.destroy();
+        this._graph = null;
+        return this;
+      }
+    }
+
+    /**
+     * Main class of the player. The player itself has no GUI, but can be controlled via provided API.
+     */
     class StormStreamer extends EventDispatcher {
+      //------------------------------------------------------------------------//
+      // CONSTRUCTOR
+      //------------------------------------------------------------------------//
+      /**
+       * Constructor - creates a new StormStreamer instance
+       *
+       * @param streamConfig - Configuration object for the streamer
+       * @param autoInitialize - Whether to automatically initialize the streamer after creation
+       */
       constructor(streamConfig, autoInitialize = false) {
         super();
+        /**
+         * Indicates whether the streamer object is in development mode (provides more debug options)
+         * @private
+         */
         this.DEV_MODE = true;
-        this.STREAMER_VERSION = "0.9.2-beta.2";
-        this.COMPILE_DATE = "3/6/2025, 2:53:15 PM";
+        /**
+         * Version of this streamer in SemVer format (Major.Minor.Patch).
+         * @private
+         */
+        this.STREAMER_VERSION = "0.9.3-beta.0";
+        /**
+         * Compile date for this streamer
+         * @private
+         */
+        this.COMPILE_DATE = "3/8/2025, 11:51:35 PM";
+        /**
+         * Defines from which branch this streamer comes from e.g. "Main", "Experimental"
+         * @private
+         */
         this.STREAMER_BRANCH = "Experimental";
+        /**
+         * Defines number of streamer protocol that is required on server-side
+         * @private
+         */
         this.STREAMER_PROTOCOL_VERSION = 1;
+        /**
+         * Indicates whether streamer was initialized or not
+         * @private
+         */
         this._initialized = false;
         if (typeof window === 'undefined' || !window.document || !window.document.createElement) {
           console.error(`StormStreamer Creation Error - No "window" element in the provided context!`);
           return;
         }
+        // WINDOW.StormStreamerArray
         if (this.DEV_MODE && !('StormStreamerArray' in window)) {
           window.StormStreamerArray = [];
         }
@@ -4597,13 +6338,17 @@
         this.setStreamConfig(streamConfig);
         if (autoInitialize) this.initialize();
       }
+      /**
+       * Initializes the streamer object. From this point, a connection to the server is established and authentication occurs.
+       * It is recommended to add all event listeners before calling this method to ensure they can be properly captured.
+       */
       initialize() {
         if (this._isRemoved) return;
         if (this._configManager == null) throw Error("Stream Config was not provided for this streamer! 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._streamerController = new StreamerController(this);
+        this._storageManager = new StorageManager(this); // Storing user data
+        this._stageController = new StageController(this); // Visual elements like VideoElement
+        this._networkController = new NetworkController(this); // Networking and connection with a server
+        this._streamerController = new StreamerController(this); // Video Playback
         this._statsController = new StatsController(this);
         this._graphs = [];
         this._initialized = true;
@@ -4611,8 +6356,16 @@
           ref: this
         });
       }
+      /**
+       * Sets stream config for the streamer (or overwrites an existing one).
+       *
+       * @param streamConfig - New configuration object for the streamer
+       */
       setStreamConfig(streamConfig) {
         if (this._isRemoved) return;
+        /**
+         * In case the original streamConfig is modified elsewhere we have to create a separate copy and store it ourselves
+         */
         const copiedStreamConfig = JSON.parse(JSON.stringify(streamConfig));
         if (this._configManager == null) {
           this._configManager = new ConfigManager(copiedStreamConfig);
@@ -4636,10 +6389,21 @@
           });
         }
       }
+      //------------------------------------------------------------------------//
+      // PLAYBACK / STREAMING
+      //------------------------------------------------------------------------//
+      /**
+       * Returns true if this streamer instance is currently connected to a Storm Server/Cloud instance.
+       *
+       * @returns Boolean indicating connection status
+       */
       isConnected() {
         var _a, _b;
         return (_b = (_a = this._networkController) === null || _a === void 0 ? void 0 : _a.getConnection().isConnectionActive()) !== null && _b !== void 0 ? _b : false;
       }
+      /**
+       * Mutes the streamer's video object. Audio output will be silenced.
+       */
       mute() {
         if (this._stageController != null) {
           if (this._stageController.getScreenElement() != null) {
@@ -4649,6 +6413,9 @@
         }
         this._configManager.getSettingsData().getAudioData().muted = true;
       }
+      /**
+       * Unmutes the streamer's video object. Audio output will be restored.
+       */
       unmute() {
         if (this._stageController != null) {
           if (this._stageController.getScreenElement() != null) {
@@ -4658,10 +6425,20 @@
         }
         this._configManager.getSettingsData().getAudioData().muted = false;
       }
+      /**
+       * Checks whether the streamer audio is currently muted.
+       *
+       * @returns Boolean indicating mute status
+       */
       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;
       }
+      /**
+       * Toggles between mute and unmute states. Returns the new mute state.
+       *
+       * @returns New mute state (true = muted, false = unmuted)
+       */
       toggleMute() {
         const isMuted = this.isMute();
         if (isMuted) {
@@ -4671,6 +6448,12 @@
         }
         return !isMuted;
       }
+      /**
+       * Sets new volume for the streamer (0-100). Once the method is performed, the volumeChange event will be triggered.
+       * If the video was muted prior to the volume change, it will be automatically unmuted.
+       *
+       * @param newVolume - Volume level (0-100)
+       */
       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) {
@@ -4678,96 +6461,217 @@
         }
         this._configManager.getSettingsData().getAudioData().startVolume = newVolume;
       }
+      /**
+       * Returns current streamer volume (0-100).
+       *
+       * @returns Current volume level
+       */
       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;
       }
+      /**
+       * Returns the list of available camera devices.
+       *
+       * @returns Array of camera input devices
+       */
       getCameraList() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getCameraList()) !== null && _b !== void 0 ? _b : [];
       }
+      /**
+       * Returns the list of available microphone devices.
+       *
+       * @returns Array of microphone input devices
+       */
       getMicrophoneList() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getMicrophoneList()) !== null && _b !== void 0 ? _b : [];
       }
+      /**
+       * Sets the active camera device by ID.
+       *
+       * @param cameraID - ID of the camera device to use
+       */
       setCamera(cameraID) {
         var _a;
         (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.selectCamera(cameraID);
       }
+      /**
+       * Sets the active microphone device by ID.
+       *
+       * @param microphoneID - ID of the microphone device to use
+       */
       setMicrophone(microphoneID) {
         var _a;
         (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.selectMicrophone(microphoneID);
       }
+      /**
+       * Returns the currently active camera device.
+       *
+       * @returns Current camera device or null if none is active
+       */
       getCurrentCamera() {
         return this._streamerController.getCurrentCamera();
       }
+      /**
+       * Returns the currently active microphone device.
+       *
+       * @returns Current microphone device or null if none is active
+       */
       getCurrentMicrophone() {
         return this._streamerController.getCurrentMicrophone();
       }
+      /**
+       * Mutes or unmutes the microphone.
+       *
+       * @param microphoneState - True to mute, false to unmute
+       */
       muteMicrophone(microphoneState) {
         var _a;
         (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.muteMicrophone(microphoneState);
       }
+      /**
+       * Checks if the microphone is currently muted.
+       *
+       * @returns Boolean indicating if microphone is muted
+       */
       isMicrophoneMuted() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.isMicrophoneMuted()) !== null && _b !== void 0 ? _b : false;
       }
+      /**
+       * Returns the current publishing state of the streamer.
+       *
+       * @returns Current publishing state
+       */
       getPublishState() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getPublishState()) !== null && _b !== void 0 ? _b : exports.PublishState.NOT_INITIALIZED;
       }
+      /**
+       * Returns the total time the stream has been publishing in milliseconds.
+       *
+       * @returns Publishing time in milliseconds
+       */
       getPublishTime() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getPublishTime()) !== null && _b !== void 0 ? _b : 0;
       }
+      /**
+       * Starts publishing a stream with the given stream key.
+       *
+       * @param streamKey - Key identifying the stream to publish
+       * @returns Boolean indicating if publishing was successfully initiated
+       */
       publish(streamKey) {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.publish(streamKey)) !== null && _b !== void 0 ? _b : false;
       }
+      /**
+       * Stops publishing the current stream.
+       */
+      unpublish() {
+        var _a;
+        (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.unpublish();
+      }
+      /**
+       * Returns the current state of input devices (camera and microphone).
+       *
+       * @returns Current state of input devices
+       */
       getInputDevicesState() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getInputDeviceState()) !== null && _b !== void 0 ? _b : exports.InputDevicesState.NOT_INITIALIZED;
       }
-      getCamerState() {
+      /**
+       * Returns the current state of the camera device.
+       *
+       * @returns Current camera device state
+       */
+      getCameraState() {
         var _a, _b;
-        return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getCamerState()) !== null && _b !== void 0 ? _b : exports.DeviceState.NOT_INITIALIZED;
+        return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getCameraState()) !== null && _b !== void 0 ? _b : exports.DeviceState.NOT_INITIALIZED;
       }
+      /**
+       * Returns the current state of the microphone device.
+       *
+       * @returns Current microphone device state
+       */
       getMicrophoneState() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.getMicrophoneState()) !== null && _b !== void 0 ? _b : exports.DeviceState.NOT_INITIALIZED;
       }
+      /**
+       * Clears saved device preferences from storage.
+       */
       clearSavedDevices() {
         var _a;
         return (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.clearSavedDevices();
       }
+      /**
+       * Randomizes saved device preferences (for testing purposes).
+       */
       messSavedDevices() {
         var _a;
         return (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.messSavedDevices();
       }
+      /**
+       * Checks if the stream is ready for publishing.
+       *
+       * @returns Boolean indicating if stream is ready
+       */
       isStreamReady() {
         var _a, _b;
         return (_b = (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.isStreamReady()) !== null && _b !== void 0 ? _b : false;
       }
-      unpublish() {
-        var _a;
-        (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.unpublish();
-      }
+      //------------------------------------------------------------------------//
+      // CONTAINER
+      //------------------------------------------------------------------------//
+      /**
+       * Attaches the streamer to a new parent container using either a container ID (string) or a reference to an HTMLElement.
+       * If the instance is already attached, it will be moved to a new parent.
+       *
+       * @param container - Container ID (string) or HTMLElement reference
+       * @returns Boolean indicating if attachment was successful
+       */
       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;
       }
+      /**
+       * Detaches the streamer from the current parent element, if possible.
+       *
+       * @returns Boolean indicating if detachment was successful
+       */
       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;
       }
+      /**
+       * Returns the current parent element of the streamer, or null if none exists.
+       *
+       * @returns Current container element or null
+       */
       getContainer() {
         var _a, _b;
         return (_b = (_a = this._stageController) === null || _a === void 0 ? void 0 : _a.getParentElement()) !== null && _b !== void 0 ? _b : null;
       }
+      //------------------------------------------------------------------------//
+      // SIZE & RESIZE
+      //------------------------------------------------------------------------//
+      /**
+       * Sets a new width and height for the streamer. The values can be given as a number (in which case they are
+       * treated as the number of pixels), or as a string ending with "px" (this will also be the number of pixels) or "%",
+       * where the number is treated as a percentage of the parent container's value.
+       *
+       * @param width - Can be provided as number or a string with "%" or "px" suffix
+       * @param height - Can be provided as number or a string with "%" or "px" suffix
+       */
       setSize(width, height) {
         if (this._initialized) this._stageController.setSize(width, height);else {
           const parsedWidth = NumberUtilities.parseValue(width);
@@ -4778,6 +6682,13 @@
           this._configManager.getSettingsData().getVideoData().videoHeightInPixels = parsedHeight.isPixels;
         }
       }
+      /**
+       * Sets a new width for the streamer. The value can be given as a number (in which case it is treated as the
+       * number of pixels), or as a string ending with "px" (this will also be the number of pixels) or "%", where the
+       * number is treated as a percentage of the parent container's value.
+       *
+       * @param width - Can be provided as number or a string with "%" or "px" suffix
+       */
       setWidth(width) {
         if (this._initialized) this._stageController.setWidth(width);else {
           const parsedWidth = NumberUtilities.parseValue(width);
@@ -4785,6 +6696,13 @@
           this._configManager.getSettingsData().getVideoData().videoWidthInPixels = parsedWidth.isPixels;
         }
       }
+      /**
+       * Sets a new height for the streamer. The value can be given as a number (in which case it is treated as the
+       * number of pixels), or as a string ending with "px" (this will also be the number of pixels) or "%", where the
+       * number is treated as a percentage of the parent container's value.
+       *
+       * @param height - Can be provided as number or a string with "%" or "px" suffix
+       */
       setHeight(height) {
         if (this._initialized) this._stageController.setHeight(height);else {
           const parsedHeight = NumberUtilities.parseValue(height);
@@ -4792,18 +6710,33 @@
           this._configManager.getSettingsData().getVideoData().videoHeightInPixels = parsedHeight.isPixels;
         }
       }
+      /**
+       * Returns current streamer width in pixels.
+       *
+       * @returns Current width in pixels
+       */
       getWidth() {
         if (this._initialized) return this._stageController.getContainerWidth();else {
           if (this._configManager.getSettingsData().getVideoData().videoWidthInPixels) return this._configManager.getSettingsData().getVideoData().videoWidthValue;
         }
         return 0;
       }
+      /**
+       * Returns current streamer height in pixels.
+       *
+       * @returns Current height in pixels
+       */
       getHeight() {
         if (this._initialized) return this._stageController.getContainerHeight();else {
           if (this._configManager.getSettingsData().getVideoData().videoHeightInPixels) return this._configManager.getSettingsData().getVideoData().videoHeightValue;
         }
         return 0;
       }
+      /**
+       * Changes the streamer scaling mode. Available modes include fill, letterbox, original, and crop.
+       *
+       * @param newMode - New scaling mode name (fill, letterbox, original, crop)
+       */
       setScalingMode(newMode) {
         if (this._stageController) {
           this._stageController.setScalingMode(newMode);
@@ -4811,6 +6744,11 @@
           this._configManager.getSettingsData().getVideoData().scalingMode = newMode;
         }
       }
+      /**
+       * Returns the current streamer scaling mode.
+       *
+       * @returns Current scaling mode
+       */
       getScalingMode() {
         if (this._stageController) {
           return this._stageController.getScalingMode();
@@ -4818,11 +6756,20 @@
           return this._configManager.getSettingsData().getVideoData().scalingMode;
         }
       }
+      /**
+       * Forces the streamer to recalculate its size based on parent internal dimensions.
+       */
       updateToSize() {
         if (this._initialized) {
           this._stageController.handleResize();
         }
       }
+      /**
+       * Returns a promise that resolves with a screenshot of the video element as a blob, or null if taking the
+       * screenshot was not possible.
+       *
+       * @returns Promise resolving to a Blob containing the screenshot or null
+       */
       makeScreenshot() {
         let canvas = document.createElement('canvas');
         let context = canvas.getContext('2d');
@@ -4844,15 +6791,53 @@
           }
         });
       }
+      //------------------------------------------------------------------------//
+      // GRAPHS
+      //------------------------------------------------------------------------//
+      /**
+       * Creates a FPS performance graph in the specified location (container ID or reference). The graph is a
+       * separate object that must be started using its start() method and stopped using its stop() method. The dimensions
+       * of the graph depend on the dimensions of the specified container.
+       *
+       * @param container - Element ID or reference to HTMLElement
+       * @returns FPS graph instance
+       */
       createFPSGraph(container) {
         return new FPSGraph(this, container);
       }
+      /**
+       * Creates a bitrate performance graph in the specified location (container ID or reference). The graph is a
+       * separate object that must be started using its start() method and stopped using its stop() method. The dimensions
+       * of the graph depend on the dimensions of the specified container.
+       *
+       * @param container - Element ID or reference to HTMLElement
+       * @returns Bitrate graph instance
+       */
       createBitrateGraph(container) {
         return new BitrateGraph(this, container);
       }
+      /**
+       * Creates a microphone graph in the specified location (container ID or reference). The graph is a
+       * separate object that must be started using its start() method and stopped using its stop() method. The dimensions
+       * of the graph depend on the dimensions of the specified container.
+       *
+       * @param container - Element ID or reference to HTMLElement
+       * @returns Bitrate graph instance
+       */
+      createMicrophoneGraph(container) {
+        return new MicrophoneGraph(this, container);
+      }
+      /**
+       * Adds new graph to the internal collection of active graphs.
+       *
+       * @param newGraph - Graph instance to add
+       */
       addGraph(newGraph) {
         if (this._graphs != null) this._graphs.push(newGraph);
       }
+      /**
+       * Stops all active performance graphs.
+       */
       stopAllGraphs() {
         if (this._graphs != null && this._graphs.length > 0) {
           for (let i = 0; i < this._graphs.length; i++) {
@@ -4860,82 +6845,198 @@
           }
         }
       }
+      //------------------------------------------------------------------------//
+      // FULLSCREEN
+      //------------------------------------------------------------------------//
+      /**
+       * Enters fullscreen mode for the streamer container.
+       */
       enterFullScreen() {
         if (this._initialized && this._stageController) this._stageController.enterFullScreen();
       }
+      /**
+       * Exits fullscreen mode.
+       */
       exitFullScreen() {
         if (this._initialized && this._stageController) this._stageController.exitFullScreen();
       }
+      /**
+       * Returns true if the streamer is currently in fullscreen mode.
+       *
+       * @returns Boolean indicating fullscreen status
+       */
       isFullScreenMode() {
         if (this._initialized && this._stageController) return this._stageController.isFullScreenMode();
         return false;
       }
+      //------------------------------------------------------------------------//
+      // SIMPLE GETS & SETS
+      //------------------------------------------------------------------------//
+      /**
+       * Returns the current stream key or null if none is set.
+       *
+       * @returns Current stream key or null
+       */
       getStreamKey() {
         var _a, _b, _c;
         return (_c = (_b = (_a = this.getConfigManager()) === null || _a === void 0 ? void 0 : _a.getStreamData()) === null || _b === void 0 ? void 0 : _b.streamKey) !== null && _c !== void 0 ? _c : null;
       }
+      /**
+       * Returns the Stats Controller instance which contains statistical data about streaming performance.
+       *
+       * @returns Stats controller instance or null
+       */
       getStatsController() {
         return this._statsController;
       }
+      /**
+       * Returns the unique ID of this streamer instance. Each subsequent instance has a higher number.
+       *
+       * @returns Streamer instance ID
+       */
       getStreamerID() {
         return this._streamerID;
       }
+      /**
+       * Returns the logger instance used by this streamer.
+       *
+       * @returns Logger instance
+       */
       getLogger() {
         return this._logger;
       }
+      /**
+       * Returns the configuration manager for this streamer.
+       *
+       * @returns Config manager instance or null
+       */
       getConfigManager() {
         return this._configManager;
       }
+      /**
+       * Returns the network controller which manages all server communication.
+       *
+       * @returns Network controller instance or null
+       */
       getNetworkController() {
         return this._networkController;
       }
+      /**
+       * Returns the streamer controller which manages media stream operations.
+       *
+       * @returns Streamer controller instance or null
+       */
       getStreamerController() {
         return this._streamerController;
       }
+      /**
+       * Returns the stage controller which manages visual presentation.
+       *
+       * @returns Stage controller instance or null
+       */
       getStageController() {
         return this._stageController;
       }
+      /**
+       * Returns the storage manager which handles persistent data storage.
+       *
+       * @returns Storage manager instance or null
+       */
+      getStorageManager() {
+        return this._storageManager;
+      }
+      /**
+       * Returns the HTML video element used by this streamer instance.
+       *
+       * @returns Video element or null
+       */
       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;
       }
+      /**
+       * Returns true if this streamer instance has already been initialized.
+       *
+       * @returns Boolean indicating initialization status
+       */
       isInitialized() {
         return this._initialized;
       }
+      /**
+       * Returns the version of this streamer instance. The version is returned in the SemVer format (Major.Minor.Patch).
+       *
+       * @returns Streamer version string
+       */
       getVersion() {
         return this.STREAMER_VERSION;
       }
+      /**
+       * Returns the development branch of this streamer (e.g., main, experimental).
+       *
+       * @returns Branch name string
+       */
       getBranch() {
         return this.STREAMER_BRANCH;
       }
-      getStorageManager() {
-        return this._storageManager;
-      }
+      //------------------------------------------------------------------------//
+      // EVENT
+      //------------------------------------------------------------------------//
+      /**
+       * Dispatches an event with the specified name and data.
+       *
+       * @param eventName - Name of the event to dispatch
+       * @param event - Object containing event data
+       */
       dispatchEvent(eventName, event) {
         super.dispatchEvent(eventName, event);
       }
+      //------------------------------------------------------------------------//
+      // CLEAN UP
+      //------------------------------------------------------------------------//
+      /**
+       * Starts the streaming process.
+       *
+       * @returns Promise that resolves when streaming has started
+       */
       start() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
           return (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.start();
         });
       }
+      /**
+       * Stops the streaming process.
+       */
       stop() {
         var _a;
         return (_a = this._streamerController) === null || _a === void 0 ? void 0 : _a.stop();
       }
+      //------------------------------------------------------------------------//
+      // CLEAN UP
+      //------------------------------------------------------------------------//
+      /**
+       * Destroys this instance of StormStreamer, releasing all resources and disconnecting from the server.
+       * After calling this method, the instance should not be used anymore.
+       */
       destroy() {
         var _a, _b, _c, _d;
         this._logger.warning(this, "Destroying streamer instance, bye, bye!");
         if (this.DEV_MODE && 'StormStreamerArray' in window) window.StormStreamerArray[this._streamerID] = null;
+        // part1
         this._initialized = false;
         this._isRemoved = true;
+        // part3
         (_b = (_a = this._networkController) === null || _a === void 0 ? void 0 : _a.getConnection()) === null || _b === void 0 ? void 0 : _b.destroy();
         (_c = this._streamerController) === null || _c === void 0 ? void 0 : _c.destroy();
         (_d = this._stageController) === null || _d === void 0 ? void 0 : _d.destroy();
+        // part2
         this.removeAllEventListeners();
       }
     }
+    /**
+     * Next ID for the streamer instance. Each subsequent instance has a higher number.
+     * @private
+     */
     StormStreamer.NEXT_STREAMER_ID = 0;
 
     function create(config) {