@volcengine/veplayer-plugin 2.4.1-rc.0 → 2.5.0-rc.0

package/umd/veplayer.plugin.hls.development.js

@@ -1644,7 +1644,7 @@
     }
     return offsetTime;
   };
-  var version = "3.0.19-rc.0";
+  var version = "3.0.20-alpha.4";
   var ERROR_MAP = {
     1: 5101,
     2: 5102,
@@ -1753,8 +1753,7 @@
       }
       if (this.__hooks && this.__hooks[hookName]) {
         try {
-          var _this$__hooks$hookNam;
-          var preRet = (_this$__hooks$hookNam = this.__hooks[hookName]).call.apply(_this$__hooks$hookNam, [this, this].concat(Array.prototype.slice.call(arguments)));
+          var preRet = runHooks(this, hookName, handler);
           if (preRet) {
             if (preRet.then) {
               preRet.then(function(isContinue) {
@@ -1779,6 +1778,19 @@
       }
     }.bind(this);
   }
+  function findHookIndex(hookName, handler) {
+    var __hooks = this.__hooks;
+    if (!__hooks || !Array.isArray(__hooks[hookName])) {
+      return -1;
+    }
+    var hookHandlers = __hooks[hookName];
+    for (var i = 0; i < hookHandlers.length; i++) {
+      if (hookHandlers[i] === handler) {
+        return i;
+      }
+    }
+    return -1;
+  }
   function useHooks(hookName, handler) {
     var __hooks = this.__hooks;
     if (!__hooks) {
@@ -1788,7 +1800,12 @@
       console.warn("has no supported hook which name [".concat(hookName, "]"));
       return false;
     }
-    __hooks && (__hooks[hookName] = handler);
+    if (!Array.isArray(__hooks[hookName])) {
+      __hooks[hookName] = [];
+    }
+    if (findHookIndex.call(this, hookName, handler) === -1) {
+      __hooks[hookName].push(handler);
+    }
     return true;
   }
   function removeHooks(hookName, handler) {
@@ -1796,6 +1813,13 @@
     if (!__hooks) {
       return;
     }
+    if (Array.isArray(__hooks[hookName])) {
+      var hooks = __hooks[hookName];
+      var index = findHookIndex.call(this, hookName, handler);
+      if (index !== -1) {
+        hooks.splice(index, 1);
+      }
+    }
     delete __hooks[hookName];
   }
   function hooksDescriptor(instance) {
@@ -1817,6 +1841,38 @@
   function delHooksDescriptor(instance) {
     instance.__hooks = null;
   }
+  function runHooks(obj, hookName, handler) {
+    for (var _len5 = arguments.length, args = new Array(_len5 > 3 ? _len5 - 3 : 0), _key5 = 3; _key5 < _len5; _key5++) {
+      args[_key5 - 3] = arguments[_key5];
+    }
+    if (obj.__hooks && Array.isArray(obj.__hooks[hookName])) {
+      var hooks = obj.__hooks[hookName];
+      var index = -1;
+      var runHooksRecursive = function runHooksRecursive2(obj2, hookName2, handler2) {
+        for (var _len6 = arguments.length, args2 = new Array(_len6 > 3 ? _len6 - 3 : 0), _key6 = 3; _key6 < _len6; _key6++) {
+          args2[_key6 - 3] = arguments[_key6];
+        }
+        index++;
+        if (hooks.length === 0 || index === hooks.length) {
+          return handler2.call.apply(handler2, [obj2, obj2].concat(args2));
+        }
+        var hook2 = hooks[index];
+        var ret = hook2.call.apply(hook2, [obj2, obj2].concat(args2));
+        if (ret && ret.then) {
+          return ret.then(function(data) {
+            return data === false ? null : runHooksRecursive2.apply(void 0, [obj2, hookName2, handler2].concat(args2));
+          }).catch(function(e) {
+            console.warn("[runHooks]".concat(hookName2, " reject"), e.message);
+          });
+        } else if (ret !== false) {
+          return runHooksRecursive2.apply(void 0, [obj2, hookName2, handler2].concat(args2));
+        }
+      };
+      return runHooksRecursive.apply(void 0, [obj, hookName, handler].concat(args));
+    } else {
+      return handler.call.apply(handler, [obj, obj].concat(args));
+    }
+  }
   function showErrorMsg(pluginName, msg) {
     XG_DEBUG.logError("[".concat(pluginName, "] event or callback cant be undefined or null when call ").concat(msg));
   }
@@ -2866,6 +2922,21 @@
           length: Buffer2.totalLength && Buffer2.totalLength(buffers)
         };
       }
+    }, {
+      key: "isBuffered",
+      value: function isBuffered(media, pos) {
+        if (media) {
+          var buffered = Buffer2.get(media);
+          if (buffered !== null && buffered !== void 0 && buffered.length) {
+            for (var i = 0; i < buffered.length; i++) {
+              if (pos >= buffered.start(i) && pos <= buffered.end(i)) {
+                return true;
+              }
+            }
+          }
+        }
+        return false;
+      }
     }]);
     return Buffer2;
   }();
