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

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

@@ -1644,7 +1644,7 @@
     }
     return offsetTime;
   };
-  var version = "3.0.20-alpha.4";
+  var version = "3.0.21-rc.5";
   var ERROR_MAP = {
     1: 5101,
     2: 5102,
@@ -2112,6 +2112,18 @@
           }
         }
       }
+    }, {
+      key: "defineMethod",
+      value: function defineMethod(Obj, map) {
+        for (var key in map) {
+          if (Object.prototype.hasOwnProperty.call(map, key) && typeof map[key] === "function") {
+            Object.defineProperty(Obj, key, {
+              configurable: true,
+              value: map[key]
+            });
+          }
+        }
+      }
     }, {
       key: "defaultConfig",
       get: function get() {
@@ -2734,7 +2746,7 @@
       arr2[i] = arr[i];
     return arr2;
   }
-  function _createForOfIteratorHelper(o, allowArrayLike) {
+  function _createForOfIteratorHelper$1(o, allowArrayLike) {
     var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
     if (!it) {
       if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") {
@@ -3089,7 +3101,7 @@
         this.logCache.apply(this, [LogCacheLevel.DEBUG].concat(args));
         if (Logger2.disabled)
           return;
-        (_console = console).debug.apply(_console, [this._prefix, nowTime$1()].concat(args));
+        (_console = console).debug.apply(_console, ["[".concat(nowTime$1(), "]"), this._prefix].concat(args));
       }
     }, {
       key: "log",
@@ -3101,7 +3113,7 @@
         this.logCache.apply(this, [LogCacheLevel.LOG].concat(args));
         if (Logger2.disabled)
           return;
-        (_console2 = console).log.apply(_console2, [this._prefix, nowTime$1()].concat(args));
+        (_console2 = console).log.apply(_console2, ["[".concat(nowTime$1(), "]"), this._prefix].concat(args));
       }
     }, {
       key: "warn",
@@ -3113,7 +3125,7 @@
         this.logCache.apply(this, [LogCacheLevel.WARN].concat(args));
         if (Logger2.disabled)
           return;
-        (_console3 = console).warn.apply(_console3, [this._prefix, nowTime$1()].concat(args));
+        (_console3 = console).warn.apply(_console3, ["[".concat(nowTime$1(), "]"), this._prefix].concat(args));
       }
     }, {
       key: "error",
@@ -3125,7 +3137,7 @@
         this.logCache.apply(this, [LogCacheLevel.ERROR].concat(args));
         if (Logger2.disabled)
           return;
-        (_console4 = console).error.apply(_console4, [this._prefix, nowTime$1()].concat(args));
+        (_console4 = console).error.apply(_console4, ["[".concat(nowTime$1(), "]"), this._prefix].concat(args));
       }
     }, {
       key: "logCache",
@@ -3140,7 +3152,7 @@
           var finLogText = logText.map(function(item) {
             return logable(item);
           });
-          text = this._prefix + nowTime$1() + JSON.stringify(finLogText);
+          text = "[".concat(nowTime$1(), "]") + this._prefix + JSON.stringify(finLogText);
         } catch (e) {
           return;
         }
@@ -4056,8 +4068,8 @@
       response
     };
   }
-  function calculateSpeed(byteLen, millisec) {
-    return Math.round(byteLen * 8 * 1e3 / millisec / 1024);
+  function calculateSpeed(byteLen, milliSecond) {
+    return Math.round(byteLen * 8 * 1e3 / milliSecond / 1024);
   }
   var EVENT = {
     ERROR: "error",
@@ -4069,6 +4081,7 @@
     SOURCEBUFFER_CREATED: "core.sourcebuffercreated",
     MEDIASOURCE_OPENED: "core.mediasourceopened",
     ANALYZE_DURATION_EXCEEDED: "core.analyzedurationexceeded",
+    APPEND_BUFFER: "core.appendbuffer",
     REMOVE_BUFFER: "core.removebuffer",
     BUFFEREOS: "core.buffereos",
     KEYFRAME: "core.keyframe",
@@ -4841,7 +4854,7 @@
       value: function _getHeaders(xhr) {
         var headerLines = xhr.getAllResponseHeaders().trim().split("\r\n");
         var headers = {};
-        var _iterator = _createForOfIteratorHelper(headerLines), _step;
+        var _iterator = _createForOfIteratorHelper$1(headerLines), _step;
         try {
           for (_iterator.s(); !(_step = _iterator.n()).done; ) {
             var header = _step.value;
@@ -4863,7 +4876,7 @@
     }]);
     return XhrLoader2;
   }(EventEmitter);
-  var _excluded$1 = ["retry", "retryDelay", "onRetryError", "transformError"];
+  var _excluded$2 = ["retry", "retryDelay", "onRetryError", "transformError"];
   var Task = /* @__PURE__ */ function() {
     function Task2(type, config) {
       _classCallCheck$1(this, Task2);
@@ -4883,7 +4896,7 @@
       key: "exec",
       value: function exec() {
         var _this = this;
-        var _this$_config = this._config, retry = _this$_config.retry, retryDelay = _this$_config.retryDelay, onRetryError = _this$_config.onRetryError, transformError = _this$_config.transformError, rest = _objectWithoutProperties(_this$_config, _excluded$1);
+        var _this$_config = this._config, retry = _this$_config.retry, retryDelay = _this$_config.retryDelay, onRetryError = _this$_config.onRetryError, transformError = _this$_config.transformError, rest = _objectWithoutProperties(_this$_config, _excluded$2);
         var request = /* @__PURE__ */ function() {
           var _ref = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee() {
             var response, error, isRetry;
@@ -5679,6 +5692,60 @@
   function _nonIterableRest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
+  function _createForOfIteratorHelper(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+    if (!it) {
+      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it)
+          o = it;
+        var i = 0;
+        var F = function() {
+        };
+        return {
+          s: F,
+          n: function() {
+            if (i >= o.length)
+              return {
+                done: true
+              };
+            return {
+              done: false,
+              value: o[i++]
+            };
+          },
+          e: function(e) {
+            throw e;
+          },
+          f: F
+        };
+      }
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    var normalCompletion = true, didErr = false, err;
+    return {
+      s: function() {
+        it = it.call(o);
+      },
+      n: function() {
+        var step = it.next();
+        normalCompletion = step.done;
+        return step;
+      },
+      e: function(e) {
+        didErr = true;
+        err = e;
+      },
+      f: function() {
+        try {
+          if (!normalCompletion && it.return != null)
+            it.return();
+        } finally {
+          if (didErr)
+            throw err;
+        }
+      }
+    };
+  }
   function _toPrimitive(input, hint) {
     if (typeof input !== "object" || input === null)
       return input;
@@ -5701,13 +5768,16 @@
     METADATA: "metadata"
   };
   var VideoCodecType = {
+    AV1: "av1",
     AVC: "avc",
     HEVC: "hevc"
   };
   var AudioCodecType = {
     AAC: "aac",
     G711PCMA: "g7110a",
-    G711PCMU: "g7110m"
+    G711PCMU: "g7110m",
+    OPUS: "opus",
+    MP3: "mp3"
   };
   var WarningType = {
     LARGE_AV_SHIFT: "LARGE_AV_SHIFT",
@@ -5747,6 +5817,7 @@
       _defineProperty(this, "isVideoEncryption", false);
       _defineProperty(this, "isAudioEncryption", false);
       _defineProperty(this, "isVideo", true);
+      _defineProperty(this, "lastKeyFrameDts", 0);
       _defineProperty(this, "kid", null);
       _defineProperty(this, "pssh", null);
       _defineProperty(this, "ext", void 0);
@@ -5789,6 +5860,9 @@
     }, {
       key: "exist",
       value: function exist() {
+        if (/av01/.test(this.codec)) {
+          return true;
+        }
         return !!(this.pps.length && this.sps.length && this.codec);
       }
     }, {
@@ -5812,6 +5886,7 @@
       _defineProperty(this, "codecType", AudioCodecType.AAC);
       _defineProperty(this, "pid", -1);
       _defineProperty(this, "codec", "");
+      _defineProperty(this, "container", "");
       _defineProperty(this, "sequenceNumber", 0);
       _defineProperty(this, "sampleDuration", 0);
       _defineProperty(this, "timescale", 0);
@@ -5852,7 +5927,7 @@
     }, {
       key: "exist",
       value: function exist() {
-        return !!(this.sampleRate && this.channelCount && this.codec && this.codecType === AudioCodecType.AAC);
+        return !!(this.sampleRate && this.channelCount && (this.codec || this.container) && (this.codecType === AudioCodecType.AAC || this.codecType === AudioCodecType.G711PCMA || this.codecType === AudioCodecType.G711PCMU || this.codecType === AudioCodecType.OPUS || this.codecType === AudioCodecType.MP3));
       }
     }, {
       key: "hasSample",
@@ -7240,6 +7315,119 @@
     }]);
     return TsFixer2;
   }();
+  var BitratesMap = [32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160];
+  var FREQ = [44100, 48e3, 32e3, 22050, 24e3, 16e3, 11025, 12e3, 8e3];
+  var SamplesCoefficients = [
+    [
+      0,
+      72,
+      144,
+      12
+    ],
+    [
+      0,
+      0,
+      0,
+      0
+    ],
+    [
+      0,
+      72,
+      144,
+      12
+    ],
+    [
+      0,
+      144,
+      144,
+      12
+    ]
+  ];
+  var BytesInSlot = [
+    0,
+    1,
+    1,
+    4
+  ];
+  var chromeVersion = null;
+  var MPEG = /* @__PURE__ */ function() {
+    function MPEG2() {
+      _classCallCheck(this, MPEG2);
+    }
+    _createClass(MPEG2, null, [{
+      key: "isHeader",
+      value: function isHeader(data, offset) {
+        return offset + 1 < data.length && data[offset] === 255 && (data[offset + 1] & 224) === 224 && (data[offset + 1] & 6) !== 0;
+      }
+    }, {
+      key: "appendFrame",
+      value: function appendFrame(track, data, offset, pts, frameIndex) {
+        if (offset + 24 > data.length) {
+          return;
+        }
+        var header = MPEG2.parseHeader(data, offset);
+        if (header && offset + header.frameLength <= data.length) {
+          var frameDuration = header.samplesPerFrame * 9e4 / header.sampleRate;
+          var stamp = pts + frameIndex * frameDuration;
+          var sample = {
+            data: data.subarray(offset, offset + header.frameLength),
+            pts: stamp,
+            dts: stamp
+          };
+          sample.size = sample.data.byteLength;
+          track.config = [];
+          track.channelCount = header.channelCount;
+          track.sampleRate = header.sampleRate;
+          if (isFirefox) {
+            track.codec = "mp3";
+          } else {
+            track.container = "audio/mpeg";
+          }
+          track.samples.push(sample);
+          return {
+            length: header.frameLength
+          };
+        }
+      }
+    }, {
+      key: "parseHeader",
+      value: function parseHeader(data, offset) {
+        var mpegVersion = data[offset + 1] >> 3 & 3;
+        var mpegLayer = data[offset + 1] >> 1 & 3;
+        var bitRateIndex = data[offset + 2] >> 4 & 15;
+        var sampleRateIndex = data[offset + 2] >> 2 & 3;
+        if (mpegVersion !== 1 && bitRateIndex !== 0 && bitRateIndex !== 15 && sampleRateIndex !== 3) {
+          var paddingBit = data[offset + 2] >> 1 & 1;
+          var channelMode = data[offset + 3] >> 6;
+          var columnInBitrates = mpegVersion === 3 ? 3 - mpegLayer : mpegLayer === 3 ? 3 : 4;
+          var bitRate = BitratesMap[columnInBitrates * 14 + bitRateIndex - 1] * 1e3;
+          var columnInSampleRates = mpegVersion === 3 ? 0 : mpegVersion === 2 ? 1 : 2;
+          var sampleRate = FREQ[columnInSampleRates * 3 + sampleRateIndex];
+          var channelCount = channelMode === 3 ? 1 : 2;
+          var sampleCoefficient = SamplesCoefficients[mpegVersion][mpegLayer];
+          var bytesInSlot = BytesInSlot[mpegLayer];
+          var samplesPerFrame = sampleCoefficient * 8 * bytesInSlot;
+          var frameLength = Math.floor(sampleCoefficient * bitRate / sampleRate + paddingBit) * bytesInSlot;
+          if (chromeVersion === null) {
+            var userAgent = navigator.userAgent || "";
+            var result = userAgent.match(/Chrome\/(\d+)/i);
+            chromeVersion = result ? parseInt(result[1]) : 0;
+          }
+          var needChromeFix = !!chromeVersion && chromeVersion <= 87;
+          if (needChromeFix && mpegLayer === 2 && bitRate >= 224e3 && channelMode === 0) {
+            data[offset + 3] = data[offset + 3] | 128;
+          }
+          return {
+            sampleRate,
+            channelCount,
+            frameLength,
+            samplesPerFrame
+          };
+        }
+      }
+    }]);
+    return MPEG2;
+  }();
   var logger$4 = new Logger$1("TsDemuxer");
   var TsDemuxer = /* @__PURE__ */ function() {
     function TsDemuxer2(videoTrack, audioTrack, metadataTrack) {
@@ -7323,6 +7511,13 @@
                     case 15:
                       audioTrack.pid = audioPid = esPid;
                       break;
+                    case 3:
+                    case 4:
+                      if (audioTrack.pid === -1) {
+                        audioTrack.pid = audioPid = esPid;
+                        audioTrack.codecType = AudioCodecType.MP3;
+                      }
+                      break;
                     case 27:
                       if (videoPid !== -1)
                         break;
@@ -7522,7 +7717,14 @@
           logger$4.warn("Cannot parse audio pes", this._audioPesData);
           return;
         }
-        this._parseAacData(pes);
+        switch (this.audioTrack.codecType) {
+          case AudioCodecType.AAC:
+            this._parseAacData(pes);
+            break;
+          case AudioCodecType.MP3:
+            this._parseMPEG(pes);
+            break;
+        }
         this._audioPesData = [];
       }
     }, {
@@ -7559,6 +7761,32 @@
           logger$4.warn("Cannot parse aac adts", pes);
         }
       }
