easyproctor-hml 2.5.33 → 2.5.35

package/index.js

@@ -14011,6 +14011,493 @@ var require_jszip_min = __commonJS({
   }
 });
 
+// node_modules/fix-webm-duration/fix-webm-duration.js
+var require_fix_webm_duration = __commonJS({
+  "node_modules/fix-webm-duration/fix-webm-duration.js"(exports2, module2) {
+    (function(name, definition) {
+      if (typeof define === "function" && define.amd) {
+        define(definition);
+      } else if (typeof module2 !== "undefined" && module2.exports) {
+        module2.exports = definition();
+      } else {
+        window.ysFixWebmDuration = definition();
+      }
+    })("fix-webm-duration", function() {
+      var sections = {
+        172351395: { name: "EBML", type: "Container" },
+        646: { name: "EBMLVersion", type: "Uint" },
+        759: { name: "EBMLReadVersion", type: "Uint" },
+        754: { name: "EBMLMaxIDLength", type: "Uint" },
+        755: { name: "EBMLMaxSizeLength", type: "Uint" },
+        642: { name: "DocType", type: "String" },
+        647: { name: "DocTypeVersion", type: "Uint" },
+        645: { name: "DocTypeReadVersion", type: "Uint" },
+        108: { name: "Void", type: "Binary" },
+        63: { name: "CRC-32", type: "Binary" },
+        190023271: { name: "SignatureSlot", type: "Container" },
+        16010: { name: "SignatureAlgo", type: "Uint" },
+        16026: { name: "SignatureHash", type: "Uint" },
+        16037: { name: "SignaturePublicKey", type: "Binary" },
+        16053: { name: "Signature", type: "Binary" },
+        15963: { name: "SignatureElements", type: "Container" },
+        15995: { name: "SignatureElementList", type: "Container" },
+        9522: { name: "SignedElement", type: "Binary" },
+        139690087: { name: "Segment", type: "Container" },
+        21863284: { name: "SeekHead", type: "Container" },
+        3515: { name: "Seek", type: "Container" },
+        5035: { name: "SeekID", type: "Binary" },
+        5036: { name: "SeekPosition", type: "Uint" },
+        88713574: { name: "Info", type: "Container" },
+        13220: { name: "SegmentUID", type: "Binary" },
+        13188: { name: "SegmentFilename", type: "String" },
+        1882403: { name: "PrevUID", type: "Binary" },
+        1868715: { name: "PrevFilename", type: "String" },
+        2013475: { name: "NextUID", type: "Binary" },
+        1999803: { name: "NextFilename", type: "String" },
+        1092: { name: "SegmentFamily", type: "Binary" },
+        10532: { name: "ChapterTranslate", type: "Container" },
+        10748: { name: "ChapterTranslateEditionUID", type: "Uint" },
+        10687: { name: "ChapterTranslateCodec", type: "Uint" },
+        10661: { name: "ChapterTranslateID", type: "Binary" },
+        710577: { name: "TimecodeScale", type: "Uint" },
+        1161: { name: "Duration", type: "Float" },
+        1121: { name: "DateUTC", type: "Date" },
+        15273: { name: "Title", type: "String" },
+        3456: { name: "MuxingApp", type: "String" },
+        5953: { name: "WritingApp", type: "String" },
+        // 0xf43b675: { name: 'Cluster', type: 'Container' },
+        103: { name: "Timecode", type: "Uint" },
+        6228: { name: "SilentTracks", type: "Container" },
+        6359: { name: "SilentTrackNumber", type: "Uint" },
+        39: { name: "Position", type: "Uint" },
+        43: { name: "PrevSize", type: "Uint" },
+        35: { name: "SimpleBlock", type: "Binary" },
+        32: { name: "BlockGroup", type: "Container" },
+        33: { name: "Block", type: "Binary" },
+        34: { name: "BlockVirtual", type: "Binary" },
+        13729: { name: "BlockAdditions", type: "Container" },
+        38: { name: "BlockMore", type: "Container" },
+        110: { name: "BlockAddID", type: "Uint" },
+        37: { name: "BlockAdditional", type: "Binary" },
+        27: { name: "BlockDuration", type: "Uint" },
+        122: { name: "ReferencePriority", type: "Uint" },
+        123: { name: "ReferenceBlock", type: "Int" },
+        125: { name: "ReferenceVirtual", type: "Int" },
+        36: { name: "CodecState", type: "Binary" },
+        13730: { name: "DiscardPadding", type: "Int" },
+        14: { name: "Slices", type: "Container" },
+        104: { name: "TimeSlice", type: "Container" },
+        76: { name: "LaceNumber", type: "Uint" },
+        77: { name: "FrameNumber", type: "Uint" },
+        75: { name: "BlockAdditionID", type: "Uint" },
+        78: { name: "Delay", type: "Uint" },
+        79: { name: "SliceDuration", type: "Uint" },
+        72: { name: "ReferenceFrame", type: "Container" },
+        73: { name: "ReferenceOffset", type: "Uint" },
+        74: { name: "ReferenceTimeCode", type: "Uint" },
+        47: { name: "EncryptedBlock", type: "Binary" },
+        106212971: { name: "Tracks", type: "Container" },
+        46: { name: "TrackEntry", type: "Container" },
+        87: { name: "TrackNumber", type: "Uint" },
+        13253: { name: "TrackUID", type: "Uint" },
+        3: { name: "TrackType", type: "Uint" },
+        57: { name: "FlagEnabled", type: "Uint" },
+        8: { name: "FlagDefault", type: "Uint" },
+        5546: { name: "FlagForced", type: "Uint" },
+        28: { name: "FlagLacing", type: "Uint" },
+        11751: { name: "MinCache", type: "Uint" },
+        11768: { name: "MaxCache", type: "Uint" },
+        254851: { name: "DefaultDuration", type: "Uint" },
+        216698: { name: "DefaultDecodedFieldDuration", type: "Uint" },
+        209231: { name: "TrackTimecodeScale", type: "Float" },
+        4991: { name: "TrackOffset", type: "Int" },
+        5614: { name: "MaxBlockAdditionID", type: "Uint" },
+        4974: { name: "Name", type: "String" },
+        177564: { name: "Language", type: "String" },
+        6: { name: "CodecID", type: "String" },
+        9122: { name: "CodecPrivate", type: "Binary" },
+        362120: { name: "CodecName", type: "String" },
+        13382: { name: "AttachmentLink", type: "Uint" },
+        1742487: { name: "CodecSettings", type: "String" },
+        1785920: { name: "CodecInfoURL", type: "String" },
+        438848: { name: "CodecDownloadURL", type: "String" },
+        42: { name: "CodecDecodeAll", type: "Uint" },
+        12203: { name: "TrackOverlay", type: "Uint" },
+        5802: { name: "CodecDelay", type: "Uint" },
+        5819: { name: "SeekPreRoll", type: "Uint" },
+        9764: { name: "TrackTranslate", type: "Container" },
+        9980: { name: "TrackTranslateEditionUID", type: "Uint" },
+        9919: { name: "TrackTranslateCodec", type: "Uint" },
+        9893: { name: "TrackTranslateTrackID", type: "Binary" },
+        96: { name: "Video", type: "Container" },
+        26: { name: "FlagInterlaced", type: "Uint" },
+        5048: { name: "StereoMode", type: "Uint" },
+        5056: { name: "AlphaMode", type: "Uint" },
+        5049: { name: "OldStereoMode", type: "Uint" },
+        48: { name: "PixelWidth", type: "Uint" },
+        58: { name: "PixelHeight", type: "Uint" },
+        5290: { name: "PixelCropBottom", type: "Uint" },
+        5307: { name: "PixelCropTop", type: "Uint" },
+        5324: { name: "PixelCropLeft", type: "Uint" },
+        5341: { name: "PixelCropRight", type: "Uint" },
+        5296: { name: "DisplayWidth", type: "Uint" },
+        5306: { name: "DisplayHeight", type: "Uint" },
+        5298: { name: "DisplayUnit", type: "Uint" },
+        5299: { name: "AspectRatioType", type: "Uint" },
+        963876: { name: "ColourSpace", type: "Binary" },
+        1029411: { name: "GammaValue", type: "Float" },
+        230371: { name: "FrameRate", type: "Float" },
+        97: { name: "Audio", type: "Container" },
+        53: { name: "SamplingFrequency", type: "Float" },
+        14517: { name: "OutputSamplingFrequency", type: "Float" },
+        31: { name: "Channels", type: "Uint" },
+        15739: { name: "ChannelPositions", type: "Binary" },
+        8804: { name: "BitDepth", type: "Uint" },
+        98: { name: "TrackOperation", type: "Container" },
+        99: { name: "TrackCombinePlanes", type: "Container" },
+        100: { name: "TrackPlane", type: "Container" },
+        101: { name: "TrackPlaneUID", type: "Uint" },
+        102: { name: "TrackPlaneType", type: "Uint" },
+        105: { name: "TrackJoinBlocks", type: "Container" },
+        109: { name: "TrackJoinUID", type: "Uint" },
+        64: { name: "TrickTrackUID", type: "Uint" },
+        65: { name: "TrickTrackSegmentUID", type: "Binary" },
+        70: { name: "TrickTrackFlag", type: "Uint" },
+        71: { name: "TrickMasterTrackUID", type: "Uint" },
+        68: { name: "TrickMasterTrackSegmentUID", type: "Binary" },
+        11648: { name: "ContentEncodings", type: "Container" },
+        8768: { name: "ContentEncoding", type: "Container" },
+        4145: { name: "ContentEncodingOrder", type: "Uint" },
+        4146: { name: "ContentEncodingScope", type: "Uint" },
+        4147: { name: "ContentEncodingType", type: "Uint" },
+        4148: { name: "ContentCompression", type: "Container" },
+        596: { name: "ContentCompAlgo", type: "Uint" },
+        597: { name: "ContentCompSettings", type: "Binary" },
+        4149: { name: "ContentEncryption", type: "Container" },
+        2017: { name: "ContentEncAlgo", type: "Uint" },
+        2018: { name: "ContentEncKeyID", type: "Binary" },
+        2019: { name: "ContentSignature", type: "Binary" },
+        2020: { name: "ContentSigKeyID", type: "Binary" },
+        2021: { name: "ContentSigAlgo", type: "Uint" },
+        2022: { name: "ContentSigHashAlgo", type: "Uint" },
+        206814059: { name: "Cues", type: "Container" },
+        59: { name: "CuePoint", type: "Container" },
+        51: { name: "CueTime", type: "Uint" },
+        55: { name: "CueTrackPositions", type: "Container" },
+        119: { name: "CueTrack", type: "Uint" },
+        113: { name: "CueClusterPosition", type: "Uint" },
+        112: { name: "CueRelativePosition", type: "Uint" },
+        50: { name: "CueDuration", type: "Uint" },
+        4984: { name: "CueBlockNumber", type: "Uint" },
+        106: { name: "CueCodecState", type: "Uint" },
+        91: { name: "CueReference", type: "Container" },
+        22: { name: "CueRefTime", type: "Uint" },
+        23: { name: "CueRefCluster", type: "Uint" },
+        4959: { name: "CueRefNumber", type: "Uint" },
+        107: { name: "CueRefCodecState", type: "Uint" },
+        155296873: { name: "Attachments", type: "Container" },
+        8615: { name: "AttachedFile", type: "Container" },
+        1662: { name: "FileDescription", type: "String" },
+        1646: { name: "FileName", type: "String" },
+        1632: { name: "FileMimeType", type: "String" },
+        1628: { name: "FileData", type: "Binary" },
+        1710: { name: "FileUID", type: "Uint" },
+        1653: { name: "FileReferral", type: "Binary" },
+        1633: { name: "FileUsedStartTime", type: "Uint" },
+        1634: { name: "FileUsedEndTime", type: "Uint" },
+        4433776: { name: "Chapters", type: "Container" },
+        1465: { name: "EditionEntry", type: "Container" },
+        1468: { name: "EditionUID", type: "Uint" },
+        1469: { name: "EditionFlagHidden", type: "Uint" },
+        1499: { name: "EditionFlagDefault", type: "Uint" },
+        1501: { name: "EditionFlagOrdered", type: "Uint" },
+        54: { name: "ChapterAtom", type: "Container" },
+        13252: { name: "ChapterUID", type: "Uint" },
+        5716: { name: "ChapterStringUID", type: "String" },
+        17: { name: "ChapterTimeStart", type: "Uint" },
+        18: { name: "ChapterTimeEnd", type: "Uint" },
+        24: { name: "ChapterFlagHidden", type: "Uint" },
+        1432: { name: "ChapterFlagEnabled", type: "Uint" },
+        11879: { name: "ChapterSegmentUID", type: "Binary" },
+        11964: { name: "ChapterSegmentEditionUID", type: "Uint" },
+        9155: { name: "ChapterPhysicalEquiv", type: "Uint" },
+        15: { name: "ChapterTrack", type: "Container" },
+        9: { name: "ChapterTrackNumber", type: "Uint" },
+        0: { name: "ChapterDisplay", type: "Container" },
+        5: { name: "ChapString", type: "String" },
+        892: { name: "ChapLanguage", type: "String" },
+        894: { name: "ChapCountry", type: "String" },
+        10564: { name: "ChapProcess", type: "Container" },
+        10581: { name: "ChapProcessCodecID", type: "Uint" },
+        1293: { name: "ChapProcessPrivate", type: "Binary" },
+        10513: { name: "ChapProcessCommand", type: "Container" },
+        10530: { name: "ChapProcessTime", type: "Uint" },
+        10547: { name: "ChapProcessData", type: "Binary" },
+        39109479: { name: "Tags", type: "Container" },
+        13171: { name: "Tag", type: "Container" },
+        9152: { name: "Targets", type: "Container" },
+        10442: { name: "TargetTypeValue", type: "Uint" },
+        9162: { name: "TargetType", type: "String" },
+        9157: { name: "TagTrackUID", type: "Uint" },
+        9161: { name: "TagEditionUID", type: "Uint" },
+        9156: { name: "TagChapterUID", type: "Uint" },
+        9158: { name: "TagAttachmentUID", type: "Uint" },
+        10184: { name: "SimpleTag", type: "Container" },
+        1443: { name: "TagName", type: "String" },
+        1146: { name: "TagLanguage", type: "String" },
+        1156: { name: "TagDefault", type: "Uint" },
+        1159: { name: "TagString", type: "String" },
+        1157: { name: "TagBinary", type: "Binary" }
+      };
+      function doInherit(newClass, baseClass) {
+        newClass.prototype = Object.create(baseClass.prototype);
+        newClass.prototype.constructor = newClass;
+      }
+      function WebmBase(name, type) {
+        this.name = name || "Unknown";
+        this.type = type || "Unknown";
+      }
+      WebmBase.prototype.updateBySource = function() {
+      };
+      WebmBase.prototype.setSource = function(source) {
+        this.source = source;
+        this.updateBySource();
+      };
+      WebmBase.prototype.updateByData = function() {
+      };
+      WebmBase.prototype.setData = function(data) {
+        this.data = data;
+        this.updateByData();
+      };
+      function WebmUint(name, type) {
+        WebmBase.call(this, name, type || "Uint");
+      }
+      doInherit(WebmUint, WebmBase);
+      function padHex(hex) {
+        return hex.length % 2 === 1 ? "0" + hex : hex;
+      }
+      WebmUint.prototype.updateBySource = function() {
+        this.data = "";
+        for (var i3 = 0; i3 < this.source.length; i3++) {
+          var hex = this.source[i3].toString(16);
+          this.data += padHex(hex);
+        }
+      };
+      WebmUint.prototype.updateByData = function() {
+        var length = this.data.length / 2;
+        this.source = new Uint8Array(length);
+        for (var i3 = 0; i3 < length; i3++) {
+          var hex = this.data.substr(i3 * 2, 2);
+          this.source[i3] = parseInt(hex, 16);
+        }
+      };
+      WebmUint.prototype.getValue = function() {
+        return parseInt(this.data, 16);
+      };
+      WebmUint.prototype.setValue = function(value) {
+        this.setData(padHex(value.toString(16)));
+      };
+      function WebmFloat(name, type) {
+        WebmBase.call(this, name, type || "Float");
+      }
+      doInherit(WebmFloat, WebmBase);
+      WebmFloat.prototype.getFloatArrayType = function() {
+        return this.source && this.source.length === 4 ? Float32Array : Float64Array;
+      };
+      WebmFloat.prototype.updateBySource = function() {
+        var byteArray = this.source.reverse();
+        var floatArrayType = this.getFloatArrayType();
+        var floatArray = new floatArrayType(byteArray.buffer);
+        this.data = floatArray[0];
+      };
+      WebmFloat.prototype.updateByData = function() {
+        var floatArrayType = this.getFloatArrayType();
+        var floatArray = new floatArrayType([this.data]);
+        var byteArray = new Uint8Array(floatArray.buffer);
+        this.source = byteArray.reverse();
+      };
+      WebmFloat.prototype.getValue = function() {
+        return this.data;
+      };
+      WebmFloat.prototype.setValue = function(value) {
+        this.setData(value);
+      };
+      function WebmContainer(name, type) {
+        WebmBase.call(this, name, type || "Container");
+      }
+      doInherit(WebmContainer, WebmBase);
+      WebmContainer.prototype.readByte = function() {
+        return this.source[this.offset++];
+      };
+      WebmContainer.prototype.readUint = function() {
+        var firstByte = this.readByte();
+        var bytes = 8 - firstByte.toString(2).length;
+        var value = firstByte - (1 << 7 - bytes);
+        for (var i3 = 0; i3 < bytes; i3++) {
+          value *= 256;
+          value += this.readByte();
+        }
+        return value;
+      };
+      WebmContainer.prototype.updateBySource = function() {
+        this.data = [];
+        for (this.offset = 0; this.offset < this.source.length; this.offset = end) {
+          var id = this.readUint();
+          var len = this.readUint();
+          var end = Math.min(this.offset + len, this.source.length);
+          var data = this.source.slice(this.offset, end);
+          var info = sections[id] || { name: "Unknown", type: "Unknown" };
+          var ctr = WebmBase;
+          switch (info.type) {
+            case "Container":
+              ctr = WebmContainer;
+              break;
+            case "Uint":
+              ctr = WebmUint;
+              break;
+            case "Float":
+              ctr = WebmFloat;
+              break;
+          }
+          var section = new ctr(info.name, info.type);
+          section.setSource(data);
+          this.data.push({
+            id,
+            idHex: id.toString(16),
+            data: section
+          });
+        }
+      };
+      WebmContainer.prototype.writeUint = function(x3, draft) {
+        for (var bytes = 1, flag = 128; x3 >= flag && bytes < 8; bytes++, flag *= 128) {
+        }
+        if (!draft) {
+          var value = flag + x3;
+          for (var i3 = bytes - 1; i3 >= 0; i3--) {
+            var c3 = value % 256;
+            this.source[this.offset + i3] = c3;
+            value = (value - c3) / 256;
+          }
+        }
+        this.offset += bytes;
+      };
+      WebmContainer.prototype.writeSections = function(draft) {
+        this.offset = 0;
+        for (var i3 = 0; i3 < this.data.length; i3++) {
+          var section = this.data[i3], content = section.data.source, contentLength = content.length;
+          this.writeUint(section.id, draft);
+          this.writeUint(contentLength, draft);
+          if (!draft) {
+            this.source.set(content, this.offset);
+          }
+          this.offset += contentLength;
+        }
+        return this.offset;
+      };
+      WebmContainer.prototype.updateByData = function() {
+        var length = this.writeSections("draft");
+        this.source = new Uint8Array(length);
+        this.writeSections();
+      };
+      WebmContainer.prototype.getSectionById = function(id) {
+        for (var i3 = 0; i3 < this.data.length; i3++) {
+          var section = this.data[i3];
+          if (section.id === id) {
+            return section.data;
+          }
+        }
+        return null;
+      };
+      function WebmFile(source) {
+        WebmContainer.call(this, "File", "File");
+        this.setSource(source);
+      }
+      doInherit(WebmFile, WebmContainer);
+      WebmFile.prototype.fixDuration = function(duration, options) {
+        var logger = options && options.logger;
+        if (logger === void 0) {
+          logger = function(message) {
+            console.log(message);
+          };
+        } else if (!logger) {
+          logger = function() {
+          };
+        }
+        var segmentSection = this.getSectionById(139690087);
+        if (!segmentSection) {
+          logger("[fix-webm-duration] Segment section is missing");
+          return false;
+        }
+        var infoSection = segmentSection.getSectionById(88713574);
+        if (!infoSection) {
+          logger("[fix-webm-duration] Info section is missing");
+          return false;
+        }
+        var timeScaleSection = infoSection.getSectionById(710577);
+        if (!timeScaleSection) {
+          logger("[fix-webm-duration] TimecodeScale section is missing");
+          return false;
+        }
+        var durationSection = infoSection.getSectionById(1161);
+        if (durationSection) {
+          if (durationSection.getValue() <= 0) {
+            logger(`[fix-webm-duration] Duration section is present, but the value is ${durationSection.getValue()}`);
+            durationSection.setValue(duration);
+          } else {
+            logger(`[fix-webm-duration] Duration section is present, and the value is ${durationSection.getValue()}`);
+            return false;
+          }
+        } else {
+          logger("[fix-webm-duration] Duration section is missing");
+          durationSection = new WebmFloat("Duration", "Float");
+          durationSection.setValue(duration);
+          infoSection.data.push({
+            id: 1161,
+            data: durationSection
+          });
+        }
+        timeScaleSection.setValue(1e6);
+        infoSection.updateByData();
+        segmentSection.updateByData();
+        this.updateByData();
+        return true;
+      };
+      WebmFile.prototype.toBlob = function(mimeType) {
+        return new Blob([this.source.buffer], { type: mimeType || "video/webm" });
+      };
+      function fixWebmDuration3(blob, duration, callback, options) {
+        if (typeof callback === "object") {
+          options = callback;
+          callback = void 0;
+        }
+        if (!callback) {
+          return new Promise(function(resolve) {
+            fixWebmDuration3(blob, duration, resolve, options);
+          });
+        }
+        try {
+          var reader = new FileReader();
+          reader.onloadend = function() {
+            try {
+              var file = new WebmFile(new Uint8Array(reader.result));
+              if (file.fixDuration(duration, options)) {
+                blob = file.toBlob(blob.type);
+              }
+            } catch (ex) {
+            }
+            callback(blob);
+          };
+          reader.readAsArrayBuffer(blob);
+        } catch (ex) {
+          callback(blob);
+        }
+      }
+      fixWebmDuration3.default = fixWebmDuration3;
+      return fixWebmDuration3;
+    });
+  }
+});
+
 // node_modules/file-saver/dist/FileSaver.min.js
 var require_FileSaver_min = __commonJS({
   "node_modules/file-saver/dist/FileSaver.min.js"(exports2, module2) {
@@ -26127,7 +26614,7 @@ var FaceDetection = class extends BaseDetection {
   stopDetection() {
     super.stopDetection();
     if (this.emmitedFaceAlert) {
-      this.handleOk("face_ok", "face_detection_on_stream");
+      this.handleOk("face_stop", "face_detection_on_stream");
     }
   }
   // displayVideoDetections(result: { detections: any; }) {
@@ -30355,6 +30842,7 @@ function recorder(stream4, buffer, onBufferSizeError = false, onBufferSizeErrorC
         buffer.push(e3.data);
       }
       if (stopped) {
+        console.log("buildMediaRecorder ondataavailable stopped");
         resolvePromise && resolvePromise();
       }
     };
@@ -30424,6 +30912,9 @@ function recorder(stream4, buffer, onBufferSizeError = false, onBufferSizeErrorC
       if (mediaRecorder.state == "recording") {
         console.log("stopRecording Recorder est\xE1 em estado recording, iniciando stop");
         resolvePromise = resolve;
+        mediaRecorder.onstop = () => {
+          console.log("recorder onstop");
+        };
         stopped = true;
         mediaRecorder.stop();
       } else {
@@ -30839,6 +31330,7 @@ var VolumeMeter = class {
 
 // src/new-flow/recorders/CameraRecorder.ts
 var import_jszip_min = __toESM(require_jszip_min());
+var import_fix_webm_duration = __toESM(require_fix_webm_duration());
 var CameraRecorder = class {
   constructor(options, videoOptions, paramsConfig, backend, backendToken) {
     this.blobs = [];
@@ -30889,6 +31381,7 @@ var CameraRecorder = class {
     this.hardwareStream = null;
     this.internalClonedStream = null;
     this.videoElement = null;
+    this.duration = 0;
     this.currentRetries = 0;
     this.packageCount = 0;
     this.noiseWait = 20;
@@ -31113,10 +31606,17 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     console.log("Camera Recorder started OK");
   }
   async stopRecording() {
-    var _a2, _b, _c2;
+    var _a2, _b, _c2, _d;
     console.log("Camera Recorder stopRecording");
     this.isCanvasLoopActive = false;
+    this.faceDetection && this.faceDetection.detecting && this.faceDetection.stopDetection();
+    this.objectDetection && this.objectDetection.detecting && this.objectDetection.stopDetection();
+    clearInterval(this.imageInterval);
+    clearInterval(this.sendFrameInterval);
+    this.volumeMeter && this.volumeMeter.stop();
+    this.intervalNoiseDetection && clearInterval(this.intervalNoiseDetection);
     this.recordingStop && await this.recordingStop();
+    this.duration = Date.now() - ((_a2 = this.getStartTime()) == null ? void 0 : _a2.getTime()) || 0;
     try {
       if (this.animationFrameId) {
         cancelAnimationFrame(this.animationFrameId);
@@ -31134,28 +31634,22 @@ Setting: ${JSON.stringify(settings, null, 2)}`
         this.hardwareStream = null;
       }
       if (this.videoElement) {
-        (_a2 = this.videoElement) == null ? void 0 : _a2.remove();
+        (_b = this.videoElement) == null ? void 0 : _b.remove();
         this.videoElement = null;
       }
       if (this.video) {
-        (_b = this.video) == null ? void 0 : _b.remove();
+        (_c2 = this.video) == null ? void 0 : _c2.remove();
       }
       if (this.canvas) {
-        (_c2 = this.canvas) == null ? void 0 : _c2.remove();
+        (_d = this.canvas) == null ? void 0 : _d.remove();
       }
     } catch {
       console.error("Erro ao parar os streams de m\xEDdia.");
     }
-    this.faceDetection && this.faceDetection.detecting && this.faceDetection.stopDetection();
-    this.objectDetection && this.objectDetection.detecting && this.objectDetection.stopDetection();
-    clearInterval(this.imageInterval);
-    clearInterval(this.sendFrameInterval);
     if (this.options.proctoringType == "REALTIME" && this.upload && this.backendToken) {
       await this.sendPackage(this.filesToUpload);
       await this.filesToUpload.splice(0, this.filesToUpload.length);
     }
-    this.volumeMeter && this.volumeMeter.stop();
-    this.intervalNoiseDetection && clearInterval(this.intervalNoiseDetection);
   }
   async pauseRecording() {
     await this.recordingPause();
@@ -31289,6 +31783,15 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     const settings = this.cameraStream.getVideoTracks()[0].getSettings();
     const settingsAudio = this.cameraStream.getAudioTracks()[0].getSettings();
     if (this.options.proctoringType == "VIDEO" || this.options.proctoringType == "REALTIME" || this.options.proctoringType == "IMAGE" && ((_a2 = this.paramsConfig.imageBehaviourParameters) == null ? void 0 : _a2.saveVideo)) {
+      const rawBlob = new Blob(this.blobs, {
+        type: ((_b = this.recorderOptions) == null ? void 0 : _b.mimeType) || "video/webm"
+      });
+      const fixedBlob = await (0, import_fix_webm_duration.default)(rawBlob, this.duration);
+      const file = new File(
+        [fixedBlob],
+        `EP_${session.id}_camera_0.webm`,
+        { type: rawBlob.type }
+      );
       session.addRecording({
         device: `Audio
 	Sample Rate: ${settingsAudio.sampleRate}
@@ -31296,9 +31799,7 @@ Setting: ${JSON.stringify(settings, null, 2)}`
 
 	Video:
 	${JSON.stringify(this.recorderOptions)}`,
-        file: new File(this.blobs, `EP_${session.id}_camera_0.webm`, {
-          type: ((_b = this.recorderOptions) == null ? void 0 : _b.mimeType) || "video/webm"
-        }),
+        file,
         origin: "Camera" /* Camera */
       });
     }
@@ -33023,8 +33524,8 @@ var CapturePhoto = class {
   }
 };
 
-// src/extension/extension.ts
-var Extension = class {
+// src/extension/extensionEasyProctor.ts
+var ExtensionEasyProctor = class {
   constructor() {
     this.hasExtension = false;
     this.tryes = 0;
@@ -33069,6 +33570,89 @@ var Extension = class {
   }
 };
 
+// src/extension/extensionEasyCatcher.ts
+var ExtensionEasyCatcher = class {
+  constructor(options) {
+    this.hasExtension = false;
+    this.tryes = 0;
+    this.responseStart = false;
+    this.options = options || {};
+  }
+  /**
+   * Verifica se a extensão está instalada e ativa.
+   * Retorna o número da versão se encontrada, ou lança erro após timeout.
+   */
+  checkExtensionInstalled(timeoutMs = 2e3) {
+    return new Promise((resolve, reject) => {
+      let handled = false;
+      const handler = (event) => {
+        if (event.source === window && event.data.sender === "easyproctor-extension" && event.data.message_name === "version") {
+          handled = true;
+          window.removeEventListener("message", handler);
+          resolve(event.data.message);
+        }
+      };
+      window.addEventListener("message", handler);
+      window.postMessage({
+        type: "easycatcher",
+        func: "verifyExtensionEasycatcher"
+      }, "*");
+      setTimeout(() => {
+        if (!handled) {
+          window.removeEventListener("message", handler);
+          reject(new Error("Extens\xE3o n\xE3o detectada ou n\xE3o respondeu."));
+        }
+      }, timeoutMs);
+    });
+  }
+  /**
+   * Solicita o JSON da sessão atual capturado pela extensão.
+   */
+  getSessionData(timeoutMs = 5e3) {
+    return new Promise((resolve, reject) => {
+      let handled = false;
+      const handler = (event) => {
+        if (event.source === window && event.data.sender === "easyproctor-extension" && event.data.message_name === "data_response") {
+          handled = true;
+          window.removeEventListener("message", handler);
+          resolve(event.data.payload);
+        }
+      };
+      window.addEventListener("message", handler);
+      window.postMessage({
+        type: "easycatcher",
+        func: "getDataExtensionEasycatcher"
+      }, "*");
+      setTimeout(() => {
+        if (!handled) {
+          window.removeEventListener("message", handler);
+          reject(new Error("Timeout ao aguardar dados da extens\xE3o."));
+        }
+      }, timeoutMs);
+    });
+  }
+  start() {
+    return new Promise((resolve, reject) => {
+      let handled = false;
+      const handler = (event) => {
+        if (event.source === window && event.data.sender === "easyproctor-extension" && event.data.message_name === "started_confirmed") {
+          handled = true;
+          window.removeEventListener("message", handler);
+          resolve(true);
+        }
+      };
+      window.addEventListener("message", handler);
+      window.postMessage({ type: "easycatcher", func: "startExtensionEasycatcher" }, "*");
+      setTimeout(() => {
+        if (!handled) {
+          window.removeEventListener("message", handler);
+          reject(new Error("Timeout: Extens\xE3o n\xE3o confirmou o in\xEDcio."));
+        }
+      }, 3e3);
+    });
+  }
+};
+
 // src/modules/onChangeDevices.ts
 var onChangeDevices = class {
   constructor(repositoryDevices, proctoringId2, sessionOptions, allRecorders) {
@@ -33265,6 +33849,22 @@ var ProctoringUploader = class {
           }
         },
         token
+      ).catch(
+        async (e3) => {
+          console.log("Upload File Error", e3), trackers.registerError(this.proctoringId, `Upload File
+	Name: ${rec.file.name}
+Error: ${e3.message}
+	Size: ${e3.error}`);
+          await uploadService.upload(
+            {
+              file: rec.file,
+              onProgress: (progress) => {
+                if (onProgress) onProgress(progress);
+              }
+            },
+            token
+          );
+        }
       );
       if (result) {
         let fileType = "";
@@ -35973,10 +36573,12 @@ registerProcessor("audio-processor", AudioProcessor);
 `;
 
 // src/new-flow/recorders/ScreenRecorder.ts
+var import_fix_webm_duration2 = __toESM(require_fix_webm_duration());
 var ScreenRecorder = class {
   constructor(options) {
     this.blobs = [];
     this.blobsFinal = [];
+    this.duration = 0;
     this.options = options;
   }
   setProctoringId(proctoringId2) {
@@ -36058,15 +36660,24 @@ var ScreenRecorder = class {
   async resumeRecording() {
   }
   async stopRecording() {
+    var _a2;
     this.recordingStop && await this.recordingStop();
+    this.duration = Date.now() - ((_a2 = this.startTime) == null ? void 0 : _a2.getTime()) || 0;
   }
   async saveOnSession(session) {
     if (isMobileDevice()) return;
+    const rawBlob = new Blob(this.blobs, {
+      type: "video/webm"
+    });
+    const fixedBlob = await (0, import_fix_webm_duration2.default)(rawBlob, this.duration);
+    const file = new File(
+      [fixedBlob],
+      `EP_${session.id}_screen_0.webm`,
+      { type: rawBlob.type }
+    );
     session.addRecording({
       device: "",
-      file: new File(this.blobs, `EP_${session.id}_screen_0.webm`, {
-        type: "video/webm"
-      }),
+      file,
       origin: "Screen" /* Screen */
     });
   }
@@ -37144,7 +37755,7 @@ var Proctoring = class {
           begin: alert.begin,
           end: alert.end,
           warningCategoryEnum: this.convertRealtimeTypeToWarningType(alert.type),
-          alertImageBase64: await this.allRecorders.cameraRecorder.getCurrentImageBase64(),
+          alertImageBase64: alert.description !== "face_stop" ? await this.allRecorders.cameraRecorder.getCurrentImageBase64() : "",
           retry: verifyCount < verifyMaxRetries - 1 ? true : false
         });
         return response;
@@ -37257,7 +37868,10 @@ var Proctoring = class {
       if (this.context.token === void 0) {
         throw TOKEN_MISSING;
       }
-      this.extension = new Extension();
+      if (options.useChallenge) {
+        this.extensionEasycatcher = new ExtensionEasyCatcher();
+      }
+      this.extension = new ExtensionEasyProctor();
       this.extension.addEventListener();
       const baseURL = this.backend.selectBaseUrl(this.context.type);
       const devices = await enumarateDevices();
@@ -37346,7 +37960,7 @@ Navigator: ${JSON.stringify(_navigator2)}`
           verifyingFace = true;
           verifyFirstFaceIntervalCount++;
           try {
-            var response = await this.backend.verifyFace(this.proctoringId, await this.allRecorders.cameraRecorder.getCurrentImageBase64(), verifyFirstFaceIntervalCount > 5 ? false : true);
+            var response = await this.backend.verifyFace(this.proctoringId, await this.allRecorders.cameraRecorder.getCurrentImageBase64(), verifyFirstFaceIntervalCount > 2 ? false : true);
             verifyingFace = false;
             clearInterval(this.verifyFirstFaceInterval);
           } catch (error) {
@@ -37354,7 +37968,7 @@ Navigator: ${JSON.stringify(_navigator2)}`
             return;
           }
         }
-      }, 1500);
+      }, 5e3);
       return startResponse;
     } catch (error) {
       console.log(error);
@@ -37607,6 +38221,61 @@ Error: ` + error
       _screenStream: (_a2 = this.allRecorders.screenRecorder) == null ? void 0 : _a2.screenStream
     };
   }
+  async startChallenge(templateId) {
+    var _a2;
+    if (!this.sessionOptions.useChallenge) {
+      throw new Error("useChallenge is set as false on start method");
+    }
+    await this.extensionEasycatcher.checkExtensionInstalled().catch((err) => {
+      throw new Error("EasyCatcher Extension is not installed");
+    });
+    this.extensionEasycatcher.start();
+    const start = Date.now() - ((_a2 = this.allRecorders.cameraRecorder.getStartTime()) == null ? void 0 : _a2.getTime()) || 0;
+    await this.backend.startChallenge({
+      proctoringId: this.proctoringId,
+      templateId,
+      start
+    }).then((resp) => {
+      console.log(resp);
+      this.challengeId = resp.id;
+    }).catch((reason) => {
+      trackers.registerError(
+        this.proctoringId,
+        "N\xE3o foi poss\xEDvel iniciar desafio!"
+      );
+      throw reason;
+    });
+    this.isChallengeRunning = true;
+  }
+  async stopChallenge() {
+    var _a2;
+    if (!this.isChallengeRunning) {
+      throw new Error("Challenge not started");
+    }
+    try {
+      const sessionData = await this.extensionEasycatcher.getSessionData();
+      const end = Date.now() - ((_a2 = this.allRecorders.cameraRecorder.getStartTime()) == null ? void 0 : _a2.getTime()) || 0;
+      await this.backend.stopChallenge(
+        this.challengeId,
+        {
+          end,
+          data: sessionData
+        }
+      ).catch((reason) => {
+        trackers.registerError(
+          this.proctoringId,
+          "N\xE3o foi poss\xEDvel finalizar o desafio no backend!"
+        );
+        return void 0;
+      });
+      this.isChallengeRunning = false;
+    } catch (error) {
+      trackers.registerError(
+        this.proctoringId,
+        "Erro ao recuperar dados da extens\xE3o: " + error.message
+      );
+    }
+  }
 };
 
 // src/proctoring/SignTerm.ts
@@ -37834,6 +38503,8 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
     return originalStart(parameters2, videoOptions);
   };
   const finish = proctoring.finish.bind(proctoring);
+  const startChallenge = proctoring.startChallenge.bind(proctoring);
+  const stopChallenge = proctoring.stopChallenge.bind(proctoring);
   const pause = proctoring.pause.bind(proctoring);
   const resume = proctoring.resume.bind(proctoring);
   const onFocus = proctoring.setOnFocusCallback.bind(proctoring);
@@ -37856,6 +38527,8 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
     login,
     start,
     finish,
+    startChallenge,
+    stopChallenge,
     onFocus,
     onLostFocus,
     onChangeDevices: onChangeDevices2,