@@ -5986,7 +6057,7 @@
             continue;
           }
           frameLength = (data[i + 3] & 3) << 11 | data[i + 4] << 3 | (data[i + 5] & 224) >> 5;
-          if (len - i < frameLength)
+          if (!frameLength || len - i < frameLength)
             break;
           protectionSkipBytes = (~data[i + 1] & 1) * 2;
           frames.push({
@@ -6180,6 +6251,15 @@
       return parseInt(item, 16);
     });
   }
+  function combineToFloat(integer, decimal) {
+    return Number(integer + "." + decimal);
+  }
+  function toDegree(matrix) {
+    if (matrix.length < 5)
+      return 0;
+    var scaled0 = Math.hypot(matrix[0], matrix[3]), scaled1 = Math.hypot(matrix[1], matrix[4]);
+    return 0 === scaled0 || 0 === scaled1 ? 0 : 180 * Math.atan2(matrix[1] / scaled1, matrix[0] / scaled0) / Math.PI;
+  }
   var NALu = /* @__PURE__ */ function() {
     function NALu2() {
       _classCallCheck(this, NALu2);
@@ -6842,13 +6922,16 @@
   var AUDIO_EXCETION_LOG_EMIT_DURATION = 5 * 9e4;
   var MAX_VIDEO_FRAME_DURATION = 9e4;
   var MAX_DTS_DELTA_WITH_NEXT_CHUNK = 9e4 / 2;
+  var LARGE_AV_FIRST_FRAME_FORCE_FIX_THRESHOLD = 9e4 * 5;
   var TsFixer = /* @__PURE__ */ function() {
-    function TsFixer2(videoTrack, audioTrack, metadataTrack) {
+    function TsFixer2(videoTrack, audioTrack, metadataTrack, fixerConfig) {
       _classCallCheck(this, TsFixer2);
       this.videoTrack = videoTrack;
       this.audioTrack = audioTrack;
       this.metadataTrack = metadataTrack;
       this._baseDts = -1;
+      this._baseVideoDts = -1;
+      this._baseAudioDts = -1;
       this._baseDtsInited = false;
       this._audioNextPts = void 0;
       this._videoNextDts = void 0;
@@ -6857,6 +6940,8 @@
       this._lastAudioExceptionGapDot = 0;
       this._lastAudioExceptionOverlapDot = 0;
       this._lastAudioExceptionLargeGapDot = 0;
+      this._needForceFixLargeGap = fixerConfig === null || fixerConfig === void 0 ? void 0 : fixerConfig.forceFixLargeGap;
+      this._largeGapThreshold = (fixerConfig === null || fixerConfig === void 0 ? void 0 : fixerConfig.largeGapThreshold) || LARGE_AV_FIRST_FRAME_FORCE_FIX_THRESHOLD;
     }
     _createClass(TsFixer2, [{
       key: "fix",
@@ -6884,10 +6969,16 @@
         if (discontinuity) {
           this._calculateBaseDts(this.audioTrack, this.videoTrack);
           this._baseDts -= startTime;
+          this._baseAudioDts -= startTime;
+          this._baseVideoDts -= startTime;
         }
         if (!contiguous) {
           this._videoNextDts = vaDelta > 0 ? startTime + vaDelta : startTime;
           this._audioNextPts = vaDelta > 0 ? startTime : startTime - vaDelta;
+          if (this._needForceFixLargeGap) {
+            this._videoNextDts = 0;
+            this._audioNextPts = 0;
+          }
           var vDeltaToNextDts = firstVideoSample ? firstVideoSample.dts - this._baseDts - this._videoNextDts : 0;
           var aDeltaToNextDts = firstAudioSample ? firstAudioSample.pts - this._baseDts - this._audioNextPts : 0;
           if (Math.abs(vDeltaToNextDts || aDeltaToNextDts) > MAX_VIDEO_FRAME_DURATION) {
@@ -6920,8 +7011,8 @@
         if (!samples.length)
           return;
         samples.forEach(function(x) {
-          x.dts -= _this2._baseDts;
-          x.pts -= _this2._baseDts;
+          x.dts -= _this2._needForceFixLargeGap ? _this2._baseVideoDts : _this2._baseDts;
+          x.pts -= _this2._needForceFixLargeGap ? _this2._baseVideoDts : _this2._baseDts;
         });
         if (this._videoNextDts === void 0) {
           var samp0 = samples[0];
@@ -7014,7 +7105,7 @@
         if (!samples.length)
           return;
         samples.forEach(function(x) {
-          x.pts -= _this3._baseDts;
+          x.pts -= _this3._needForceFixLargeGap ? _this3._baseAudioDts : _this3._baseDts;
           x.dts = x.pts;
         });
         this._doFixAudioInternal(audioTrack, samples, 9e4);
@@ -7031,12 +7122,15 @@
         var videoBaseDts = Infinity;
         if (audioSamps.length) {
           audioTrack.baseDts = audioBasePts = audioSamps[0].pts;
+          this._baseAudioDts = audioBasePts;
         }
         if (videoSamps.length) {
           videoTrack.baseDts = videoBaseDts = videoSamps[0].dts;
+          this._baseVideoDts = videoBaseDts;
         }
         this._baseDts = Math.min(audioBasePts, videoBaseDts);
         var delta = videoBaseDts - audioBasePts;
+        var largeGap = false;
         if (Number.isFinite(delta) && Math.abs(delta) > LARGE_AV_FIRST_FRAME_GAP) {
           videoTrack.warnings.push({
             type: WarningType.LARGE_AV_SHIFT,
@@ -7046,6 +7140,16 @@
             delta
           });
         }
+        if (Number.isFinite(delta) && Math.abs(delta) > this._largeGapThreshold * MAX_SILENT_FRAME_DURATION) {
+          largeGap = true;
+        }
+        if (!this._baseDtsInited) {
+          if (largeGap && this._needForceFixLargeGap) {
+            this._needForceFixLargeGap = true;
+          } else {
+            this._needForceFixLargeGap = false;
+          }
+        }
         this._baseDtsInited = true;
         return true;
       }
@@ -7139,6 +7243,7 @@
   var logger$4 = new Logger$1("TsDemuxer");
   var TsDemuxer = /* @__PURE__ */ function() {
     function TsDemuxer2(videoTrack, audioTrack, metadataTrack) {
+      var fixerConfig = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
       _classCallCheck(this, TsDemuxer2);
       _defineProperty(this, "_pmtId", -1);
       _defineProperty(this, "_remainingPacketData", null);
@@ -7148,7 +7253,7 @@
       this.videoTrack = videoTrack || new VideoTrack();
       this.audioTrack = audioTrack || new AudioTrack();
       this.metadataTrack = metadataTrack || new MetadataTrack();
-      this._fixer = new TsFixer(this.videoTrack, this.audioTrack, this.metadataTrack);
+      this._fixer = new TsFixer(this.videoTrack, this.audioTrack, this.metadataTrack, fixerConfig);
     }
     _createClass(TsDemuxer2, [{
       key: "demux",
@@ -7495,6 +7600,166 @@
     }]);
     return TsDemuxer2;
   }();
+  var ByteReader = /* @__PURE__ */ function() {
+    function ByteReader2(buf, offset, len) {
+      _classCallCheck(this, ByteReader2);
+      this.dv = new DataView(buf);
+      this.start = this.offset = offset || this.dv.byteOffset;
+      this.end = len ? this.start + len : this.dv.byteLength;
+    }
+    _createClass(ByteReader2, [{
+      key: "buffer",
+      get: function get() {
+        return this.dv.buffer;
+      }
+    }, {
+      key: "unreadLength",
+      get: function get() {
+        return Math.max(this.end - this.offset, 0);
+      }
+    }, {
+      key: "size",
+      get: function get() {
+        return this.end - this.start;
+      }
+    }, {
+      key: "readFloat",
+      value: function readFloat(byteNum) {
+        var val = 0;
+        switch (byteNum) {
+          case 4:
+            val = this.dv.getFloat32(this.offset);
+            break;
+          case 8:
+            val = this.dv.getFloat64(this.offset);
+            break;
+          default:
+            throw new Error("read ".concat(byteNum, "-byte float is not supported"));
+        }
+        this.offset += byteNum;
+        return val;
+      }
+    }, {
+      key: "back",
+      value: function back(byteNum) {
+        this.offset -= byteNum;
+      }
+    }, {
+      key: "skip",
+      value: function skip(byteNum) {
+        this.offset += byteNum;
+      }
+    }, {
+      key: "readInt",
+      value: function readInt(byteNum) {
+        var offset = this.offset;
+        this.offset += byteNum;
+        switch (byteNum) {
+          case 1:
+            return this.dv.getInt8(offset);
+          case 2:
+            return this.dv.getInt16(offset);
+          case 4:
+            return this.dv.getInt32(offset);
+          default:
+            throw new Error("read ".concat(byteNum, "-byte integers is not supported"));
+        }
+      }
+    }, {
+      key: "read",
+      value: function read(byteNum) {
+        var offset = this.offset;
+        this.offset += byteNum;
+        switch (byteNum) {
+          case 1:
+            return this.dv.getUint8(offset);
+          case 2:
+            return this.dv.getUint16(offset);
+          case 3:
+            return (this.dv.getUint16(offset) << 8) + this.dv.getUint8(offset + 2);
+          case 4:
+            return this.dv.getUint32(offset);
+          default:
+            this.back(byteNum - 4);
+            return this.read(byteNum - 4) + this.dv.getUint32(offset) * Math.pow(256, byteNum - 4);
+        }
+      }
+    }, {
+      key: "write",
+      value: function write(byteNum, val) {
+        var offset = this.offset;
+        this.offset += byteNum;
+        switch (byteNum) {
+          case 1:
+            return this.dv.setUint8(offset, val);
+          case 2:
+            return this.dv.setUint16(offset, val);
+          case 3:
+            return this.dv.setUint8(offset, val >>> 16), this.dv.setUint16(offset + 1, 65535 & val);
+          case 4:
+            return this.dv.setUint32(offset, val);
+          default:
+            throw new Error("write ".concat(byteNum, "-byte integers is not supported"));
+        }
+      }
+    }, {
+      key: "readToBuffer",
+      value: function readToBuffer(len) {
+        var buffer;
+        if (this.offset || len) {
+          buffer = this.dv.buffer.slice(this.offset, len ? this.offset + len : void 0);
+        } else {
+          buffer = this.dv.buffer;
+        }
+        this.offset += buffer.byteLength;
+        return buffer;
+      }
+    }, {
+      key: "readToUint8",
+      value: function readToUint8(len) {
+        var uint8 = new Uint8Array(this.dv.buffer, this.offset, len || this.unreadLength);
+        this.offset += uint8.byteLength;
+        return uint8;
+      }
+    }, {
+      key: "readString",
+      value: function readString(len) {
+        var i = 0, str = "";
+        for (; i < len; i++) {
+          str += String.fromCharCode(this.dv.getUint8(this.offset));
+          this.offset++;
+        }
+        return str;
+      }
+    }], [{
+      key: "fromUint8",
+      value: function fromUint8(uint8) {
+        return new ByteReader2(uint8.buffer, uint8.byteOffset, uint8.byteLength);
+      }
+    }, {
+      key: "concatUint8s",
+      value: function concatUint8s(args) {
+        var uint8 = new Uint8Array(args.reduce(function(ret, v) {
+          return ret + v.byteLength;
+        }, 0));
+        var offset = 0;
+        args.forEach(function(v) {
+          uint8.set(v, offset);
+          offset += v.byteLength;
+        });
+        return uint8;
+      }
+    }, {
+      key: "concatUint8",
+      value: function concatUint8() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return this.concatUint8s(args);
+      }
+    }]);
+    return ByteReader2;
+  }();
   var MP4Parser = /* @__PURE__ */ function() {
     function MP4Parser2() {
       _classCallCheck(this, MP4Parser2);
@@ -7652,18 +7917,36 @@
       key: "tkhd",
       value: function tkhd(box) {
         return parseBox(box, true, function(ret, data) {
-          var start = 0;
+          var byte = ByteReader.fromUint8(data);
           if (ret.version === 1) {
-            ret.trackId = readBig32(data, 16);
-            ret.duration = readBig64(data, 24);
-            start += 32;
+            byte.read(8);
+            byte.read(8);
+            ret.trackId = byte.read(4);
+            byte.read(4);
+            ret.duration = byte.read(8);
           } else {
-            ret.trackId = readBig32(data, 8);
-            ret.duration = readBig32(data, 16);
-            start += 20;
+            byte.read(4);
+            byte.read(4);
+            ret.trackId = byte.read(4);
+            byte.read(4);
+            ret.duration = byte.read(4);
+          }
+          byte.skip(16);
+          ret.matrix = [];
+          for (var i = 0; i < 36; i++) {
+            ret.matrix.push(byte.read(1));
+          }
+          byte.back(36);
+          var caculatedMatrix = [];
+          for (var _i = 0, int32; _i < 3; _i++) {
+            caculatedMatrix.push(combineToFloat(byte.readInt(2), byte.readInt(2)));
+            caculatedMatrix.push(combineToFloat(byte.readInt(2), byte.readInt(2)));
+            int32 = byte.readInt(4);
+            caculatedMatrix.push(combineToFloat(int32 >> 30, int32 & 1073741823));
           }
-          ret.width = readBig32(data, start + 52);
-          ret.height = readBig32(data, start + 56);
+          ret.rotation = toDegree(caculatedMatrix);
+          ret.width = byte.read(4);
+          ret.height = byte.read(4);
         });
       }
     }, {
@@ -7793,7 +8076,7 @@
           if (ret.version > 0) {
             var numKeyIds = readBig32(data, start);
             start += 4;
-            for (var _i = 0; _i < ("" + numKeyIds).length; _i++) {
+            for (var _i2 = 0; _i2 < ("" + numKeyIds).length; _i2++) {
               for (var j = 0; j < 16; j++) {
                 var keyId = data[start];
                 start += 1;
@@ -7929,7 +8212,7 @@
           ret.ppsLength = data[start];
           start += 1;
           ret.pps = [];
-          for (var _i2 = 0; _i2 < ret.ppsLength; _i2++) {
+          for (var _i3 = 0; _i3 < ret.ppsLength; _i3++) {
             var _size = readBig16(data, start);
             start += 2;
             ret.pps.push(data.subarray(start, start += _size));
@@ -8098,7 +8381,7 @@
               start += 8;
             }
           } else {
-            for (var _i3 = 0; _i3 < entryCount; _i3++) {
+            for (var _i4 = 0; _i4 < entryCount; _i4++) {
               entries.push({
                 count: readBig32(data, start),
                 offset: -(~readBig32(data, start + 4) + 1)
@@ -8320,6 +8603,8 @@
           v.mvhdTimecale = moov.mvhd.timescale;
           v.timescale = v.formatTimescale = vTrack.mdia.mdhd.timescale;
           v.duration = vTrack.mdia.mdhd.duration || v.mvhdDurtion / v.mvhdTimecale * v.timescale;
+          v.rotation = vTrack.tkhd.rotation;
+          v.matrix = vTrack.tkhd.matrix;
           var e1 = vTrack.mdia.minf.stbl.stsd.entries[0];
           v.width = e1.width;
           v.height = e1.height;
@@ -10886,11 +11171,11 @@
   });
   var logger$3 = new Logger$2("Transmuxer");
   var Transmuxer = /* @__PURE__ */ function() {
-    function Transmuxer2(hls, isMP4, needRemux) {
+    function Transmuxer2(hls, isMP4, needRemux, fixerConfig) {
       _classCallCheck$3(this, Transmuxer2);
       _defineProperty$3(this, "_initSegmentId", "");
       this.hls = hls;
-      this._demuxer = isMP4 ? new FMP4Demuxer() : new TsDemuxer();
+      this._demuxer = isMP4 ? new FMP4Demuxer() : new TsDemuxer(null, null, null, fixerConfig);
       this._isMP4 = isMP4;
       if (needRemux)
         this._remuxer = new FMP4Remuxer(this._demuxer.videoTrack, this._demuxer.audioTrack);
@@ -11157,11 +11442,11 @@
           return;
         if (TsDemuxer.probe(chunk)) {
           if (!this._transmuxer)
-            this._transmuxer = new Transmuxer(this.hls, false, !this._softVideo);
+            this._transmuxer = new Transmuxer(this.hls, false, !this._softVideo, this.hls.config.fixerConfig);
         } else if (MP4Parser.probe(chunk)) {
           if (this._softVideo) {
             if (!this._transmuxer)
-              this._transmuxer = new Transmuxer(this.hls, true);
+              this._transmuxer = new Transmuxer(this.hls, true, null, this.hls.config.fixerConfig);
           } else {
             this._directAppend = true;
             var mix = false;
@@ -11604,7 +11889,11 @@
       minSegmentsStartPlay: 3,
       preferMMS: false,
       preferMMSStreaming: false,
-      mseLowLatency: true
+      mseLowLatency: true,
+      fixerConfig: {
+        forceFixLargeGap: false,
+        largeGapThreshold: 5
+      }
     }, cfg), {}, {
       media
     });
@@ -11719,6 +12008,8 @@
     _defineProperty$3(this, "lowLatency", false);
     _defineProperty$3(this, "endPartIndex", 0);
     _defineProperty$3(this, "segments", []);
+    _defineProperty$3(this, "dateRanges", {});
+    _defineProperty$3(this, "skippedSegments", 0);
   });
   var MediaSegment = /* @__PURE__ */ function() {
     function MediaSegment2(parentUrl) {
@@ -11890,6 +12181,38 @@
       }
     }
   }
+  function isValidDaterange(attr, dateRangeWithSameId) {
+    var _badValueForSameId;
+    if (dateRangeWithSameId) {
+      for (var key in dateRangeWithSameId) {
+        if (Object.prototype.hasOwnProperty.call(dateRangeWithSameId, key) && attr[key] !== dateRangeWithSameId[key]) {
+          _badValueForSameId = key;
+          break;
+        }
+      }
+    }
+    var duration = null;
+    if (attr.DURATION) {
+      duration = parseFloat(attr.DURATION);
+      if (!Number.isFinite(duration)) {
+        duration = null;
+      } else if (attr._endDate) {
+        duration = (attr._endDate.getTime() - attr._startDate.getTime()) / 1e3;
+      }
+    }
+    var cue = enumeratedStringList(attr.CUE || attr["X-CUE"], {
+      pre: false,
+      post: false,
+      once: false
+    });
+    return !!attr.ID && !_badValueForSameId && Number.isFinite(attr._startDate.getTime()) && (duration === null || duration >= 0) && (!(attr.END_ON_NEXT === "YES") || !!attr.CLASS) && (!attr.CUE || !cue.pre && !cue.post || cue.pre !== cue.post) && (!(attr.CLASS === "com.apple.hls.interstitial") || "X-ASSET-URI" in attr || "X-ASSET-LIST" in attr);
+  }
+  function enumeratedStringList(attrValue, dict) {
+    return (attrValue ? attrValue.split(/[ ,]+/) : []).reduce(function(result, identifier) {
+      result[identifier.toLowerCase()] = true;
+      return result;
+    }, dict);
+  }
   function parseMasterPlaylist(lines, parentUrl) {
     var master = new MasterPlaylist();
     var index = 0;
@@ -11998,9 +12321,6 @@
     var endOfList = false;
     var partSegmentIndex = 0;
     while (line = lines[index++]) {
-      if (endOfList) {
-        break;
-      }
       if (line[0] !== "#") {
         if (media.lowLatency) {
           curSN++;
@@ -12054,11 +12374,6 @@
           break;
         case "ENDLIST":
           {
-            var _lastSegment = media.segments[media.segments.length - 1];
-            if (_lastSegment) {
-              _lastSegment.isLast = true;
-            }
-            media.live = false;
             endOfList = true;
           }
           break;
@@ -12155,6 +12470,29 @@
             curSegment = new MediaSegment(parentUrl);
           }
           break;
+        case "SKIP":
+          {
+            var _attr5 = parseAttr(data);
+            var skippedSegments = parseInt(_attr5["SKIPPED-SEGMENTS"], 10);
+            if (skippedSegments <= Number.MAX_SAFE_INTEGER) {
+              media.skippedSegments += skippedSegments;
+            }
+          }
+          break;
+        case "DATERANGE":
+          {
+            var _attr6 = parseAttr(data);
+            var dateRangeWithSameId = media.dateRanges[_attr6.ID];
+            _attr6._startDate = dateRangeWithSameId ? dateRangeWithSameId._startDate : new Date(_attr6["START-DATE"]);
+            var endDate = (dateRangeWithSameId === null || dateRangeWithSameId === void 0 ? void 0 : dateRangeWithSameId._endDate) || new Date(_attr6.END_DATE);
+            if (Number.isFinite(endDate)) {
+              _attr6._endDate = endDate;
+            }
+            if (isValidDaterange(_attr6, dateRangeWithSameId) || media.skippedSegments) {
+              media.dateRanges[_attr6.ID] = _attr6;
+            }
+          }
+          break;
       }
     }
     media.segments = media.segments.filter(function(x) {
@@ -12162,11 +12500,14 @@
     });
     var lastSegment = media.segments[media.segments.length - 1];
     if (lastSegment) {
-      media.endSN = lastSegment.sn;
-      media.endPartIndex = lastSegment.partIndex;
-      if (endOfList && !lastSegment.isLast) {
+      if (endOfList) {
         lastSegment.isLast = true;
       }
+      media.endSN = lastSegment.sn;
+      media.endPartIndex = lastSegment.partIndex;
+    }
+    if (endOfList) {
+      media.live = false;
     }
     media.totalDuration = totalDuration;
     media.endCC = curCC;
@@ -13263,7 +13604,7 @@
       _defineProperty$3(_assertThisInitialized$2(_this), "_switchUrlOpts", null);
       _defineProperty$3(_assertThisInitialized$2(_this), "_isProcessQuotaExceeded", false);
       _defineProperty$3(_assertThisInitialized$2(_this), "_loadSegment", /* @__PURE__ */ _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee() {
-        var nextSeg, _assertThisInitialize, config, bInfo, bufferThroughout;
+        var _this$_playlist, nextSegment, lastSegment, _assertThisInitialize, config, minFrameDuration, maxBufferThroughout, bInfo, bufferThroughout;
         return _regeneratorRuntime$1().wrap(function _callee$(_context) {
           while (1)
             switch (_context.prev = _context.next) {
@@ -13274,42 +13615,44 @@
                 }
                 return _context.abrupt("return");
               case 2:
-                nextSeg = _this._playlist.nextSegment;
+                _this$_playlist = _this._playlist, nextSegment = _this$_playlist.nextSegment, lastSegment = _this$_playlist.lastSegment;
                 _assertThisInitialize = _assertThisInitialized$2(_this), config = _assertThisInitialize.config;
-                if (nextSeg) {
-                  _context.next = 6;
+                minFrameDuration = 0.016;
+                maxBufferThroughout = Math.min(Math.max((lastSegment === null || lastSegment === void 0 ? void 0 : lastSegment.duration) - minFrameDuration / 2 || 0, minFrameDuration), 0.1);
+                if (nextSegment) {
+                  _context.next = 8;
                   break;
                 }
                 return _context.abrupt("return");
-              case 6:
+              case 8:
                 if (_this.isLive) {
-                  _context.next = 16;
+                  _context.next = 18;
                   break;
                 }
                 bInfo = _this.bufferInfo();
                 if (_this.media.paused && !_this.media.currentTime) {
                   bInfo = _this.bufferInfo(bInfo.nextStart || 0.5);
                 }
-                bufferThroughout = Math.abs(bInfo.end - _this.media.duration) < 0.1;
+                bufferThroughout = Math.abs(bInfo.end - _this.media.duration) < maxBufferThroughout;
                 if (!(bInfo.remaining >= config.preloadTime || bufferThroughout)) {
-                  _context.next = 13;
+                  _context.next = 15;
                   break;
                 }
                 _this._tryEos();
                 return _context.abrupt("return");
-              case 13:
+              case 15:
                 if (!(config.preferMMSStreaming && !_this._bufferService.msStreaming)) {
-                  _context.next = 15;
+                  _context.next = 17;
                   break;
                 }
                 return _context.abrupt("return");
-              case 15:
-                if (!_this._urlSwitching && _this._prevSegSn !== nextSeg.sn - 1 && bInfo.end && Math.abs(nextSeg.start - bInfo.end) > 1) {
+              case 17:
+                if (!_this._urlSwitching && _this._prevSegSn !== nextSegment.sn - 1 && bInfo.end && Math.abs(nextSegment.start - bInfo.end) > 1) {
                   _this._playlist.setNextSegmentByIndex(_this._playlist.findSegmentIndexByTime(bInfo.end + 0.1));
                 }
-              case 16:
+              case 18:
                 return _context.abrupt("return", _this._loadSegmentDirect());
-              case 17:
+              case 19:
               case "end":
                 return _context.stop();
             }
@@ -14562,8 +14905,8 @@
       value: function _tryEos() {
         var _this$_bufferService3, _this$_bufferService4;
         var media = this.media;
-        var _this$_playlist = this._playlist, nextSegment = _this$_playlist.nextSegment, lastSegment = _this$_playlist.lastSegment;
-        var eosAllowed = !nextSegment && media.readyState && media.duration > 0 && ((_this$_bufferService3 = this._bufferService) === null || _this$_bufferService3 === void 0 ? void 0 : _this$_bufferService3.msIsOpened) && !((_this$_bufferService4 = this._bufferService) !== null && _this$_bufferService4 !== void 0 && _this$_bufferService4.msHasOpTasks);
+        var _this$_playlist2 = this._playlist, nextSegment = _this$_playlist2.nextSegment, lastSegment = _this$_playlist2.lastSegment;
+        var eosAllowed = (!nextSegment || lastSegment && Buffer$1.isBuffered(media, lastSegment.start + lastSegment.duration / 2)) && media.readyState && media.duration > 0 && ((_this$_bufferService3 = this._bufferService) === null || _this$_bufferService3 === void 0 ? void 0 : _this$_bufferService3.msIsOpened) && !((_this$_bufferService4 = this._bufferService) !== null && _this$_bufferService4 !== void 0 && _this$_bufferService4.msHasOpTasks);
         if (!eosAllowed) {
           return;
         }
@@ -14599,7 +14942,7 @@
     }]);
     return Hls2;
   }(EventEmitter);
-  _defineProperty$3(Hls, "version", "3.0.19-rc.0");
+  _defineProperty$3(Hls, "version", "3.0.20-alpha.2");
   try {
     if (localStorage.getItem("xgd")) {
       Hls.enableLogger();