+    }, {
+      key: "_parseMPEG",
+      value: function _parseMPEG(pes) {
+        var data = pes.data;
+        var length = data.length;
+        var frameIndex = 0;
+        var offset = 0;
+        var pts = pes.pts;
+        if (pts === void 0) {
+          logger$4.warn("[tsdemuxer]: MPEG PES unknown PTS");
+          return;
+        }
+        while (offset < length) {
+          if (MPEG.isHeader(data, offset)) {
+            var frame = MPEG.appendFrame(this.audioTrack, data, offset, pts, frameIndex);
+            if (frame) {
+              offset += frame.length;
+              frameIndex++;
+            } else {
+              break;
+            }
+          } else {
+            offset++;
+          }
+        }
+      }
     }], [{
       key: "probe",
       value: function probe(data) {
@@ -7605,7 +7833,7 @@
       _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;
+      this.end = len ? this.start + len : this.start + this.dv.byteLength;
     }
     _createClass(ByteReader2, [{
       key: "buffer",
@@ -7707,7 +7935,7 @@
       value: function readToBuffer(len) {
         var buffer;
         if (this.offset || len) {
-          buffer = this.dv.buffer.slice(this.offset, len ? this.offset + len : void 0);
+          buffer = this.dv.buffer.slice(this.offset, len ? this.offset + len : this.end);
         } else {
           buffer = this.dv.buffer;
         }
@@ -7760,6 +7988,47 @@
     }]);
     return ByteReader2;
   }();
+  var BitReader = /* @__PURE__ */ function() {
+    function BitReader2(val, size) {
+      _classCallCheck(this, BitReader2);
+      this.offset = 0;
+      this.val = val;
+      this.size = size;
+    }
+    _createClass(BitReader2, [{
+      key: "skip",
+      value: function skip(len) {
+        this.offset += len;
+      }
+    }, {
+      key: "read",
+      value: function read(len) {
+        var unreadLength = this.size - this.offset - len;
+        if (unreadLength >= 0) {
+          var bits = 0, i = 0;
+          this.offset += len;
+          if (this.size > 31) {
+            for (; i < len; i++) {
+              bits += Math.pow(2, i);
+            }
+            return this.val / Math.pow(2, unreadLength) & bits;
+          } else {
+            for (; i < len; i++) {
+              bits += 1 << i;
+            }
+            return this.val >>> unreadLength & bits;
+          }
+        }
+        throw new Error("the number of the read operation exceeds the total length limit of bits");
+      }
+    }], [{
+      key: "fromByte",
+      value: function fromByte(byte, len) {
+        return new BitReader2(byte.read(len), len << 3);
+      }
+    }]);
+    return BitReader2;
+  }();
   var MP4Parser = /* @__PURE__ */ function() {
     function MP4Parser2() {
       _classCallCheck(this, MP4Parser2);
@@ -8099,6 +8368,8 @@
           ret.entryCount = readBig32(data);
           ret.entries = MP4Parser2.findBox(data.subarray(4), [], start + 4).map(function(b) {
             switch (b.type) {
+              case "av01":
+                return MP4Parser2.av01(b);
               case "avc1":
               case "avc2":
               case "avc3":
@@ -8178,6 +8449,69 @@
           }
         });
       }
+    }, {
+      key: "colr",
+      value: function colr(box) {
+        return parseBox(box, false, function(ret, data) {
+          var byte = ByteReader.fromUint8(data);
+          ret.data = box.data;
+          ret.colorType = byte.readString(4);
+          if (ret.colorType === "nclx") {
+            ret.colorPrimaries = byte.read(2);
+            ret.transferCharacteristics = byte.read(2);
+            ret.matrixCoefficients = byte.read(2);
+            ret.fullRangeFlag = byte.read(1) >> 7;
+          } else if (ret.colorType === "rICC" || ret.colorType === "prof") {
+            ret.iccProfile = data.readToUint8();
+          }
+        });
+      }
+    }, {
+      key: "av01",
+      value: function av01(box) {
+        return parseBox(box, false, function(ret, data, start) {
+          var bodyStart = parseVisualSampleEntry(ret, data);
+          var bodyData = data.subarray(bodyStart);
+          start += bodyStart;
+          ret.av1C = MP4Parser2.av1C(MP4Parser2.findBox(bodyData, ["av1C"], start)[0]);
+          ret.colr = MP4Parser2.colr(MP4Parser2.findBox(bodyData, ["colr"], start)[0]);
+        });
+      }
+    }, {
+      key: "av1C",
+      value: function av1C(box) {
+        return parseBox(box, false, function(ret, data) {
+          ret.data = box.data;
+          var byte = ByteReader.fromUint8(data);
+          var bit = BitReader.fromByte(byte, 4);
+          ret.marker = bit.read(1);
+          ret.version = bit.read(7);
+          ret.seqProfile = bit.read(3);
+          ret.seqLevelIdx0 = bit.read(5);
+          ret.seqTier0 = bit.read(1);
+          ret.highBitdepth = bit.read(1);
+          ret.twelveBit = bit.read(1);
+          ret.monochrome = bit.read(1);
+          ret.chromaSubsamplingX = bit.read(1);
+          ret.chromaSubsamplingY = bit.read(1);
+          ret.chromaSamplePosition = bit.read(2);
+          ret.reserved = bit.read(3);
+          ret.initialPresentationDelayPresent = bit.read(1);
+          if (ret.initialPresentationDelayPresent) {
+            ret.initialPresentationDelayMinusOne = bit.read(4);
+          } else {
+            ret.initialPresentationDelayMinusOne = 0;
+          }
+          ret.configOBUs = byte.readToUint8();
+          var bitdepth;
+          if (ret.seqLevelIdx0 === 2 && ret.highBitdepth === 1) {
+            bitdepth = ret.twelveBit === 1 ? "12" : "10";
+          } else if (ret.seqProfile <= 2) {
+            bitdepth = ret.highBitdepth === 1 ? "10" : "08";
+          }
+          ret.codec = ["av01", ret.seqProfile, (ret.seqLevelIdx0 < 10 ? "0" + ret.seqLevelIdx0 : ret.seqLevelIdx0) + (ret.seqTier0 ? "H" : "M"), bitdepth].join(".");
+        });
+      }
     }, {
       key: "avc1",
       value: function avc1(box) {
@@ -8611,7 +8945,12 @@
           if (e1.pasp) {
             v.sarRatio = [e1.pasp.hSpacing, e1.pasp.vSpacing];
           }
-          if (e1.hvcC) {
+          if (e1.av1C) {
+            v.codecType = VideoCodecType.AV1;
+            v.codec = e1.av1C.codec;
+            v.av1C = e1.av1C.data;
+            v.colr = e1.colr.data;
+          } else if (e1.hvcC) {
             v.codecType = VideoCodecType.HEVC;
             v.codec = e1.hvcC.codec;
             v.vps = e1.hvcC.vps;
@@ -8930,8 +9269,9 @@
   function parseBox(box, isFullBox, parse2) {
     if (!box)
       return;
-    if (box.size !== box.data.length)
+    if (box.size !== box.data.length) {
       throw new Error("box ".concat(box.type, " size !== data.length"));
+    }
     var ret = {
       start: box.start,
       size: box.size,
@@ -8970,11 +9310,167 @@
   var FMP4Demuxer = /* @__PURE__ */ function() {
     function FMP4Demuxer2(videoTrack, audioTrack, metadataTrack) {
       _classCallCheck(this, FMP4Demuxer2);
+      _defineProperty(this, "__loadedMoofWraps", []);
+      _defineProperty(this, "__lastRemainData", null);
+      _defineProperty(this, "__lastRemainDataStart", 0);
+      _defineProperty(this, "__nextMoofStart", -1);
       this.videoTrack = videoTrack || new VideoTrack();
       this.audioTrack = audioTrack || new AudioTrack();
       this.metadataTrack = metadataTrack || new MetadataTrack();
     }
     _createClass(FMP4Demuxer2, [{
+      key: "demuxPart",
+      value: function demuxPart(partData, partDataStart, moov) {
+        var _this = this;
+        var videoTrack = this.videoTrack, audioTrack = this.audioTrack;
+        var videoExist = videoTrack.exist();
+        var audioExist = audioTrack.exist();
+        var isAV01 = /av01/.test(videoTrack.codec);
+        videoTrack.samples = [];
+        audioTrack.samples = [];
+        var data = partData;
+        var dataStart = partDataStart;
+        if (this.__lastRemainData) {
+          var lastRemainDataEnd = this.__lastRemainDataStart + this.__lastRemainData.byteLength;
+          var continuous = partDataStart <= lastRemainDataEnd && partDataStart > this.__lastRemainDataStart && partDataStart + partData.byteLength > lastRemainDataEnd;
+          if (continuous) {
+            var noDuplicateData = partData.subarray(this.__lastRemainData.byteLength + this.__lastRemainDataStart - partDataStart);
+            data = concatUint8Array(this.__lastRemainData, noDuplicateData);
+            dataStart = this.__lastRemainDataStart;
+            this.__lastRemainData = null;
+          } else {
+            this.__lastRemainData = null;
+            this.__lastRemainDataStart = 0;
+            this.__nextMoofStart = -1;
+          }
+        }
+        if (!moov) {
+          var moovBox = MP4Parser.findBox(data, ["moov"])[0];
+          if (!moovBox)
+            throw new Error("cannot found moov box");
+          moov = MP4Parser.moov(moovBox);
+        }
+        if (data) {
+          var dataEnd = dataStart + data.byteLength;
+          if (!videoExist && !audioExist) {
+            MP4Parser.moovToTrack(moov, videoTrack, audioTrack);
+          }
+          var moofBoxes = [];
+          if (this.__nextMoofStart < 0) {
+            MP4Parser.findBox(data, ["moof"], dataStart).forEach(function(v) {
+              return moofBoxes.push(v);
+            });
+          } else if (this.__nextMoofStart >= dataStart && this.__nextMoofStart <= dataEnd - 8) {
+            MP4Parser.findBox(data.subarray(this.__nextMoofStart - dataStart), ["moof"], this.__nextMoofStart).forEach(function(v) {
+              return moofBoxes.push(v);
+            });
+          }
+          moofBoxes.filter(function(moofBox) {
+            return moofBox.size <= moofBox.data.length;
+          }).forEach(function(moofBox) {
+            var moof = MP4Parser.moof(moofBox);
+            _this.__nextMoofStart = moof.start + Math.max.apply(Math, _toConsumableArray(moof.traf.map(function(v) {
+              return v.trun.samples.reduce(function(ret, w) {
+                return ret + w.size;
+              }, v.trun.dataOffset || 0);
+            })));
+            _this.__loadedMoofWraps.push({
+              start: moof.start,
+              nextMoofStart: _this.__nextMoofStart,
+              moof
+            });
+            _this.__loadedMoofWraps.sort(function(p, n) {
+              return p.start - n.start;
+            });
+          });
+          var _iterator = _createForOfIteratorHelper(this.__loadedMoofWraps), _step;
+          try {
+            var _loop = function _loop2() {
+              var moofWrap = _step.value;
+              if (moofWrap.start > dataEnd || moofWrap.nextMoofStart < dataStart) {
+                return "continue";
+              }
+              var moofStart = moofWrap.start;
+              var tracks = MP4Parser.moofToSamples(moofWrap.moof, videoTrack, audioTrack);
+              var videoBaseMediaDecodeTime = videoTrack.baseMediaDecodeTime;
+              var audioBaseMediaDecodeTime = audioTrack.baseMediaDecodeTime;
+              var nalSize;
+              Object.keys(tracks).forEach(function(k) {
+                if (videoTrack.id == k) {
+                  tracks[k].some(function(x) {
+                    var xStart = x.offset += moofStart;
+                    if (xStart < dataStart) {
+                      return;
+                    }
+                    if (xStart + x.size > dataEnd) {
+                      return true;
+                    }
+                    var sample = new VideoSample((x.pts || x.dts) + videoBaseMediaDecodeTime, x.dts + videoBaseMediaDecodeTime);
+                    sample.duration = x.duration;
+                    sample.gopId = x.gopId;
+                    if (x.keyframe)
+                      sample.setToKeyframe();
+                    var sampleData = data.subarray(xStart - dataStart, xStart - dataStart + x.size);
+                    sample.data = sampleData;
+                    if (!isAV01) {
+                      var start = 0;
+                      var len = sampleData.length - 1;
+                      while (start < len) {
+                        nalSize = readBig32(sampleData, start);
+                        start += 4;
+                        sample.units.push(sampleData.subarray(start, start + nalSize));
+                        start += nalSize;
+                      }
+                    }
+                    _this.__lastRemainDataStart = xStart + x.size;
+                    videoTrack.samples.push(sample);
+                  });
+                } else if (audioTrack.id == k) {
+                  tracks[k].some(function(x) {
+                    var xStart = x.offset + moofStart;
+                    if (xStart < dataStart) {
+                      return;
+                    }
+                    if (xStart + x.size > dataEnd) {
+                      return true;
+                    }
+                    var sampleData = data.subarray(xStart - dataStart, xStart - dataStart + x.size);
+                    audioTrack.samples.push(new AudioSample(x.dts + audioBaseMediaDecodeTime, sampleData, x.duration));
+                    _this.__lastRemainDataStart = xStart + x.size;
+                  });
+                }
+              });
+            };
+            for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+              var _ret = _loop();
+              if (_ret === "continue")
+                continue;
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+        if (this.__lastRemainDataStart > dataStart && this.__lastRemainDataStart < data.byteLength + dataStart) {
+          this.__lastRemainData = data.subarray(this.__lastRemainDataStart - dataStart);
+        } else {
+          this.__lastRemainData = data;
+          this.__lastRemainDataStart = dataStart;
+        }
+        if (videoTrack.samples.length) {
+          videoTrack.baseMediaDecodeTime = videoTrack.samples[0].pts;
+        }
+        if (audioTrack.samples.length) {
+          audioTrack.baseMediaDecodeTime = audioTrack.samples[0].pts;
+        }
+        return {
+          videoTrack,
+          audioTrack,
+          metadataTrack: this.metadataTrack
+        };
+      }
+    }, {
       key: "demux",
       value: function demux(videoData, audioData) {
         var videoTrack = this.videoTrack, audioTrack = this.audioTrack;
@@ -9466,10 +9962,16 @@
           if (track.useEME && track.enca) {
             content = MP42.enca(track);
           } else {
-            content = MP42.mp4a(track);
+            if (track.codecType === AudioCodecType.OPUS) {
+              content = MP42.opus(track);
+            } else {
+              content = MP42.mp4a(track);
+            }
           }
         } else if (track.useEME && track.encv) {
           content = MP42.encv(track);
+        } else if (track.av1C) {
+          content = MP42.av01(track);
         } else {
           content = MP42.avc1hev1(track);
         }
@@ -9683,12 +10185,9 @@
         return MP42.box(MP42.types.sinf, content, MP42.box(MP42.types.frma, frma), MP42.box(MP42.types.schm, schm), schi);
       }
     }, {
-      key: "avc1hev1",
-      value: function avc1hev1(track) {
-        var isHevc = track.codecType === VideoCodecType.HEVC;
-        var typ = isHevc ? MP42.types.hvc1 : MP42.types.avc1;
-        var config = isHevc ? MP42.hvcC(track) : MP42.avcC(track);
-        var boxes = [new Uint8Array([
+      key: "av01",
+      value: function av01(track) {
+        return MP42.box(MP42.types.av01, new Uint8Array([
           0,
           0,
           0,
@@ -9767,48 +10266,135 @@
           24,
           17,
           17
-        ]), config];
-        if (isHevc) {
-          boxes.push(MP42.box(MP42.types.fiel, new Uint8Array([1, 0])));
-        } else if (track.sarRatio && track.sarRatio.length > 1) {
-          boxes.push(MP42.pasp(track.sarRatio));
-        }
-        return MP42.box.apply(MP42, [typ].concat(boxes));
+        ]), track.av1C, track.colr);
       }
     }, {
-      key: "avcC",
-      value: function avcC(track) {
-        var _concat$concat2, _ref2;
-        var sps = [];
-        var pps = [];
-        var len;
-        track.sps.forEach(function(s) {
-          len = s.byteLength;
-          sps.push(len >>> 8 & 255);
-          sps.push(len & 255);
-          sps.push.apply(sps, _toConsumableArray(s));
-        });
-        track.pps.forEach(function(p) {
-          len = p.byteLength;
-          pps.push(len >>> 8 & 255);
-          pps.push(len & 255);
-          pps.push.apply(pps, _toConsumableArray(p));
-        });
-        return MP42.box(MP42.types.avcC, new Uint8Array((_concat$concat2 = (_ref2 = [
+      key: "avc1hev1",
+      value: function avc1hev1(track) {
+        var isHevc = track.codecType === VideoCodecType.HEVC;
+        var typ = isHevc ? MP42.types.hvc1 : MP42.types.avc1;
+        var config = isHevc ? MP42.hvcC(track) : MP42.avcC(track);
+        var boxes = [new Uint8Array([
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
           1,
-          sps[3],
-          sps[4],
-          sps[5],
-          252 | 3,
-          224 | track.sps.length
-        ]).concat.apply(_ref2, sps).concat([track.pps.length])).concat.apply(_concat$concat2, pps)));
-      }
-    }, {
-      key: "hvcC",
-      value: function hvcC(track) {
-        var hvcC2 = track.hvcC;
-        if (hvcC2 instanceof ArrayBuffer || hvcC2 instanceof Uint8Array)
-          return hvcC2;
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          track.width >> 8 & 255,
+          track.width & 255,
+          track.height >> 8 & 255,
+          track.height & 255,
+          0,
+          72,
+          0,
+          0,
+          0,
+          72,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          24,
+          17,
+          17
+        ]), config];
+        if (isHevc) {
+          boxes.push(MP42.box(MP42.types.fiel, new Uint8Array([1, 0])));
+        } else if (track.sarRatio && track.sarRatio.length > 1) {
+          boxes.push(MP42.pasp(track.sarRatio));
+        }
+        return MP42.box.apply(MP42, [typ].concat(boxes));
+      }
+    }, {
+      key: "avcC",
+      value: function avcC(track) {
+        var _concat$concat2, _ref2;
+        var sps = [];
+        var pps = [];
+        var len;
+        track.sps.forEach(function(s) {
+          len = s.byteLength;
+          sps.push(len >>> 8 & 255);
+          sps.push(len & 255);
+          sps.push.apply(sps, _toConsumableArray(s));
+        });
+        track.pps.forEach(function(p) {
+          len = p.byteLength;
+          pps.push(len >>> 8 & 255);
+          pps.push(len & 255);
+          pps.push.apply(pps, _toConsumableArray(p));
+        });
+        return MP42.box(MP42.types.avcC, new Uint8Array((_concat$concat2 = (_ref2 = [
+          1,
+          sps[3],
+          sps[4],
+          sps[5],
+          252 | 3,
+          224 | track.sps.length
+        ]).concat.apply(_ref2, sps).concat([track.pps.length])).concat.apply(_concat$concat2, pps)));
+      }
+    }, {
+      key: "hvcC",
+      value: function hvcC(track) {
+        var hvcC2 = track.hvcC;
+        if (hvcC2 instanceof ArrayBuffer || hvcC2 instanceof Uint8Array)
+          return hvcC2;
         var vps = track.vps, sps = track.sps, pps = track.pps;
         var data;
         if (hvcC2) {
@@ -10052,6 +10638,53 @@
         )));
         return esds2;
       }
+    }, {
+      key: "opus",
+      value: function opus(track) {
+        var opusAudioDescription = new Uint8Array([
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          track.channelCount,
+          0,
+          16,
+          0,
+          0,
+          0,
+          0,
+          track.sampleRate >> 8 & 255,
+          track.sampleRate & 255,
+          0,
+          0
+        ]);
+        var opusSpecificConfig = track.config.length ? MP42.dOps(track) : [];
+        return MP42.box(MP42.types.Opus, opusAudioDescription, opusSpecificConfig);
+      }
+    }, {
+      key: "dOps",
+      value: function dOps(track) {
+        if (track.config) {
+          track.config[4] = track.sampleRate >>> 24 & 255;
+          track.config[5] = track.sampleRate >>> 16 & 255;
+          track.config[6] = track.sampleRate >>> 8 & 255;
+          track.config[7] = track.sampleRate & 255;
+          return MP42.box(MP42.types.dOps, track.config);
+        }
+      }
     }, {
       key: "mvex",
       value: function mvex(tracks) {
@@ -10654,7 +11287,7 @@
     }]);
     return MP42;
   }();
-  _defineProperty(MP4, "types", ["avc1", "avcC", "hvc1", "hvcC", "dinf", "dref", "esds", "ftyp", "hdlr", "mdat", "mdhd", "mdia", "mfhd", "minf", "moof", "moov", "mp4a", "mvex", "mvhd", "pasp", "stbl", "stco", "stsc", "stsd", "stsz", "stts", "tfdt", "tfhd", "traf", "trak", "trex", "tkhd", "vmhd", "smhd", "ctts", "stss", "styp", "pssh", "sidx", "sbgp", "saiz", "saio", "senc", "trun", "encv", "enca", "sinf", "btrt", "frma", "tenc", "schm", "schi", "mehd", "fiel", "sdtp"].reduce(function(p, c) {
+  _defineProperty(MP4, "types", ["Opus", "dOps", "av01", "av1C", "avc1", "avcC", "hvc1", "hvcC", "dinf", "dref", "esds", "ftyp", "hdlr", "mdat", "mdhd", "mdia", "mfhd", "minf", "moof", "moov", "mp4a", "mvex", "mvhd", "pasp", "stbl", "stco", "stsc", "stsd", "stsz", "stts", "tfdt", "tfhd", "traf", "trak", "trex", "tkhd", "vmhd", "smhd", "ctts", "stss", "styp", "pssh", "sidx", "sbgp", "saiz", "saio", "senc", "trun", "encv", "enca", "sinf", "btrt", "frma", "tenc", "schm", "schi", "mehd", "fiel", "sdtp"].reduce(function(p, c) {
     p[c] = [c.charCodeAt(0), c.charCodeAt(1), c.charCodeAt(2), c.charCodeAt(3)];
     return p;
   }, /* @__PURE__ */ Object.create(null)));
@@ -10989,30 +11622,46 @@
           };
         }
         var samples = track.samples;
+        var isAV01 = /av01/.test(track.codec);
         var mdatSize = 0;
-        samples.forEach(function(s) {
-          mdatSize += s.units.reduce(function(t, c) {
-            return t + c.byteLength;
-          }, 0);
-          mdatSize += s.units.length * 4;
-        });
-        var mdata = new Uint8Array(mdatSize);
-        var mdatView = new DataView(mdata.buffer);
-        var _loop = function _loop2(_offset, _sample) {
-          _sample = samples[i];
-          var sampleSize = 0;
-          _sample.units.forEach(function(u) {
-            mdatView.setUint32(_offset, u.byteLength);
-            _offset += 4;
-            mdata.set(u, _offset);
-            _offset += u.byteLength;
-            sampleSize += 4 + u.byteLength;
+        if (isAV01) {
+          samples.forEach(function(s) {
+            mdatSize += s.data.byteLength;
           });
-          _sample.size = sampleSize;
-          offset = _offset, sample = _sample;
-        };
-        for (var i = 0, l = samples.length, offset = 0, sample; i < l; i++) {
-          _loop(offset, sample);
+        } else {
+          samples.forEach(function(s) {
+            mdatSize += s.units.reduce(function(t, c) {
+              return t + c.byteLength;
+            }, 0);
+            mdatSize += s.units.length * 4;
+          });
+        }
+        var mdata = new Uint8Array(mdatSize);
+        if (isAV01) {
+          for (var i = 0, l = samples.length, offset = 0, sample; i < l; i++) {
+            sample = samples[i];
+            mdata.set(sample.data, offset);
+            sample.size = sample.data.byteLength;
+            offset += sample.size;
+          }
+        } else {
+          var mdatView = new DataView(mdata.buffer);
+          var _loop = function _loop2(_offset2, _sample2) {
+            _sample2 = samples[_i];
+            var sampleSize = 0;
+            _sample2.units.forEach(function(u) {
+              mdatView.setUint32(_offset2, u.byteLength);
+              _offset2 += 4;
+              mdata.set(u, _offset2);
+              _offset2 += u.byteLength;
+              sampleSize += 4 + u.byteLength;
+            });
+            _sample2.size = sampleSize;
+            _offset = _offset2, _sample = _sample2;
+          };
+          for (var _i = 0, _l = samples.length, _offset = 0, _sample; _i < _l; _i++) {
+            _loop(_offset, _sample);
+          }
         }
         var mdat = MP4.mdat(mdata);
         var moof = MP4.moof([track]);
@@ -11206,7 +11855,8 @@
           timescale: audioTrack.timescale,
           firstDts: audioTrack.firstDts / videoTrack.timescale,
           firstPts: audioTrack.firstPts / videoTrack.timescale,
-          duration: audioTrack.samplesDuration / videoTrack.timescale
+          duration: audioTrack.samplesDuration / videoTrack.timescale,
+          container: audioTrack.container
         };
         var newId = "".concat(videoTrack.codec, "/").concat(videoTrack.width, "/").concat(videoTrack.height, "/").concat(audioTrack.codec, "/").concat(audioTrack.config);
         if (newId !== this._initSegmentId) {
@@ -11330,7 +11980,7 @@
     }]);
     return Transmuxer2;
   }();
-  var _excluded = ["data"], _excluded2 = ["data"];
+  var _excluded$1 = ["data"], _excluded2 = ["data"];
   var logger$2 = new Logger$2("BufferService");
   var BufferService = /* @__PURE__ */ function() {
     function BufferService2(hls) {
@@ -11496,7 +12146,8 @@
       key: "appendBuffer",
       value: function() {
         var _appendBuffer = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee2(segment, audioSegment, videoChunk, audioChunk, discontinuity, contiguous, startTime) {
-          var p, needInit, _this$_transmuxer$tra, _this$_transmuxer$tra2, video, audio, isFirstAppend, mse, _p, videoData, videoRest, audioData, audioRest;
+          var _this2 = this;
+          var afterAppend, p, needInit, _this$_transmuxer$tra, _this$_transmuxer$tra2, video, audio, isFirstAppend, mse, _p, videoData, videoRest, audioData, audioRest;
           return _regeneratorRuntime$1().wrap(function _callee2$(_context2) {
             while (1)
               switch (_context2.prev = _context2.next) {
@@ -11507,8 +12158,18 @@
                   }
                   return _context2.abrupt("return");
                 case 2:
+                  afterAppend = function afterAppend2() {
+                    var _this2$hls;
+                    if ((_this2$hls = _this2.hls) !== null && _this2$hls !== void 0 && _this2$hls.emit) {
+                      var _this2$hls2;
+                      (_this2$hls2 = _this2.hls) === null || _this2$hls2 === void 0 ? void 0 : _this2$hls2.emit(EVENT.APPEND_BUFFER, {
+                        start: segment.start,
+                        end: segment.end
+                      });
+                    }
+                  };
                   if (!this._directAppend) {
-                    _context2.next = 7;
+                    _context2.next = 8;
                     break;
                   }
                   p = [];
@@ -11516,8 +12177,8 @@
                     p.push(this._mse.append(MSE.VIDEO, videoChunk));
                   if (audioChunk)
                     p.push(this._mse.append(MSE.AUDIO, audioChunk));
-                  return _context2.abrupt("return", Promise.all(p));
-                case 7:
+                  return _context2.abrupt("return", Promise.all(p).then(afterAppend));
+                case 8:
                   needInit = this._needInitSegment || discontinuity;
                   _this$_transmuxer$tra = this._transmuxer.transmux(videoChunk, audioChunk, needInit, contiguous, startTime, this._needInitSegment || discontinuity), _this$_transmuxer$tra2 = _slicedToArray$1(_this$_transmuxer$tra, 2), video = _this$_transmuxer$tra2[0], audio = _this$_transmuxer$tra2[1];
                   if (audioChunk && audioSegment) {
@@ -11533,21 +12194,22 @@
                     this.hls.emit(Event$1.NO_AUDIO_TRACK);
                   }
                   if (!this._softVideo) {
-                    _context2.next = 18;
+                    _context2.next = 20;
                     break;
                   }
                   this._softVideo.appendBuffer(video, audio);
                   this._needInitSegment = false;
-                  _context2.next = 28;
+                  afterAppend();
+                  _context2.next = 30;
                   break;
-                case 18:
+                case 20:
                   if (!this._mse) {
-                    _context2.next = 28;
+                    _context2.next = 30;
                     break;
                   }
                   isFirstAppend = !this._sourceCreated;
                   if (isFirstAppend) {
-                    this._createMseSource(video === null || video === void 0 ? void 0 : video.codec, audio === null || audio === void 0 ? void 0 : audio.codec);
+                    this._createMseSource(video === null || video === void 0 ? void 0 : video.codec, audio === null || audio === void 0 ? void 0 : audio.codec, audio === null || audio === void 0 ? void 0 : audio.container);
                   }
                   this._needInitSegment = false;
                   mse = this._mse;
@@ -11558,15 +12220,15 @@
                     });
                   }
                   if (video) {
-                    videoData = video.data, videoRest = _objectWithoutProperties$1(video, _excluded);
+                    videoData = video.data, videoRest = _objectWithoutProperties$1(video, _excluded$1);
                     _p.push(mse.append(MSE.VIDEO, videoData, videoRest));
                   }
                   if (audio) {
                     audioData = audio.data, audioRest = _objectWithoutProperties$1(audio, _excluded2);
                     _p.push(mse.append(MSE.AUDIO, audioData, audioRest));
                   }
-                  return _context2.abrupt("return", Promise.all(_p));
-                case 28:
+                  return _context2.abrupt("return", Promise.all(_p).then(afterAppend));
+                case 30:
                 case "end":
                   return _context2.stop();
               }
@@ -11581,7 +12243,7 @@
       key: "removeBuffer",
       value: function() {
         var _removeBuffer = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee3() {
-          var _this2 = this;
+          var _this3 = this;
           var start, end, media, _args3 = arguments;
           return _regeneratorRuntime$1().wrap(function _callee3$(_context3) {
             while (1)
@@ -11597,7 +12259,7 @@
                   return _context3.abrupt("return");
                 case 5:
                   return _context3.abrupt("return", this._mse.clearBuffer(start, end).then(function() {
-                    return _this2.hls.emit(EVENT.REMOVE_BUFFER, {
+                    return _this3.hls.emit(EVENT.REMOVE_BUFFER, {
                       start,
                       end,
                       removeEnd: end
@@ -11778,30 +12440,51 @@
         return setLiveSeekableRange;
       }()
     }, {
-      key: "destroy",
+      key: "detachMedia",
       value: function() {
-        var _destroy = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee9() {
-          var _this$_decryptor;
+        var _detachMedia = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee9() {
           return _regeneratorRuntime$1().wrap(function _callee9$(_context9) {
             while (1)
               switch (_context9.prev = _context9.next) {
                 case 0:
-                  (_this$_decryptor = this._decryptor) === null || _this$_decryptor === void 0 ? void 0 : _this$_decryptor.destroy();
                   if (!this._mse) {
-                    _context9.next = 4;
+                    _context9.next = 3;
                     break;
                   }
-                  _context9.next = 4;
+                  _context9.next = 3;
                   return this._mse.unbindMedia();
-                case 4:
+                case 3:
+                case "end":
+                  return _context9.stop();
+              }
+          }, _callee9, this);
+        }));
+        function detachMedia() {
+          return _detachMedia.apply(this, arguments);
+        }
+        return detachMedia;
+      }()
+    }, {
+      key: "destroy",
+      value: function() {
+        var _destroy = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee10() {
+          var _this$_decryptor;
+          return _regeneratorRuntime$1().wrap(function _callee10$(_context10) {
+            while (1)
+              switch (_context10.prev = _context10.next) {
+                case 0:
+                  (_this$_decryptor = this._decryptor) === null || _this$_decryptor === void 0 ? void 0 : _this$_decryptor.destroy();
+                  _context10.next = 3;
+                  return this.detachMedia();
+                case 3:
                   this._decryptor = null;
                   this._mse = null;
                   this._softVideo = null;
-                case 7:
+                case 6:
                 case "end":
-                  return _context9.stop();
+                  return _context10.stop();
               }
-          }, _callee9, this);
+          }, _callee10, this);
         }));
         function destroy() {
           return _destroy.apply(this, arguments);
@@ -11810,7 +12493,7 @@
       }()
     }, {
       key: "_createMseSource",
-      value: function _createMseSource(videoCodec, audioCodec) {
+      value: function _createMseSource(videoCodec, audioCodec, container) {
         logger$2.debug("create mse source, videoCodec=".concat(videoCodec, ", audioCodec=").concat(audioCodec));
         var mse = this._mse;
         if (!mse)
@@ -11822,6 +12505,9 @@
         if (audioCodec) {
           mse.createSource(MSE.AUDIO, "audio/mp4;codecs=".concat(audioCodec));
           this._sourceCreated = true;
+        } else if (container) {
+          mse.createSource(MSE.AUDIO, "".concat(container, ';codecs=""'));
+          this._sourceCreated = true;
         }
         this.hls.emit(EVENT.SOURCEBUFFER_CREATED);
       }
@@ -12131,6 +12817,31 @@
     }]);
     return MediaSegmentKey2;
   }();
+  var HlsUrlParameters = /* @__PURE__ */ function() {
+    function HlsUrlParameters2(msn, part, skip) {
+      _classCallCheck$3(this, HlsUrlParameters2);
+      this.msn = msn;
+      this.part = part;
+      this.skip = skip;
+    }
+    _createClass$3(HlsUrlParameters2, [{
+      key: "addDirectives",
+      value: function addDirectives(uri) {
+        var url = new self.URL(uri);
+        if (this.msn !== void 0) {
+          url.searchParams.set("_HLS_msn", this.msn.toString());
+        }
+        if (this.part) {
+          url.searchParams.set("_HLS_part", this.part.toString());
+        }
+        if (this.skip) {
+          url.searchParams.set("_HLS_skip", this.skip);
+        }
+        return url.href;
+      }
+    }]);
+    return HlsUrlParameters2;
+  }();
   var REGEXP_TAG = /^#(EXT[^:]*)(?::(.*))?$/;
   var REGEXP_ATTR = /([^=]+)=(?:"([^"]*)"|([^",]*))(?:,|$)/g;
   var REGEXP_ABSOLUTE_URL = /^(?:[a-zA-Z0-9+\-.]+:)?\/\//;
@@ -12369,7 +13080,7 @@
             media.canBlockReload = _attr["CAN-BLOCK-RELOAD"] === "YES";
             media.partHoldBack = parseFloat(_attr["PART-HOLD-BACK"] || 0);
             media.canSkipUntil = parseFloat(_attr["CAN-SKIP-UNTIL"] || 0);
-            media.canSkipDateRanges = _attr["CAN-SKIP-DATERANGES"] === "YES";
+            media.canSkipDateRanges = media.canSkipUntil > 0 && _attr["CAN-SKIP-DATERANGES"] === "YES";
           }
           break;
         case "ENDLIST":
@@ -12413,6 +13124,15 @@
           }
           break;
         case "PRELOAD-HINT":
+          {
+            var _attr3 = parseAttr(data);
+            media.preloadHint = _attr3;
+            if (_attr3["TYPE"] === "PART" && _attr3["URI"]) {
+              var tmp = _attr3["URI"].split(".ts")[0].split("-");
+              media.nextSN = tmp[3];
+              media.nextIndex = tmp[tmp.length - 1];
+            }
+          }
           break;
         case "PROGRAM-DATE-TIME":
           curSegment.dataTime = data;
@@ -12432,21 +13152,21 @@
           break;
         case "KEY":
           {
-            var _attr3 = parseAttr(data);
-            if (_attr3.METHOD === "NONE") {
+            var _attr4 = parseAttr(data);
+            if (_attr4.METHOD === "NONE") {
               curKey = null;
               break;
             }
             curKey = new MediaSegmentKey();
-            curKey.method = _attr3.METHOD;
-            curKey.url = /^blob:/.test(_attr3.URI) ? _attr3.URI : getAbsoluteUrl(_attr3.URI, parentUrl);
-            curKey.keyFormat = _attr3.KEYFORMAT || "identity";
-            curKey.keyFormatVersions = _attr3.KEYFORMATVERSIONS;
+            curKey.method = _attr4.METHOD;
+            curKey.url = /^blob:/.test(_attr4.URI) ? _attr4.URI : getAbsoluteUrl(_attr4.URI, parentUrl);
+            curKey.keyFormat = _attr4.KEYFORMAT || "identity";
+            curKey.keyFormatVersions = _attr4.KEYFORMATVERSIONS;
             if (!curKey.isSupported()) {
-              throw new Error("encrypt ".concat(_attr3.METHOD, "/").concat(_attr3.KEYFORMAT, " is not supported"));
+              throw new Error("encrypt ".concat(_attr4.METHOD, "/").concat(_attr4.KEYFORMAT, " is not supported"));
             }
-            if (_attr3.IV) {
-              var str = _attr3.IV.slice(2);
+            if (_attr4.IV) {
+              var str = _attr4.IV.slice(2);
               str = (str.length & 1 ? "0" : "") + str;
               curKey.iv = new Uint8Array(str.length / 2);
               for (var i = 0, l = str.length / 2; i < l; i++) {
@@ -12457,10 +13177,10 @@
           break;
         case "MAP":
           {
-            var _attr4 = parseAttr(data);
-            curSegment.url = getAbsoluteUrl(_attr4.URI, parentUrl);
-            if (_attr4.BYTERANGE)
-              curSegment.setByteRange(_attr4.BYTERANGE);
+            var _attr5 = parseAttr(data);
+            curSegment.url = getAbsoluteUrl(_attr5.URI, parentUrl);
+            if (_attr5.BYTERANGE)
+              curSegment.setByteRange(_attr5.BYTERANGE);
             curSegment.isInitSegment = true;
             curSegment.sn = 0;
             if (curKey) {
@@ -12472,24 +13192,25 @@
           break;
         case "SKIP":
           {
-            var _attr5 = parseAttr(data);
-            var skippedSegments = parseInt(_attr5["SKIPPED-SEGMENTS"], 10);
+            var _attr6 = parseAttr(data);
+            var skippedSegments = parseInt(_attr6["SKIPPED-SEGMENTS"], 10);
             if (skippedSegments <= Number.MAX_SAFE_INTEGER) {
               media.skippedSegments += skippedSegments;
+              curSN += 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);
+            var _attr7 = parseAttr(data);
+            var dateRangeWithSameId = media.dateRanges[_attr7.ID];
+            _attr7._startDate = dateRangeWithSameId ? dateRangeWithSameId._startDate : new Date(_attr7["START-DATE"]);
+            var endDate = (dateRangeWithSameId === null || dateRangeWithSameId === void 0 ? void 0 : dateRangeWithSameId._endDate) || new Date(_attr7.END_DATE);
             if (Number.isFinite(endDate)) {
-              _attr6._endDate = endDate;
+              _attr7._endDate = endDate;
             }
-            if (isValidDaterange(_attr6, dateRangeWithSameId) || media.skippedSegments) {
-              media.dateRanges[_attr6.ID] = _attr6;
+            if (isValidDaterange(_attr7, dateRangeWithSameId) || media.skippedSegments) {
+              media.dateRanges[_attr7.ID] = _attr7;
             }
           }
           break;
@@ -12686,6 +13407,13 @@
                         playlist
                       });
                     } else {
+                      if (this._useLowLatency) {
+                        if (playlist.canBlockReload) {
+                          this.deliveryDirectives = new HlsUrlParameters(playlist.nextSN, playlist.nextIndex, "");
+                        } else {
+                          this.deliveryDirectives = null;
+                        }
+                      }
                       this.hls.emit(Event$1.HLS_LEVEL_LOADED, {
                         playlist
                       });
@@ -12742,41 +13470,45 @@
         var retryCount = this.hls.config.pollRetryCount;
         var fn = /* @__PURE__ */ function() {
           var _ref2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee2() {
-            var res;
+            var reqUrl, res;
             return _regeneratorRuntime$1().wrap(function _callee2$(_context2) {
               while (1)
                 switch (_context2.prev = _context2.next) {
                   case 0:
                     clearTimeout(_this2._timer);
-                    _context2.prev = 1;
-                    _context2.next = 4;
-                    return _this2.load(url, audioUrl, subtitleUrl);
-                  case 4:
+                    reqUrl = url;
+                    _context2.prev = 2;
+                    if (_this2.deliveryDirectives) {
+                      reqUrl = _this2.deliveryDirectives.addDirectives(url);
+                    }
+                    _context2.next = 6;
+                    return _this2.load(reqUrl, audioUrl, subtitleUrl);
+                  case 6:
                     res = _context2.sent;
                     if (res[0]) {
-                      _context2.next = 7;
+                      _context2.next = 9;
                       break;
                     }
                     return _context2.abrupt("return");
-                  case 7:
+                  case 9:
                     retryCount = _this2.hls.config.pollRetryCount;
                     cb(res[0], res[1], res[2]);
-                    _context2.next = 15;
+                    _context2.next = 17;
                     break;
-                  case 11:
-                    _context2.prev = 11;
-                    _context2.t0 = _context2["catch"](1);
+                  case 13:
+                    _context2.prev = 13;
+                    _context2.t0 = _context2["catch"](2);
                     retryCount--;
                     if (retryCount <= 0) {
                       errorCb(_context2.t0);
                     }
-                  case 15:
+                  case 17:
                     _this2._timer = setTimeout(fn, time);
-                  case 16:
+                  case 18:
                   case "end":
                     return _context2.stop();
                 }
-            }, _callee2, null, [[1, 11]]);
+            }, _callee2, null, [[2, 13]]);
           }));
           return function fn2() {
             return _ref2.apply(this, arguments);
@@ -13306,7 +14038,7 @@
     }, {
       key: "clearOldSegment",
       value: function clearOldSegment() {
-        var maxPlaylistSize = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 50;
+        var maxPlaylistSize = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.hls.config.maxPlaylistSize || 50;
         var stream = this.currentStream;
         if (!this.dvrWindow || !stream)
           return;
@@ -13817,7 +14549,6 @@
           return;
         _this._startTick();
         var media = _this.media;
-        var buffered = Buffer$1.get(media);
         var segLoaderError = _this._segmentLoader.error;
         _this._onCheckQuotaExceeded();
         if (_this._isProcessQuotaExceeded) {
@@ -13834,7 +14565,7 @@
           }
           return;
         }
-        if (Buffer$1.end(buffered) >= 0.1 && media.readyState) {
+        if (media.readyState) {
           if (isMediaPlaying(media)) {
             _this._loadSegment();
             if (_this._gapService) {
@@ -13900,6 +14631,12 @@
         var _this$_bufferService;
         return (_this$_bufferService = this._bufferService) === null || _this$_bufferService === void 0 ? void 0 : _this$_bufferService.baseDts;
       }
+    }, {
+      key: "abrSwitchPoint",
+      get: function get() {
+        var targetSeg = this._urlSwitching ? this._playlist.currentSegment : this._playlist.nextSegment;
+        return targetSeg ? targetSeg.start + targetSeg.duration / 2 : null;
+      }
     }, {
       key: "speedInfo",
       value: function speedInfo() {
@@ -13925,30 +14662,37 @@
     }, {
       key: "load",
       value: function() {
-        var _load = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee4(url) {
-          var reuseMse, _args4 = arguments;
+        var _load = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee4() {
+          var url, options, reuseMse, _args4 = arguments;
           return _regeneratorRuntime$1().wrap(function _callee4$(_context4) {
             while (1)
               switch (_context4.prev = _context4.next) {
                 case 0:
-                  reuseMse = _args4.length > 1 && _args4[1] !== void 0 ? _args4[1] : false;
+                  url = _args4.length > 0 && _args4[0] !== void 0 ? _args4[0] : "";
+                  options = _args4.length > 1 && _args4[1] !== void 0 ? _args4[1] : {};
+                  reuseMse = typeof options === "boolean" ? options : !!(options !== null && options !== void 0 && options.reuseMse);
+                  if (_typeof$2(options) === "object" && options !== null && options !== void 0 && options.clearSwitchStatus) {
+                    this._urlSwitching = false;
+                    this._switchUrlOpts = null;
+                    this.config.startTime = void 0;
+                  }
                   if (url)
                     this.config.url = url;
                   url = this.config.url;
-                  _context4.next = 5;
+                  _context4.next = 8;
                   return this._reset(reuseMse);
-                case 5:
-                  _context4.next = 7;
+                case 8:
+                  _context4.next = 10;
                   return this._loadData(url);
-                case 7:
+                case 10:
                   this._startTick();
-                case 8:
+                case 11:
                 case "end":
                   return _context4.stop();
               }
           }, _callee4, this);
         }));
-        function load(_x) {
+        function load() {
           return _load.apply(this, arguments);
         }
         return load;
@@ -13957,7 +14701,7 @@
       key: "_loadData",
       value: function() {
         var _loadData2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee5(url) {
-          var manifest, currentStream, _this$_switchUrlOpts, _this$_switchUrlOpts2, switchTimePoint, segIdx, nextSeg, bufferClearStartPoint, preIndex, startTime, _this$_switchUrlOpts3;
+          var manifest, currentStream, preIndex, _this$_switchUrlOpts, _this$_switchUrlOpts3, _this$_switchUrlOpts4, _this$_switchUrlOpts2, switchTimePoint, segIdx, nextSeg, bufferClearStartPoint, startTime, _this$_switchUrlOpts5;
           return _regeneratorRuntime$1().wrap(function _callee5$(_context5) {
             while (1)
               switch (_context5.prev = _context5.next) {
@@ -13978,41 +14722,46 @@
                 case 5:
                   manifest = _context5.sent;
                   currentStream = this._playlist.currentStream;
-                  if (!(this._urlSwitching && !this.isLive)) {
-                    _context5.next = 17;
+                  if (!this._urlSwitching) {
+                    _context5.next = 23;
                     break;
                   }
+                  if (!this.isLive) {
+                    _context5.next = 14;
+                    break;
+                  }
+                  preIndex = this._playlist.setNextSegmentBySN(this._prevSegSn);
+                  logger.log("segment nb=".concat(this._prevSegSn, " index of ").concat(preIndex, " in the new playlist"));
+                  if (preIndex === -1) {
+                    this._prevSegCc = null;
+                    this._prevSegSn = null;
+                  }
+                  _context5.next = 23;
+                  break;
+                case 14:
                   if (currentStream.bitrate === 0 && (_this$_switchUrlOpts = this._switchUrlOpts) !== null && _this$_switchUrlOpts !== void 0 && _this$_switchUrlOpts.bitrate) {
                     currentStream.bitrate = (_this$_switchUrlOpts2 = this._switchUrlOpts) === null || _this$_switchUrlOpts2 === void 0 ? void 0 : _this$_switchUrlOpts2.bitrate;
                   }
-                  switchTimePoint = this._getSeamlessSwitchPoint();
+                  switchTimePoint = typeof ((_this$_switchUrlOpts3 = this._switchUrlOpts) === null || _this$_switchUrlOpts3 === void 0 ? void 0 : _this$_switchUrlOpts3.startTime) === "number" ? (_this$_switchUrlOpts4 = this._switchUrlOpts) === null || _this$_switchUrlOpts4 === void 0 ? void 0 : _this$_switchUrlOpts4.startTime : this._getSeamlessSwitchPoint();
                   this.config.startTime = switchTimePoint;
                   segIdx = this._playlist.findSegmentIndexByTime(switchTimePoint);
                   nextSeg = this._playlist.getSegmentByIndex(segIdx + 1);
                   if (!nextSeg) {
-                    _context5.next = 17;
+                    _context5.next = 23;
                     break;
                   }
                   bufferClearStartPoint = nextSeg.start;
-                  _context5.next = 17;
+                  _context5.next = 23;
                   return this._bufferService.removeBuffer(bufferClearStartPoint);
-                case 17:
-                  if (this._urlSwitching && this.isLive) {
-                    preIndex = this._playlist.setNextSegmentBySN(this._prevSegSn);
-                    logger.log("segment nb=".concat(this._prevSegSn, " index of ").concat(preIndex, " in the new playlist"));
-                    if (preIndex === -1) {
-                      this._prevSegCc = null;
-                      this._prevSegSn = null;
-                    }
-                  }
+                case 23:
                   if (manifest) {
-                    _context5.next = 20;
+                    _context5.next = 25;
                     break;
                   }
                   return _context5.abrupt("return");
-                case 20:
+                case 25:
                   if (!this.isLive) {
-                    _context5.next = 31;
+                    _context5.next = 36;
                     break;
                   }
                   this._bufferService.setLiveSeekableRange(0, 4294967295);
@@ -14025,35 +14774,35 @@
                   if (!manifest.isMaster)
                     this._pollM3U8(url);
                   if (!(this._playlist.nbSegments < this.config.minSegmentsStartPlay)) {
-                    _context5.next = 28;
+                    _context5.next = 33;
                     break;
                   }
                   return _context5.abrupt("return");
-                case 28:
-                  _context5.next = 30;
+                case 33:
+                  _context5.next = 35;
                   return this._loadSegment();
-                case 30:
+                case 35:
                   return _context5.abrupt("return");
-                case 31:
-                  _context5.next = 33;
+                case 36:
+                  _context5.next = 38;
                   return this._bufferService.updateDuration(currentStream.totalDuration);
-                case 33:
+                case 38:
                   startTime = this.config.startTime;
                   if (startTime) {
-                    if (!((_this$_switchUrlOpts3 = this._switchUrlOpts) !== null && _this$_switchUrlOpts3 !== void 0 && _this$_switchUrlOpts3.seamless)) {
+                    if (!((_this$_switchUrlOpts5 = this._switchUrlOpts) !== null && _this$_switchUrlOpts5 !== void 0 && _this$_switchUrlOpts5.seamless)) {
                       this.media.currentTime = startTime;
                     }
                     this._playlist.setNextSegmentByIndex(this._playlist.findSegmentIndexByTime(startTime) || 0);
                   }
-                  _context5.next = 37;
+                  _context5.next = 42;
                   return this._loadSegment();
-                case 37:
+                case 42:
                 case "end":
                   return _context5.stop();
               }
           }, _callee5, this);
         }));
-        function _loadData(_x2) {
+        function _loadData(_x) {
           return _loadData2.apply(this, arguments);
         }
         return _loadData;
@@ -14067,18 +14816,20 @@
               switch (_context6.prev = _context6.next) {
                 case 0:
                   this.config.startTime = 0;
-                  _context6.next = 3;
+                  this._urlSwitching = false;
+                  this._switchUrlOpts = null;
+                  _context6.next = 5;
                   return this.load();
-                case 3:
+                case 5:
                   this._reloadOnPlay = false;
                   return _context6.abrupt("return", this.media.play(!isPlayEmit));
-                case 5:
+                case 7:
                 case "end":
                   return _context6.stop();
               }
           }, _callee6, this);
         }));
-        function replay(_x3) {
+        function replay(_x2) {
           return _replay.apply(this, arguments);
         }
         return replay;
@@ -14183,7 +14934,7 @@
               }
           }, _callee7, this, [[18, 29]]);
         }));
-        function switchURL(_x4) {
+        function switchURL(_x3) {
           return _switchURL.apply(this, arguments);
         }
         return switchURL;
@@ -14269,7 +15020,7 @@
               }
           }, _callee8, this, [[8, 16], [21, 31]]);
         }));
-        function switchStream(_x5) {
+        function switchStream(_x4) {
           return _switchStream.apply(this, arguments);
         }
         return switchStream;
@@ -14355,7 +15106,7 @@
               }
           }, _callee9, this, [[10, 18], [22, 32]]);
         }));
