easyproctor-hml 2.5.34 → 2.5.36

package/esm/index.js

@@ -2400,6 +2400,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"(exports, module) {
+    (function(name, definition) {
+      if (typeof define === "function" && define.amd) {
+        define(definition);
+      } else if (typeof module !== "undefined" && module.exports) {
+        module.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"(exports, module) {
@@ -8658,6 +9145,7 @@ var BaseDetection = class {
       // objectDetection
       runningMode: this.runningMode
     });
+    console.log("BaseDetection initializeDetector", this.detectorType);
   }
   stopDetection() {
     this.animationFrameId && clearTimeout(this.animationFrameId);
@@ -8669,6 +9157,7 @@ var BaseDetection = class {
   }
   enableCam(cameraStream) {
     var _a2;
+    console.log("BaseDetection enableCam");
     if (!this.detector) {
       console.log("Wait! Detector not loaded yet.");
       return;
@@ -8710,6 +9199,7 @@ var BaseDetection = class {
             }
         `;
     document.getElementsByTagName("head")[0].appendChild(style);
+    console.log("BaseDetection enableCam OK");
   }
   async predictWebcam() {
     if (this.lastVideoTime === -1) {
@@ -8838,11 +9328,13 @@ var FaceDetection = class extends BaseDetection {
     );
     this.emmitedPositionAlert = false;
     this.emmitedFaceAlert = false;
+    console.log("FaceDetection constructor");
+    this.numFacesSent = -1;
   }
   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; }) {
@@ -9005,6 +9497,8 @@ var FaceDetection = class extends BaseDetection {
   }
   verify(result) {
     var _a2;
+    console.log("this.numFacesSent", this.numFacesSent);
+    console.log("result.detections.length", result.detections.length);
     if (((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.detectFace) && result.detections.length !== this.numFacesSent) {
       this.numFacesSent = result.detections.length;
       if (result.detections.length === 0) {
@@ -12258,6 +12752,7 @@ function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCa
         buffer.push(e3.data);
       }
       if (stopped) {
+        console.log("buildMediaRecorder ondataavailable stopped");
         resolvePromise && resolvePromise();
       }
     };
@@ -12327,6 +12822,9 @@ function recorder(stream, buffer, onBufferSizeError = false, onBufferSizeErrorCa
       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 {
@@ -12742,6 +13240,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 = [];
@@ -12792,6 +13291,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;
@@ -13016,10 +13516,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);
@@ -13037,28 +13544,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 (e3) {
       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();
@@ -13192,6 +13693,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}
@@ -13199,9 +13709,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 */
       });
     }
@@ -15251,6 +15759,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 = "";
@@ -17959,10 +18483,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) {
@@ -18044,15 +18570,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 */
     });
   }
@@ -21978,7 +22513,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;
@@ -22183,7 +22718,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) {
@@ -22191,7 +22726,7 @@ Navigator: ${JSON.stringify(_navigator2)}`
             return;
           }
         }
-      }, 1500);
+      }, 5e3);
       return startResponse;
     } catch (error) {
       console.log(error);