easyproctor-hml 0.0.21 → 0.0.23

package/esm/index.js

@@ -18,6 +18,3634 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
 
+// node_modules/recordrtc/RecordRTC.js
+var require_RecordRTC = __commonJS({
+  "node_modules/recordrtc/RecordRTC.js"(exports, module) {
+    "use strict";
+    function RecordRTC(mediaStream, config) {
+      if (!mediaStream) {
+        throw "First parameter is required.";
+      }
+      config = config || {
+        type: "video"
+      };
+      config = new RecordRTCConfiguration(mediaStream, config);
+      var self2 = this;
+      function startRecording(config2) {
+        if (!config.disableLogs) {
+          console.log("RecordRTC version: ", self2.version);
+        }
+        if (!!config2) {
+          config = new RecordRTCConfiguration(mediaStream, config2);
+        }
+        if (!config.disableLogs) {
+          console.log("started recording " + config.type + " stream.");
+        }
+        if (mediaRecorder) {
+          mediaRecorder.clearRecordedData();
+          mediaRecorder.record();
+          setState("recording");
+          if (self2.recordingDuration) {
+            handleRecordingDuration();
+          }
+          return self2;
+        }
+        initRecorder(function() {
+          if (self2.recordingDuration) {
+            handleRecordingDuration();
+          }
+        });
+        return self2;
+      }
+      function initRecorder(initCallback) {
+        if (initCallback) {
+          config.initCallback = function() {
+            initCallback();
+            initCallback = config.initCallback = null;
+          };
+        }
+        var Recorder = new GetRecorderType(mediaStream, config);
+        mediaRecorder = new Recorder(mediaStream, config);
+        mediaRecorder.record();
+        setState("recording");
+        if (!config.disableLogs) {
+          console.log("Initialized recorderType:", mediaRecorder.constructor.name, "for output-type:", config.type);
+        }
+      }
+      function stopRecording(callback) {
+        callback = callback || function() {
+        };
+        if (!mediaRecorder) {
+          warningLog();
+          return;
+        }
+        if (self2.state === "paused") {
+          self2.resumeRecording();
+          setTimeout(function() {
+            stopRecording(callback);
+          }, 1);
+          return;
+        }
+        if (self2.state !== "recording" && !config.disableLogs) {
+          console.warn('Recording state should be: "recording", however current state is: ', self2.state);
+        }
+        if (!config.disableLogs) {
+          console.log("Stopped recording " + config.type + " stream.");
+        }
+        if (config.type !== "gif") {
+          mediaRecorder.stop(_callback);
+        } else {
+          mediaRecorder.stop();
+          _callback();
+        }
+        setState("stopped");
+        function _callback(__blob) {
+          if (!mediaRecorder) {
+            if (typeof callback.call === "function") {
+              callback.call(self2, "");
+            } else {
+              callback("");
+            }
+            return;
+          }
+          Object.keys(mediaRecorder).forEach(function(key) {
+            if (typeof mediaRecorder[key] === "function") {
+              return;
+            }
+            self2[key] = mediaRecorder[key];
+          });
+          var blob = mediaRecorder.blob;
+          if (!blob) {
+            if (__blob) {
+              mediaRecorder.blob = blob = __blob;
+            } else {
+              throw "Recording failed.";
+            }
+          }
+          if (blob && !config.disableLogs) {
+            console.log(blob.type, "->", bytesToSize(blob.size));
+          }
+          if (callback) {
+            var url;
+            try {
+              url = URL2.createObjectURL(blob);
+            } catch (e) {
+            }
+            if (typeof callback.call === "function") {
+              callback.call(self2, url);
+            } else {
+              callback(url);
+            }
+          }
+          if (!config.autoWriteToDisk) {
+            return;
+          }
+          getDataURL(function(dataURL) {
+            var parameter = {};
+            parameter[config.type + "Blob"] = dataURL;
+            DiskStorage.Store(parameter);
+          });
+        }
+      }
+      function pauseRecording() {
+        if (!mediaRecorder) {
+          warningLog();
+          return;
+        }
+        if (self2.state !== "recording") {
+          if (!config.disableLogs) {
+            console.warn("Unable to pause the recording. Recording state: ", self2.state);
+          }
+          return;
+        }
+        setState("paused");
+        mediaRecorder.pause();
+        if (!config.disableLogs) {
+          console.log("Paused recording.");
+        }
+      }
+      function resumeRecording() {
+        if (!mediaRecorder) {
+          warningLog();
+          return;
+        }
+        if (self2.state !== "paused") {
+          if (!config.disableLogs) {
+            console.warn("Unable to resume the recording. Recording state: ", self2.state);
+          }
+          return;
+        }
+        setState("recording");
+        mediaRecorder.resume();
+        if (!config.disableLogs) {
+          console.log("Resumed recording.");
+        }
+      }
+      function readFile(_blob) {
+        postMessage(new FileReaderSync().readAsDataURL(_blob));
+      }
+      function getDataURL(callback, _mediaRecorder) {
+        if (!callback) {
+          throw "Pass a callback function over getDataURL.";
+        }
+        var blob = _mediaRecorder ? _mediaRecorder.blob : (mediaRecorder || {}).blob;
+        if (!blob) {
+          if (!config.disableLogs) {
+            console.warn("Blob encoder did not finish its job yet.");
+          }
+          setTimeout(function() {
+            getDataURL(callback, _mediaRecorder);
+          }, 1e3);
+          return;
+        }
+        if (typeof Worker !== "undefined" && !navigator.mozGetUserMedia) {
+          var webWorker = processInWebWorker(readFile);
+          webWorker.onmessage = function(event) {
+            callback(event.data);
+          };
+          webWorker.postMessage(blob);
+        } else {
+          var reader = new FileReader();
+          reader.readAsDataURL(blob);
+          reader.onload = function(event) {
+            callback(event.target.result);
+          };
+        }
+        function processInWebWorker(_function) {
+          try {
+            var blob2 = URL2.createObjectURL(new Blob([
+              _function.toString(),
+              "this.onmessage =  function (eee) {" + _function.name + "(eee.data);}"
+            ], {
+              type: "application/javascript"
+            }));
+            var worker = new Worker(blob2);
+            URL2.revokeObjectURL(blob2);
+            return worker;
+          } catch (e) {
+          }
+        }
+      }
+      function handleRecordingDuration(counter) {
+        counter = counter || 0;
+        if (self2.state === "paused") {
+          setTimeout(function() {
+            handleRecordingDuration(counter);
+          }, 1e3);
+          return;
+        }
+        if (self2.state === "stopped") {
+          return;
+        }
+        if (counter >= self2.recordingDuration) {
+          stopRecording(self2.onRecordingStopped);
+          return;
+        }
+        counter += 1e3;
+        setTimeout(function() {
+          handleRecordingDuration(counter);
+        }, 1e3);
+      }
+      function setState(state) {
+        if (!self2) {
+          return;
+        }
+        self2.state = state;
+        if (typeof self2.onStateChanged.call === "function") {
+          self2.onStateChanged.call(self2, state);
+        } else {
+          self2.onStateChanged(state);
+        }
+      }
+      var WARNING = 'It seems that recorder is destroyed or "startRecording" is not invoked for ' + config.type + " recorder.";
+      function warningLog() {
+        if (config.disableLogs === true) {
+          return;
+        }
+        console.warn(WARNING);
+      }
+      var mediaRecorder;
+      var returnObject = {
+        startRecording,
+        stopRecording,
+        pauseRecording,
+        resumeRecording,
+        initRecorder,
+        setRecordingDuration: function(recordingDuration, callback) {
+          if (typeof recordingDuration === "undefined") {
+            throw "recordingDuration is required.";
+          }
+          if (typeof recordingDuration !== "number") {
+            throw "recordingDuration must be a number.";
+          }
+          self2.recordingDuration = recordingDuration;
+          self2.onRecordingStopped = callback || function() {
+          };
+          return {
+            onRecordingStopped: function(callback2) {
+              self2.onRecordingStopped = callback2;
+            }
+          };
+        },
+        clearRecordedData: function() {
+          if (!mediaRecorder) {
+            warningLog();
+            return;
+          }
+          mediaRecorder.clearRecordedData();
+          if (!config.disableLogs) {
+            console.log("Cleared old recorded data.");
+          }
+        },
+        getBlob: function() {
+          if (!mediaRecorder) {
+            warningLog();
+            return;
+          }
+          return mediaRecorder.blob;
+        },
+        getDataURL,
+        toURL: function() {
+          if (!mediaRecorder) {
+            warningLog();
+            return;
+          }
+          return URL2.createObjectURL(mediaRecorder.blob);
+        },
+        getInternalRecorder: function() {
+          return mediaRecorder;
+        },
+        save: function(fileName) {
+          if (!mediaRecorder) {
+            warningLog();
+            return;
+          }
+          invokeSaveAsDialog(mediaRecorder.blob, fileName);
+        },
+        getFromDisk: function(callback) {
+          if (!mediaRecorder) {
+            warningLog();
+            return;
+          }
+          RecordRTC.getFromDisk(config.type, callback);
+        },
+        setAdvertisementArray: function(arrayOfWebPImages) {
+          config.advertisement = [];
+          var length = arrayOfWebPImages.length;
+          for (var i = 0; i < length; i++) {
+            config.advertisement.push({
+              duration: i,
+              image: arrayOfWebPImages[i]
+            });
+          }
+        },
+        blob: null,
+        bufferSize: 0,
+        sampleRate: 0,
+        buffer: null,
+        reset: function() {
+          if (self2.state === "recording" && !config.disableLogs) {
+            console.warn("Stop an active recorder.");
+          }
+          if (mediaRecorder && typeof mediaRecorder.clearRecordedData === "function") {
+            mediaRecorder.clearRecordedData();
+          }
+          mediaRecorder = null;
+          setState("inactive");
+          self2.blob = null;
+        },
+        onStateChanged: function(state) {
+          if (!config.disableLogs) {
+            console.log("Recorder state changed:", state);
+          }
+        },
+        state: "inactive",
+        getState: function() {
+          return self2.state;
+        },
+        destroy: function() {
+          var disableLogsCache = config.disableLogs;
+          config = {
+            disableLogs: true
+          };
+          self2.reset();
+          setState("destroyed");
+          returnObject = self2 = null;
+          if (Storage.AudioContextConstructor) {
+            Storage.AudioContextConstructor.close();
+            Storage.AudioContextConstructor = null;
+          }
+          config.disableLogs = disableLogsCache;
+          if (!config.disableLogs) {
+            console.log("RecordRTC is destroyed.");
+          }
+        },
+        version: "5.6.2"
+      };
+      if (!this) {
+        self2 = returnObject;
+        return returnObject;
+      }
+      for (var prop in returnObject) {
+        this[prop] = returnObject[prop];
+      }
+      self2 = this;
+      return returnObject;
+    }
+    RecordRTC.version = "5.6.2";
+    if (typeof module !== "undefined") {
+      module.exports = RecordRTC;
+    }
+    if (typeof define === "function" && define.amd) {
+      define("RecordRTC", [], function() {
+        return RecordRTC;
+      });
+    }
+    RecordRTC.getFromDisk = function(type, callback) {
+      if (!callback) {
+        throw "callback is mandatory.";
+      }
+      console.log("Getting recorded " + (type === "all" ? "blobs" : type + " blob ") + " from disk!");
+      DiskStorage.Fetch(function(dataURL, _type) {
+        if (type !== "all" && _type === type + "Blob" && callback) {
+          callback(dataURL);
+        }
+        if (type === "all" && callback) {
+          callback(dataURL, _type.replace("Blob", ""));
+        }
+      });
+    };
+    RecordRTC.writeToDisk = function(options) {
+      console.log("Writing recorded blob(s) to disk!");
+      options = options || {};
+      if (options.audio && options.video && options.gif) {
+        options.audio.getDataURL(function(audioDataURL) {
+          options.video.getDataURL(function(videoDataURL) {
+            options.gif.getDataURL(function(gifDataURL) {
+              DiskStorage.Store({
+                audioBlob: audioDataURL,
+                videoBlob: videoDataURL,
+                gifBlob: gifDataURL
+              });
+            });
+          });
+        });
+      } else if (options.audio && options.video) {
+        options.audio.getDataURL(function(audioDataURL) {
+          options.video.getDataURL(function(videoDataURL) {
+            DiskStorage.Store({
+              audioBlob: audioDataURL,
+              videoBlob: videoDataURL
+            });
+          });
+        });
+      } else if (options.audio && options.gif) {
+        options.audio.getDataURL(function(audioDataURL) {
+          options.gif.getDataURL(function(gifDataURL) {
+            DiskStorage.Store({
+              audioBlob: audioDataURL,
+              gifBlob: gifDataURL
+            });
+          });
+        });
+      } else if (options.video && options.gif) {
+        options.video.getDataURL(function(videoDataURL) {
+          options.gif.getDataURL(function(gifDataURL) {
+            DiskStorage.Store({
+              videoBlob: videoDataURL,
+              gifBlob: gifDataURL
+            });
+          });
+        });
+      } else if (options.audio) {
+        options.audio.getDataURL(function(audioDataURL) {
+          DiskStorage.Store({
+            audioBlob: audioDataURL
+          });
+        });
+      } else if (options.video) {
+        options.video.getDataURL(function(videoDataURL) {
+          DiskStorage.Store({
+            videoBlob: videoDataURL
+          });
+        });
+      } else if (options.gif) {
+        options.gif.getDataURL(function(gifDataURL) {
+          DiskStorage.Store({
+            gifBlob: gifDataURL
+          });
+        });
+      }
+    };
+    function RecordRTCConfiguration(mediaStream, config) {
+      if (!config.recorderType && !config.type) {
+        if (!!config.audio && !!config.video) {
+          config.type = "video";
+        } else if (!!config.audio && !config.video) {
+          config.type = "audio";
+        }
+      }
+      if (config.recorderType && !config.type) {
+        if (config.recorderType === WhammyRecorder || config.recorderType === CanvasRecorder || typeof WebAssemblyRecorder !== "undefined" && config.recorderType === WebAssemblyRecorder) {
+          config.type = "video";
+        } else if (config.recorderType === GifRecorder) {
+          config.type = "gif";
+        } else if (config.recorderType === StereoAudioRecorder) {
+          config.type = "audio";
+        } else if (config.recorderType === MediaStreamRecorder) {
+          if (getTracks(mediaStream, "audio").length && getTracks(mediaStream, "video").length) {
+            config.type = "video";
+          } else if (!getTracks(mediaStream, "audio").length && getTracks(mediaStream, "video").length) {
+            config.type = "video";
+          } else if (getTracks(mediaStream, "audio").length && !getTracks(mediaStream, "video").length) {
+            config.type = "audio";
+          } else {
+          }
+        }
+      }
+      if (typeof MediaStreamRecorder !== "undefined" && typeof MediaRecorder !== "undefined" && "requestData" in MediaRecorder.prototype) {
+        if (!config.mimeType) {
+          config.mimeType = "video/webm";
+        }
+        if (!config.type) {
+          config.type = config.mimeType.split("/")[0];
+        }
+        if (!config.bitsPerSecond) {
+        }
+      }
+      if (!config.type) {
+        if (config.mimeType) {
+          config.type = config.mimeType.split("/")[0];
+        }
+        if (!config.type) {
+          config.type = "audio";
+        }
+      }
+      return config;
+    }
+    function GetRecorderType(mediaStream, config) {
+      var recorder2;
+      if (isChrome || isEdge || isOpera) {
+        recorder2 = StereoAudioRecorder;
+      }
+      if (typeof MediaRecorder !== "undefined" && "requestData" in MediaRecorder.prototype && !isChrome) {
+        recorder2 = MediaStreamRecorder;
+      }
+      if (config.type === "video" && (isChrome || isOpera)) {
+        recorder2 = WhammyRecorder;
+        if (typeof WebAssemblyRecorder !== "undefined" && typeof ReadableStream !== "undefined") {
+          recorder2 = WebAssemblyRecorder;
+        }
+      }
+      if (config.type === "gif") {
+        recorder2 = GifRecorder;
+      }
+      if (config.type === "canvas") {
+        recorder2 = CanvasRecorder;
+      }
+      if (isMediaRecorderCompatible() && recorder2 !== CanvasRecorder && recorder2 !== GifRecorder && typeof MediaRecorder !== "undefined" && "requestData" in MediaRecorder.prototype) {
+        if (getTracks(mediaStream, "video").length || getTracks(mediaStream, "audio").length) {
+          if (config.type === "audio") {
+            if (typeof MediaRecorder.isTypeSupported === "function" && MediaRecorder.isTypeSupported("audio/webm")) {
+              recorder2 = MediaStreamRecorder;
+            }
+          } else {
+            if (typeof MediaRecorder.isTypeSupported === "function" && MediaRecorder.isTypeSupported("video/webm")) {
+              recorder2 = MediaStreamRecorder;
+            }
+          }
+        }
+      }
+      if (mediaStream instanceof Array && mediaStream.length) {
+        recorder2 = MultiStreamRecorder;
+      }
+      if (config.recorderType) {
+        recorder2 = config.recorderType;
+      }
+      if (!config.disableLogs && !!recorder2 && !!recorder2.name) {
+        console.log("Using recorderType:", recorder2.name || recorder2.constructor.name);
+      }
+      if (!recorder2 && isSafari2) {
+        recorder2 = MediaStreamRecorder;
+      }
+      return recorder2;
+    }
+    function MRecordRTC(mediaStream) {
+      this.addStream = function(_mediaStream) {
+        if (_mediaStream) {
+          mediaStream = _mediaStream;
+        }
+      };
+      this.mediaType = {
+        audio: true,
+        video: true
+      };
+      this.startRecording = function() {
+        var mediaType = this.mediaType;
+        var recorderType;
+        var mimeType = this.mimeType || {
+          audio: null,
+          video: null,
+          gif: null
+        };
+        if (typeof mediaType.audio !== "function" && isMediaRecorderCompatible() && !getTracks(mediaStream, "audio").length) {
+          mediaType.audio = false;
+        }
+        if (typeof mediaType.video !== "function" && isMediaRecorderCompatible() && !getTracks(mediaStream, "video").length) {
+          mediaType.video = false;
+        }
+        if (typeof mediaType.gif !== "function" && isMediaRecorderCompatible() && !getTracks(mediaStream, "video").length) {
+          mediaType.gif = false;
+        }
+        if (!mediaType.audio && !mediaType.video && !mediaType.gif) {
+          throw "MediaStream must have either audio or video tracks.";
+        }
+        if (!!mediaType.audio) {
+          recorderType = null;
+          if (typeof mediaType.audio === "function") {
+            recorderType = mediaType.audio;
+          }
+          this.audioRecorder = new RecordRTC(mediaStream, {
+            type: "audio",
+            bufferSize: this.bufferSize,
+            sampleRate: this.sampleRate,
+            numberOfAudioChannels: this.numberOfAudioChannels || 2,
+            disableLogs: this.disableLogs,
+            recorderType,
+            mimeType: mimeType.audio,
+            timeSlice: this.timeSlice,
+            onTimeStamp: this.onTimeStamp
+          });
+          if (!mediaType.video) {
+            this.audioRecorder.startRecording();
+          }
+        }
+        if (!!mediaType.video) {
+          recorderType = null;
+          if (typeof mediaType.video === "function") {
+            recorderType = mediaType.video;
+          }
+          var newStream = mediaStream;
+          if (isMediaRecorderCompatible() && !!mediaType.audio && typeof mediaType.audio === "function") {
+            var videoTrack = getTracks(mediaStream, "video")[0];
+            if (isFirefox) {
+              newStream = new MediaStream();
+              newStream.addTrack(videoTrack);
+              if (recorderType && recorderType === WhammyRecorder) {
+                recorderType = MediaStreamRecorder;
+              }
+            } else {
+              newStream = new MediaStream();
+              newStream.addTrack(videoTrack);
+            }
+          }
+          this.videoRecorder = new RecordRTC(newStream, {
+            type: "video",
+            video: this.video,
+            canvas: this.canvas,
+            frameInterval: this.frameInterval || 10,
+            disableLogs: this.disableLogs,
+            recorderType,
+            mimeType: mimeType.video,
+            timeSlice: this.timeSlice,
+            onTimeStamp: this.onTimeStamp,
+            workerPath: this.workerPath,
+            webAssemblyPath: this.webAssemblyPath,
+            frameRate: this.frameRate,
+            bitrate: this.bitrate
+          });
+          if (!mediaType.audio) {
+            this.videoRecorder.startRecording();
+          }
+        }
+        if (!!mediaType.audio && !!mediaType.video) {
+          var self2 = this;
+          var isSingleRecorder = isMediaRecorderCompatible() === true;
+          if (mediaType.audio instanceof StereoAudioRecorder && !!mediaType.video) {
+            isSingleRecorder = false;
+          } else if (mediaType.audio !== true && mediaType.video !== true && mediaType.audio !== mediaType.video) {
+            isSingleRecorder = false;
+          }
+          if (isSingleRecorder === true) {
+            self2.audioRecorder = null;
+            self2.videoRecorder.startRecording();
+          } else {
+            self2.videoRecorder.initRecorder(function() {
+              self2.audioRecorder.initRecorder(function() {
+                self2.videoRecorder.startRecording();
+                self2.audioRecorder.startRecording();
+              });
+            });
+          }
+        }
+        if (!!mediaType.gif) {
+          recorderType = null;
+          if (typeof mediaType.gif === "function") {
+            recorderType = mediaType.gif;
+          }
+          this.gifRecorder = new RecordRTC(mediaStream, {
+            type: "gif",
+            frameRate: this.frameRate || 200,
+            quality: this.quality || 10,
+            disableLogs: this.disableLogs,
+            recorderType,
+            mimeType: mimeType.gif
+          });
+          this.gifRecorder.startRecording();
+        }
+      };
+      this.stopRecording = function(callback) {
+        callback = callback || function() {
+        };
+        if (this.audioRecorder) {
+          this.audioRecorder.stopRecording(function(blobURL) {
+            callback(blobURL, "audio");
+          });
+        }
+        if (this.videoRecorder) {
+          this.videoRecorder.stopRecording(function(blobURL) {
+            callback(blobURL, "video");
+          });
+        }
+        if (this.gifRecorder) {
+          this.gifRecorder.stopRecording(function(blobURL) {
+            callback(blobURL, "gif");
+          });
+        }
+      };
+      this.pauseRecording = function() {
+        if (this.audioRecorder) {
+          this.audioRecorder.pauseRecording();
+        }
+        if (this.videoRecorder) {
+          this.videoRecorder.pauseRecording();
+        }
+        if (this.gifRecorder) {
+          this.gifRecorder.pauseRecording();
+        }
+      };
+      this.resumeRecording = function() {
+        if (this.audioRecorder) {
+          this.audioRecorder.resumeRecording();
+        }
+        if (this.videoRecorder) {
+          this.videoRecorder.resumeRecording();
+        }
+        if (this.gifRecorder) {
+          this.gifRecorder.resumeRecording();
+        }
+      };
+      this.getBlob = function(callback) {
+        var output = {};
+        if (this.audioRecorder) {
+          output.audio = this.audioRecorder.getBlob();
+        }
+        if (this.videoRecorder) {
+          output.video = this.videoRecorder.getBlob();
+        }
+        if (this.gifRecorder) {
+          output.gif = this.gifRecorder.getBlob();
+        }
+        if (callback) {
+          callback(output);
+        }
+        return output;
+      };
+      this.destroy = function() {
+        if (this.audioRecorder) {
+          this.audioRecorder.destroy();
+          this.audioRecorder = null;
+        }
+        if (this.videoRecorder) {
+          this.videoRecorder.destroy();
+          this.videoRecorder = null;
+        }
+        if (this.gifRecorder) {
+          this.gifRecorder.destroy();
+          this.gifRecorder = null;
+        }
+      };
+      this.getDataURL = function(callback) {
+        this.getBlob(function(blob) {
+          if (blob.audio && blob.video) {
+            getDataURL(blob.audio, function(_audioDataURL) {
+              getDataURL(blob.video, function(_videoDataURL) {
+                callback({
+                  audio: _audioDataURL,
+                  video: _videoDataURL
+                });
+              });
+            });
+          } else if (blob.audio) {
+            getDataURL(blob.audio, function(_audioDataURL) {
+              callback({
+                audio: _audioDataURL
+              });
+            });
+          } else if (blob.video) {
+            getDataURL(blob.video, function(_videoDataURL) {
+              callback({
+                video: _videoDataURL
+              });
+            });
+          }
+        });
+        function getDataURL(blob, callback00) {
+          if (typeof Worker !== "undefined") {
+            var webWorker = processInWebWorker(function readFile(_blob) {
+              postMessage(new FileReaderSync().readAsDataURL(_blob));
+            });
+            webWorker.onmessage = function(event) {
+              callback00(event.data);
+            };
+            webWorker.postMessage(blob);
+          } else {
+            var reader = new FileReader();
+            reader.readAsDataURL(blob);
+            reader.onload = function(event) {
+              callback00(event.target.result);
+            };
+          }
+        }
+        function processInWebWorker(_function) {
+          var blob = URL2.createObjectURL(new Blob([
+            _function.toString(),
+            "this.onmessage =  function (eee) {" + _function.name + "(eee.data);}"
+          ], {
+            type: "application/javascript"
+          }));
+          var worker = new Worker(blob);
+          var url;
+          if (typeof URL2 !== "undefined") {
+            url = URL2;
+          } else if (typeof webkitURL !== "undefined") {
+            url = webkitURL;
+          } else {
+            throw "Neither URL nor webkitURL detected.";
+          }
+          url.revokeObjectURL(blob);
+          return worker;
+        }
+      };
+      this.writeToDisk = function() {
+        RecordRTC.writeToDisk({
+          audio: this.audioRecorder,
+          video: this.videoRecorder,
+          gif: this.gifRecorder
+        });
+      };
+      this.save = function(args) {
+        args = args || {
+          audio: true,
+          video: true,
+          gif: true
+        };
+        if (!!args.audio && this.audioRecorder) {
+          this.audioRecorder.save(typeof args.audio === "string" ? args.audio : "");
+        }
+        if (!!args.video && this.videoRecorder) {
+          this.videoRecorder.save(typeof args.video === "string" ? args.video : "");
+        }
+        if (!!args.gif && this.gifRecorder) {
+          this.gifRecorder.save(typeof args.gif === "string" ? args.gif : "");
+        }
+      };
+    }
+    MRecordRTC.getFromDisk = RecordRTC.getFromDisk;
+    MRecordRTC.writeToDisk = RecordRTC.writeToDisk;
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.MRecordRTC = MRecordRTC;
+    }
+    var browserFakeUserAgent = "Fake/5.0 (FakeOS) AppleWebKit/123 (KHTML, like Gecko) Fake/12.3.4567.89 Fake/123.45";
+    (function(that) {
+      if (!that) {
+        return;
+      }
+      if (typeof window !== "undefined") {
+        return;
+      }
+      if (typeof global === "undefined") {
+        return;
+      }
+      global.navigator = {
+        userAgent: browserFakeUserAgent,
+        getUserMedia: function() {
+        }
+      };
+      if (!global.console) {
+        global.console = {};
+      }
+      if (typeof global.console.log === "undefined" || typeof global.console.error === "undefined") {
+        global.console.error = global.console.log = global.console.log || function() {
+          console.log(arguments);
+        };
+      }
+      if (typeof document === "undefined") {
+        that.document = {
+          documentElement: {
+            appendChild: function() {
+              return "";
+            }
+          }
+        };
+        document.createElement = document.captureStream = document.mozCaptureStream = function() {
+          var obj = {
+            getContext: function() {
+              return obj;
+            },
+            play: function() {
+            },
+            pause: function() {
+            },
+            drawImage: function() {
+            },
+            toDataURL: function() {
+              return "";
+            },
+            style: {}
+          };
+          return obj;
+        };
+        that.HTMLVideoElement = function() {
+        };
+      }
+      if (typeof location === "undefined") {
+        that.location = {
+          protocol: "file:",
+          href: "",
+          hash: ""
+        };
+      }
+      if (typeof screen === "undefined") {
+        that.screen = {
+          width: 0,
+          height: 0
+        };
+      }
+      if (typeof URL2 === "undefined") {
+        that.URL = {
+          createObjectURL: function() {
+            return "";
+          },
+          revokeObjectURL: function() {
+            return "";
+          }
+        };
+      }
+      that.window = global;
+    })(typeof global !== "undefined" ? global : null);
+    var requestAnimationFrame = window.requestAnimationFrame;
+    if (typeof requestAnimationFrame === "undefined") {
+      if (typeof webkitRequestAnimationFrame !== "undefined") {
+        requestAnimationFrame = webkitRequestAnimationFrame;
+      } else if (typeof mozRequestAnimationFrame !== "undefined") {
+        requestAnimationFrame = mozRequestAnimationFrame;
+      } else if (typeof msRequestAnimationFrame !== "undefined") {
+        requestAnimationFrame = msRequestAnimationFrame;
+      } else if (typeof requestAnimationFrame === "undefined") {
+        lastTime = 0;
+        requestAnimationFrame = function(callback, element) {
+          var currTime = new Date().getTime();
+          var timeToCall = Math.max(0, 16 - (currTime - lastTime));
+          var id = setTimeout(function() {
+            callback(currTime + timeToCall);
+          }, timeToCall);
+          lastTime = currTime + timeToCall;
+          return id;
+        };
+      }
+    }
+    var lastTime;
+    var cancelAnimationFrame = window.cancelAnimationFrame;
+    if (typeof cancelAnimationFrame === "undefined") {
+      if (typeof webkitCancelAnimationFrame !== "undefined") {
+        cancelAnimationFrame = webkitCancelAnimationFrame;
+      } else if (typeof mozCancelAnimationFrame !== "undefined") {
+        cancelAnimationFrame = mozCancelAnimationFrame;
+      } else if (typeof msCancelAnimationFrame !== "undefined") {
+        cancelAnimationFrame = msCancelAnimationFrame;
+      } else if (typeof cancelAnimationFrame === "undefined") {
+        cancelAnimationFrame = function(id) {
+          clearTimeout(id);
+        };
+      }
+    }
+    var AudioContext2 = window.AudioContext;
+    if (typeof AudioContext2 === "undefined") {
+      if (typeof webkitAudioContext !== "undefined") {
+        AudioContext2 = webkitAudioContext;
+      }
+      if (typeof mozAudioContext !== "undefined") {
+        AudioContext2 = mozAudioContext;
+      }
+    }
+    var URL2 = window.URL;
+    if (typeof URL2 === "undefined" && typeof webkitURL !== "undefined") {
+      URL2 = webkitURL;
+    }
+    if (typeof navigator !== "undefined" && typeof navigator.getUserMedia === "undefined") {
+      if (typeof navigator.webkitGetUserMedia !== "undefined") {
+        navigator.getUserMedia = navigator.webkitGetUserMedia;
+      }
+      if (typeof navigator.mozGetUserMedia !== "undefined") {
+        navigator.getUserMedia = navigator.mozGetUserMedia;
+      }
+    }
+    var isEdge = navigator.userAgent.indexOf("Edge") !== -1 && (!!navigator.msSaveBlob || !!navigator.msSaveOrOpenBlob);
+    var isOpera = !!window.opera || navigator.userAgent.indexOf("OPR/") !== -1;
+    var isFirefox = navigator.userAgent.toLowerCase().indexOf("firefox") > -1 && "netscape" in window && / rv:/.test(navigator.userAgent);
+    var isChrome = !isOpera && !isEdge && !!navigator.webkitGetUserMedia || isElectron() || navigator.userAgent.toLowerCase().indexOf("chrome/") !== -1;
+    var isSafari2 = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+    if (isSafari2 && !isChrome && navigator.userAgent.indexOf("CriOS") !== -1) {
+      isSafari2 = false;
+      isChrome = true;
+    }
+    var MediaStream = window.MediaStream;
+    if (typeof MediaStream === "undefined" && typeof webkitMediaStream !== "undefined") {
+      MediaStream = webkitMediaStream;
+    }
+    if (typeof MediaStream !== "undefined") {
+      if (typeof MediaStream.prototype.stop === "undefined") {
+        MediaStream.prototype.stop = function() {
+          this.getTracks().forEach(function(track) {
+            track.stop();
+          });
+        };
+      }
+    }
+    function bytesToSize(bytes) {
+      var k = 1e3;
+      var sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+      if (bytes === 0) {
+        return "0 Bytes";
+      }
+      var i = parseInt(Math.floor(Math.log(bytes) / Math.log(k)), 10);
+      return (bytes / Math.pow(k, i)).toPrecision(3) + " " + sizes[i];
+    }
+    function invokeSaveAsDialog(file, fileName) {
+      if (!file) {
+        throw "Blob object is required.";
+      }
+      if (!file.type) {
+        try {
+          file.type = "video/webm";
+        } catch (e) {
+        }
+      }
+      var fileExtension = (file.type || "video/webm").split("/")[1];
+      if (fileExtension.indexOf(";") !== -1) {
+        fileExtension = fileExtension.split(";")[0];
+      }
+      if (fileName && fileName.indexOf(".") !== -1) {
+        var splitted = fileName.split(".");
+        fileName = splitted[0];
+        fileExtension = splitted[1];
+      }
+      var fileFullName = (fileName || Math.round(Math.random() * 9999999999) + 888888888) + "." + fileExtension;
+      if (typeof navigator.msSaveOrOpenBlob !== "undefined") {
+        return navigator.msSaveOrOpenBlob(file, fileFullName);
+      } else if (typeof navigator.msSaveBlob !== "undefined") {
+        return navigator.msSaveBlob(file, fileFullName);
+      }
+      var hyperlink = document.createElement("a");
+      hyperlink.href = URL2.createObjectURL(file);
+      hyperlink.download = fileFullName;
+      hyperlink.style = "display:none;opacity:0;color:transparent;";
+      (document.body || document.documentElement).appendChild(hyperlink);
+      if (typeof hyperlink.click === "function") {
+        hyperlink.click();
+      } else {
+        hyperlink.target = "_blank";
+        hyperlink.dispatchEvent(new MouseEvent("click", {
+          view: window,
+          bubbles: true,
+          cancelable: true
+        }));
+      }
+      URL2.revokeObjectURL(hyperlink.href);
+    }
+    function isElectron() {
+      if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+        return true;
+      }
+      if (typeof process !== "undefined" && typeof process.versions === "object" && !!process.versions.electron) {
+        return true;
+      }
+      if (typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent.indexOf("Electron") >= 0) {
+        return true;
+      }
+      return false;
+    }
+    function getTracks(stream, kind) {
+      if (!stream || !stream.getTracks) {
+        return [];
+      }
+      return stream.getTracks().filter(function(t) {
+        return t.kind === (kind || "audio");
+      });
+    }
+    function setSrcObject(stream, element) {
+      if ("srcObject" in element) {
+        element.srcObject = stream;
+      } else if ("mozSrcObject" in element) {
+        element.mozSrcObject = stream;
+      } else {
+        element.srcObject = stream;
+      }
+    }
+    function getSeekableBlob2(inputBlob, callback) {
+      if (typeof EBML === "undefined") {
+        throw new Error("Please link: https://www.webrtc-experiment.com/EBML.js");
+      }
+      var reader = new EBML.Reader();
+      var decoder = new EBML.Decoder();
+      var tools = EBML.tools;
+      var fileReader = new FileReader();
+      fileReader.onload = function(e) {
+        var ebmlElms = decoder.decode(this.result);
+        ebmlElms.forEach(function(element) {
+          reader.read(element);
+        });
+        reader.stop();
+        var refinedMetadataBuf = tools.makeMetadataSeekable(reader.metadatas, reader.duration, reader.cues);
+        var body = this.result.slice(reader.metadataSize);
+        var newBlob = new Blob([refinedMetadataBuf, body], {
+          type: "video/webm"
+        });
+        callback(newBlob);
+      };
+      fileReader.readAsArrayBuffer(inputBlob);
+    }
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.invokeSaveAsDialog = invokeSaveAsDialog;
+      RecordRTC.getTracks = getTracks;
+      RecordRTC.getSeekableBlob = getSeekableBlob2;
+      RecordRTC.bytesToSize = bytesToSize;
+      RecordRTC.isElectron = isElectron;
+    }
+    var Storage = {};
+    if (typeof AudioContext2 !== "undefined") {
+      Storage.AudioContext = AudioContext2;
+    } else if (typeof webkitAudioContext !== "undefined") {
+      Storage.AudioContext = webkitAudioContext;
+    }
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.Storage = Storage;
+    }
+    function isMediaRecorderCompatible() {
+      if (isFirefox || isSafari2 || isEdge) {
+        return true;
+      }
+      var nVer = navigator.appVersion;
+      var nAgt = navigator.userAgent;
+      var fullVersion = "" + parseFloat(navigator.appVersion);
+      var majorVersion = parseInt(navigator.appVersion, 10);
+      var nameOffset, verOffset, ix;
+      if (isChrome || isOpera) {
+        verOffset = nAgt.indexOf("Chrome");
+        fullVersion = nAgt.substring(verOffset + 7);
+      }
+      if ((ix = fullVersion.indexOf(";")) !== -1) {
+        fullVersion = fullVersion.substring(0, ix);
+      }
+      if ((ix = fullVersion.indexOf(" ")) !== -1) {
+        fullVersion = fullVersion.substring(0, ix);
+      }
+      majorVersion = parseInt("" + fullVersion, 10);
+      if (isNaN(majorVersion)) {
+        fullVersion = "" + parseFloat(navigator.appVersion);
+        majorVersion = parseInt(navigator.appVersion, 10);
+      }
+      return majorVersion >= 49;
+    }
+    function MediaStreamRecorder(mediaStream, config) {
+      var self2 = this;
+      if (typeof mediaStream === "undefined") {
+        throw 'First argument "MediaStream" is required.';
+      }
+      if (typeof MediaRecorder === "undefined") {
+        throw "Your browser does not support the Media Recorder API. Please try other modules e.g. WhammyRecorder or StereoAudioRecorder.";
+      }
+      config = config || {
+        mimeType: "video/webm"
+      };
+      if (config.type === "audio") {
+        if (getTracks(mediaStream, "video").length && getTracks(mediaStream, "audio").length) {
+          var stream;
+          if (!!navigator.mozGetUserMedia) {
+            stream = new MediaStream();
+            stream.addTrack(getTracks(mediaStream, "audio")[0]);
+          } else {
+            stream = new MediaStream(getTracks(mediaStream, "audio"));
+          }
+          mediaStream = stream;
+        }
+        if (!config.mimeType || config.mimeType.toString().toLowerCase().indexOf("audio") === -1) {
+          config.mimeType = isChrome ? "audio/webm" : "audio/ogg";
+        }
+        if (config.mimeType && config.mimeType.toString().toLowerCase() !== "audio/ogg" && !!navigator.mozGetUserMedia) {
+          config.mimeType = "audio/ogg";
+        }
+      }
+      var arrayOfBlobs = [];
+      this.getArrayOfBlobs = function() {
+        return arrayOfBlobs;
+      };
+      this.record = function() {
+        self2.blob = null;
+        self2.clearRecordedData();
+        self2.timestamps = [];
+        allStates = [];
+        arrayOfBlobs = [];
+        var recorderHints = config;
+        if (!config.disableLogs) {
+          console.log("Passing following config over MediaRecorder API.", recorderHints);
+        }
+        if (mediaRecorder) {
+          mediaRecorder = null;
+        }
+        if (isChrome && !isMediaRecorderCompatible()) {
+          recorderHints = "video/vp8";
+        }
+        if (typeof MediaRecorder.isTypeSupported === "function" && recorderHints.mimeType) {
+          if (!MediaRecorder.isTypeSupported(recorderHints.mimeType)) {
+            if (!config.disableLogs) {
+              console.warn("MediaRecorder API seems unable to record mimeType:", recorderHints.mimeType);
+            }
+            recorderHints.mimeType = config.type === "audio" ? "audio/webm" : "video/webm";
+          }
+        }
+        try {
+          mediaRecorder = new MediaRecorder(mediaStream, recorderHints);
+          config.mimeType = recorderHints.mimeType;
+        } catch (e) {
+          mediaRecorder = new MediaRecorder(mediaStream);
+        }
+        if (recorderHints.mimeType && !MediaRecorder.isTypeSupported && "canRecordMimeType" in mediaRecorder && mediaRecorder.canRecordMimeType(recorderHints.mimeType) === false) {
+          if (!config.disableLogs) {
+            console.warn("MediaRecorder API seems unable to record mimeType:", recorderHints.mimeType);
+          }
+        }
+        mediaRecorder.ondataavailable = function(e) {
+          if (e.data) {
+            allStates.push("ondataavailable: " + bytesToSize(e.data.size));
+          }
+          if (typeof config.timeSlice === "number") {
+            if (e.data && e.data.size) {
+              arrayOfBlobs.push(e.data);
+              updateTimeStamp();
+              if (typeof config.ondataavailable === "function") {
+                var blob = config.getNativeBlob ? e.data : new Blob([e.data], {
+                  type: getMimeType(recorderHints)
+                });
+                config.ondataavailable(blob);
+              }
+            }
+            return;
+          }
+          if (!e.data || !e.data.size || e.data.size < 100 || self2.blob) {
+            if (self2.recordingCallback) {
+              self2.recordingCallback(new Blob([], {
+                type: getMimeType(recorderHints)
+              }));
+              self2.recordingCallback = null;
+            }
+            return;
+          }
+          self2.blob = config.getNativeBlob ? e.data : new Blob([e.data], {
+            type: getMimeType(recorderHints)
+          });
+          if (self2.recordingCallback) {
+            self2.recordingCallback(self2.blob);
+            self2.recordingCallback = null;
+          }
+        };
+        mediaRecorder.onstart = function() {
+          allStates.push("started");
+        };
+        mediaRecorder.onpause = function() {
+          allStates.push("paused");
+        };
+        mediaRecorder.onresume = function() {
+          allStates.push("resumed");
+        };
+        mediaRecorder.onstop = function() {
+          allStates.push("stopped");
+        };
+        mediaRecorder.onerror = function(error) {
+          if (!error) {
+            return;
+          }
+          if (!error.name) {
+            error.name = "UnknownError";
+          }
+          allStates.push("error: " + error);
+          if (!config.disableLogs) {
+            if (error.name.toString().toLowerCase().indexOf("invalidstate") !== -1) {
+              console.error("The MediaRecorder is not in a state in which the proposed operation is allowed to be executed.", error);
+            } else if (error.name.toString().toLowerCase().indexOf("notsupported") !== -1) {
+              console.error("MIME type (", recorderHints.mimeType, ") is not supported.", error);
+            } else if (error.name.toString().toLowerCase().indexOf("security") !== -1) {
+              console.error("MediaRecorder security error", error);
+            } else if (error.name === "OutOfMemory") {
+              console.error("The UA has exhaused the available memory. User agents SHOULD provide as much additional information as possible in the message attribute.", error);
+            } else if (error.name === "IllegalStreamModification") {
+              console.error("A modification to the stream has occurred that makes it impossible to continue recording. An example would be the addition of a Track while recording is occurring. User agents SHOULD provide as much additional information as possible in the message attribute.", error);
+            } else if (error.name === "OtherRecordingError") {
+              console.error("Used for an fatal error other than those listed above. User agents SHOULD provide as much additional information as possible in the message attribute.", error);
+            } else if (error.name === "GenericError") {
+              console.error("The UA cannot provide the codec or recording option that has been requested.", error);
+            } else {
+              console.error("MediaRecorder Error", error);
+            }
+          }
+          (function(looper) {
+            if (!self2.manuallyStopped && mediaRecorder && mediaRecorder.state === "inactive") {
+              delete config.timeslice;
+              mediaRecorder.start(10 * 60 * 1e3);
+              return;
+            }
+            setTimeout(looper, 1e3);
+          })();
+          if (mediaRecorder.state !== "inactive" && mediaRecorder.state !== "stopped") {
+            mediaRecorder.stop();
+          }
+        };
+        if (typeof config.timeSlice === "number") {
+          updateTimeStamp();
+          mediaRecorder.start(config.timeSlice);
+        } else {
+          mediaRecorder.start(36e5);
+        }
+        if (config.initCallback) {
+          config.initCallback();
+        }
+      };
+      this.timestamps = [];
+      function updateTimeStamp() {
+        self2.timestamps.push(new Date().getTime());
+        if (typeof config.onTimeStamp === "function") {
+          config.onTimeStamp(self2.timestamps[self2.timestamps.length - 1], self2.timestamps);
+        }
+      }
+      function getMimeType(secondObject) {
+        if (mediaRecorder && mediaRecorder.mimeType) {
+          return mediaRecorder.mimeType;
+        }
+        return secondObject.mimeType || "video/webm";
+      }
+      this.stop = function(callback) {
+        callback = callback || function() {
+        };
+        self2.manuallyStopped = true;
+        if (!mediaRecorder) {
+          return;
+        }
+        this.recordingCallback = callback;
+        if (mediaRecorder.state === "recording") {
+          mediaRecorder.stop();
+        }
+        if (typeof config.timeSlice === "number") {
+          setTimeout(function() {
+            self2.blob = new Blob(arrayOfBlobs, {
+              type: getMimeType(config)
+            });
+            self2.recordingCallback(self2.blob);
+          }, 100);
+        }
+      };
+      this.pause = function() {
+        if (!mediaRecorder) {
+          return;
+        }
+        if (mediaRecorder.state === "recording") {
+          mediaRecorder.pause();
+        }
+      };
+      this.resume = function() {
+        if (!mediaRecorder) {
+          return;
+        }
+        if (mediaRecorder.state === "paused") {
+          mediaRecorder.resume();
+        }
+      };
+      this.clearRecordedData = function() {
+        if (mediaRecorder && mediaRecorder.state === "recording") {
+          self2.stop(clearRecordedDataCB);
+        }
+        clearRecordedDataCB();
+      };
+      function clearRecordedDataCB() {
+        arrayOfBlobs = [];
+        mediaRecorder = null;
+        self2.timestamps = [];
+      }
+      var mediaRecorder;
+      this.getInternalRecorder = function() {
+        return mediaRecorder;
+      };
+      function isMediaStreamActive() {
+        if ("active" in mediaStream) {
+          if (!mediaStream.active) {
+            return false;
+          }
+        } else if ("ended" in mediaStream) {
+          if (mediaStream.ended) {
+            return false;
+          }
+        }
+        return true;
+      }
+      this.blob = null;
+      this.getState = function() {
+        if (!mediaRecorder) {
+          return "inactive";
+        }
+        return mediaRecorder.state || "inactive";
+      };
+      var allStates = [];
+      this.getAllStates = function() {
+        return allStates;
+      };
+      if (typeof config.checkForInactiveTracks === "undefined") {
+        config.checkForInactiveTracks = false;
+      }
+      var self2 = this;
+      (function looper() {
+        if (!mediaRecorder || config.checkForInactiveTracks === false) {
+          return;
+        }
+        if (isMediaStreamActive() === false) {
+          if (!config.disableLogs) {
+            console.log("MediaStream seems stopped.");
+          }
+          self2.stop();
+          return;
+        }
+        setTimeout(looper, 1e3);
+      })();
+      this.name = "MediaStreamRecorder";
+      this.toString = function() {
+        return this.name;
+      };
+    }
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.MediaStreamRecorder = MediaStreamRecorder;
+    }
+    function StereoAudioRecorder(mediaStream, config) {
+      if (!getTracks(mediaStream, "audio").length) {
+        throw "Your stream has no audio tracks.";
+      }
+      config = config || {};
+      var self2 = this;
+      var leftchannel = [];
+      var rightchannel = [];
+      var recording = false;
+      var recordingLength = 0;
+      var jsAudioNode;
+      var numberOfAudioChannels = 2;
+      var desiredSampRate = config.desiredSampRate;
+      if (config.leftChannel === true) {
+        numberOfAudioChannels = 1;
+      }
+      if (config.numberOfAudioChannels === 1) {
+        numberOfAudioChannels = 1;
+      }
+      if (!numberOfAudioChannels || numberOfAudioChannels < 1) {
+        numberOfAudioChannels = 2;
+      }
+      if (!config.disableLogs) {
+        console.log("StereoAudioRecorder is set to record number of channels: " + numberOfAudioChannels);
+      }
+      if (typeof config.checkForInactiveTracks === "undefined") {
+        config.checkForInactiveTracks = true;
+      }
+      function isMediaStreamActive() {
+        if (config.checkForInactiveTracks === false) {
+          return true;
+        }
+        if ("active" in mediaStream) {
+          if (!mediaStream.active) {
+            return false;
+          }
+        } else if ("ended" in mediaStream) {
+          if (mediaStream.ended) {
+            return false;
+          }
+        }
+        return true;
+      }
+      this.record = function() {
+        if (isMediaStreamActive() === false) {
+          throw "Please make sure MediaStream is active.";
+        }
+        resetVariables();
+        isAudioProcessStarted = isPaused = false;
+        recording = true;
+        if (typeof config.timeSlice !== "undefined") {
+          looper();
+        }
+      };
+      function mergeLeftRightBuffers(config2, callback) {
+        function mergeAudioBuffers(config3, cb) {
+          var numberOfAudioChannels2 = config3.numberOfAudioChannels;
+          var leftBuffers = config3.leftBuffers.slice(0);
+          var rightBuffers = config3.rightBuffers.slice(0);
+          var sampleRate2 = config3.sampleRate;
+          var internalInterleavedLength = config3.internalInterleavedLength;
+          var desiredSampRate2 = config3.desiredSampRate;
+          if (numberOfAudioChannels2 === 2) {
+            leftBuffers = mergeBuffers(leftBuffers, internalInterleavedLength);
+            rightBuffers = mergeBuffers(rightBuffers, internalInterleavedLength);
+            if (desiredSampRate2) {
+              leftBuffers = interpolateArray(leftBuffers, desiredSampRate2, sampleRate2);
+              rightBuffers = interpolateArray(rightBuffers, desiredSampRate2, sampleRate2);
+            }
+          }
+          if (numberOfAudioChannels2 === 1) {
+            leftBuffers = mergeBuffers(leftBuffers, internalInterleavedLength);
+            if (desiredSampRate2) {
+              leftBuffers = interpolateArray(leftBuffers, desiredSampRate2, sampleRate2);
+            }
+          }
+          if (desiredSampRate2) {
+            sampleRate2 = desiredSampRate2;
+          }
+          function interpolateArray(data, newSampleRate, oldSampleRate) {
+            var fitCount = Math.round(data.length * (newSampleRate / oldSampleRate));
+            var newData = [];
+            var springFactor = Number((data.length - 1) / (fitCount - 1));
+            newData[0] = data[0];
+            for (var i2 = 1; i2 < fitCount - 1; i2++) {
+              var tmp = i2 * springFactor;
+              var before = Number(Math.floor(tmp)).toFixed();
+              var after = Number(Math.ceil(tmp)).toFixed();
+              var atPoint = tmp - before;
+              newData[i2] = linearInterpolate(data[before], data[after], atPoint);
+            }
+            newData[fitCount - 1] = data[data.length - 1];
+            return newData;
+          }
+          function linearInterpolate(before, after, atPoint) {
+            return before + (after - before) * atPoint;
+          }
+          function mergeBuffers(channelBuffer, rLength) {
+            var result = new Float64Array(rLength);
+            var offset = 0;
+            var lng2 = channelBuffer.length;
+            for (var i2 = 0; i2 < lng2; i2++) {
+              var buffer2 = channelBuffer[i2];
+              result.set(buffer2, offset);
+              offset += buffer2.length;
+            }
+            return result;
+          }
+          function interleave(leftChannel, rightChannel) {
+            var length = leftChannel.length + rightChannel.length;
+            var result = new Float64Array(length);
+            var inputIndex = 0;
+            for (var index2 = 0; index2 < length; ) {
+              result[index2++] = leftChannel[inputIndex];
+              result[index2++] = rightChannel[inputIndex];
+              inputIndex++;
+            }
+            return result;
+          }
+          function writeUTFBytes(view2, offset, string) {
+            var lng2 = string.length;
+            for (var i2 = 0; i2 < lng2; i2++) {
+              view2.setUint8(offset + i2, string.charCodeAt(i2));
+            }
+          }
+          var interleaved;
+          if (numberOfAudioChannels2 === 2) {
+            interleaved = interleave(leftBuffers, rightBuffers);
+          }
+          if (numberOfAudioChannels2 === 1) {
+            interleaved = leftBuffers;
+          }
+          var interleavedLength = interleaved.length;
+          var resultingBufferLength = 44 + interleavedLength * 2;
+          var buffer = new ArrayBuffer(resultingBufferLength);
+          var view = new DataView(buffer);
+          writeUTFBytes(view, 0, "RIFF");
+          view.setUint32(4, 36 + interleavedLength * 2, true);
+          writeUTFBytes(view, 8, "WAVE");
+          writeUTFBytes(view, 12, "fmt ");
+          view.setUint32(16, 16, true);
+          view.setUint16(20, 1, true);
+          view.setUint16(22, numberOfAudioChannels2, true);
+          view.setUint32(24, sampleRate2, true);
+          view.setUint32(28, sampleRate2 * numberOfAudioChannels2 * 2, true);
+          view.setUint16(32, numberOfAudioChannels2 * 2, true);
+          view.setUint16(34, 16, true);
+          writeUTFBytes(view, 36, "data");
+          view.setUint32(40, interleavedLength * 2, true);
+          var lng = interleavedLength;
+          var index = 44;
+          var volume = 1;
+          for (var i = 0; i < lng; i++) {
+            view.setInt16(index, interleaved[i] * (32767 * volume), true);
+            index += 2;
+          }
+          if (cb) {
+            return cb({
+              buffer,
+              view
+            });
+          }
+          postMessage({
+            buffer,
+            view
+          });
+        }
+        if (config2.noWorker) {
+          mergeAudioBuffers(config2, function(data) {
+            callback(data.buffer, data.view);
+          });
+          return;
+        }
+        var webWorker = processInWebWorker(mergeAudioBuffers);
+        webWorker.onmessage = function(event) {
+          callback(event.data.buffer, event.data.view);
+          URL2.revokeObjectURL(webWorker.workerURL);
+          webWorker.terminate();
+        };
+        webWorker.postMessage(config2);
+      }
+      function processInWebWorker(_function) {
+        var workerURL = URL2.createObjectURL(new Blob([
+          _function.toString(),
+          ";this.onmessage =  function (eee) {" + _function.name + "(eee.data);}"
+        ], {
+          type: "application/javascript"
+        }));
+        var worker = new Worker(workerURL);
+        worker.workerURL = workerURL;
+        return worker;
+      }
+      this.stop = function(callback) {
+        callback = callback || function() {
+        };
+        recording = false;
+        mergeLeftRightBuffers({
+          desiredSampRate,
+          sampleRate,
+          numberOfAudioChannels,
+          internalInterleavedLength: recordingLength,
+          leftBuffers: leftchannel,
+          rightBuffers: numberOfAudioChannels === 1 ? [] : rightchannel,
+          noWorker: config.noWorker
+        }, function(buffer, view) {
+          self2.blob = new Blob([view], {
+            type: "audio/wav"
+          });
+          self2.buffer = new ArrayBuffer(view.buffer.byteLength);
+          self2.view = view;
+          self2.sampleRate = desiredSampRate || sampleRate;
+          self2.bufferSize = bufferSize;
+          self2.length = recordingLength;
+          isAudioProcessStarted = false;
+          if (callback) {
+            callback(self2.blob);
+          }
+        });
+      };
+      if (typeof RecordRTC.Storage === "undefined") {
+        RecordRTC.Storage = {
+          AudioContextConstructor: null,
+          AudioContext: window.AudioContext || window.webkitAudioContext
+        };
+      }
+      if (!RecordRTC.Storage.AudioContextConstructor || RecordRTC.Storage.AudioContextConstructor.state === "closed") {
+        RecordRTC.Storage.AudioContextConstructor = new RecordRTC.Storage.AudioContext();
+      }
+      var context = RecordRTC.Storage.AudioContextConstructor;
+      var audioInput = context.createMediaStreamSource(mediaStream);
+      var legalBufferValues = [0, 256, 512, 1024, 2048, 4096, 8192, 16384];
+      var bufferSize = typeof config.bufferSize === "undefined" ? 4096 : config.bufferSize;
+      if (legalBufferValues.indexOf(bufferSize) === -1) {
+        if (!config.disableLogs) {
+          console.log("Legal values for buffer-size are " + JSON.stringify(legalBufferValues, null, "	"));
+        }
+      }
+      if (context.createJavaScriptNode) {
+        jsAudioNode = context.createJavaScriptNode(bufferSize, numberOfAudioChannels, numberOfAudioChannels);
+      } else if (context.createScriptProcessor) {
+        jsAudioNode = context.createScriptProcessor(bufferSize, numberOfAudioChannels, numberOfAudioChannels);
+      } else {
+        throw "WebAudio API has no support on this browser.";
+      }
+      audioInput.connect(jsAudioNode);
+      if (!config.bufferSize) {
+        bufferSize = jsAudioNode.bufferSize;
+      }
+      var sampleRate = typeof config.sampleRate !== "undefined" ? config.sampleRate : context.sampleRate || 44100;
+      if (sampleRate < 22050 || sampleRate > 96e3) {
+        if (!config.disableLogs) {
+          console.log("sample-rate must be under range 22050 and 96000.");
+        }
+      }
+      if (!config.disableLogs) {
+        if (config.desiredSampRate) {
+          console.log("Desired sample-rate: " + config.desiredSampRate);
+        }
+      }
+      var isPaused = false;
+      this.pause = function() {
+        isPaused = true;
+      };
+      this.resume = function() {
+        if (isMediaStreamActive() === false) {
+          throw "Please make sure MediaStream is active.";
+        }
+        if (!recording) {
+          if (!config.disableLogs) {
+            console.log("Seems recording has been restarted.");
+          }
+          this.record();
+          return;
+        }
+        isPaused = false;
+      };
+      this.clearRecordedData = function() {
+        config.checkForInactiveTracks = false;
+        if (recording) {
+          this.stop(clearRecordedDataCB);
+        }
+        clearRecordedDataCB();
+      };
+      function resetVariables() {
+        leftchannel = [];
+        rightchannel = [];
+        recordingLength = 0;
+        isAudioProcessStarted = false;
+        recording = false;
+        isPaused = false;
+        context = null;
+        self2.leftchannel = leftchannel;
+        self2.rightchannel = rightchannel;
+        self2.numberOfAudioChannels = numberOfAudioChannels;
+        self2.desiredSampRate = desiredSampRate;
+        self2.sampleRate = sampleRate;
+        self2.recordingLength = recordingLength;
+        intervalsBasedBuffers = {
+          left: [],
+          right: [],
+          recordingLength: 0
+        };
+      }
+      function clearRecordedDataCB() {
+        if (jsAudioNode) {
+          jsAudioNode.onaudioprocess = null;
+          jsAudioNode.disconnect();
+          jsAudioNode = null;
+        }
+        if (audioInput) {
+          audioInput.disconnect();
+          audioInput = null;
+        }
+        resetVariables();
+      }
+      this.name = "StereoAudioRecorder";
+      this.toString = function() {
+        return this.name;
+      };
+      var isAudioProcessStarted = false;
+      function onAudioProcessDataAvailable(e) {
+        if (isPaused) {
+          return;
+        }
+        if (isMediaStreamActive() === false) {
+          if (!config.disableLogs) {
+            console.log("MediaStream seems stopped.");
+          }
+          jsAudioNode.disconnect();
+          recording = false;
+        }
+        if (!recording) {
+          if (audioInput) {
+            audioInput.disconnect();
+            audioInput = null;
+          }
+          return;
+        }
+        if (!isAudioProcessStarted) {
+          isAudioProcessStarted = true;
+          if (config.onAudioProcessStarted) {
+            config.onAudioProcessStarted();
+          }
+          if (config.initCallback) {
+            config.initCallback();
+          }
+        }
+        var left = e.inputBuffer.getChannelData(0);
+        var chLeft = new Float32Array(left);
+        leftchannel.push(chLeft);
+        if (numberOfAudioChannels === 2) {
+          var right = e.inputBuffer.getChannelData(1);
+          var chRight = new Float32Array(right);
+          rightchannel.push(chRight);
+        }
+        recordingLength += bufferSize;
+        self2.recordingLength = recordingLength;
+        if (typeof config.timeSlice !== "undefined") {
+          intervalsBasedBuffers.recordingLength += bufferSize;
+          intervalsBasedBuffers.left.push(chLeft);
+          if (numberOfAudioChannels === 2) {
+            intervalsBasedBuffers.right.push(chRight);
+          }
+        }
+      }
+      jsAudioNode.onaudioprocess = onAudioProcessDataAvailable;
+      if (context.createMediaStreamDestination) {
+        jsAudioNode.connect(context.createMediaStreamDestination());
+      } else {
+        jsAudioNode.connect(context.destination);
+      }
+      this.leftchannel = leftchannel;
+      this.rightchannel = rightchannel;
+      this.numberOfAudioChannels = numberOfAudioChannels;
+      this.desiredSampRate = desiredSampRate;
+      this.sampleRate = sampleRate;
+      self2.recordingLength = recordingLength;
+      var intervalsBasedBuffers = {
+        left: [],
+        right: [],
+        recordingLength: 0
+      };
+      function looper() {
+        if (!recording || typeof config.ondataavailable !== "function" || typeof config.timeSlice === "undefined") {
+          return;
+        }
+        if (intervalsBasedBuffers.left.length) {
+          mergeLeftRightBuffers({
+            desiredSampRate,
+            sampleRate,
+            numberOfAudioChannels,
+            internalInterleavedLength: intervalsBasedBuffers.recordingLength,
+            leftBuffers: intervalsBasedBuffers.left,
+            rightBuffers: numberOfAudioChannels === 1 ? [] : intervalsBasedBuffers.right
+          }, function(buffer, view) {
+            var blob = new Blob([view], {
+              type: "audio/wav"
+            });
+            config.ondataavailable(blob);
+            setTimeout(looper, config.timeSlice);
+          });
+          intervalsBasedBuffers = {
+            left: [],
+            right: [],
+            recordingLength: 0
+          };
+        } else {
+          setTimeout(looper, config.timeSlice);
+        }
+      }
+    }
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.StereoAudioRecorder = StereoAudioRecorder;
+    }
+    function CanvasRecorder(htmlElement, config) {
+      if (typeof html2canvas === "undefined") {
+        throw "Please link: https://www.webrtc-experiment.com/screenshot.js";
+      }
+      config = config || {};
+      if (!config.frameInterval) {
+        config.frameInterval = 10;
+      }
+      var isCanvasSupportsStreamCapturing = false;
+      ["captureStream", "mozCaptureStream", "webkitCaptureStream"].forEach(function(item) {
+        if (item in document.createElement("canvas")) {
+          isCanvasSupportsStreamCapturing = true;
+        }
+      });
+      var _isChrome = (!!window.webkitRTCPeerConnection || !!window.webkitGetUserMedia) && !!window.chrome;
+      var chromeVersion = 50;
+      var matchArray = navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./);
+      if (_isChrome && matchArray && matchArray[2]) {
+        chromeVersion = parseInt(matchArray[2], 10);
+      }
+      if (_isChrome && chromeVersion < 52) {
+        isCanvasSupportsStreamCapturing = false;
+      }
+      if (config.useWhammyRecorder) {
+        isCanvasSupportsStreamCapturing = false;
+      }
+      var globalCanvas, mediaStreamRecorder;
+      if (isCanvasSupportsStreamCapturing) {
+        if (!config.disableLogs) {
+          console.log("Your browser supports both MediRecorder API and canvas.captureStream!");
+        }
+        if (htmlElement instanceof HTMLCanvasElement) {
+          globalCanvas = htmlElement;
+        } else if (htmlElement instanceof CanvasRenderingContext2D) {
+          globalCanvas = htmlElement.canvas;
+        } else {
+          throw "Please pass either HTMLCanvasElement or CanvasRenderingContext2D.";
+        }
+      } else if (!!navigator.mozGetUserMedia) {
+        if (!config.disableLogs) {
+          console.error("Canvas recording is NOT supported in Firefox.");
+        }
+      }
+      var isRecording;
+      this.record = function() {
+        isRecording = true;
+        if (isCanvasSupportsStreamCapturing && !config.useWhammyRecorder) {
+          var canvasMediaStream;
+          if ("captureStream" in globalCanvas) {
+            canvasMediaStream = globalCanvas.captureStream(25);
+          } else if ("mozCaptureStream" in globalCanvas) {
+            canvasMediaStream = globalCanvas.mozCaptureStream(25);
+          } else if ("webkitCaptureStream" in globalCanvas) {
+            canvasMediaStream = globalCanvas.webkitCaptureStream(25);
+          }
+          try {
+            var mdStream = new MediaStream();
+            mdStream.addTrack(getTracks(canvasMediaStream, "video")[0]);
+            canvasMediaStream = mdStream;
+          } catch (e) {
+          }
+          if (!canvasMediaStream) {
+            throw "captureStream API are NOT available.";
+          }
+          mediaStreamRecorder = new MediaStreamRecorder(canvasMediaStream, {
+            mimeType: config.mimeType || "video/webm"
+          });
+          mediaStreamRecorder.record();
+        } else {
+          whammy.frames = [];
+          lastTime2 = new Date().getTime();
+          drawCanvasFrame();
+        }
+        if (config.initCallback) {
+          config.initCallback();
+        }
+      };
+      this.getWebPImages = function(callback) {
+        if (htmlElement.nodeName.toLowerCase() !== "canvas") {
+          callback();
+          return;
+        }
+        var framesLength = whammy.frames.length;
+        whammy.frames.forEach(function(frame, idx) {
+          var framesRemaining = framesLength - idx;
+          if (!config.disableLogs) {
+            console.log(framesRemaining + "/" + framesLength + " frames remaining");
+          }
+          if (config.onEncodingCallback) {
+            config.onEncodingCallback(framesRemaining, framesLength);
+          }
+          var webp = frame.image.toDataURL("image/webp", 1);
+          whammy.frames[idx].image = webp;
+        });
+        if (!config.disableLogs) {
+          console.log("Generating WebM");
+        }
+        callback();
+      };
+      this.stop = function(callback) {
+        isRecording = false;
+        var that = this;
+        if (isCanvasSupportsStreamCapturing && mediaStreamRecorder) {
+          mediaStreamRecorder.stop(callback);
+          return;
+        }
+        this.getWebPImages(function() {
+          whammy.compile(function(blob) {
+            if (!config.disableLogs) {
+              console.log("Recording finished!");
+            }
+            that.blob = blob;
+            if (that.blob.forEach) {
+              that.blob = new Blob([], {
+                type: "video/webm"
+              });
+            }
+            if (callback) {
+              callback(that.blob);
+            }
+            whammy.frames = [];
+          });
+        });
+      };
+      var isPausedRecording = false;
+      this.pause = function() {
+        isPausedRecording = true;
+        if (mediaStreamRecorder instanceof MediaStreamRecorder) {
+          mediaStreamRecorder.pause();
+          return;
+        }
+      };
+      this.resume = function() {
+        isPausedRecording = false;
+        if (mediaStreamRecorder instanceof MediaStreamRecorder) {
+          mediaStreamRecorder.resume();
+          return;
+        }
+        if (!isRecording) {
+          this.record();
+        }
+      };
+      this.clearRecordedData = function() {
+        if (isRecording) {
+          this.stop(clearRecordedDataCB);
+        }
+        clearRecordedDataCB();
+      };
+      function clearRecordedDataCB() {
+        whammy.frames = [];
+        isRecording = false;
+        isPausedRecording = false;
+      }
+      this.name = "CanvasRecorder";
+      this.toString = function() {
+        return this.name;
+      };
+      function cloneCanvas() {
+        var newCanvas = document.createElement("canvas");
+        var context = newCanvas.getContext("2d");
+        newCanvas.width = htmlElement.width;
+        newCanvas.height = htmlElement.height;
+        context.drawImage(htmlElement, 0, 0);
+        return newCanvas;
+      }
+      function drawCanvasFrame() {
+        if (isPausedRecording) {
+          lastTime2 = new Date().getTime();
+          return setTimeout(drawCanvasFrame, 500);
+        }
+        if (htmlElement.nodeName.toLowerCase() === "canvas") {
+          var duration = new Date().getTime() - lastTime2;
+          lastTime2 = new Date().getTime();
+          whammy.frames.push({
+            image: cloneCanvas(),
+            duration
+          });
+          if (isRecording) {
+            setTimeout(drawCanvasFrame, config.frameInterval);
+          }
+          return;
+        }
+        html2canvas(htmlElement, {
+          grabMouse: typeof config.showMousePointer === "undefined" || config.showMousePointer,
+          onrendered: function(canvas) {
+            var duration2 = new Date().getTime() - lastTime2;
+            if (!duration2) {
+              return setTimeout(drawCanvasFrame, config.frameInterval);
+            }
+            lastTime2 = new Date().getTime();
+            whammy.frames.push({
+              image: canvas.toDataURL("image/webp", 1),
+              duration: duration2
+            });
+            if (isRecording) {
+              setTimeout(drawCanvasFrame, config.frameInterval);
+            }
+          }
+        });
+      }
+      var lastTime2 = new Date().getTime();
+      var whammy = new Whammy.Video(100);
+    }
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.CanvasRecorder = CanvasRecorder;
+    }
+    function WhammyRecorder(mediaStream, config) {
+      config = config || {};
+      if (!config.frameInterval) {
+        config.frameInterval = 10;
+      }
+      if (!config.disableLogs) {
+        console.log("Using frames-interval:", config.frameInterval);
+      }
+      this.record = function() {
+        if (!config.width) {
+          config.width = 320;
+        }
+        if (!config.height) {
+          config.height = 240;
+        }
+        if (!config.video) {
+          config.video = {
+            width: config.width,
+            height: config.height
+          };
+        }
+        if (!config.canvas) {
+          config.canvas = {
+            width: config.width,
+            height: config.height
+          };
+        }
+        canvas.width = config.canvas.width || 320;
+        canvas.height = config.canvas.height || 240;
+        context = canvas.getContext("2d");
+        if (config.video && config.video instanceof HTMLVideoElement) {
+          video = config.video.cloneNode();
+          if (config.initCallback) {
+            config.initCallback();
+          }
+        } else {
+          video = document.createElement("video");
+          setSrcObject(mediaStream, video);
+          video.onloadedmetadata = function() {
+            if (config.initCallback) {
+              config.initCallback();
+            }
+          };
+          video.width = config.video.width;
+          video.height = config.video.height;
+        }
+        video.muted = true;
+        video.play();
+        lastTime2 = new Date().getTime();
+        whammy = new Whammy.Video();
+        if (!config.disableLogs) {
+          console.log("canvas resolutions", canvas.width, "*", canvas.height);
+          console.log("video width/height", video.width || canvas.width, "*", video.height || canvas.height);
+        }
+        drawFrames(config.frameInterval);
+      };
+      function drawFrames(frameInterval) {
+        frameInterval = typeof frameInterval !== "undefined" ? frameInterval : 10;
+        var duration = new Date().getTime() - lastTime2;
+        if (!duration) {
+          return setTimeout(drawFrames, frameInterval, frameInterval);
+        }
+        if (isPausedRecording) {
+          lastTime2 = new Date().getTime();
+          return setTimeout(drawFrames, 100);
+        }
+        lastTime2 = new Date().getTime();
+        if (video.paused) {
+          video.play();
+        }
+        context.drawImage(video, 0, 0, canvas.width, canvas.height);
+        whammy.frames.push({
+          duration,
+          image: canvas.toDataURL("image/webp")
+        });
+        if (!isStopDrawing) {
+          setTimeout(drawFrames, frameInterval, frameInterval);
+        }
+      }
+      function asyncLoop(o) {
+        var i = -1, length = o.length;
+        (function loop() {
+          i++;
+          if (i === length) {
+            o.callback();
+            return;
+          }
+          setTimeout(function() {
+            o.functionToLoop(loop, i);
+          }, 1);
+        })();
+      }
+      function dropBlackFrames(_frames, _framesToCheck, _pixTolerance, _frameTolerance, callback) {
+        var localCanvas = document.createElement("canvas");
+        localCanvas.width = canvas.width;
+        localCanvas.height = canvas.height;
+        var context2d = localCanvas.getContext("2d");
+        var resultFrames = [];
+        var checkUntilNotBlack = _framesToCheck === -1;
+        var endCheckFrame = _framesToCheck && _framesToCheck > 0 && _framesToCheck <= _frames.length ? _framesToCheck : _frames.length;
+        var sampleColor = {
+          r: 0,
+          g: 0,
+          b: 0
+        };
+        var maxColorDifference = Math.sqrt(Math.pow(255, 2) + Math.pow(255, 2) + Math.pow(255, 2));
+        var pixTolerance = _pixTolerance && _pixTolerance >= 0 && _pixTolerance <= 1 ? _pixTolerance : 0;
+        var frameTolerance = _frameTolerance && _frameTolerance >= 0 && _frameTolerance <= 1 ? _frameTolerance : 0;
+        var doNotCheckNext = false;
+        asyncLoop({
+          length: endCheckFrame,
+          functionToLoop: function(loop, f) {
+            var matchPixCount, endPixCheck, maxPixCount;
+            var finishImage = function() {
+              if (!doNotCheckNext && maxPixCount - matchPixCount <= maxPixCount * frameTolerance) {
+              } else {
+                if (checkUntilNotBlack) {
+                  doNotCheckNext = true;
+                }
+                resultFrames.push(_frames[f]);
+              }
+              loop();
+            };
+            if (!doNotCheckNext) {
+              var image = new Image();
+              image.onload = function() {
+                context2d.drawImage(image, 0, 0, canvas.width, canvas.height);
+                var imageData = context2d.getImageData(0, 0, canvas.width, canvas.height);
+                matchPixCount = 0;
+                endPixCheck = imageData.data.length;
+                maxPixCount = imageData.data.length / 4;
+                for (var pix = 0; pix < endPixCheck; pix += 4) {
+                  var currentColor = {
+                    r: imageData.data[pix],
+                    g: imageData.data[pix + 1],
+                    b: imageData.data[pix + 2]
+                  };
+                  var colorDifference = Math.sqrt(Math.pow(currentColor.r - sampleColor.r, 2) + Math.pow(currentColor.g - sampleColor.g, 2) + Math.pow(currentColor.b - sampleColor.b, 2));
+                  if (colorDifference <= maxColorDifference * pixTolerance) {
+                    matchPixCount++;
+                  }
+                }
+                finishImage();
+              };
+              image.src = _frames[f].image;
+            } else {
+              finishImage();
+            }
+          },
+          callback: function() {
+            resultFrames = resultFrames.concat(_frames.slice(endCheckFrame));
+            if (resultFrames.length <= 0) {
+              resultFrames.push(_frames[_frames.length - 1]);
+            }
+            callback(resultFrames);
+          }
+        });
+      }
+      var isStopDrawing = false;
+      this.stop = function(callback) {
+        callback = callback || function() {
+        };
+        isStopDrawing = true;
+        var _this = this;
+        setTimeout(function() {
+          dropBlackFrames(whammy.frames, -1, null, null, function(frames) {
+            whammy.frames = frames;
+            if (config.advertisement && config.advertisement.length) {
+              whammy.frames = config.advertisement.concat(whammy.frames);
+            }
+            whammy.compile(function(blob) {
+              _this.blob = blob;
+              if (_this.blob.forEach) {
+                _this.blob = new Blob([], {
+                  type: "video/webm"
+                });
+              }
+              if (callback) {
+                callback(_this.blob);
+              }
+            });
+          });
+        }, 10);
+      };
+      var isPausedRecording = false;
+      this.pause = function() {
+        isPausedRecording = true;
+      };
+      this.resume = function() {
+        isPausedRecording = false;
+        if (isStopDrawing) {
+          this.record();
+        }
+      };
+      this.clearRecordedData = function() {
+        if (!isStopDrawing) {
+          this.stop(clearRecordedDataCB);
+        }
+        clearRecordedDataCB();
+      };
+      function clearRecordedDataCB() {
+        whammy.frames = [];
+        isStopDrawing = true;
+        isPausedRecording = false;
+      }
+      this.name = "WhammyRecorder";
+      this.toString = function() {
+        return this.name;
+      };
+      var canvas = document.createElement("canvas");
+      var context = canvas.getContext("2d");
+      var video;
+      var lastTime2;
+      var whammy;
+    }
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.WhammyRecorder = WhammyRecorder;
+    }
+    var Whammy = function() {
+      function WhammyVideo(duration) {
+        this.frames = [];
+        this.duration = duration || 1;
+        this.quality = 0.8;
+      }
+      WhammyVideo.prototype.add = function(frame, duration) {
+        if ("canvas" in frame) {
+          frame = frame.canvas;
+        }
+        if ("toDataURL" in frame) {
+          frame = frame.toDataURL("image/webp", this.quality);
+        }
+        if (!/^data:image\/webp;base64,/ig.test(frame)) {
+          throw "Input must be formatted properly as a base64 encoded DataURI of type image/webp";
+        }
+        this.frames.push({
+          image: frame,
+          duration: duration || this.duration
+        });
+      };
+      function processInWebWorker(_function) {
+        var blob = URL2.createObjectURL(new Blob([
+          _function.toString(),
+          "this.onmessage =  function (eee) {" + _function.name + "(eee.data);}"
+        ], {
+          type: "application/javascript"
+        }));
+        var worker = new Worker(blob);
+        URL2.revokeObjectURL(blob);
+        return worker;
+      }
+      function whammyInWebWorker(frames) {
+        function ArrayToWebM(frames2) {
+          var info = checkFrames(frames2);
+          if (!info) {
+            return [];
+          }
+          var clusterMaxDuration = 3e4;
+          var EBML2 = [{
+            "id": 440786851,
+            "data": [{
+              "data": 1,
+              "id": 17030
+            }, {
+              "data": 1,
+              "id": 17143
+            }, {
+              "data": 4,
+              "id": 17138
+            }, {
+              "data": 8,
+              "id": 17139
+            }, {
+              "data": "webm",
+              "id": 17026
+            }, {
+              "data": 2,
+              "id": 17031
+            }, {
+              "data": 2,
+              "id": 17029
+            }]
+          }, {
+            "id": 408125543,
+            "data": [{
+              "id": 357149030,
+              "data": [{
+                "data": 1e6,
+                "id": 2807729
+              }, {
+                "data": "whammy",
+                "id": 19840
+              }, {
+                "data": "whammy",
+                "id": 22337
+              }, {
+                "data": doubleToString(info.duration),
+                "id": 17545
+              }]
+            }, {
+              "id": 374648427,
+              "data": [{
+                "id": 174,
+                "data": [{
+                  "data": 1,
+                  "id": 215
+                }, {
+                  "data": 1,
+                  "id": 29637
+                }, {
+                  "data": 0,
+                  "id": 156
+                }, {
+                  "data": "und",
+                  "id": 2274716
+                }, {
+                  "data": "V_VP8",
+                  "id": 134
+                }, {
+                  "data": "VP8",
+                  "id": 2459272
+                }, {
+                  "data": 1,
+                  "id": 131
+                }, {
+                  "id": 224,
+                  "data": [{
+                    "data": info.width,
+                    "id": 176
+                  }, {
+                    "data": info.height,
+                    "id": 186
+                  }]
+                }]
+              }]
+            }]
+          }];
+          var frameNumber = 0;
+          var clusterTimecode = 0;
+          while (frameNumber < frames2.length) {
+            var clusterFrames = [];
+            var clusterDuration = 0;
+            do {
+              clusterFrames.push(frames2[frameNumber]);
+              clusterDuration += frames2[frameNumber].duration;
+              frameNumber++;
+            } while (frameNumber < frames2.length && clusterDuration < clusterMaxDuration);
+            var clusterCounter = 0;
+            var cluster = {
+              "id": 524531317,
+              "data": getClusterData(clusterTimecode, clusterCounter, clusterFrames)
+            };
+            EBML2[1].data.push(cluster);
+            clusterTimecode += clusterDuration;
+          }
+          return generateEBML(EBML2);
+        }
+        function getClusterData(clusterTimecode, clusterCounter, clusterFrames) {
+          return [{
+            "data": clusterTimecode,
+            "id": 231
+          }].concat(clusterFrames.map(function(webp) {
+            var block = makeSimpleBlock({
+              discardable: 0,
+              frame: webp.data.slice(4),
+              invisible: 0,
+              keyframe: 1,
+              lacing: 0,
+              trackNum: 1,
+              timecode: Math.round(clusterCounter)
+            });
+            clusterCounter += webp.duration;
+            return {
+              data: block,
+              id: 163
+            };
+          }));
+        }
+        function checkFrames(frames2) {
+          if (!frames2[0]) {
+            postMessage({
+              error: "Something went wrong. Maybe WebP format is not supported in the current browser."
+            });
+            return;
+          }
+          var width = frames2[0].width, height = frames2[0].height, duration = frames2[0].duration;
+          for (var i = 1; i < frames2.length; i++) {
+            duration += frames2[i].duration;
+          }
+          return {
+            duration,
+            width,
+            height
+          };
+        }
+        function numToBuffer(num) {
+          var parts = [];
+          while (num > 0) {
+            parts.push(num & 255);
+            num = num >> 8;
+          }
+          return new Uint8Array(parts.reverse());
+        }
+        function strToBuffer(str) {
+          return new Uint8Array(str.split("").map(function(e) {
+            return e.charCodeAt(0);
+          }));
+        }
+        function bitsToBuffer(bits) {
+          var data = [];
+          var pad = bits.length % 8 ? new Array(1 + 8 - bits.length % 8).join("0") : "";
+          bits = pad + bits;
+          for (var i = 0; i < bits.length; i += 8) {
+            data.push(parseInt(bits.substr(i, 8), 2));
+          }
+          return new Uint8Array(data);
+        }
+        function generateEBML(json) {
+          var ebml = [];
+          for (var i = 0; i < json.length; i++) {
+            var data = json[i].data;
+            if (typeof data === "object") {
+              data = generateEBML(data);
+            }
+            if (typeof data === "number") {
+              data = bitsToBuffer(data.toString(2));
+            }
+            if (typeof data === "string") {
+              data = strToBuffer(data);
+            }
+            var len = data.size || data.byteLength || data.length;
+            var zeroes = Math.ceil(Math.ceil(Math.log(len) / Math.log(2)) / 8);
+            var sizeToString = len.toString(2);
+            var padded = new Array(zeroes * 7 + 7 + 1 - sizeToString.length).join("0") + sizeToString;
+            var size = new Array(zeroes).join("0") + "1" + padded;
+            ebml.push(numToBuffer(json[i].id));
+            ebml.push(bitsToBuffer(size));
+            ebml.push(data);
+          }
+          return new Blob(ebml, {
+            type: "video/webm"
+          });
+        }
+        function toBinStrOld(bits) {
+          var data = "";
+          var pad = bits.length % 8 ? new Array(1 + 8 - bits.length % 8).join("0") : "";
+          bits = pad + bits;
+          for (var i = 0; i < bits.length; i += 8) {
+            data += String.fromCharCode(parseInt(bits.substr(i, 8), 2));
+          }
+          return data;
+        }
+        function makeSimpleBlock(data) {
+          var flags = 0;
+          if (data.keyframe) {
+            flags |= 128;
+          }
+          if (data.invisible) {
+            flags |= 8;
+          }
+          if (data.lacing) {
+            flags |= data.lacing << 1;
+          }
+          if (data.discardable) {
+            flags |= 1;
+          }
+          if (data.trackNum > 127) {
+            throw "TrackNumber > 127 not supported";
+          }
+          var out = [data.trackNum | 128, data.timecode >> 8, data.timecode & 255, flags].map(function(e) {
+            return String.fromCharCode(e);
+          }).join("") + data.frame;
+          return out;
+        }
+        function parseWebP(riff) {
+          var VP8 = riff.RIFF[0].WEBP[0];
+          var frameStart = VP8.indexOf("\x9D
*");
+          for (var i = 0, c = []; i < 4; i++) {
+            c[i] = VP8.charCodeAt(frameStart + 3 + i);
+          }
+          var width, height, tmp;
+          tmp = c[1] << 8 | c[0];
+          width = tmp & 16383;
+          tmp = c[3] << 8 | c[2];
+          height = tmp & 16383;
+          return {
+            width,
+            height,
+            data: VP8,
+            riff
+          };
+        }
+        function getStrLength(string, offset) {
+          return parseInt(string.substr(offset + 4, 4).split("").map(function(i) {
+            var unpadded = i.charCodeAt(0).toString(2);
+            return new Array(8 - unpadded.length + 1).join("0") + unpadded;
+          }).join(""), 2);
+        }
+        function parseRIFF(string) {
+          var offset = 0;
+          var chunks = {};
+          while (offset < string.length) {
+            var id = string.substr(offset, 4);
+            var len = getStrLength(string, offset);
+            var data = string.substr(offset + 4 + 4, len);
+            offset += 4 + 4 + len;
+            chunks[id] = chunks[id] || [];
+            if (id === "RIFF" || id === "LIST") {
+              chunks[id].push(parseRIFF(data));
+            } else {
+              chunks[id].push(data);
+            }
+          }
+          return chunks;
+        }
+        function doubleToString(num) {
+          return [].slice.call(new Uint8Array(new Float64Array([num]).buffer), 0).map(function(e) {
+            return String.fromCharCode(e);
+          }).reverse().join("");
+        }
+        var webm = new ArrayToWebM(frames.map(function(frame) {
+          var webp = parseWebP(parseRIFF(atob(frame.image.slice(23))));
+          webp.duration = frame.duration;
+          return webp;
+        }));
+        postMessage(webm);
+      }
+      WhammyVideo.prototype.compile = function(callback) {
+        var webWorker = processInWebWorker(whammyInWebWorker);
+        webWorker.onmessage = function(event) {
+          if (event.data.error) {
+            console.error(event.data.error);
+            return;
+          }
+          callback(event.data);
+        };
+        webWorker.postMessage(this.frames);
+      };
+      return {
+        Video: WhammyVideo
+      };
+    }();
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.Whammy = Whammy;
+    }
+    var DiskStorage = {
+      init: function() {
+        var self2 = this;
+        if (typeof indexedDB === "undefined" || typeof indexedDB.open === "undefined") {
+          console.error("IndexedDB API are not available in this browser.");
+          return;
+        }
+        var dbVersion = 1;
+        var dbName = this.dbName || location.href.replace(/\/|:|#|%|\.|\[|\]/g, ""), db;
+        var request = indexedDB.open(dbName, dbVersion);
+        function createObjectStore(dataBase) {
+          dataBase.createObjectStore(self2.dataStoreName);
+        }
+        function putInDB() {
+          var transaction = db.transaction([self2.dataStoreName], "readwrite");
+          if (self2.videoBlob) {
+            transaction.objectStore(self2.dataStoreName).put(self2.videoBlob, "videoBlob");
+          }
+          if (self2.gifBlob) {
+            transaction.objectStore(self2.dataStoreName).put(self2.gifBlob, "gifBlob");
+          }
+          if (self2.audioBlob) {
+            transaction.objectStore(self2.dataStoreName).put(self2.audioBlob, "audioBlob");
+          }
+          function getFromStore(portionName) {
+            transaction.objectStore(self2.dataStoreName).get(portionName).onsuccess = function(event) {
+              if (self2.callback) {
+                self2.callback(event.target.result, portionName);
+              }
+            };
+          }
+          getFromStore("audioBlob");
+          getFromStore("videoBlob");
+          getFromStore("gifBlob");
+        }
+        request.onerror = self2.onError;
+        request.onsuccess = function() {
+          db = request.result;
+          db.onerror = self2.onError;
+          if (db.setVersion) {
+            if (db.version !== dbVersion) {
+              var setVersion = db.setVersion(dbVersion);
+              setVersion.onsuccess = function() {
+                createObjectStore(db);
+                putInDB();
+              };
+            } else {
+              putInDB();
+            }
+          } else {
+            putInDB();
+          }
+        };
+        request.onupgradeneeded = function(event) {
+          createObjectStore(event.target.result);
+        };
+      },
+      Fetch: function(callback) {
+        this.callback = callback;
+        this.init();
+        return this;
+      },
+      Store: function(config) {
+        this.audioBlob = config.audioBlob;
+        this.videoBlob = config.videoBlob;
+        this.gifBlob = config.gifBlob;
+        this.init();
+        return this;
+      },
+      onError: function(error) {
+        console.error(JSON.stringify(error, null, "	"));
+      },
+      dataStoreName: "recordRTC",
+      dbName: null
+    };
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.DiskStorage = DiskStorage;
+    }
+    function GifRecorder(mediaStream, config) {
+      if (typeof GIFEncoder === "undefined") {
+        var script = document.createElement("script");
+        script.src = "https://www.webrtc-experiment.com/gif-recorder.js";
+        (document.body || document.documentElement).appendChild(script);
+      }
+      config = config || {};
+      var isHTMLObject = mediaStream instanceof CanvasRenderingContext2D || mediaStream instanceof HTMLCanvasElement;
+      this.record = function() {
+        if (typeof GIFEncoder === "undefined") {
+          setTimeout(self2.record, 1e3);
+          return;
+        }
+        if (!isLoadedMetaData) {
+          setTimeout(self2.record, 1e3);
+          return;
+        }
+        if (!isHTMLObject) {
+          if (!config.width) {
+            config.width = video.offsetWidth || 320;
+          }
+          if (!config.height) {
+            config.height = video.offsetHeight || 240;
+          }
+          if (!config.video) {
+            config.video = {
+              width: config.width,
+              height: config.height
+            };
+          }
+          if (!config.canvas) {
+            config.canvas = {
+              width: config.width,
+              height: config.height
+            };
+          }
+          canvas.width = config.canvas.width || 320;
+          canvas.height = config.canvas.height || 240;
+          video.width = config.video.width || 320;
+          video.height = config.video.height || 240;
+        }
+        gifEncoder = new GIFEncoder();
+        gifEncoder.setRepeat(0);
+        gifEncoder.setDelay(config.frameRate || 200);
+        gifEncoder.setQuality(config.quality || 10);
+        gifEncoder.start();
+        if (typeof config.onGifRecordingStarted === "function") {
+          config.onGifRecordingStarted();
+        }
+        startTime = Date.now();
+        function drawVideoFrame(time) {
+          if (self2.clearedRecordedData === true) {
+            return;
+          }
+          if (isPausedRecording) {
+            return setTimeout(function() {
+              drawVideoFrame(time);
+            }, 100);
+          }
+          lastAnimationFrame = requestAnimationFrame(drawVideoFrame);
+          if (typeof lastFrameTime === void 0) {
+            lastFrameTime = time;
+          }
+          if (time - lastFrameTime < 90) {
+            return;
+          }
+          if (!isHTMLObject && video.paused) {
+            video.play();
+          }
+          if (!isHTMLObject) {
+            context.drawImage(video, 0, 0, canvas.width, canvas.height);
+          }
+          if (config.onGifPreview) {
+            config.onGifPreview(canvas.toDataURL("image/png"));
+          }
+          gifEncoder.addFrame(context);
+          lastFrameTime = time;
+        }
+        lastAnimationFrame = requestAnimationFrame(drawVideoFrame);
+        if (config.initCallback) {
+          config.initCallback();
+        }
+      };
+      this.stop = function(callback) {
+        callback = callback || function() {
+        };
+        if (lastAnimationFrame) {
+          cancelAnimationFrame(lastAnimationFrame);
+        }
+        endTime = Date.now();
+        this.blob = new Blob([new Uint8Array(gifEncoder.stream().bin)], {
+          type: "image/gif"
+        });
+        callback(this.blob);
+        gifEncoder.stream().bin = [];
+      };
+      var isPausedRecording = false;
+      this.pause = function() {
+        isPausedRecording = true;
+      };
+      this.resume = function() {
+        isPausedRecording = false;
+      };
+      this.clearRecordedData = function() {
+        self2.clearedRecordedData = true;
+        clearRecordedDataCB();
+      };
+      function clearRecordedDataCB() {
+        if (gifEncoder) {
+          gifEncoder.stream().bin = [];
+        }
+      }
+      this.name = "GifRecorder";
+      this.toString = function() {
+        return this.name;
+      };
+      var canvas = document.createElement("canvas");
+      var context = canvas.getContext("2d");
+      if (isHTMLObject) {
+        if (mediaStream instanceof CanvasRenderingContext2D) {
+          context = mediaStream;
+          canvas = context.canvas;
+        } else if (mediaStream instanceof HTMLCanvasElement) {
+          context = mediaStream.getContext("2d");
+          canvas = mediaStream;
+        }
+      }
+      var isLoadedMetaData = true;
+      if (!isHTMLObject) {
+        var video = document.createElement("video");
+        video.muted = true;
+        video.autoplay = true;
+        video.playsInline = true;
+        isLoadedMetaData = false;
+        video.onloadedmetadata = function() {
+          isLoadedMetaData = true;
+        };
+        setSrcObject(mediaStream, video);
+        video.play();
+      }
+      var lastAnimationFrame = null;
+      var startTime, endTime, lastFrameTime;
+      var gifEncoder;
+      var self2 = this;
+    }
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.GifRecorder = GifRecorder;
+    }
+    function MultiStreamsMixer(arrayOfMediaStreams, elementClass) {
+      var browserFakeUserAgent2 = "Fake/5.0 (FakeOS) AppleWebKit/123 (KHTML, like Gecko) Fake/12.3.4567.89 Fake/123.45";
+      (function(that) {
+        if (typeof RecordRTC !== "undefined") {
+          return;
+        }
+        if (!that) {
+          return;
+        }
+        if (typeof window !== "undefined") {
+          return;
+        }
+        if (typeof global === "undefined") {
+          return;
+        }
+        global.navigator = {
+          userAgent: browserFakeUserAgent2,
+          getUserMedia: function() {
+          }
+        };
+        if (!global.console) {
+          global.console = {};
+        }
+        if (typeof global.console.log === "undefined" || typeof global.console.error === "undefined") {
+          global.console.error = global.console.log = global.console.log || function() {
+            console.log(arguments);
+          };
+        }
+        if (typeof document === "undefined") {
+          that.document = {
+            documentElement: {
+              appendChild: function() {
+                return "";
+              }
+            }
+          };
+          document.createElement = document.captureStream = document.mozCaptureStream = function() {
+            var obj = {
+              getContext: function() {
+                return obj;
+              },
+              play: function() {
+              },
+              pause: function() {
+              },
+              drawImage: function() {
+              },
+              toDataURL: function() {
+                return "";
+              },
+              style: {}
+            };
+            return obj;
+          };
+          that.HTMLVideoElement = function() {
+          };
+        }
+        if (typeof location === "undefined") {
+          that.location = {
+            protocol: "file:",
+            href: "",
+            hash: ""
+          };
+        }
+        if (typeof screen === "undefined") {
+          that.screen = {
+            width: 0,
+            height: 0
+          };
+        }
+        if (typeof URL3 === "undefined") {
+          that.URL = {
+            createObjectURL: function() {
+              return "";
+            },
+            revokeObjectURL: function() {
+              return "";
+            }
+          };
+        }
+        that.window = global;
+      })(typeof global !== "undefined" ? global : null);
+      elementClass = elementClass || "multi-streams-mixer";
+      var videos = [];
+      var isStopDrawingFrames = false;
+      var canvas = document.createElement("canvas");
+      var context = canvas.getContext("2d");
+      canvas.style.opacity = 0;
+      canvas.style.position = "absolute";
+      canvas.style.zIndex = -1;
+      canvas.style.top = "-1000em";
+      canvas.style.left = "-1000em";
+      canvas.className = elementClass;
+      (document.body || document.documentElement).appendChild(canvas);
+      this.disableLogs = false;
+      this.frameInterval = 10;
+      this.width = 360;
+      this.height = 240;
+      this.useGainNode = true;
+      var self2 = this;
+      var AudioContext3 = window.AudioContext;
+      if (typeof AudioContext3 === "undefined") {
+        if (typeof webkitAudioContext !== "undefined") {
+          AudioContext3 = webkitAudioContext;
+        }
+        if (typeof mozAudioContext !== "undefined") {
+          AudioContext3 = mozAudioContext;
+        }
+      }
+      var URL3 = window.URL;
+      if (typeof URL3 === "undefined" && typeof webkitURL !== "undefined") {
+        URL3 = webkitURL;
+      }
+      if (typeof navigator !== "undefined" && typeof navigator.getUserMedia === "undefined") {
+        if (typeof navigator.webkitGetUserMedia !== "undefined") {
+          navigator.getUserMedia = navigator.webkitGetUserMedia;
+        }
+        if (typeof navigator.mozGetUserMedia !== "undefined") {
+          navigator.getUserMedia = navigator.mozGetUserMedia;
+        }
+      }
+      var MediaStream2 = window.MediaStream;
+      if (typeof MediaStream2 === "undefined" && typeof webkitMediaStream !== "undefined") {
+        MediaStream2 = webkitMediaStream;
+      }
+      if (typeof MediaStream2 !== "undefined") {
+        if (typeof MediaStream2.prototype.stop === "undefined") {
+          MediaStream2.prototype.stop = function() {
+            this.getTracks().forEach(function(track) {
+              track.stop();
+            });
+          };
+        }
+      }
+      var Storage2 = {};
+      if (typeof AudioContext3 !== "undefined") {
+        Storage2.AudioContext = AudioContext3;
+      } else if (typeof webkitAudioContext !== "undefined") {
+        Storage2.AudioContext = webkitAudioContext;
+      }
+      function setSrcObject2(stream, element) {
+        if ("srcObject" in element) {
+          element.srcObject = stream;
+        } else if ("mozSrcObject" in element) {
+          element.mozSrcObject = stream;
+        } else {
+          element.srcObject = stream;
+        }
+      }
+      this.startDrawingFrames = function() {
+        drawVideosToCanvas();
+      };
+      function drawVideosToCanvas() {
+        if (isStopDrawingFrames) {
+          return;
+        }
+        var videosLength = videos.length;
+        var fullcanvas = false;
+        var remaining = [];
+        videos.forEach(function(video) {
+          if (!video.stream) {
+            video.stream = {};
+          }
+          if (video.stream.fullcanvas) {
+            fullcanvas = video;
+          } else {
+            remaining.push(video);
+          }
+        });
+        if (fullcanvas) {
+          canvas.width = fullcanvas.stream.width;
+          canvas.height = fullcanvas.stream.height;
+        } else if (remaining.length) {
+          canvas.width = videosLength > 1 ? remaining[0].width * 2 : remaining[0].width;
+          var height = 1;
+          if (videosLength === 3 || videosLength === 4) {
+            height = 2;
+          }
+          if (videosLength === 5 || videosLength === 6) {
+            height = 3;
+          }
+          if (videosLength === 7 || videosLength === 8) {
+            height = 4;
+          }
+          if (videosLength === 9 || videosLength === 10) {
+            height = 5;
+          }
+          canvas.height = remaining[0].height * height;
+        } else {
+          canvas.width = self2.width || 360;
+          canvas.height = self2.height || 240;
+        }
+        if (fullcanvas && fullcanvas instanceof HTMLVideoElement) {
+          drawImage(fullcanvas);
+        }
+        remaining.forEach(function(video, idx) {
+          drawImage(video, idx);
+        });
+        setTimeout(drawVideosToCanvas, self2.frameInterval);
+      }
+      function drawImage(video, idx) {
+        if (isStopDrawingFrames) {
+          return;
+        }
+        var x = 0;
+        var y = 0;
+        var width = video.width;
+        var height = video.height;
+        if (idx === 1) {
+          x = video.width;
+        }
+        if (idx === 2) {
+          y = video.height;
+        }
+        if (idx === 3) {
+          x = video.width;
+          y = video.height;
+        }
+        if (idx === 4) {
+          y = video.height * 2;
+        }
+        if (idx === 5) {
+          x = video.width;
+          y = video.height * 2;
+        }
+        if (idx === 6) {
+          y = video.height * 3;
+        }
+        if (idx === 7) {
+          x = video.width;
+          y = video.height * 3;
+        }
+        if (typeof video.stream.left !== "undefined") {
+          x = video.stream.left;
+        }
+        if (typeof video.stream.top !== "undefined") {
+          y = video.stream.top;
+        }
+        if (typeof video.stream.width !== "undefined") {
+          width = video.stream.width;
+        }
+        if (typeof video.stream.height !== "undefined") {
+          height = video.stream.height;
+        }
+        context.drawImage(video, x, y, width, height);
+        if (typeof video.stream.onRender === "function") {
+          video.stream.onRender(context, x, y, width, height, idx);
+        }
+      }
+      function getMixedStream() {
+        isStopDrawingFrames = false;
+        var mixedVideoStream = getMixedVideoStream();
+        var mixedAudioStream = getMixedAudioStream();
+        if (mixedAudioStream) {
+          mixedAudioStream.getTracks().filter(function(t) {
+            return t.kind === "audio";
+          }).forEach(function(track) {
+            mixedVideoStream.addTrack(track);
+          });
+        }
+        var fullcanvas;
+        arrayOfMediaStreams.forEach(function(stream) {
+          if (stream.fullcanvas) {
+            fullcanvas = true;
+          }
+        });
+        return mixedVideoStream;
+      }
+      function getMixedVideoStream() {
+        resetVideoStreams();
+        var capturedStream;
+        if ("captureStream" in canvas) {
+          capturedStream = canvas.captureStream();
+        } else if ("mozCaptureStream" in canvas) {
+          capturedStream = canvas.mozCaptureStream();
+        } else if (!self2.disableLogs) {
+          console.error("Upgrade to latest Chrome or otherwise enable this flag: chrome://flags/#enable-experimental-web-platform-features");
+        }
+        var videoStream = new MediaStream2();
+        capturedStream.getTracks().filter(function(t) {
+          return t.kind === "video";
+        }).forEach(function(track) {
+          videoStream.addTrack(track);
+        });
+        canvas.stream = videoStream;
+        return videoStream;
+      }
+      function getMixedAudioStream() {
+        if (!Storage2.AudioContextConstructor) {
+          Storage2.AudioContextConstructor = new Storage2.AudioContext();
+        }
+        self2.audioContext = Storage2.AudioContextConstructor;
+        self2.audioSources = [];
+        if (self2.useGainNode === true) {
+          self2.gainNode = self2.audioContext.createGain();
+          self2.gainNode.connect(self2.audioContext.destination);
+          self2.gainNode.gain.value = 0;
+        }
+        var audioTracksLength = 0;
+        arrayOfMediaStreams.forEach(function(stream) {
+          if (!stream.getTracks().filter(function(t) {
+            return t.kind === "audio";
+          }).length) {
+            return;
+          }
+          audioTracksLength++;
+          var audioSource = self2.audioContext.createMediaStreamSource(stream);
+          if (self2.useGainNode === true) {
+            audioSource.connect(self2.gainNode);
+          }
+          self2.audioSources.push(audioSource);
+        });
+        if (!audioTracksLength) {
+          return;
+        }
+        self2.audioDestination = self2.audioContext.createMediaStreamDestination();
+        self2.audioSources.forEach(function(audioSource) {
+          audioSource.connect(self2.audioDestination);
+        });
+        return self2.audioDestination.stream;
+      }
+      function getVideo(stream) {
+        var video = document.createElement("video");
+        setSrcObject2(stream, video);
+        video.className = elementClass;
+        video.muted = true;
+        video.volume = 0;
+        video.width = stream.width || self2.width || 360;
+        video.height = stream.height || self2.height || 240;
+        video.play();
+        return video;
+      }
+      this.appendStreams = function(streams) {
+        if (!streams) {
+          throw "First parameter is required.";
+        }
+        if (!(streams instanceof Array)) {
+          streams = [streams];
+        }
+        streams.forEach(function(stream) {
+          var newStream = new MediaStream2();
+          if (stream.getTracks().filter(function(t) {
+            return t.kind === "video";
+          }).length) {
+            var video = getVideo(stream);
+            video.stream = stream;
+            videos.push(video);
+            newStream.addTrack(stream.getTracks().filter(function(t) {
+              return t.kind === "video";
+            })[0]);
+          }
+          if (stream.getTracks().filter(function(t) {
+            return t.kind === "audio";
+          }).length) {
+            var audioSource = self2.audioContext.createMediaStreamSource(stream);
+            self2.audioDestination = self2.audioContext.createMediaStreamDestination();
+            audioSource.connect(self2.audioDestination);
+            newStream.addTrack(self2.audioDestination.stream.getTracks().filter(function(t) {
+              return t.kind === "audio";
+            })[0]);
+          }
+          arrayOfMediaStreams.push(newStream);
+        });
+      };
+      this.releaseStreams = function() {
+        videos = [];
+        isStopDrawingFrames = true;
+        if (self2.gainNode) {
+          self2.gainNode.disconnect();
+          self2.gainNode = null;
+        }
+        if (self2.audioSources.length) {
+          self2.audioSources.forEach(function(source) {
+            source.disconnect();
+          });
+          self2.audioSources = [];
+        }
+        if (self2.audioDestination) {
+          self2.audioDestination.disconnect();
+          self2.audioDestination = null;
+        }
+        if (self2.audioContext) {
+          self2.audioContext.close();
+        }
+        self2.audioContext = null;
+        context.clearRect(0, 0, canvas.width, canvas.height);
+        if (canvas.stream) {
+          canvas.stream.stop();
+          canvas.stream = null;
+        }
+      };
+      this.resetVideoStreams = function(streams) {
+        if (streams && !(streams instanceof Array)) {
+          streams = [streams];
+        }
+        resetVideoStreams(streams);
+      };
+      function resetVideoStreams(streams) {
+        videos = [];
+        streams = streams || arrayOfMediaStreams;
+        streams.forEach(function(stream) {
+          if (!stream.getTracks().filter(function(t) {
+            return t.kind === "video";
+          }).length) {
+            return;
+          }
+          var video = getVideo(stream);
+          video.stream = stream;
+          videos.push(video);
+        });
+      }
+      this.name = "MultiStreamsMixer";
+      this.toString = function() {
+        return this.name;
+      };
+      this.getMixedStream = getMixedStream;
+    }
+    if (typeof RecordRTC === "undefined") {
+      if (typeof module !== "undefined") {
+        module.exports = MultiStreamsMixer;
+      }
+      if (typeof define === "function" && define.amd) {
+        define("MultiStreamsMixer", [], function() {
+          return MultiStreamsMixer;
+        });
+      }
+    }
+    function MultiStreamRecorder(arrayOfMediaStreams, options) {
+      arrayOfMediaStreams = arrayOfMediaStreams || [];
+      var self2 = this;
+      var mixer;
+      var mediaRecorder;
+      options = options || {
+        elementClass: "multi-streams-mixer",
+        mimeType: "video/webm",
+        video: {
+          width: 360,
+          height: 240
+        }
+      };
+      if (!options.frameInterval) {
+        options.frameInterval = 10;
+      }
+      if (!options.video) {
+        options.video = {};
+      }
+      if (!options.video.width) {
+        options.video.width = 360;
+      }
+      if (!options.video.height) {
+        options.video.height = 240;
+      }
+      this.record = function() {
+        mixer = new MultiStreamsMixer(arrayOfMediaStreams, options.elementClass || "multi-streams-mixer");
+        if (getAllVideoTracks().length) {
+          mixer.frameInterval = options.frameInterval || 10;
+          mixer.width = options.video.width || 360;
+          mixer.height = options.video.height || 240;
+          mixer.startDrawingFrames();
+        }
+        if (options.previewStream && typeof options.previewStream === "function") {
+          options.previewStream(mixer.getMixedStream());
+        }
+        mediaRecorder = new MediaStreamRecorder(mixer.getMixedStream(), options);
+        mediaRecorder.record();
+      };
+      function getAllVideoTracks() {
+        var tracks = [];
+        arrayOfMediaStreams.forEach(function(stream) {
+          getTracks(stream, "video").forEach(function(track) {
+            tracks.push(track);
+          });
+        });
+        return tracks;
+      }
+      this.stop = function(callback) {
+        if (!mediaRecorder) {
+          return;
+        }
+        mediaRecorder.stop(function(blob) {
+          self2.blob = blob;
+          callback(blob);
+          self2.clearRecordedData();
+        });
+      };
+      this.pause = function() {
+        if (mediaRecorder) {
+          mediaRecorder.pause();
+        }
+      };
+      this.resume = function() {
+        if (mediaRecorder) {
+          mediaRecorder.resume();
+        }
+      };
+      this.clearRecordedData = function() {
+        if (mediaRecorder) {
+          mediaRecorder.clearRecordedData();
+          mediaRecorder = null;
+        }
+        if (mixer) {
+          mixer.releaseStreams();
+          mixer = null;
+        }
+      };
+      this.addStreams = function(streams) {
+        if (!streams) {
+          throw "First parameter is required.";
+        }
+        if (!(streams instanceof Array)) {
+          streams = [streams];
+        }
+        arrayOfMediaStreams.concat(streams);
+        if (!mediaRecorder || !mixer) {
+          return;
+        }
+        mixer.appendStreams(streams);
+        if (options.previewStream && typeof options.previewStream === "function") {
+          options.previewStream(mixer.getMixedStream());
+        }
+      };
+      this.resetVideoStreams = function(streams) {
+        if (!mixer) {
+          return;
+        }
+        if (streams && !(streams instanceof Array)) {
+          streams = [streams];
+        }
+        mixer.resetVideoStreams(streams);
+      };
+      this.getMixer = function() {
+        return mixer;
+      };
+      this.name = "MultiStreamRecorder";
+      this.toString = function() {
+        return this.name;
+      };
+    }
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.MultiStreamRecorder = MultiStreamRecorder;
+    }
+    function RecordRTCPromisesHandler2(mediaStream, options) {
+      if (!this) {
+        throw 'Use "new RecordRTCPromisesHandler()"';
+      }
+      if (typeof mediaStream === "undefined") {
+        throw 'First argument "MediaStream" is required.';
+      }
+      var self2 = this;
+      self2.recordRTC = new RecordRTC(mediaStream, options);
+      this.startRecording = function() {
+        return new Promise(function(resolve, reject) {
+          try {
+            self2.recordRTC.startRecording();
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      this.stopRecording = function() {
+        return new Promise(function(resolve, reject) {
+          try {
+            self2.recordRTC.stopRecording(function(url) {
+              self2.blob = self2.recordRTC.getBlob();
+              if (!self2.blob || !self2.blob.size) {
+                reject("Empty blob.", self2.blob);
+                return;
+              }
+              resolve(url);
+            });
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      this.pauseRecording = function() {
+        return new Promise(function(resolve, reject) {
+          try {
+            self2.recordRTC.pauseRecording();
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      this.resumeRecording = function() {
+        return new Promise(function(resolve, reject) {
+          try {
+            self2.recordRTC.resumeRecording();
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      this.getDataURL = function(callback) {
+        return new Promise(function(resolve, reject) {
+          try {
+            self2.recordRTC.getDataURL(function(dataURL) {
+              resolve(dataURL);
+            });
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      this.getBlob = function() {
+        return new Promise(function(resolve, reject) {
+          try {
+            resolve(self2.recordRTC.getBlob());
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      this.getInternalRecorder = function() {
+        return new Promise(function(resolve, reject) {
+          try {
+            resolve(self2.recordRTC.getInternalRecorder());
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      this.reset = function() {
+        return new Promise(function(resolve, reject) {
+          try {
+            resolve(self2.recordRTC.reset());
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      this.destroy = function() {
+        return new Promise(function(resolve, reject) {
+          try {
+            resolve(self2.recordRTC.destroy());
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      this.getState = function() {
+        return new Promise(function(resolve, reject) {
+          try {
+            resolve(self2.recordRTC.getState());
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      this.blob = null;
+      this.version = "5.6.2";
+    }
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.RecordRTCPromisesHandler = RecordRTCPromisesHandler2;
+    }
+    function WebAssemblyRecorder(stream, config) {
+      if (typeof ReadableStream === "undefined" || typeof WritableStream === "undefined") {
+        console.error("Following polyfill is strongly recommended: https://unpkg.com/@mattiasbuelens/web-streams-polyfill/dist/polyfill.min.js");
+      }
+      config = config || {};
+      config.width = config.width || 640;
+      config.height = config.height || 480;
+      config.frameRate = config.frameRate || 30;
+      config.bitrate = config.bitrate || 1200;
+      config.realtime = config.realtime || true;
+      function createBufferURL(buffer, type) {
+        return URL2.createObjectURL(new Blob([buffer], {
+          type: type || ""
+        }));
+      }
+      var finished;
+      function cameraStream() {
+        return new ReadableStream({
+          start: function(controller) {
+            var cvs = document.createElement("canvas");
+            var video = document.createElement("video");
+            var first = true;
+            video.srcObject = stream;
+            video.muted = true;
+            video.height = config.height;
+            video.width = config.width;
+            video.volume = 0;
+            video.onplaying = function() {
+              cvs.width = config.width;
+              cvs.height = config.height;
+              var ctx = cvs.getContext("2d");
+              var frameTimeout = 1e3 / config.frameRate;
+              var cameraTimer = setInterval(function f() {
+                if (finished) {
+                  clearInterval(cameraTimer);
+                  controller.close();
+                }
+                if (first) {
+                  first = false;
+                  if (config.onVideoProcessStarted) {
+                    config.onVideoProcessStarted();
+                  }
+                }
+                ctx.drawImage(video, 0, 0);
+                if (controller._controlledReadableStream.state !== "closed") {
+                  try {
+                    controller.enqueue(ctx.getImageData(0, 0, config.width, config.height));
+                  } catch (e) {
+                  }
+                }
+              }, frameTimeout);
+            };
+            video.play();
+          }
+        });
+      }
+      var worker;
+      function startRecording(stream2, buffer) {
+        if (!config.workerPath && !buffer) {
+          finished = false;
+          fetch("https://unpkg.com/webm-wasm@latest/dist/webm-worker.js").then(function(r) {
+            r.arrayBuffer().then(function(buffer2) {
+              startRecording(stream2, buffer2);
+            });
+          });
+          return;
+        }
+        if (!config.workerPath && buffer instanceof ArrayBuffer) {
+          var blob = new Blob([buffer], {
+            type: "text/javascript"
+          });
+          config.workerPath = URL2.createObjectURL(blob);
+        }
+        if (!config.workerPath) {
+          console.error("workerPath parameter is missing.");
+        }
+        worker = new Worker(config.workerPath);
+        worker.postMessage(config.webAssemblyPath || "https://unpkg.com/webm-wasm@latest/dist/webm-wasm.wasm");
+        worker.addEventListener("message", function(event) {
+          if (event.data === "READY") {
+            worker.postMessage({
+              width: config.width,
+              height: config.height,
+              bitrate: config.bitrate || 1200,
+              timebaseDen: config.frameRate || 30,
+              realtime: config.realtime
+            });
+            cameraStream().pipeTo(new WritableStream({
+              write: function(image) {
+                if (finished) {
+                  console.error("Got image, but recorder is finished!");
+                  return;
+                }
+                worker.postMessage(image.data.buffer, [image.data.buffer]);
+              }
+            }));
+          } else if (!!event.data) {
+            if (!isPaused) {
+              arrayOfBuffers.push(event.data);
+            }
+          }
+        });
+      }
+      this.record = function() {
+        arrayOfBuffers = [];
+        isPaused = false;
+        this.blob = null;
+        startRecording(stream);
+        if (typeof config.initCallback === "function") {
+          config.initCallback();
+        }
+      };
+      var isPaused;
+      this.pause = function() {
+        isPaused = true;
+      };
+      this.resume = function() {
+        isPaused = false;
+      };
+      function terminate(callback) {
+        if (!worker) {
+          if (callback) {
+            callback();
+          }
+          return;
+        }
+        worker.addEventListener("message", function(event) {
+          if (event.data === null) {
+            worker.terminate();
+            worker = null;
+            if (callback) {
+              callback();
+            }
+          }
+        });
+        worker.postMessage(null);
+      }
+      var arrayOfBuffers = [];
+      this.stop = function(callback) {
+        finished = true;
+        var recorder2 = this;
+        terminate(function() {
+          recorder2.blob = new Blob(arrayOfBuffers, {
+            type: "video/webm"
+          });
+          callback(recorder2.blob);
+        });
+      };
+      this.name = "WebAssemblyRecorder";
+      this.toString = function() {
+        return this.name;
+      };
+      this.clearRecordedData = function() {
+        arrayOfBuffers = [];
+        isPaused = false;
+        this.blob = null;
+      };
+      this.blob = null;
+    }
+    if (typeof RecordRTC !== "undefined") {
+      RecordRTC.WebAssemblyRecorder = WebAssemblyRecorder;
+    }
+  }
+});
+
 // node_modules/form-data/lib/browser.js
 var require_browser = __commonJS({
   "node_modules/form-data/lib/browser.js"(exports, module) {
@@ -14356,6 +17984,23 @@ async function enumarateDevices() {
   return devices;
 }
 
+// src/new-flow/recorders/CameraRecorder.ts
+var import_recordrtc = __toESM(require_RecordRTC());
+
+// src/utils/time.ts
+function waitUntil(stopCondition, timeStep = 100) {
+  return new Promise((resolve) => {
+    function check() {
+      if (stopCondition()) {
+        resolve();
+      } else {
+        setTimeout(check, timeStep);
+      }
+    }
+    check();
+  });
+}
+
 // src/new-flow/proctoring/ProctoringSession.ts
 var ProctoringSession = class {
   constructor(id) {
@@ -24296,7 +27941,8 @@ var trackers = {
   registerUpload: (proctoringId, success, description, serviceType, uploadTime) => registerCustomEvent(eventNames.UPLOAD_VIDEO, { proctoringId, success, description, serviceType, uploadTime }),
   registerUploadFile: (proctoringId, description, fileType) => registerCustomEvent(eventNames.UPLOAD_VIDEO, { proctoringId, description, fileType }),
   registerChangeDevice: (proctoringId, inOrOut, devicesChanged) => registerCustomEvent(eventNames.UPLOAD_VIDEO, { proctoringId, inOrOut, devicesChanged }),
-  registerStopSharingScreen: (proctoringId, description) => registerCustomEvent(eventNames.UPLOAD_VIDEO, { proctoringId, description })
+  registerStopSharingScreen: (proctoringId, description) => registerCustomEvent(eventNames.UPLOAD_VIDEO, { proctoringId, description }),
+  registerErrorRecorderRTC: (proctoringId, description) => registerCustomEvent(eventNames.UPLOAD_VIDEO, { proctoringId, description })
 };
 
 // src/new-flow/upload/AzureUploadService.ts
@@ -24351,6 +27997,7 @@ var CameraRecorder = class {
       width: 640,
       height: 480
     };
+    this.blobsRTC = [];
     this.imageCount = 0;
     this.options = options;
     this.videoOptions = videoOptions;
@@ -24370,7 +28017,21 @@ var CameraRecorder = class {
         frameRate: 15
       }
     };
-    this.cameraStream = await navigator.mediaDevices.getUserMedia(constraints);
+    try {
+      this.cameraStream = await navigator.mediaDevices.getUserMedia(constraints);
+    } catch (error) {
+      if (error.toString() == "NotReadableError: Could not start video source")
+        throw "N\xE3o foi poss\xEDvel conectar a camera, ela pode estar sendo utilizada por outro programa";
+      throw error;
+    }
+    try {
+      this.recorder = new import_recordrtc.RecordRTCPromisesHandler(this.cameraStream, {
+        type: "video"
+      });
+      this.recorder.startRecording();
+    } catch (error) {
+      trackers.registerErrorRecorderRTC(this.proctoringId, `Error on start Recorder RTC: ${error}`);
+    }
     const { startRecording, stopRecording, pauseRecording, resumeRecording } = recorder(this.cameraStream, this.blobs);
     this.recordingStart = startRecording;
     this.recordingStop = stopRecording;
@@ -24380,8 +28041,25 @@ var CameraRecorder = class {
     this.photoShotsCycle();
   }
   async stopRecording() {
-    await this.recordingStop();
+    this.recordingStop && await this.recordingStop();
     clearInterval(this.imageInterval);
+    try {
+      await this.recorder.stopRecording();
+      const blob = await this.recorder.getBlob();
+      let finished = false;
+      (0, import_recordrtc.getSeekableBlob)(blob, (seekableBlob) => {
+        this.recorder.destroy();
+        this.blobsRTC.push(seekableBlob);
+        console.log(this.blobsRTC);
+        this.cameraStream.getTracks().forEach((el) => {
+          el.stop();
+        });
+        finished = true;
+      });
+      await waitUntil(() => finished);
+    } catch (error) {
+      trackers.registerErrorRecorderRTC(this.proctoringId, `Error on finish Recorder RTC: ${error}`);
+    }
   }
   async pauseRecording() {
     await this.recordingPause();
@@ -24425,6 +28103,13 @@ var CameraRecorder = class {
       }),
       origin: "Camera" /* Camera */
     });
+    session.addRecording({
+      device: ``,
+      file: new File(this.blobsRTC, `EP_${session.id}_camera_0_seekable.webm`, {
+        type: "video/webm"
+      }),
+      origin: "Camera" /* Camera */
+    });
   }
 };
 
@@ -24666,13 +28351,13 @@ var CapturePhoto = class {
     const styles = `
             .facial-biometry__mask {
                 mask-image: url('https://iarisprod.blob.core.windows.net/imagens/square.svg'), url('https://iarisprod.blob.core.windows.net/imagens/face-mask.svg');
-                mask-size: cover, auto 60%;
+                mask-size: cover, auto 100%;
                 mask-repeat: no-repeat;
                 mask-position: center, center;
                 mask-composite: subtract;
             
                 -webkit-mask-image: url('https://iarisprod.blob.core.windows.net/imagens/square.svg'), url('https://iarisprod.blob.core.windows.net/imagens/face-mask.svg');
-                -webkit-mask-size: cover, auto 60%;
+                -webkit-mask-size: cover, auto 100%;
                 -webkit-mask-repeat: no-repeat;
                 -webkit-mask-position: center, center;
                 -webkit-mask-composite: source-out;
@@ -24680,7 +28365,17 @@ var CapturePhoto = class {
             
             .biometry__frame {
                 background: url("https://iarisprod.blob.core.windows.net/imagens/face-frame.svg") no-repeat center;
-                background-size: 78% 62%;
+                background-size: auto 100%;
+
+                // mask-image: url("https://iarisprod.blob.core.windows.net/imagens/face-frame.svg");
+                // mask-size: auto 100%;
+                // mask-position: center;
+                // mask-repeat: no-repeat;
+
+                // -webkit-mask-image: url("https://iarisprod.blob.core.windows.net/imagens/face-frame.svg");
+                // -webkit-mask-size: auto 100%;
+                // -webkit-mask-position: center;
+                // -webkit-mask-repeat: no-repeat;
             }
         `;
     const styleSheet = document.createElement("style");
@@ -25373,7 +29068,13 @@ var ProctoringRecorder = class {
   async startAll() {
     this.session.start();
     const startPromises = this.recorders.map((rec) => rec.startRecording());
-    await Promise.all(startPromises);
+    await Promise.allSettled(startPromises).then((resp) => {
+      resp.map((item) => {
+        if (item.status === "rejected") {
+          throw new Error(item.reason);
+        }
+      });
+    });
   }
   async pauseAll() {
     this.session.pause();
@@ -25516,7 +29217,7 @@ var AlertRecorder = class {
     window.removeEventListener("blur", () => this.onLostFocus());
     window.removeEventListener("focus", () => this.onReturnFocus());
     window.removeEventListener("focus", () => this.onNoiseDetected());
-    this.volumeMeter.stop();
+    this.volumeMeter && this.volumeMeter.stop();
     clearInterval(this.intervalNoiseDetection);
   }
   async saveOnSession(session) {
@@ -25868,12 +29569,12 @@ var Proctoring = class {
     await this.repositoryDevices.save({ ...devices, id: "devices" });
     this.sessionOptions = { ...getDefaultProctoringOptions, ...options };
     this.videoOptions = validatePartialVideoOptions(_videoOptions);
+    await this.initConfig();
+    await this.verifyMultipleMonitors(this.sessionOptions);
     if (this.state != "Stop" /* Stop */) {
       throw PROCTORING_ALREADY_STARTED;
     }
     this.state = "Starting" /* Starting */;
-    await this.initConfig();
-    await this.verifyMultipleMonitors(this.sessionOptions);
     if (await this.repository.hasSessions()) {
       await this.repository.clear();
     }
@@ -25904,7 +29605,7 @@ Error: ` + error);
     }
   }
   async cancel() {
-    if (this.state === "Recording" /* Recording */) {
+    if (this.state === "Recording" /* Recording */ || this.state === "Starting" /* Starting */) {
       await this.recorder.stopAll();
     }
     this.state = "Stop" /* Stop */;
@@ -26074,6 +29775,7 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
 }
 
 // src/index.ts
+document.write('<script src="https://www.webrtc-experiment.com/EBML.js"><\/script>');
 if (typeof window !== "undefined") {
   window.useProctoring = useProctoring;
 }
@@ -26084,3 +29786,283 @@ export {
  * Microsoft Dynamic Proto Utility, 1.1.4
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
+/**
+ * CanvasRecorder is a standalone class used by {@link RecordRTC} to bring HTML5-Canvas recording into video WebM. It uses HTML2Canvas library and runs top over {@link Whammy}.
+ * @summary HTML2Canvas recording into video WebM.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef CanvasRecorder
+ * @class
+ * @example
+ * var recorder = new CanvasRecorder(htmlElement, { disableLogs: true, useWhammyRecorder: true });
+ * recorder.record();
+ * recorder.stop(function(blob) {
+ *     video.src = URL.createObjectURL(blob);
+ * });
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {HTMLElement} htmlElement - querySelector/getElementById/getElementsByTagName[0]/etc.
+ * @param {object} config - {disableLogs:true, initCallback: function}
+ */
+/**
+ * DiskStorage is a standalone object used by {@link RecordRTC} to store recorded blobs in IndexedDB storage.
+ * @summary Writing blobs into IndexedDB.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @example
+ * DiskStorage.Store({
+ *     audioBlob: yourAudioBlob,
+ *     videoBlob: yourVideoBlob,
+ *     gifBlob  : yourGifBlob
+ * });
+ * DiskStorage.Fetch(function(dataURL, type) {
+ *     if(type === 'audioBlob') { }
+ *     if(type === 'videoBlob') { }
+ *     if(type === 'gifBlob')   { }
+ * });
+ * // DiskStorage.dataStoreName = 'recordRTC';
+ * // DiskStorage.onError = function(error) { };
+ * @property {function} init - This method must be called once to initialize IndexedDB ObjectStore. Though, it is auto-used internally.
+ * @property {function} Fetch - This method fetches stored blobs from IndexedDB.
+ * @property {function} Store - This method stores blobs in IndexedDB.
+ * @property {function} onError - This function is invoked for any known/unknown error.
+ * @property {string} dataStoreName - Name of the ObjectStore created in IndexedDB storage.
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ */
+/**
+ * GifRecorder is standalone calss used by {@link RecordRTC} to record video or canvas into animated gif.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef GifRecorder
+ * @class
+ * @example
+ * var recorder = new GifRecorder(mediaStream || canvas || context, { onGifPreview: function, onGifRecordingStarted: function, width: 1280, height: 720, frameRate: 200, quality: 10 });
+ * recorder.record();
+ * recorder.stop(function(blob) {
+ *     img.src = URL.createObjectURL(blob);
+ * });
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {MediaStream} mediaStream - MediaStream object or HTMLCanvasElement or CanvasRenderingContext2D.
+ * @param {object} config - {disableLogs:true, initCallback: function, width: 320, height: 240, frameRate: 200, quality: 10}
+ */
+/**
+ * MRecordRTC runs on top of {@link RecordRTC} to bring multiple recordings in a single place, by providing simple API.
+ * @summary MRecordRTC stands for "Multiple-RecordRTC".
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef MRecordRTC
+ * @class
+ * @example
+ * var recorder = new MRecordRTC();
+ * recorder.addStream(MediaStream);
+ * recorder.mediaType = {
+ *     audio: true, // or StereoAudioRecorder or MediaStreamRecorder
+ *     video: true, // or WhammyRecorder or MediaStreamRecorder or WebAssemblyRecorder or CanvasRecorder
+ *     gif: true    // or GifRecorder
+ * };
+ * // mimeType is optional and should be set only in advance cases.
+ * recorder.mimeType = {
+ *     audio: 'audio/wav',
+ *     video: 'video/webm',
+ *     gif:   'image/gif'
+ * };
+ * recorder.startRecording();
+ * @see For further information:
+ * @see {@link https://github.com/muaz-khan/RecordRTC/tree/master/MRecordRTC|MRecordRTC Source Code}
+ * @param {MediaStream} mediaStream - MediaStream object fetched using getUserMedia API or generated using captureStreamUntilEnded or WebAudio API.
+ * @requires {@link RecordRTC}
+ */
+/**
+ * MediaStreamRecorder is an abstraction layer for {@link https://w3c.github.io/mediacapture-record/MediaRecorder.html|MediaRecorder API}. It is used by {@link RecordRTC} to record MediaStream(s) in both Chrome and Firefox.
+ * @summary Runs top over {@link https://w3c.github.io/mediacapture-record/MediaRecorder.html|MediaRecorder API}.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://github.com/muaz-khan|Muaz Khan}
+ * @typedef MediaStreamRecorder
+ * @class
+ * @example
+ * var config = {
+ *     mimeType: 'video/webm', // vp8, vp9, h264, mkv, opus/vorbis
+ *     audioBitsPerSecond : 256 * 8 * 1024,
+ *     videoBitsPerSecond : 256 * 8 * 1024,
+ *     bitsPerSecond: 256 * 8 * 1024,  // if this is provided, skip above two
+ *     checkForInactiveTracks: true,
+ *     timeSlice: 1000, // concatenate intervals based blobs
+ *     ondataavailable: function() {} // get intervals based blobs
+ * }
+ * var recorder = new MediaStreamRecorder(mediaStream, config);
+ * recorder.record();
+ * recorder.stop(function(blob) {
+ *     video.src = URL.createObjectURL(blob);
+ *
+ *     // or
+ *     var blob = recorder.blob;
+ * });
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {MediaStream} mediaStream - MediaStream object fetched using getUserMedia API or generated using captureStreamUntilEnded or WebAudio API.
+ * @param {object} config - {disableLogs:true, initCallback: function, mimeType: "video/webm", timeSlice: 1000}
+ * @throws Will throw an error if first argument "MediaStream" is missing. Also throws error if "MediaRecorder API" are not supported by the browser.
+ */
+/**
+ * MultiStreamRecorder can record multiple videos in single container.
+ * @summary Multi-videos recorder.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef MultiStreamRecorder
+ * @class
+ * @example
+ * var options = {
+ *     mimeType: 'video/webm'
+ * }
+ * var recorder = new MultiStreamRecorder(ArrayOfMediaStreams, options);
+ * recorder.record();
+ * recorder.stop(function(blob) {
+ *     video.src = URL.createObjectURL(blob);
+ *
+ *     // or
+ *     var blob = recorder.blob;
+ * });
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {MediaStreams} mediaStreams - Array of MediaStreams.
+ * @param {object} config - {disableLogs:true, frameInterval: 1, mimeType: "video/webm"}
+ */
+/**
+ * RecordRTCPromisesHandler adds promises support in {@link RecordRTC}. Try a {@link https://github.com/muaz-khan/RecordRTC/blob/master/simple-demos/RecordRTCPromisesHandler.html|demo here}
+ * @summary Promises for {@link RecordRTC}
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef RecordRTCPromisesHandler
+ * @class
+ * @example
+ * var recorder = new RecordRTCPromisesHandler(mediaStream, options);
+ * recorder.startRecording()
+ *         .then(successCB)
+ *         .catch(errorCB);
+ * // Note: You can access all RecordRTC API using "recorder.recordRTC" e.g. 
+ * recorder.recordRTC.onStateChanged = function(state) {};
+ * recorder.recordRTC.setRecordingDuration(5000);
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {MediaStream} mediaStream - Single media-stream object, array of media-streams, html-canvas-element, etc.
+ * @param {object} config - {type:"video", recorderType: MediaStreamRecorder, disableLogs: true, numberOfAudioChannels: 1, bufferSize: 0, sampleRate: 0, video: HTMLVideoElement, etc.}
+ * @throws Will throw an error if "new" keyword is not used to initiate "RecordRTCPromisesHandler". Also throws error if first argument "MediaStream" is missing.
+ * @requires {@link RecordRTC}
+ */
+/**
+ * StereoAudioRecorder is a standalone class used by {@link RecordRTC} to bring "stereo" audio-recording in chrome.
+ * @summary JavaScript standalone object for stereo audio recording.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef StereoAudioRecorder
+ * @class
+ * @example
+ * var recorder = new StereoAudioRecorder(MediaStream, {
+ *     sampleRate: 44100,
+ *     bufferSize: 4096
+ * });
+ * recorder.record();
+ * recorder.stop(function(blob) {
+ *     video.src = URL.createObjectURL(blob);
+ * });
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {MediaStream} mediaStream - MediaStream object fetched using getUserMedia API or generated using captureStreamUntilEnded or WebAudio API.
+ * @param {object} config - {sampleRate: 44100, bufferSize: 4096, numberOfAudioChannels: 1, etc.}
+ */
+/**
+ * Storage is a standalone object used by {@link RecordRTC} to store reusable objects e.g. "new AudioContext".
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @example
+ * Storage.AudioContext === webkitAudioContext
+ * @property {webkitAudioContext} AudioContext - Keeps a reference to AudioContext object.
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ */
+/**
+ * WebAssemblyRecorder lets you create webm videos in JavaScript via WebAssembly. The library consumes raw RGBA32 buffers (4 bytes per pixel) and turns them into a webm video with the given framerate and quality. This makes it compatible out-of-the-box with ImageData from a CANVAS. With realtime mode you can also use webm-wasm for streaming webm videos.
+ * @summary Video recording feature in Chrome, Firefox and maybe Edge.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef WebAssemblyRecorder
+ * @class
+ * @example
+ * var recorder = new WebAssemblyRecorder(mediaStream);
+ * recorder.record();
+ * recorder.stop(function(blob) {
+ *     video.src = URL.createObjectURL(blob);
+ * });
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {MediaStream} mediaStream - MediaStream object fetched using getUserMedia API or generated using captureStreamUntilEnded or WebAudio API.
+ * @param {object} config - {webAssemblyPath:'webm-wasm.wasm',workerPath: 'webm-worker.js', frameRate: 30, width: 1920, height: 1080, bitrate: 1024, realtime: true}
+ */
+/**
+ * Whammy is a standalone class used by {@link RecordRTC} to bring video recording in Chrome. It is written by {@link https://github.com/antimatter15|antimatter15}
+ * @summary A real time javascript webm encoder based on a canvas hack.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef Whammy
+ * @class
+ * @example
+ * var recorder = new Whammy().Video(15);
+ * recorder.add(context || canvas || dataURL);
+ * var output = recorder.compile();
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ */
+/**
+ * WhammyRecorder is a standalone class used by {@link RecordRTC} to bring video recording in Chrome. It runs top over {@link Whammy}.
+ * @summary Video recording feature in Chrome.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef WhammyRecorder
+ * @class
+ * @example
+ * var recorder = new WhammyRecorder(mediaStream);
+ * recorder.record();
+ * recorder.stop(function(blob) {
+ *     video.src = URL.createObjectURL(blob);
+ * });
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {MediaStream} mediaStream - MediaStream object fetched using getUserMedia API or generated using captureStreamUntilEnded or WebAudio API.
+ * @param {object} config - {disableLogs: true, initCallback: function, video: HTMLVideoElement, etc.}
+ */
+/**
+ * {@link GetRecorderType} is an inner/private helper for {@link RecordRTC}.
+ * @summary It returns best recorder-type available for your browser.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef GetRecorderType
+ * @class
+ * @example
+ * var RecorderType = GetRecorderType(options);
+ * var recorder = new RecorderType(options);
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {MediaStream} mediaStream - MediaStream object fetched using getUserMedia API or generated using captureStreamUntilEnded or WebAudio API.
+ * @param {object} config - {type:"video", disableLogs: true, numberOfAudioChannels: 1, bufferSize: 0, sampleRate: 0, video: HTMLVideoElement, etc.}
+ */
+/**
+ * {@link RecordRTCConfiguration} is an inner/private helper for {@link RecordRTC}.
+ * @summary It configures the 2nd parameter passed over {@link RecordRTC} and returns a valid "config" object.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef RecordRTCConfiguration
+ * @class
+ * @example
+ * var options = RecordRTCConfiguration(mediaStream, options);
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {MediaStream} mediaStream - MediaStream object fetched using getUserMedia API or generated using captureStreamUntilEnded or WebAudio API.
+ * @param {object} config - {type:"video", disableLogs: true, numberOfAudioChannels: 1, bufferSize: 0, sampleRate: 0, video: HTMLVideoElement, getNativeBlob:true, etc.}
+ */
+/**
+ * {@link https://github.com/muaz-khan/RecordRTC|RecordRTC} is a WebRTC JavaScript library for audio/video as well as screen activity recording. It supports Chrome, Firefox, Opera, Android, and Microsoft Edge. Platforms: Linux, Mac and Windows. 
+ * @summary Record audio, video or screen inside the browser.
+ * @license {@link https://github.com/muaz-khan/RecordRTC/blob/master/LICENSE|MIT}
+ * @author {@link https://MuazKhan.com|Muaz Khan}
+ * @typedef RecordRTC
+ * @class
+ * @example
+ * var recorder = RecordRTC(mediaStream or [arrayOfMediaStream], {
+ *     type: 'video', // audio or video or gif or canvas
+ *     recorderType: MediaStreamRecorder || CanvasRecorder || StereoAudioRecorder || Etc
+ * });
+ * recorder.startRecording();
+ * @see For further information:
+ * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
+ * @param {MediaStream} mediaStream - Single media-stream object, array of media-streams, html-canvas-element, etc.
+ * @param {object} config - {type:"video", recorderType: MediaStreamRecorder, disableLogs: true, numberOfAudioChannels: 1, bufferSize: 0, sampleRate: 0, desiredSampRate: 16000, video: HTMLVideoElement, etc.}
+ */