-        function switchAudioStream(_x6) {
+        function switchAudioStream(_x5) {
           return _switchAudioStream.apply(this, arguments);
         }
         return switchAudioStream;
@@ -14380,25 +15131,50 @@
               }
           }, _callee10, this);
         }));
-        function switchSubtitleStream(_x7) {
+        function switchSubtitleStream(_x6) {
           return _switchSubtitleStream.apply(this, arguments);
         }
         return switchSubtitleStream;
       }()
     }, {
-      key: "destroy",
+      key: "detachMedia",
       value: function() {
-        var _destroy = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee11() {
-          var _this$_seiService2;
+        var _detachMedia = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee11() {
           return _regeneratorRuntime$1().wrap(function _callee11$(_context11) {
             while (1)
               switch (_context11.prev = _context11.next) {
+                case 0:
+                  if (!this._bufferService) {
+                    _context11.next = 3;
+                    break;
+                  }
+                  _context11.next = 3;
+                  return this._bufferService.detachMedia();
+                case 3:
+                case "end":
+                  return _context11.stop();
+              }
+          }, _callee11, this);
+        }));
+        function detachMedia() {
+          return _detachMedia.apply(this, arguments);
+        }
+        return detachMedia;
+      }()
+    }, {
+      key: "destroy",
+      value: function() {
+        var _destroy = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee12() {
+          var _this$_seiService2;
+          return _regeneratorRuntime$1().wrap(function _callee12$(_context12) {
+            while (1)
+              switch (_context12.prev = _context12.next) {
                 case 0:
                   if (this.media) {
-                    _context11.next = 2;
+                    _context12.next = 2;
                     break;
                   }
-                  return _context11.abrupt("return");
+                  return _context12.abrupt("return");
                 case 2:
                   this.removeAllListeners();
                   this._playlist.reset();
@@ -14409,15 +15185,15 @@
                   this.media.removeEventListener("pause", this._onPause);
                   this.media.removeEventListener("seeking", this._onSeeking);
                   this.media.removeEventListener("timeupdate", this._onTimeupdate);
-                  _context11.next = 13;
+                  _context12.next = 13;
                   return Promise.all([this._clear(), this._bufferService.destroy()]);
                 case 13:
                   this.media = null;
                 case 14:
                 case "end":
-                  return _context11.stop();
+                  return _context12.stop();
               }
-          }, _callee11, this);
+          }, _callee12, this);
         }));
         function destroy() {
           return _destroy.apply(this, arguments);
@@ -14427,48 +15203,48 @@
     }, {
       key: "_loadM3U8",
       value: function() {
-        var _loadM3U = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee12(url) {
+        var _loadM3U = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee13(url) {
           var playlist, _this$config$manifest, _this$config$manifest2, manifest, _ref4, _ref5, _this$_playlist$curre;
-          return _regeneratorRuntime$1().wrap(function _callee12$(_context12) {
+          return _regeneratorRuntime$1().wrap(function _callee13$(_context13) {
             while (1)
-              switch (_context12.prev = _context12.next) {
+              switch (_context13.prev = _context13.next) {
                 case 0:
-                  _context12.prev = 0;
+                  _context13.prev = 0;
                   manifest = (_this$config$manifest = this.config.manifestList) === null || _this$config$manifest === void 0 ? void 0 : (_this$config$manifest2 = _this$config$manifest.filter(function(x) {
                     return x.url === url;
                   })[0]) === null || _this$config$manifest2 === void 0 ? void 0 : _this$config$manifest2.manifest;
                   if (!manifest) {
-                    _context12.next = 6;
+                    _context13.next = 6;
                     break;
                   }
-                  _context12.t0 = this._manifestLoader.parseText(manifest, url);
-                  _context12.next = 9;
+                  _context13.t0 = this._manifestLoader.parseText(manifest, url);
+                  _context13.next = 9;
                   break;
                 case 6:
-                  _context12.next = 8;
+                  _context13.next = 8;
                   return this._manifestLoader.load(url);
                 case 8:
-                  _context12.t0 = _context12.sent;
+                  _context13.t0 = _context13.sent;
                 case 9:
-                  _ref4 = _context12.t0;
+                  _ref4 = _context13.t0;
                   _ref5 = _slicedToArray$1(_ref4, 1);
                   playlist = _ref5[0];
-                  _context12.next = 17;
+                  _context13.next = 17;
                   break;
                 case 14:
-                  _context12.prev = 14;
-                  _context12.t1 = _context12["catch"](0);
-                  throw this._emitError(StreamingError.create(_context12.t1));
+                  _context13.prev = 14;
+                  _context13.t1 = _context13["catch"](0);
+                  throw this._emitError(StreamingError.create(_context13.t1));
                 case 17:
                   if (playlist) {
-                    _context12.next = 19;
+                    _context13.next = 19;
                     break;
                   }
-                  return _context12.abrupt("return");
+                  return _context13.abrupt("return");
                 case 19:
                   this._playlist.upsertPlaylist(playlist);
                   if (!playlist.isMaster) {
-                    _context12.next = 24;
+                    _context13.next = 24;
                     break;
                   }
                   if ((_this$_playlist$curre = this._playlist.currentStream.subtitleStreams) !== null && _this$_playlist$curre !== void 0 && _this$_playlist$curre.length) {
@@ -14476,18 +15252,18 @@
                       list: this._playlist.currentStream.subtitleStreams
                     });
                   }
-                  _context12.next = 24;
+                  _context13.next = 24;
                   return this._refreshM3U8();
                 case 24:
                   this.emit(Event$1.STREAM_PARSED);
-                  return _context12.abrupt("return", playlist);
+                  return _context13.abrupt("return", playlist);
                 case 26:
                 case "end":
-                  return _context12.stop();
+                  return _context13.stop();
               }
-          }, _callee12, this, [[0, 14]]);
+          }, _callee13, this, [[0, 14]]);
         }));
-        function _loadM3U8(_x8) {
+        function _loadM3U8(_x7) {
           return _loadM3U.apply(this, arguments);
         }
         return _loadM3U8;
@@ -14521,7 +15297,7 @@
         var isEmpty = this._playlist.isEmpty;
         var pollInterval;
         if (this._playlist.lowLatency) {
-          pollInterval = (this._playlist.currentStream.partTargetDuration * 2 || 0) * 1e3;
+          pollInterval = (this._playlist.currentStream.partTargetDuration || 0) * 1e3;
         } else {
           var _this$_playlist$lastS;
           pollInterval = (((_this$_playlist$lastS = this._playlist.lastSegment) === null || _this$_playlist$lastS === void 0 ? void 0 : _this$_playlist$lastS.duration) || 0) * 1e3;
@@ -14549,53 +15325,53 @@
     }, {
       key: "_loadSegmentDirect",
       value: function() {
-        var _loadSegmentDirect2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee13(loadOnce) {
+        var _loadSegmentDirect2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee14(loadOnce) {
           var seg, appended, cachedError, _this$_playlist$curre2, bufferEnd, sameStream;
-          return _regeneratorRuntime$1().wrap(function _callee13$(_context13) {
+          return _regeneratorRuntime$1().wrap(function _callee14$(_context14) {
             while (1)
-              switch (_context13.prev = _context13.next) {
+              switch (_context14.prev = _context14.next) {
                 case 0:
                   seg = this._playlist.nextSegment;
                   if (seg) {
-                    _context13.next = 3;
+                    _context14.next = 3;
                     break;
                   }
-                  return _context13.abrupt("return");
+                  return _context14.abrupt("return");
                 case 3:
                   appended = false;
                   cachedError = null;
-                  _context13.prev = 5;
+                  _context14.prev = 5;
                   this._segmentProcessing = true;
                   logger.log("load segment, sn:".concat(seg.sn, ", [").concat(seg.start, ", ").concat(seg.end, "], partIndex:").concat(seg.partIndex));
-                  _context13.next = 10;
+                  _context14.next = 10;
                   return this._reqAndBufferSegment(seg, this._playlist.getAudioSegment(seg));
                 case 10:
-                  appended = _context13.sent;
-                  _context13.next = 16;
+                  appended = _context14.sent;
+                  _context14.next = 16;
                   break;
                 case 13:
-                  _context13.prev = 13;
-                  _context13.t0 = _context13["catch"](5);
-                  cachedError = _context13.t0;
+                  _context14.prev = 13;
+                  _context14.t0 = _context14["catch"](5);
+                  cachedError = _context14.t0;
                 case 16:
-                  _context13.prev = 16;
+                  _context14.prev = 16;
                   this._segmentProcessing = false;
-                  return _context13.finish(16);
+                  return _context14.finish(16);
                 case 19:
                   if (!cachedError) {
-                    _context13.next = 26;
+                    _context14.next = 26;
                     break;
                   }
                   if (!this._bufferService.isFull()) {
-                    _context13.next = 25;
+                    _context14.next = 25;
                     break;
                   }
                   logger.log("load segment, sn:".concat(seg.sn, ", partIndex:").concat(seg.partIndex));
                   this._segmentProcessing = true;
                   this._isProcessQuotaExceeded = true;
-                  return _context13.abrupt("return", false);
+                  return _context14.abrupt("return", false);
                 case 25:
-                  return _context13.abrupt("return", this._emitError(StreamingError.create(cachedError)));
+                  return _context14.abrupt("return", this._emitError(StreamingError.create(cachedError)));
                 case 26:
                   if (appended) {
                     bufferEnd = this.bufferInfo().end;
@@ -14621,14 +15397,14 @@
                       this._loadSegment();
                     }
                   }
-                  return _context13.abrupt("return", appended);
+                  return _context14.abrupt("return", appended);
                 case 28:
                 case "end":
-                  return _context13.stop();
+                  return _context14.stop();
               }
-          }, _callee13, this, [[5, 13, 16, 19]]);
+          }, _callee14, this, [[5, 13, 16, 19]]);
         }));
-        function _loadSegmentDirect(_x9) {
+        function _loadSegmentDirect(_x8) {
           return _loadSegmentDirect2.apply(this, arguments);
         }
         return _loadSegmentDirect;
@@ -14636,45 +15412,45 @@
     }, {
       key: "_reqAndBufferSegment",
       value: function() {
-        var _reqAndBufferSegment2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee14(seg, audioSeg) {
+        var _reqAndBufferSegment2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee15(seg, audioSeg) {
           var _this$_bufferService2;
           var cc, discontinuity, responses, data, sn, start, stream, before, contiguous, segStart;
-          return _regeneratorRuntime$1().wrap(function _callee14$(_context14) {
+          return _regeneratorRuntime$1().wrap(function _callee15$(_context15) {
             while (1)
-              switch (_context14.prev = _context14.next) {
+              switch (_context15.prev = _context15.next) {
                 case 0:
                   cc = seg ? seg.cc : audioSeg.cc;
                   discontinuity = this._prevSegCc !== cc;
                   responses = [];
-                  _context14.prev = 3;
-                  _context14.next = 6;
+                  _context15.prev = 3;
+                  _context15.next = 6;
                   return this._segmentLoader.load(seg, audioSeg, discontinuity);
                 case 6:
-                  responses = _context14.sent;
-                  _context14.next = 14;
+                  responses = _context15.sent;
+                  _context15.next = 14;
                   break;
                 case 9:
-                  _context14.prev = 9;
-                  _context14.t0 = _context14["catch"](3);
-                  _context14.t0.fatal = false;
-                  this._segmentLoader.error = _context14.t0;
-                  throw _context14.t0;
+                  _context15.prev = 9;
+                  _context15.t0 = _context15["catch"](3);
+                  _context15.t0.fatal = false;
+                  this._segmentLoader.error = _context15.t0;
+                  throw _context15.t0;
                 case 14:
                   if (responses[0]) {
-                    _context14.next = 16;
+                    _context15.next = 16;
                     break;
                   }
-                  return _context14.abrupt("return");
+                  return _context15.abrupt("return");
                 case 16:
-                  _context14.next = 18;
+                  _context15.next = 18;
                   return (_this$_bufferService2 = this._bufferService).decryptBuffer.apply(_this$_bufferService2, _toConsumableArray$2(responses));
                 case 18:
-                  data = _context14.sent;
+                  data = _context15.sent;
                   if (data) {
-                    _context14.next = 21;
+                    _context15.next = 21;
                     break;
                   }
-                  return _context14.abrupt("return");
+                  return _context15.abrupt("return");
                 case 21:
                   sn = seg ? seg.sn : audioSeg.sn;
                   start = seg ? seg.start : audioSeg.start;
@@ -14688,26 +15464,26 @@
                     logger.warn("update the new playlist liveEdge, segment id=".concat(sn, ", buffer start=").concat(segStart, ", liveEdge=").concat(this._playlist.liveEdge));
                     start = segStart;
                   }
-                  _context14.next = 30;
+                  _context15.next = 30;
                   return this._bufferService.appendBuffer(seg, audioSeg, data[0], data[1], discontinuity, contiguous, start);
                 case 30:
                   this.emit(Event$1.APPEND_COST, {
                     elapsed: Date.now() - before,
                     url: seg.url
                   });
-                  _context14.next = 33;
+                  _context15.next = 33;
                   return this._bufferService.evictBuffer(this.config.bufferBehind);
                 case 33:
                   this._prevSegCc = cc;
                   this._prevSegSn = sn;
-                  return _context14.abrupt("return", true);
+                  return _context15.abrupt("return", true);
                 case 36:
                 case "end":
-                  return _context14.stop();
+                  return _context15.stop();
               }
-          }, _callee14, this, [[3, 9]]);
+          }, _callee15, this, [[3, 9]]);
         }));
-        function _reqAndBufferSegment(_x10, _x11) {
+        function _reqAndBufferSegment(_x9, _x10) {
           return _reqAndBufferSegment2.apply(this, arguments);
         }
         return _reqAndBufferSegment;
@@ -14715,11 +15491,11 @@
     }, {
       key: "_onCheckQuotaExceeded",
       value: function() {
-        var _onCheckQuotaExceeded2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee15() {
+        var _onCheckQuotaExceeded2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee16() {
           var seekTime, buffered, inBuffered, i, bufferBehind, mediaTime;
-          return _regeneratorRuntime$1().wrap(function _callee15$(_context15) {
+          return _regeneratorRuntime$1().wrap(function _callee16$(_context16) {
             while (1)
-              switch (_context15.prev = _context15.next) {
+              switch (_context16.prev = _context16.next) {
                 case 0:
                   seekTime = this.media.currentTime;
                   buffered = this.media.buffered;
@@ -14727,37 +15503,37 @@
                   i = 0;
                 case 4:
                   if (!(i < buffered.length)) {
-                    _context15.next = 11;
+                    _context16.next = 11;
                     break;
                   }
                   if (!(buffered.start(0) >= seekTime && seekTime < buffered.end(i))) {
-                    _context15.next = 8;
+                    _context16.next = 8;
                     break;
                   }
                   inBuffered = true;
-                  return _context15.abrupt("break", 11);
+                  return _context16.abrupt("break", 11);
                 case 8:
                   i++;
-                  _context15.next = 4;
+                  _context16.next = 4;
                   break;
                 case 11:
                   if (!this._bufferService.isFull()) {
-                    _context15.next = 17;
+                    _context16.next = 17;
                     break;
                   }
                   bufferBehind = inBuffered ? this.config.bufferBehind : 5;
                   mediaTime = this.media.currentTime;
                   if (!(mediaTime - bufferBehind > 0)) {
-                    _context15.next = 17;
+                    _context16.next = 17;
                     break;
                   }
-                  _context15.next = 17;
+                  _context16.next = 17;
                   return this._bufferService.removeBuffer(0, mediaTime - bufferBehind);
                 case 17:
                 case "end":
-                  return _context15.stop();
+                  return _context16.stop();
               }
-          }, _callee15, this);
+          }, _callee16, this);
         }));
         function _onCheckQuotaExceeded() {
           return _onCheckQuotaExceeded2.apply(this, arguments);
@@ -14775,22 +15551,22 @@
     }, {
       key: "_clear",
       value: function() {
-        var _clear2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee16() {
-          return _regeneratorRuntime$1().wrap(function _callee16$(_context16) {
+        var _clear2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee17() {
+          return _regeneratorRuntime$1().wrap(function _callee17$(_context17) {
             while (1)
-              switch (_context16.prev = _context16.next) {
+              switch (_context17.prev = _context17.next) {
                 case 0:
                   clearTimeout(this._disconnectTimer);
                   this._stopTick();
-                  _context16.next = 4;
+                  _context17.next = 4;
                   return Promise.all([this._segmentLoader.cancel(), this._manifestLoader.stopPoll()]);
                 case 4:
                   this._segmentProcessing = false;
                 case 5:
                 case "end":
-                  return _context16.stop();
+                  return _context17.stop();
               }
-          }, _callee16, this);
+          }, _callee17, this);
         }));
         function _clear() {
           return _clear2.apply(this, arguments);
@@ -14800,14 +15576,14 @@
     }, {
       key: "_reset",
       value: function() {
-        var _reset2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee17() {
+        var _reset2 = _asyncToGenerator$1(/* @__PURE__ */ _regeneratorRuntime$1().mark(function _callee18() {
           var _this$_seiService3;
-          var reuseMse, _args17 = arguments;
-          return _regeneratorRuntime$1().wrap(function _callee17$(_context17) {
+          var reuseMse, _args18 = arguments;
+          return _regeneratorRuntime$1().wrap(function _callee18$(_context18) {
             while (1)
-              switch (_context17.prev = _context17.next) {
+              switch (_context18.prev = _context18.next) {
                 case 0:
-                  reuseMse = _args17.length > 0 && _args17[0] !== void 0 ? _args17[0] : false;
+                  reuseMse = _args18.length > 0 && _args18[0] !== void 0 ? _args18[0] : false;
                   this._reloadOnPlay = false;
                   this._prevSegSn = null;
                   this._prevSegCc = null;
@@ -14816,15 +15592,15 @@
                   this._segmentLoader.reset();
                   (_this$_seiService3 = this._seiService) === null || _this$_seiService3 === void 0 ? void 0 : _this$_seiService3.reset();
                   this._stats.reset();
-                  _context17.next = 11;
+                  _context18.next = 11;
                   return this._clear();
                 case 11:
-                  return _context17.abrupt("return", this._bufferService.reset(reuseMse));
+                  return _context18.abrupt("return", this._bufferService.reset(reuseMse));
                 case 12:
                 case "end":
-                  return _context17.stop();
+                  return _context18.stop();
               }
-          }, _callee17, this);
+          }, _callee18, this);
         }));
         function _reset() {
           return _reset2.apply(this, arguments);
@@ -14942,7 +15718,7 @@
     }]);
     return Hls2;
   }(EventEmitter);
-  _defineProperty$3(Hls, "version", "3.0.20-alpha.2");
+  _defineProperty$3(Hls, "version", "3.0.21-rc.5");
   try {
     if (localStorage.getItem("xgd")) {
       Hls.enableLogger();
@@ -15033,6 +15809,7 @@
     }]);
     return PluginExtension2;
   }();
+  var _excluded = ["currentTime"];
   function parseSwitchUrlArgs(args, plugin) {
     var player = plugin.player;
     var curTime = player.currentTime;
@@ -15043,9 +15820,14 @@
       case "boolean":
         options.seamless = args;
         break;
-      case "object":
-        Object.assign(options, args);
+      case "object": {
+        var currentTime = args.currentTime, rest = _objectWithoutProperties$1(args, _excluded);
+        Object.assign(options, rest);
+        if (typeof currentTime === "number") {
+          options.startTime = currentTime;
+        }
         break;
+      }
     }
     return options;
   }
@@ -15055,10 +15837,11 @@
     function HlsPlugin2() {
       var _this;
       _classCallCheck$3(this, HlsPlugin2);
-      for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
-        _args[_key] = arguments[_key];
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
       }
-      _this = _super.call.apply(_super, [this].concat(_args));
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty$3(_assertThisInitialized$2(_this), "logger", logger);
       _defineProperty$3(_assertThisInitialized$2(_this), "hls", null);
       _defineProperty$3(_assertThisInitialized$2(_this), "pluginExtension", null);
       _defineProperty$3(_assertThisInitialized$2(_this), "getStats", function() {
@@ -15070,24 +15853,6 @@
         var lang = _ref.lang;
         (_this$hls2 = _this.hls) === null || _this$hls2 === void 0 ? void 0 : _this$hls2.switchSubtitleStream(lang);
       });
-      _defineProperty$3(_assertThisInitialized$2(_this), "_onSwitchURL", function(url, args) {
-        return new Promise(function(resolve, reject) {
-          var _assertThisInitialize = _assertThisInitialized$2(_this), player = _assertThisInitialize.player, hls = _assertThisInitialize.hls;
-          if (hls) {
-            var _this$player$config, _this$player$config$h;
-            var options = parseSwitchUrlArgs(args, _assertThisInitialized$2(_this));
-            player.config.url = url;
-            hls.switchURL(url, options).then(function() {
-              return resolve(true);
-            }).catch(reject);
-            if (!options.seamless && (_this$player$config = _this.player.config) !== null && _this$player$config !== void 0 && (_this$player$config$h = _this$player$config.hls) !== null && _this$player$config$h !== void 0 && _this$player$config$h.keepStatusAfterSwitch) {
-              _this._keepPauseStatus();
-            }
-          } else {
-            reject();
-          }
-        });
-      });
       _defineProperty$3(_assertThisInitialized$2(_this), "_keepPauseStatus", function() {
         var paused = _this.player.paused;
         if (!paused)
@@ -15112,8 +15877,8 @@
     }, {
       key: "softDecode",
       get: function get() {
-        var _this$player, _this$player$config2;
-        var mediaType = (_this$player = this.player) === null || _this$player === void 0 ? void 0 : (_this$player$config2 = _this$player.config) === null || _this$player$config2 === void 0 ? void 0 : _this$player$config2.mediaType;
+        var _this$player, _this$player$config;
+        var mediaType = (_this$player = this.player) === null || _this$player === void 0 ? void 0 : (_this$player$config = _this$player.config) === null || _this$player$config === void 0 ? void 0 : _this$player$config.mediaType;
         return !!mediaType && mediaType !== "video" && mediaType !== "audio";
       }
     }, {
@@ -15121,13 +15886,35 @@
       value: function beforePlayerInit() {
         var _this2 = this;
         var config = this.player.config;
+        var mediaElem = this.player.media || this.player.video;
         var hlsOpts = config.hls || {};
         if (!config.url && !config.__allowHlsEmptyUrl__ || !hlsOpts.preferMMS && MSE.isMMSOnly()) {
           return;
         }
         if (this.hls)
           this.hls.destroy();
-        this.player.switchURL = this._onSwitchURL;
+        var descriptor = Object.getOwnPropertyDescriptor(this.player, "switchURL");
+        if (!descriptor || descriptor.writable) {
+          this.player.switchURL = function(url, args) {
+            return new Promise(function(resolve, reject) {
+              var player = _this2.player, hls = _this2.hls;
+              if (hls) {
+                var _this2$player$config, _this2$player$config$;
+                var options = parseSwitchUrlArgs(args, _this2);
+                player.config.url = url;
+                hls.switchURL(url, options).then(function() {
+                  return resolve(true);
+                }).catch(reject);
+                if (!options.seamless && (_this2$player$config = _this2.player.config) !== null && _this2$player$config !== void 0 && (_this2$player$config$ = _this2$player$config.hls) !== null && _this2$player$config$ !== void 0 && _this2$player$config$.keepStatusAfterSwitch) {
+                  _this2._keepPauseStatus();
+                }
+              } else {
+                reject();
+              }
+            });
+          };
+        }
+        var onSwitchUrl = this.player.switchURL;
         this.player.handleSource = false;
         hlsOpts.innerDegrade = hlsOpts.innerDegrade || config.innerDegrade;
         if (hlsOpts.disconnectTime === null || hlsOpts.disconnectTime === void 0)
@@ -15135,7 +15922,7 @@
         this.hls = new Hls(_objectSpread2$2({
           softDecode: this.softDecode,
           isLive: config.isLive,
-          media: this.player.media || this.player.video,
+          media: mediaElem,
           startTime: config.startTime,
           url: config.url
         }, hlsOpts));
@@ -15153,7 +15940,7 @@
         if (this.softDecode) {
           this.pluginExtension = new PluginExtension(_objectSpread2$2({
             isLive: config.isLive,
-            media: this.player.video
+            media: mediaElem
           }, hlsOpts), this);
           this.player.forceDegradeToVideo = function() {
             var _this2$pluginExtensio;
@@ -15170,8 +15957,8 @@
             return (_this2$hls2 = _this2.hls) === null || _this2$hls2 === void 0 ? void 0 : _this2$hls2.replay();
           });
         }
+        this.on(URL_CHANGE, onSwitchUrl);
         this.on(SWITCH_SUBTITLE, this._onSwitchSubtitle);
-        this.on(URL_CHANGE, this._onSwitchURL);
         this.on(DESTROY, this.destroy.bind(this));
         this._transError();
         this._transCoreEvent(EVENT.TTFB);
@@ -15181,6 +15968,7 @@
         this._transCoreEvent(EVENT.LOAD_RETRY);
         this._transCoreEvent(EVENT.SOURCEBUFFER_CREATED);
         this._transCoreEvent(EVENT.MEDIASOURCE_OPENED);
+        this._transCoreEvent(EVENT.APPEND_BUFFER);
         this._transCoreEvent(EVENT.REMOVE_BUFFER);
         this._transCoreEvent(EVENT.BUFFEREOS);
         this._transCoreEvent(EVENT.KEYFRAME);
@@ -15200,7 +15988,9 @@
         this._transCoreEvent(Event$1.SUBTITLE_PLAYLIST);
         this._transCoreEvent(Event$1.APPEND_COST);
         if (config.url) {
-          this.hls.load(config.url, true).catch(function(e) {
+          this.hls.load(config.url, {
+            reuseMse: true
+          }).catch(function(e) {
           });
         }
       }