hls.js 1.6.0-beta.2.0.canary.10924 → 1.6.0-beta.2.0.canary.10926

package/dist/hls.light.mjs

@@ -402,7 +402,7 @@ function enableLogs(debugConfig, context, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.2.0.canary.10924"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.2.0.canary.10926"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -1062,8 +1062,8 @@ function getCodecTiers(levels, audioTracksByGroup, minAutoLevel, maxAutoLevel) {
   }, {});
 }
 function useAlternateAudio(audioTrackUrl, hls) {
-  var _hls$levels$hls$loadL;
-  return !!audioTrackUrl && audioTrackUrl !== ((_hls$levels$hls$loadL = hls.levels[hls.loadLevel]) == null ? undefined : _hls$levels$hls$loadL.uri);
+  var _hls$loadLevelObj;
+  return !!audioTrackUrl && audioTrackUrl !== ((_hls$loadLevelObj = hls.loadLevelObj) == null ? undefined : _hls$loadLevelObj.uri);
 }
 
 class AbrController extends Logger {
@@ -1557,8 +1557,8 @@ class AbrController extends Logger {
     }
     // If no matching level found, see if min auto level would be a better option
     const minLevel = hls.levels[minAutoLevel];
-    const autoLevel = hls.levels[hls.loadLevel];
-    if ((minLevel == null ? undefined : minLevel.bitrate) < (autoLevel == null ? undefined : autoLevel.bitrate)) {
+    const autoLevel = hls.loadLevelObj;
+    if (autoLevel && (minLevel == null ? undefined : minLevel.bitrate) < autoLevel.bitrate) {
       return minAutoLevel;
     }
     // or if bitrate is not lower, continue to use loadLevel
@@ -2042,7 +2042,7 @@ class ErrorController extends Logger {
       case ErrorDetails.SUBTITLE_LOAD_ERROR:
       case ErrorDetails.SUBTITLE_TRACK_LOAD_TIMEOUT:
         if (context) {
-          const level = hls.levels[hls.loadLevel];
+          const level = hls.loadLevelObj;
           if (level && (context.type === PlaylistContextType.AUDIO_TRACK && level.hasAudioGroup(context.groupId) || context.type === PlaylistContextType.SUBTITLE_TRACK && level.hasSubtitleGroup(context.groupId))) {
             // Perform Pathway switch or Redundant failover if possible for fastest recovery
             // otherwise allow playlist retry count to reach max error retries
@@ -2055,7 +2055,7 @@ class ErrorController extends Logger {
         return;
       case ErrorDetails.KEY_SYSTEM_STATUS_OUTPUT_RESTRICTED:
         {
-          const level = hls.levels[hls.loadLevel];
+          const level = hls.loadLevelObj;
           const restrictedHdcpLevel = level == null ? undefined : level.attrs['HDCP-LEVEL'];
           if (restrictedHdcpLevel) {
             data.errorAction = {
@@ -7254,36 +7254,53 @@ class BufferHelper {
     }
     return false;
   }
+  static bufferedRanges(media) {
+    if (media) {
+      const timeRanges = BufferHelper.getBuffered(media);
+      return BufferHelper.timeRangesToArray(timeRanges);
+    }
+    return [];
+  }
+  static timeRangesToArray(timeRanges) {
+    const buffered = [];
+    for (let i = 0; i < timeRanges.length; i++) {
+      buffered.push({
+        start: timeRanges.start(i),
+        end: timeRanges.end(i)
+      });
+    }
+    return buffered;
+  }
   static bufferInfo(media, pos, maxHoleDuration) {
     if (media) {
-      const vbuffered = BufferHelper.getBuffered(media);
-      if (vbuffered.length) {
-        const buffered = [];
-        for (let i = 0; i < vbuffered.length; i++) {
-          buffered.push({
-            start: vbuffered.start(i),
-            end: vbuffered.end(i)
-          });
-        }
+      const buffered = BufferHelper.bufferedRanges(media);
+      if (buffered.length) {
         return BufferHelper.bufferedInfo(buffered, pos, maxHoleDuration);
       }
     }
     return {
       len: 0,
       start: pos,
-      end: pos
+      end: pos,
+      bufferedIndex: -1
     };
   }
   static bufferedInfo(buffered, pos, maxHoleDuration) {
     pos = Math.max(0, pos);
     // sort on buffer.start/smaller end (IE does not always return sorted buffered range)
-    buffered.sort((a, b) => a.start - b.start || b.end - a.end);
+    if (buffered.length > 1) {
+      buffered.sort((a, b) => a.start - b.start || b.end - a.end);
+    }
+    let bufferedIndex = -1;
     let buffered2 = [];
     if (maxHoleDuration) {
       // there might be some small holes between buffer time range
       // consider that holes smaller than maxHoleDuration are irrelevant and build another
       // buffer time range representations that discards those holes
       for (let i = 0; i < buffered.length; i++) {
+        if (pos >= buffered[i].start && pos <= buffered[i].end) {
+          bufferedIndex = i;
+        }
         const buf2len = buffered2.length;
         if (buf2len) {
           const buf2end = buffered2[buf2len - 1].end;
@@ -7309,24 +7326,25 @@ class BufferHelper {
       buffered2 = buffered;
     }
     let bufferLen = 0;
+    let nextStart;
 
-    // bufferStartNext can possibly be undefined based on the conditional logic below
-    let bufferStartNext;
-
-    // bufferStart and bufferEnd are buffer boundaries around current video position
+    // bufferStart and bufferEnd are buffer boundaries around current playback position (pos)
     let bufferStart = pos;
     let bufferEnd = pos;
     for (let i = 0; i < buffered2.length; i++) {
       const start = buffered2[i].start;
       const end = buffered2[i].end;
       // logger.log('buf start/end:' + buffered.start(i) + '/' + buffered.end(i));
+      if (bufferedIndex === -1 && pos >= start && pos <= end) {
+        bufferedIndex = i;
+      }
       if (pos + maxHoleDuration >= start && pos < end) {
         // play position is inside this buffer TimeRange, retrieve end of buffer position and buffer length
         bufferStart = start;
         bufferEnd = end;
         bufferLen = bufferEnd - pos;
       } else if (pos + maxHoleDuration < start) {
-        bufferStartNext = start;
+        nextStart = start;
         break;
       }
     }
@@ -7334,8 +7352,9 @@ class BufferHelper {
       len: bufferLen,
       start: bufferStart || 0,
       end: bufferEnd || 0,
-      nextStart: bufferStartNext,
-      buffered
+      nextStart,
+      buffered,
+      bufferedIndex
     };
   }
 
@@ -7607,7 +7626,6 @@ class BaseStreamController extends TaskLoop {
       // reset startPosition and lastCurrentTime to restart playback @ stream beginning
       this.log(`setting startPosition to 0 because media ended`);
       this.startPosition = this.lastCurrentTime = 0;
-      this.triggerEnded();
     };
     this.playlistType = playlistType;
     this.hls = hls;
@@ -7681,6 +7699,12 @@ class BaseStreamController extends TaskLoop {
   resumeBuffering() {
     this.buffering = true;
   }
+  get inFlightFrag() {
+    return {
+      frag: this.fragCurrent,
+      state: this.state
+    };
+  }
   _streamEnded(bufferInfo, levelDetails) {
     // Stream is never "ended" when playlist is live or media is detached
     if (levelDetails.live || !this.media) {
@@ -7769,9 +7793,6 @@ class BaseStreamController extends TaskLoop {
     this.startFragRequested = false;
   }
   onError(event, data) {}
-  triggerEnded() {
-    /* overridden in stream-controller */
-  }
   onManifestLoaded(event, data) {
     this.startTimeOffset = data.startTimeOffset;
   }
@@ -8341,7 +8362,8 @@ class BaseStreamController extends TaskLoop {
     if (bufferInfo.len === 0 && bufferInfo.nextStart !== undefined) {
       const bufferedFragAtPos = this.fragmentTracker.getBufferedFrag(pos, type);
       if (bufferedFragAtPos && (bufferInfo.nextStart <= bufferedFragAtPos.end || bufferedFragAtPos.gap)) {
-        return BufferHelper.bufferInfo(bufferable, pos, Math.max(bufferInfo.nextStart, maxBufferHole));
+        const gapDuration = Math.max(Math.min(bufferInfo.nextStart, bufferedFragAtPos.end) - pos, maxBufferHole);
+        return BufferHelper.bufferInfo(bufferable, pos, gapDuration);
       }
     }
     return bufferInfo;
@@ -9575,7 +9597,6 @@ transfer tracks: ${JSON.stringify(transferredTracks, (key, value) => key === 'in
       const sbTrack = transferredTrack != null && transferredTrack.buffer ? transferredTrack : track;
       const sbCodec = (sbTrack == null ? undefined : sbTrack.pendingCodec) || (sbTrack == null ? undefined : sbTrack.codec);
       const trackLevelCodec = sbTrack == null ? undefined : sbTrack.levelCodec;
-      const forceChangeType = !sbTrack || !!this.hls.config.assetPlayerId;
       if (!track) {
         track = tracks[trackName] = {
           buffer: undefined,
@@ -9592,7 +9613,7 @@ transfer tracks: ${JSON.stringify(transferredTracks, (key, value) => key === 'in
       const currentCodec = currentCodecFull == null ? undefined : currentCodecFull.replace(VIDEO_CODEC_PROFILE_REPLACE, '$1');
       let trackCodec = pickMostCompleteCodecName(codec, levelCodec);
       const nextCodec = (_trackCodec = trackCodec) == null ? undefined : _trackCodec.replace(VIDEO_CODEC_PROFILE_REPLACE, '$1');
-      if (trackCodec && (currentCodec !== nextCodec || forceChangeType)) {
+      if (trackCodec && currentCodecFull && currentCodec !== nextCodec) {
         if (trackName.slice(0, 5) === 'audio') {
           trackCodec = getCodecCompatibleName(trackCodec, this.appendSource);
         }
@@ -17167,16 +17188,20 @@ const hlsDefaultConfig = _objectSpread2(_objectSpread2({
   frontBufferFlushThreshold: Infinity,
   maxBufferSize: 60 * 1000 * 1000,
   // used by stream-controller
-  maxBufferHole: 0.1,
+  maxFragLookUpTolerance: 0.25,
   // used by stream-controller
+  maxBufferHole: 0.1,
+  // used by stream-controller and gap-controller
+  detectStallWithCurrentTimeMs: 1250,
+  // used by gap-controller
   highBufferWatchdogPeriod: 2,
-  // used by stream-controller
+  // used by gap-controller
   nudgeOffset: 0.1,
-  // used by stream-controller
+  // used by gap-controller
   nudgeMaxRetry: 3,
-  // used by stream-controller
-  maxFragLookUpTolerance: 0.25,
-  // used by stream-controller
+  // used by gap-controller
+  nudgeOnVideoHole: true,
+  // used by gap-controller
   liveSyncDurationCount: 3,
   // used by latency-controller
   liveSyncOnStallIncrease: 1,
@@ -17275,7 +17300,6 @@ const hlsDefaultConfig = _objectSpread2(_objectSpread2({
   progressive: false,
   lowLatencyMode: true,
   cmcd: undefined,
-  detectStallWithCurrentTimeMs: 1250,
   enableDateRangeMetadataCues: true,
   enableEmsgMetadataCues: true,
   enableEmsgKLVMetadata: false,
@@ -17517,356 +17541,914 @@ function enableStreamingMode(config, logger) {
   }
 }
 
-function sendAddTrackEvent(track, videoEl) {
-  let event;
-  try {
-    event = new Event('addtrack');
-  } catch (err) {
-    // for IE11
-    event = document.createEvent('Event');
-    event.initEvent('addtrack', false, false);
-  }
-  event.track = track;
-  videoEl.dispatchEvent(event);
-}
-function clearCurrentCues(track, enterHandler) {
-  // When track.mode is disabled, track.cues will be null.
-  // To guarantee the removal of cues, we need to temporarily
-  // change the mode to hidden
-  const mode = track.mode;
-  if (mode === 'disabled') {
-    track.mode = 'hidden';
-  }
-  if (track.cues) {
-    for (let i = track.cues.length; i--;) {
-      if (enterHandler) {
-        track.cues[i].removeEventListener('enter', enterHandler);
-      }
-      track.removeCue(track.cues[i]);
-    }
-  }
-  if (mode === 'disabled') {
-    track.mode = mode;
-  }
-}
-function removeCuesInRange(track, start, end, predicate) {
-  const mode = track.mode;
-  if (mode === 'disabled') {
-    track.mode = 'hidden';
-  }
-  if (track.cues && track.cues.length > 0) {
-    const cues = getCuesInRange(track.cues, start, end);
-    for (let i = 0; i < cues.length; i++) {
-      if (!predicate || predicate(cues[i])) {
-        track.removeCue(cues[i]);
-      }
-    }
-  }
-  if (mode === 'disabled') {
-    track.mode = mode;
-  }
-}
-
-// Find first cue starting after given time.
-// Modified version of binary search O(log(n)).
-function getFirstCueIndexAfterTime(cues, time) {
-  // If first cue starts after time, start there
-  if (time < cues[0].startTime) {
-    return 0;
-  }
-  // If the last cue ends before time there is no overlap
-  const len = cues.length - 1;
-  if (time > cues[len].endTime) {
-    return -1;
-  }
-  let left = 0;
-  let right = len;
-  while (left <= right) {
-    const mid = Math.floor((right + left) / 2);
-    if (time < cues[mid].startTime) {
-      right = mid - 1;
-    } else if (time > cues[mid].startTime && left < len) {
-      left = mid + 1;
-    } else {
-      // If it's not lower or higher, it must be equal.
-      return mid;
-    }
-  }
-  // At this point, left and right have swapped.
-  // No direct match was found, left or right element must be the closest. Check which one has the smallest diff.
-  return cues[left].startTime - time < time - cues[right].startTime ? left : right;
-}
-function getCuesInRange(cues, start, end) {
-  const cuesFound = [];
-  const firstCueInRange = getFirstCueIndexAfterTime(cues, start);
-  if (firstCueInRange > -1) {
-    for (let i = firstCueInRange, len = cues.length; i < len; i++) {
-      const cue = cues[i];
-      if (cue.startTime >= start && cue.endTime <= end) {
-        cuesFound.push(cue);
-      } else if (cue.startTime > end) {
-        return cuesFound;
-      }
-    }
-  }
-  return cuesFound;
-}
-
-const MIN_CUE_DURATION = 0.25;
-function getCueClass() {
-  if (typeof self === 'undefined') return undefined;
-  return self.VTTCue || self.TextTrackCue;
+function addEventListener(el, type, listener) {
+  removeEventListener(el, type, listener);
+  el.addEventListener(type, listener);
 }
-function createCueWithDataFields(Cue, startTime, endTime, data, type) {
-  let cue = new Cue(startTime, endTime, '');
-  try {
-    cue.value = data;
-    if (type) {
-      cue.type = type;
-    }
-  } catch (e) {
-    cue = new Cue(startTime, endTime, JSON.stringify(type ? _objectSpread2({
-      type
-    }, data) : data));
-  }
-  return cue;
+function removeEventListener(el, type, listener) {
+  el.removeEventListener(type, listener);
 }
 
-// VTTCue latest draft allows an infinite duration, fallback
-// to MAX_VALUE if necessary
-const MAX_CUE_ENDTIME = (() => {
-  const Cue = getCueClass();
-  try {
-    Cue && new Cue(0, Number.POSITIVE_INFINITY, '');
-  } catch (e) {
-    return Number.MAX_VALUE;
-  }
-  return Number.POSITIVE_INFINITY;
-})();
-function hexToArrayBuffer(str) {
-  return Uint8Array.from(str.replace(/^0x/, '').replace(/([\da-fA-F]{2}) ?/g, '0x$1 ').replace(/ +$/, '').split(' ')).buffer;
-}
-class ID3TrackController {
-  constructor(hls) {
-    this.hls = undefined;
-    this.id3Track = null;
+const MAX_START_GAP_JUMP = 2.0;
+const SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
+const SKIP_BUFFER_RANGE_START = 0.05;
+const TICK_INTERVAL$1 = 100;
+class GapController extends TaskLoop {
+  constructor(hls, fragmentTracker) {
+    super('gap-controller', hls.logger);
+    this.hls = null;
+    this.fragmentTracker = null;
     this.media = null;
-    this.dateRangeCuesAppended = {};
-    this.removeCues = true;
-    this.onEventCueEnter = () => {
-      if (!this.hls) {
+    this.mediaSource = undefined;
+    this.nudgeRetry = 0;
+    this.stallReported = false;
+    this.stalled = null;
+    this.moved = false;
+    this.seeking = false;
+    this.buffered = {};
+    this.lastCurrentTime = 0;
+    this.ended = 0;
+    this.waiting = 0;
+    this.onMediaPlaying = () => {
+      this.ended = 0;
+      this.waiting = 0;
+    };
+    this.onMediaWaiting = () => {
+      var _this$media;
+      if ((_this$media = this.media) != null && _this$media.seeking) {
         return;
       }
-      this.hls.trigger(Events.EVENT_CUE_ENTER, {});
+      this.waiting = self.performance.now();
+      this.tick();
+    };
+    this.onMediaEnded = () => {
+      if (this.hls) {
+        var _this$media2;
+        // ended is set when triggering MEDIA_ENDED so that we do not trigger it again on stall or on tick with media.ended
+        this.ended = ((_this$media2 = this.media) == null ? undefined : _this$media2.currentTime) || 1;
+        this.hls.trigger(Events.MEDIA_ENDED, {
+          stalled: false
+        });
+      }
     };
     this.hls = hls;
-    this._registerListeners();
-  }
-  destroy() {
-    this._unregisterListeners();
-    this.id3Track = null;
-    this.media = null;
-    this.dateRangeCuesAppended = {};
-    // @ts-ignore
-    this.hls = this.onEventCueEnter = null;
+    this.fragmentTracker = fragmentTracker;
+    this.registerListeners();
   }
-  _registerListeners() {
+  registerListeners() {
     const {
       hls
     } = this;
-    hls.on(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
-    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
-    hls.on(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
-    hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
-    hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
-    hls.on(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
+    if (hls) {
+      hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+      hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+      hls.on(Events.BUFFER_APPENDED, this.onBufferAppended, this);
+    }
   }
-  _unregisterListeners() {
+  unregisterListeners() {
     const {
       hls
     } = this;
-    hls.off(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
-    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
-    hls.off(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
-    hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
-    hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
-    hls.off(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
-  }
-  // Add ID3 metatadata text track.
-  onMediaAttaching(event, data) {
-    var _data$overrides;
-    this.media = data.media;
-    if (((_data$overrides = data.overrides) == null ? undefined : _data$overrides.cueRemoval) === false) {
-      this.removeCues = false;
+    if (hls) {
+      hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+      hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+      hls.off(Events.BUFFER_APPENDED, this.onBufferAppended, this);
     }
   }
-  onMediaAttached() {
-    const details = this.hls.latestLevelDetails;
-    if (details) {
-      this.updateDateRangeCues(details);
-    }
+  destroy() {
+    super.destroy();
+    this.unregisterListeners();
+    this.media = this.hls = this.fragmentTracker = null;
+    this.mediaSource = undefined;
+  }
+  onMediaAttached(event, data) {
+    this.setInterval(TICK_INTERVAL$1);
+    this.mediaSource = data.mediaSource;
+    const media = this.media = data.media;
+    addEventListener(media, 'playing', this.onMediaPlaying);
+    addEventListener(media, 'waiting', this.onMediaWaiting);
+    addEventListener(media, 'ended', this.onMediaEnded);
   }
   onMediaDetaching(event, data) {
-    this.media = null;
-    const transferringMedia = !!data.transferMedia;
-    if (transferringMedia) {
-      return;
-    }
-    if (this.id3Track) {
-      if (this.removeCues) {
-        clearCurrentCues(this.id3Track, this.onEventCueEnter);
-      }
-      this.id3Track = null;
+    this.clearInterval();
+    const {
+      media
+    } = this;
+    if (media) {
+      removeEventListener(media, 'playing', this.onMediaPlaying);
+      removeEventListener(media, 'waiting', this.onMediaWaiting);
+      removeEventListener(media, 'ended', this.onMediaEnded);
+      this.media = null;
     }
-    this.dateRangeCuesAppended = {};
+    this.mediaSource = undefined;
   }
-  onManifestLoading() {
-    this.dateRangeCuesAppended = {};
+  onBufferAppended(event, data) {
+    this.buffered = data.timeRanges;
   }
-  createTrack(media) {
-    const track = this.getID3Track(media.textTracks);
-    track.mode = 'hidden';
-    return track;
+  get hasBuffered() {
+    return Object.keys(this.buffered).length > 0;
   }
-  getID3Track(textTracks) {
-    if (!this.media) {
+  tick() {
+    var _this$media3;
+    if (!((_this$media3 = this.media) != null && _this$media3.readyState) || !this.hasBuffered) {
       return;
     }
-    for (let i = 0; i < textTracks.length; i++) {
-      const textTrack = textTracks[i];
-      if (textTrack.kind === 'metadata' && textTrack.label === 'id3') {
-        // send 'addtrack' when reusing the textTrack for metadata,
-        // same as what we do for captions
-        sendAddTrackEvent(textTrack, this.media);
-        return textTrack;
-      }
-    }
-    return this.media.addTextTrack('metadata', 'id3');
+    const currentTime = this.media.currentTime;
+    this.poll(currentTime, this.lastCurrentTime);
+    this.lastCurrentTime = currentTime;
   }
-  onFragParsingMetadata(event, data) {
-    if (!this.media) {
+
+  /**
+   * Checks if the playhead is stuck within a gap, and if so, attempts to free it.
+   * A gap is an unbuffered range between two buffered ranges (or the start and the first buffered range).
+   *
+   * @param lastCurrentTime - Previously read playhead position
+   */
+  poll(currentTime, lastCurrentTime) {
+    var _this$hls, _this$hls2;
+    const config = (_this$hls = this.hls) == null ? undefined : _this$hls.config;
+    if (!config) {
       return;
     }
     const {
-      hls: {
-        config: {
-          enableEmsgMetadataCues,
-          enableID3MetadataCues
-        }
-      }
+      media,
+      stalled
     } = this;
-    if (!enableEmsgMetadataCues && !enableID3MetadataCues) {
+    if (!media) {
       return;
     }
     const {
-      samples
-    } = data;
+      seeking
+    } = media;
+    const seeked = this.seeking && !seeking;
+    const beginSeek = !this.seeking && seeking;
+    const pausedEndedOrHalted = media.paused && !seeking || media.ended || media.playbackRate === 0;
+    this.seeking = seeking;
 
-    // create track dynamically
-    if (!this.id3Track) {
-      this.id3Track = this.createTrack(this.media);
+    // The playhead is moving, no-op
+    if (currentTime !== lastCurrentTime) {
+      if (lastCurrentTime) {
+        this.ended = 0;
+      }
+      this.moved = true;
+      if (!seeking) {
+        this.nudgeRetry = 0;
+        // When crossing between buffered video time ranges, but not audio, flush pipeline with seek (Chrome)
+        if (config.nudgeOnVideoHole && !pausedEndedOrHalted && currentTime > lastCurrentTime) {
+          this.nudgeOnVideoHole(currentTime, lastCurrentTime);
+        }
+      }
+      if (this.waiting === 0) {
+        this.stallResolved(currentTime);
+      }
+      return;
     }
-    const Cue = getCueClass();
-    if (!Cue) {
+
+    // Clear stalled state when beginning or finishing seeking so that we don't report stalls coming out of a seek
+    if (beginSeek || seeked) {
+      if (seeked) {
+        this.stallResolved(currentTime);
+      }
       return;
     }
-    for (let i = 0; i < samples.length; i++) {
-      const type = samples[i].type;
-      if (type === MetadataSchema.emsg && !enableEmsgMetadataCues || !enableID3MetadataCues) {
-        continue;
+
+    // The playhead should not be moving
+    if (pausedEndedOrHalted) {
+      this.nudgeRetry = 0;
+      this.stallResolved(currentTime);
+      // Fire MEDIA_ENDED to workaround event not being dispatched by browser
+      if (!this.ended && media.ended && this.hls) {
+        this.ended = currentTime || 1;
+        this.hls.trigger(Events.MEDIA_ENDED, {
+          stalled: false
+        });
       }
-      const frames = getId3Frames(samples[i].data);
-      if (frames) {
-        const startTime = samples[i].pts;
-        let endTime = startTime + samples[i].duration;
-        if (endTime > MAX_CUE_ENDTIME) {
-          endTime = MAX_CUE_ENDTIME;
-        }
-        const timeDiff = endTime - startTime;
-        if (timeDiff <= 0) {
-          endTime = startTime + MIN_CUE_DURATION;
-        }
-        for (let j = 0; j < frames.length; j++) {
-          const frame = frames[j];
-          // Safari doesn't put the timestamp frame in the TextTrack
-          if (!isId3TimestampFrame(frame)) {
-            // add a bounds to any unbounded cues
-            this.updateId3CueEnds(startTime, type);
-            const cue = createCueWithDataFields(Cue, startTime, endTime, frame, type);
-            if (cue) {
-              this.id3Track.addCue(cue);
-            }
-          }
-        }
+      return;
+    }
+    if (!BufferHelper.getBuffered(media).length) {
+      this.nudgeRetry = 0;
+      return;
+    }
+
+    // Resolve stalls at buffer holes using the main buffer, whose ranges are the intersections of the A/V sourcebuffers
+    const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
+    const nextStart = bufferInfo.nextStart || 0;
+    const fragmentTracker = this.fragmentTracker;
+    if (seeking && fragmentTracker && this.hls) {
+      // Is there a fragment loading/parsing/appending before currentTime?
+      const inFlightDependency = getInFlightDependency(this.hls.inFlightFragments, currentTime);
+
+      // Waiting for seeking in a buffered range to complete
+      const hasEnoughBuffer = bufferInfo.len > MAX_START_GAP_JUMP;
+      // Next buffered range is too far ahead to jump to while still seeking
+      const noBufferHole = !nextStart || inFlightDependency || nextStart - currentTime > MAX_START_GAP_JUMP && !fragmentTracker.getPartialFragment(currentTime);
+      if (hasEnoughBuffer || noBufferHole) {
+        return;
       }
+      // Reset moved state when seeking to a point in or before a gap/hole
+      this.moved = false;
     }
-  }
-  updateId3CueEnds(startTime, type) {
-    var _this$id3Track;
-    const cues = (_this$id3Track = this.id3Track) == null ? undefined : _this$id3Track.cues;
-    if (cues) {
-      for (let i = cues.length; i--;) {
-        const cue = cues[i];
-        if (cue.type === type && cue.startTime < startTime && cue.endTime === MAX_CUE_ENDTIME) {
-          cue.endTime = startTime;
+
+    // Skip start gaps if we haven't played, but the last poll detected the start of a stall
+    // The addition poll gives the browser a chance to jump the gap for us
+    const levelDetails = (_this$hls2 = this.hls) == null ? undefined : _this$hls2.latestLevelDetails;
+    if (!this.moved && this.stalled !== null && fragmentTracker) {
+      // There is no playable buffer (seeked, waiting for buffer)
+      const isBuffered = bufferInfo.len > 0;
+      if (!isBuffered && !nextStart) {
+        return;
+      }
+      // Jump start gaps within jump threshold
+      const startJump = Math.max(nextStart, bufferInfo.start || 0) - currentTime;
+
+      // When joining a live stream with audio tracks, account for live playlist window sliding by allowing
+      // a larger jump over start gaps caused by the audio-stream-controller buffering a start fragment
+      // that begins over 1 target duration after the video start position.
+      const isLive = !!(levelDetails != null && levelDetails.live);
+      const maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
+      const partialOrGap = fragmentTracker.getPartialFragment(currentTime);
+      if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
+        if (!media.paused) {
+          this._trySkipBufferHole(partialOrGap);
         }
+        return;
       }
     }
-  }
-  onBufferFlushing(event, {
-    startOffset,
-    endOffset,
-    type
-  }) {
-    const {
-      id3Track,
-      hls
-    } = this;
-    if (!hls) {
+
+    // Start tracking stall time
+    const detectStallWithCurrentTimeMs = config.detectStallWithCurrentTimeMs;
+    const tnow = self.performance.now();
+    const tWaiting = this.waiting;
+    if (stalled === null) {
+      // Use time of recent "waiting" event
+      if (tWaiting > 0 && tnow - tWaiting < detectStallWithCurrentTimeMs) {
+        this.stalled = tWaiting;
+      } else {
+        this.stalled = tnow;
+      }
       return;
     }
-    const {
-      config: {
-        enableEmsgMetadataCues,
-        enableID3MetadataCues
+    const stalledDuration = tnow - stalled;
+    if (!seeking && (stalledDuration >= detectStallWithCurrentTimeMs || tWaiting) && this.hls) {
+      var _this$mediaSource;
+      // Dispatch MEDIA_ENDED when media.ended/ended event is not signalled at end of stream
+      if (((_this$mediaSource = this.mediaSource) == null ? undefined : _this$mediaSource.readyState) === 'ended' && !(levelDetails != null && levelDetails.live) && Math.abs(currentTime - ((levelDetails == null ? undefined : levelDetails.edge) || 0)) < 1) {
+        if (this.ended) {
+          return;
+        }
+        this.ended = currentTime || 1;
+        this.hls.trigger(Events.MEDIA_ENDED, {
+          stalled: true
+        });
+        return;
       }
-    } = hls;
-    if (id3Track && (enableEmsgMetadataCues || enableID3MetadataCues)) {
-      let predicate;
-      if (type === 'audio') {
-        predicate = cue => cue.type === MetadataSchema.audioId3 && enableID3MetadataCues;
-      } else if (type === 'video') {
-        predicate = cue => cue.type === MetadataSchema.emsg && enableEmsgMetadataCues;
-      } else {
-        predicate = cue => cue.type === MetadataSchema.audioId3 && enableID3MetadataCues || cue.type === MetadataSchema.emsg && enableEmsgMetadataCues;
+      // Report stalling after trying to fix
+      this._reportStall(bufferInfo);
+      if (!this.media || !this.hls) {
+        return;
       }
-      removeCuesInRange(id3Track, startOffset, endOffset, predicate);
     }
+    const bufferedWithHoles = BufferHelper.bufferInfo(media, currentTime, config.maxBufferHole);
+    this._tryFixBufferStall(bufferedWithHoles, stalledDuration);
   }
-  onLevelUpdated(event, {
-    details
-  }) {
-    this.updateDateRangeCues(details, true);
-  }
-  onLevelPtsUpdated(event, data) {
-    if (Math.abs(data.drift) > 0.01) {
-      this.updateDateRangeCues(data.details);
+  stallResolved(currentTime) {
+    const stalled = this.stalled;
+    if (stalled && this.hls) {
+      this.stalled = null;
+      // The playhead is now moving, but was previously stalled
+      if (this.stallReported) {
+        const stalledDuration = self.performance.now() - stalled;
+        this.log(`playback not stuck anymore @${currentTime}, after ${Math.round(stalledDuration)}ms`);
+        this.stallReported = false;
+        this.waiting = 0;
+        this.hls.trigger(Events.STALL_RESOLVED, {});
+      }
     }
   }
-  updateDateRangeCues(details, removeOldCues) {
-    if (!this.media || !details.hasProgramDateTime || !this.hls.config.enableDateRangeMetadataCues) {
-      return;
+  nudgeOnVideoHole(currentTime, lastCurrentTime) {
+    var _this$buffered$audio;
+    // Chrome will play one second past a hole in video buffered time ranges without rendering any video from the subsequent range and then stall as long as audio is buffered:
+    // https://github.com/video-dev/hls.js/issues/5631
+    // https://issues.chromium.org/issues/40280613#comment10
+    // Detect the potential for this situation and proactively seek to flush the video pipeline once the playhead passes the start of the video hole.
+    // When there are audio and video buffers and currentTime is past the end of the first video buffered range...
+    const videoSourceBuffered = this.buffered.video;
+    if (this.hls && this.media && this.fragmentTracker && (_this$buffered$audio = this.buffered.audio) != null && _this$buffered$audio.length && videoSourceBuffered && videoSourceBuffered.length > 1 && currentTime > videoSourceBuffered.end(0)) {
+      // and audio is buffered at the playhead
+      const audioBufferInfo = BufferHelper.bufferedInfo(BufferHelper.timeRangesToArray(this.buffered.audio), currentTime, 0);
+      if (audioBufferInfo.len > 1 && lastCurrentTime >= audioBufferInfo.start) {
+        const videoTimes = BufferHelper.timeRangesToArray(videoSourceBuffered);
+        const lastBufferedIndex = BufferHelper.bufferedInfo(videoTimes, lastCurrentTime, 0).bufferedIndex;
+        // nudge when crossing into another video buffered range (hole).
+        if (lastBufferedIndex > -1 && lastBufferedIndex < videoTimes.length - 1) {
+          const bufferedIndex = BufferHelper.bufferedInfo(videoTimes, currentTime, 0).bufferedIndex;
+          const holeStart = videoTimes[lastBufferedIndex].end;
+          const holeEnd = videoTimes[lastBufferedIndex + 1].start;
+          if ((bufferedIndex === -1 || bufferedIndex > lastBufferedIndex) && holeEnd - holeStart < 1 &&
+          // `maxBufferHole` may be too small and setting it to 0 should not disable this feature
+          currentTime - holeStart < 2) {
+            const error = new Error(`nudging playhead to flush pipeline after video hole. currentTime: ${currentTime} hole: ${holeStart} -> ${holeEnd} buffered index: ${bufferedIndex}`);
+            this.warn(error.message);
+            // Magic number to flush the pipeline without interuption to audio playback:
+            this.media.currentTime += 0.000001;
+            const frag = this.fragmentTracker.getPartialFragment(currentTime) || undefined;
+            const bufferInfo = BufferHelper.bufferInfo(this.media, currentTime, 0);
+            this.hls.trigger(Events.ERROR, {
+              type: ErrorTypes.MEDIA_ERROR,
+              details: ErrorDetails.BUFFER_SEEK_OVER_HOLE,
+              fatal: false,
+              error,
+              reason: error.message,
+              frag,
+              buffer: bufferInfo.len,
+              bufferInfo
+            });
+          }
+        }
+      }
     }
+  }
+
+  /**
+   * Detects and attempts to fix known buffer stalling issues.
+   * @param bufferInfo - The properties of the current buffer.
+   * @param stalledDurationMs - The amount of time Hls.js has been stalling for.
+   * @private
+   */
+  _tryFixBufferStall(bufferInfo, stalledDurationMs) {
+    var _this$hls3;
     const {
-      id3Track
+      fragmentTracker,
+      media
     } = this;
-    const {
-      dateRanges
-    } = details;
+    const config = (_this$hls3 = this.hls) == null ? undefined : _this$hls3.config;
+    if (!media || !fragmentTracker || !config) {
+      return;
+    }
+    const currentTime = media.currentTime;
+    const partial = fragmentTracker.getPartialFragment(currentTime);
+    if (partial) {
+      // Try to skip over the buffer hole caused by a partial fragment
+      // This method isn't limited by the size of the gap between buffered ranges
+      const targetTime = this._trySkipBufferHole(partial);
+      // we return here in this case, meaning
+      // the branch below only executes when we haven't seeked to a new position
+      if (targetTime || !this.media) {
+        return;
+      }
+    }
+
+    // if we haven't had to skip over a buffer hole of a partial fragment
+    // we may just have to "nudge" the playlist as the browser decoding/rendering engine
+    // needs to cross some sort of threshold covering all source-buffers content
+    // to start playing properly.
+    const bufferedRanges = bufferInfo.buffered;
+    if ((bufferedRanges && bufferedRanges.length > 1 && bufferInfo.len > config.maxBufferHole || bufferInfo.nextStart && bufferInfo.nextStart - currentTime < config.maxBufferHole) && (stalledDurationMs > config.highBufferWatchdogPeriod * 1000 || this.waiting)) {
+      this.warn('Trying to nudge playhead over buffer-hole');
+      // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
+      // We only try to jump the hole if it's under the configured size
+      this._tryNudgeBuffer(bufferInfo);
+    }
+  }
+
+  /**
+   * Triggers a BUFFER_STALLED_ERROR event, but only once per stall period.
+   * @param bufferLen - The playhead distance from the end of the current buffer segment.
+   * @private
+   */
+  _reportStall(bufferInfo) {
+    const {
+      hls,
+      media,
+      stallReported,
+      stalled
+    } = this;
+    if (!stallReported && stalled !== null && media && hls) {
+      // Report stalled error once
+      this.stallReported = true;
+      const error = new Error(`Playback stalling at @${media.currentTime} due to low buffer (${JSON.stringify(bufferInfo)})`);
+      this.warn(error.message);
+      hls.trigger(Events.ERROR, {
+        type: ErrorTypes.MEDIA_ERROR,
+        details: ErrorDetails.BUFFER_STALLED_ERROR,
+        fatal: false,
+        error,
+        buffer: bufferInfo.len,
+        bufferInfo,
+        stalled: {
+          start: stalled
+        }
+      });
+    }
+  }
+
+  /**
+   * Attempts to fix buffer stalls by jumping over known gaps caused by partial fragments
+   * @param partial - The partial fragment found at the current time (where playback is stalling).
+   * @private
+   */
+  _trySkipBufferHole(partial) {
+    var _this$hls4;
+    const {
+      fragmentTracker,
+      media
+    } = this;
+    const config = (_this$hls4 = this.hls) == null ? undefined : _this$hls4.config;
+    if (!media || !fragmentTracker || !config) {
+      return 0;
+    }
+
+    // Check if currentTime is between unbuffered regions of partial fragments
+    const currentTime = media.currentTime;
+    const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
+    const startTime = currentTime < bufferInfo.start ? bufferInfo.start : bufferInfo.nextStart;
+    if (startTime && this.hls) {
+      const bufferStarved = bufferInfo.len <= config.maxBufferHole;
+      const waiting = bufferInfo.len > 0 && bufferInfo.len < 1 && media.readyState < 3;
+      const gapLength = startTime - currentTime;
+      if (gapLength > 0 && (bufferStarved || waiting)) {
+        // Only allow large gaps to be skipped if it is a start gap, or all fragments in skip range are partial
+        if (gapLength > config.maxBufferHole) {
+          let startGap = false;
+          if (currentTime === 0) {
+            const startFrag = fragmentTracker.getAppendedFrag(0, PlaylistLevelType.MAIN);
+            if (startFrag && startTime < startFrag.end) {
+              startGap = true;
+            }
+          }
+          if (!startGap) {
+            const startProvisioned = partial || fragmentTracker.getAppendedFrag(currentTime, PlaylistLevelType.MAIN);
+            if (startProvisioned) {
+              var _this$hls$loadLevelOb;
+              // Do not seek when selected variant playlist is unloaded
+              if (!((_this$hls$loadLevelOb = this.hls.loadLevelObj) != null && _this$hls$loadLevelOb.details)) {
+                return 0;
+              }
+              // Do not seek when required fragments are inflight or appending
+              const inFlightDependency = getInFlightDependency(this.hls.inFlightFragments, startTime);
+              if (inFlightDependency) {
+                return 0;
+              }
+              // Do not seek if we can't walk tracked fragments to end of gap
+              let moreToLoad = false;
+              let pos = startProvisioned.end;
+              while (pos < startTime) {
+                const provisioned = fragmentTracker.getPartialFragment(pos);
+                if (provisioned) {
+                  pos += provisioned.duration;
+                } else {
+                  moreToLoad = true;
+                  break;
+                }
+              }
+              if (moreToLoad) {
+                return 0;
+              }
+            }
+          }
+        }
+        const targetTime = Math.max(startTime + SKIP_BUFFER_RANGE_START, currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS);
+        this.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
+        this.moved = true;
+        media.currentTime = targetTime;
+        if (!(partial != null && partial.gap)) {
+          const error = new Error(`fragment loaded with buffer holes, seeking from ${currentTime} to ${targetTime}`);
+          this.hls.trigger(Events.ERROR, {
+            type: ErrorTypes.MEDIA_ERROR,
+            details: ErrorDetails.BUFFER_SEEK_OVER_HOLE,
+            fatal: false,
+            error,
+            reason: error.message,
+            frag: partial || undefined,
+            buffer: bufferInfo.len,
+            bufferInfo
+          });
+        }
+        return targetTime;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
+   * @private
+   */
+  _tryNudgeBuffer(bufferInfo) {
+    const {
+      hls,
+      media,
+      nudgeRetry
+    } = this;
+    const config = hls == null ? undefined : hls.config;
+    if (!media || !config) {
+      return 0;
+    }
+    const currentTime = media.currentTime;
+    this.nudgeRetry++;
+    if (nudgeRetry < config.nudgeMaxRetry) {
+      const targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
+      // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
+      const error = new Error(`Nudging 'currentTime' from ${currentTime} to ${targetTime}`);
+      this.warn(error.message);
+      media.currentTime = targetTime;
+      hls.trigger(Events.ERROR, {
+        type: ErrorTypes.MEDIA_ERROR,
+        details: ErrorDetails.BUFFER_NUDGE_ON_STALL,
+        error,
+        fatal: false,
+        buffer: bufferInfo.len,
+        bufferInfo
+      });
+    } else {
+      const error = new Error(`Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`);
+      this.error(error.message);
+      hls.trigger(Events.ERROR, {
+        type: ErrorTypes.MEDIA_ERROR,
+        details: ErrorDetails.BUFFER_STALLED_ERROR,
+        error,
+        fatal: true,
+        buffer: bufferInfo.len,
+        bufferInfo
+      });
+    }
+  }
+}
+function getInFlightDependency(inFlightFragments, currentTime) {
+  const main = inFlight(inFlightFragments.main);
+  if (main && main.start <= currentTime) {
+    return main;
+  }
+  const audio = inFlight(inFlightFragments.audio);
+  if (audio && audio.start <= currentTime) {
+    return audio;
+  }
+  return null;
+}
+function inFlight(inFlightData) {
+  if (!inFlightData) {
+    return null;
+  }
+  switch (inFlightData.state) {
+    case State.IDLE:
+    case State.STOPPED:
+    case State.ENDED:
+    case State.ERROR:
+      return null;
+  }
+  return inFlightData.frag;
+}
+
+function sendAddTrackEvent(track, videoEl) {
+  let event;
+  try {
+    event = new Event('addtrack');
+  } catch (err) {
+    // for IE11
+    event = document.createEvent('Event');
+    event.initEvent('addtrack', false, false);
+  }
+  event.track = track;
+  videoEl.dispatchEvent(event);
+}
+function clearCurrentCues(track, enterHandler) {
+  // When track.mode is disabled, track.cues will be null.
+  // To guarantee the removal of cues, we need to temporarily
+  // change the mode to hidden
+  const mode = track.mode;
+  if (mode === 'disabled') {
+    track.mode = 'hidden';
+  }
+  if (track.cues) {
+    for (let i = track.cues.length; i--;) {
+      if (enterHandler) {
+        track.cues[i].removeEventListener('enter', enterHandler);
+      }
+      track.removeCue(track.cues[i]);
+    }
+  }
+  if (mode === 'disabled') {
+    track.mode = mode;
+  }
+}
+function removeCuesInRange(track, start, end, predicate) {
+  const mode = track.mode;
+  if (mode === 'disabled') {
+    track.mode = 'hidden';
+  }
+  if (track.cues && track.cues.length > 0) {
+    const cues = getCuesInRange(track.cues, start, end);
+    for (let i = 0; i < cues.length; i++) {
+      if (!predicate || predicate(cues[i])) {
+        track.removeCue(cues[i]);
+      }
+    }
+  }
+  if (mode === 'disabled') {
+    track.mode = mode;
+  }
+}
+
+// Find first cue starting after given time.
+// Modified version of binary search O(log(n)).
+function getFirstCueIndexAfterTime(cues, time) {
+  // If first cue starts after time, start there
+  if (time < cues[0].startTime) {
+    return 0;
+  }
+  // If the last cue ends before time there is no overlap
+  const len = cues.length - 1;
+  if (time > cues[len].endTime) {
+    return -1;
+  }
+  let left = 0;
+  let right = len;
+  while (left <= right) {
+    const mid = Math.floor((right + left) / 2);
+    if (time < cues[mid].startTime) {
+      right = mid - 1;
+    } else if (time > cues[mid].startTime && left < len) {
+      left = mid + 1;
+    } else {
+      // If it's not lower or higher, it must be equal.
+      return mid;
+    }
+  }
+  // At this point, left and right have swapped.
+  // No direct match was found, left or right element must be the closest. Check which one has the smallest diff.
+  return cues[left].startTime - time < time - cues[right].startTime ? left : right;
+}
+function getCuesInRange(cues, start, end) {
+  const cuesFound = [];
+  const firstCueInRange = getFirstCueIndexAfterTime(cues, start);
+  if (firstCueInRange > -1) {
+    for (let i = firstCueInRange, len = cues.length; i < len; i++) {
+      const cue = cues[i];
+      if (cue.startTime >= start && cue.endTime <= end) {
+        cuesFound.push(cue);
+      } else if (cue.startTime > end) {
+        return cuesFound;
+      }
+    }
+  }
+  return cuesFound;
+}
+
+const MIN_CUE_DURATION = 0.25;
+function getCueClass() {
+  if (typeof self === 'undefined') return undefined;
+  return self.VTTCue || self.TextTrackCue;
+}
+function createCueWithDataFields(Cue, startTime, endTime, data, type) {
+  let cue = new Cue(startTime, endTime, '');
+  try {
+    cue.value = data;
+    if (type) {
+      cue.type = type;
+    }
+  } catch (e) {
+    cue = new Cue(startTime, endTime, JSON.stringify(type ? _objectSpread2({
+      type
+    }, data) : data));
+  }
+  return cue;
+}
+
+// VTTCue latest draft allows an infinite duration, fallback
+// to MAX_VALUE if necessary
+const MAX_CUE_ENDTIME = (() => {
+  const Cue = getCueClass();
+  try {
+    Cue && new Cue(0, Number.POSITIVE_INFINITY, '');
+  } catch (e) {
+    return Number.MAX_VALUE;
+  }
+  return Number.POSITIVE_INFINITY;
+})();
+function hexToArrayBuffer(str) {
+  return Uint8Array.from(str.replace(/^0x/, '').replace(/([\da-fA-F]{2}) ?/g, '0x$1 ').replace(/ +$/, '').split(' ')).buffer;
+}
+class ID3TrackController {
+  constructor(hls) {
+    this.hls = undefined;
+    this.id3Track = null;
+    this.media = null;
+    this.dateRangeCuesAppended = {};
+    this.removeCues = true;
+    this.onEventCueEnter = () => {
+      if (!this.hls) {
+        return;
+      }
+      this.hls.trigger(Events.EVENT_CUE_ENTER, {});
+    };
+    this.hls = hls;
+    this._registerListeners();
+  }
+  destroy() {
+    this._unregisterListeners();
+    this.id3Track = null;
+    this.media = null;
+    this.dateRangeCuesAppended = {};
+    // @ts-ignore
+    this.hls = this.onEventCueEnter = null;
+  }
+  _registerListeners() {
+    const {
+      hls
+    } = this;
+    hls.on(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
+    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
+    hls.on(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
+    hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
+    hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
+    hls.on(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
+  }
+  _unregisterListeners() {
+    const {
+      hls
+    } = this;
+    hls.off(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
+    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
+    hls.off(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
+    hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
+    hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
+    hls.off(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
+  }
+  // Add ID3 metatadata text track.
+  onMediaAttaching(event, data) {
+    var _data$overrides;
+    this.media = data.media;
+    if (((_data$overrides = data.overrides) == null ? undefined : _data$overrides.cueRemoval) === false) {
+      this.removeCues = false;
+    }
+  }
+  onMediaAttached() {
+    const details = this.hls.latestLevelDetails;
+    if (details) {
+      this.updateDateRangeCues(details);
+    }
+  }
+  onMediaDetaching(event, data) {
+    this.media = null;
+    const transferringMedia = !!data.transferMedia;
+    if (transferringMedia) {
+      return;
+    }
+    if (this.id3Track) {
+      if (this.removeCues) {
+        clearCurrentCues(this.id3Track, this.onEventCueEnter);
+      }
+      this.id3Track = null;
+    }
+    this.dateRangeCuesAppended = {};
+  }
+  onManifestLoading() {
+    this.dateRangeCuesAppended = {};
+  }
+  createTrack(media) {
+    const track = this.getID3Track(media.textTracks);
+    track.mode = 'hidden';
+    return track;
+  }
+  getID3Track(textTracks) {
+    if (!this.media) {
+      return;
+    }
+    for (let i = 0; i < textTracks.length; i++) {
+      const textTrack = textTracks[i];
+      if (textTrack.kind === 'metadata' && textTrack.label === 'id3') {
+        // send 'addtrack' when reusing the textTrack for metadata,
+        // same as what we do for captions
+        sendAddTrackEvent(textTrack, this.media);
+        return textTrack;
+      }
+    }
+    return this.media.addTextTrack('metadata', 'id3');
+  }
+  onFragParsingMetadata(event, data) {
+    if (!this.media) {
+      return;
+    }
+    const {
+      hls: {
+        config: {
+          enableEmsgMetadataCues,
+          enableID3MetadataCues
+        }
+      }
+    } = this;
+    if (!enableEmsgMetadataCues && !enableID3MetadataCues) {
+      return;
+    }
+    const {
+      samples
+    } = data;
+
+    // create track dynamically
+    if (!this.id3Track) {
+      this.id3Track = this.createTrack(this.media);
+    }
+    const Cue = getCueClass();
+    if (!Cue) {
+      return;
+    }
+    for (let i = 0; i < samples.length; i++) {
+      const type = samples[i].type;
+      if (type === MetadataSchema.emsg && !enableEmsgMetadataCues || !enableID3MetadataCues) {
+        continue;
+      }
+      const frames = getId3Frames(samples[i].data);
+      if (frames) {
+        const startTime = samples[i].pts;
+        let endTime = startTime + samples[i].duration;
+        if (endTime > MAX_CUE_ENDTIME) {
+          endTime = MAX_CUE_ENDTIME;
+        }
+        const timeDiff = endTime - startTime;
+        if (timeDiff <= 0) {
+          endTime = startTime + MIN_CUE_DURATION;
+        }
+        for (let j = 0; j < frames.length; j++) {
+          const frame = frames[j];
+          // Safari doesn't put the timestamp frame in the TextTrack
+          if (!isId3TimestampFrame(frame)) {
+            // add a bounds to any unbounded cues
+            this.updateId3CueEnds(startTime, type);
+            const cue = createCueWithDataFields(Cue, startTime, endTime, frame, type);
+            if (cue) {
+              this.id3Track.addCue(cue);
+            }
+          }
+        }
+      }
+    }
+  }
+  updateId3CueEnds(startTime, type) {
+    var _this$id3Track;
+    const cues = (_this$id3Track = this.id3Track) == null ? undefined : _this$id3Track.cues;
+    if (cues) {
+      for (let i = cues.length; i--;) {
+        const cue = cues[i];
+        if (cue.type === type && cue.startTime < startTime && cue.endTime === MAX_CUE_ENDTIME) {
+          cue.endTime = startTime;
+        }
+      }
+    }
+  }
+  onBufferFlushing(event, {
+    startOffset,
+    endOffset,
+    type
+  }) {
+    const {
+      id3Track,
+      hls
+    } = this;
+    if (!hls) {
+      return;
+    }
+    const {
+      config: {
+        enableEmsgMetadataCues,
+        enableID3MetadataCues
+      }
+    } = hls;
+    if (id3Track && (enableEmsgMetadataCues || enableID3MetadataCues)) {
+      let predicate;
+      if (type === 'audio') {
+        predicate = cue => cue.type === MetadataSchema.audioId3 && enableID3MetadataCues;
+      } else if (type === 'video') {
+        predicate = cue => cue.type === MetadataSchema.emsg && enableEmsgMetadataCues;
+      } else {
+        predicate = cue => cue.type === MetadataSchema.audioId3 && enableID3MetadataCues || cue.type === MetadataSchema.emsg && enableEmsgMetadataCues;
+      }
+      removeCuesInRange(id3Track, startOffset, endOffset, predicate);
+    }
+  }
+  onLevelUpdated(event, {
+    details
+  }) {
+    this.updateDateRangeCues(details, true);
+  }
+  onLevelPtsUpdated(event, data) {
+    if (Math.abs(data.drift) > 0.01) {
+      this.updateDateRangeCues(data.details);
+    }
+  }
+  updateDateRangeCues(details, removeOldCues) {
+    if (!this.media || !details.hasProgramDateTime || !this.hls.config.enableDateRangeMetadataCues) {
+      return;
+    }
+    const {
+      id3Track
+    } = this;
+    const {
+      dateRanges
+    } = details;
     const ids = Object.keys(dateRanges);
     let dateRangeCuesAppended = this.dateRangeCuesAppended;
     // Remove cues from track not found in details.dateRanges
@@ -18473,6 +19055,9 @@ class LevelController extends BasePlaylistController {
     }
     return this._levels;
   }
+  get loadLevelObj() {
+    return this.currentLevel;
+  }
   get level() {
     return this.currentLevelIndex;
   }
@@ -18545,599 +19130,223 @@ class LevelController extends BasePlaylistController {
       this.loadPlaylist(hlsUrlParameters);
     }
   }
-  get manualLevel() {
-    return this.manualLevelIndex;
-  }
-  set manualLevel(newLevel) {
-    this.manualLevelIndex = newLevel;
-    if (this._startLevel === undefined) {
-      this._startLevel = newLevel;
-    }
-    if (newLevel !== -1) {
-      this.level = newLevel;
-    }
-  }
-  get firstLevel() {
-    return this._firstLevel;
-  }
-  set firstLevel(newLevel) {
-    this._firstLevel = newLevel;
-  }
-  get startLevel() {
-    // Setting hls.startLevel (this._startLevel) overrides config.startLevel
-    if (this._startLevel === undefined) {
-      const configStartLevel = this.hls.config.startLevel;
-      if (configStartLevel !== undefined) {
-        return configStartLevel;
-      }
-      return this.hls.firstAutoLevel;
-    }
-    return this._startLevel;
-  }
-  set startLevel(newLevel) {
-    this._startLevel = newLevel;
-  }
-  get pathwayPriority() {
-    if (this.steering) {
-      return this.steering.pathwayPriority;
-    }
-    return null;
-  }
-  set pathwayPriority(pathwayPriority) {
-    if (this.steering) {
-      const pathwaysList = this.steering.pathways();
-      const filteredPathwayPriority = pathwayPriority.filter(pathwayId => {
-        return pathwaysList.indexOf(pathwayId) !== -1;
-      });
-      if (pathwayPriority.length < 1) {
-        this.warn(`pathwayPriority ${pathwayPriority} should contain at least one pathway from list: ${pathwaysList}`);
-        return;
-      }
-      this.steering.pathwayPriority = filteredPathwayPriority;
-    }
-  }
-  onError(event, data) {
-    if (data.fatal || !data.context) {
-      return;
-    }
-    if (data.context.type === PlaylistContextType.LEVEL && data.context.level === this.level) {
-      this.checkRetry(data);
-    }
-  }
-
-  // reset errors on the successful load of a fragment
-  onFragBuffered(event, {
-    frag
-  }) {
-    if (frag !== undefined && frag.type === PlaylistLevelType.MAIN) {
-      const el = frag.elementaryStreams;
-      if (!Object.keys(el).some(type => !!el[type])) {
-        return;
-      }
-      const level = this._levels[frag.level];
-      if (level != null && level.loadError) {
-        this.log(`Resetting level error count of ${level.loadError} on frag buffered`);
-        level.loadError = 0;
-      }
-    }
-  }
-  onLevelLoaded(event, data) {
-    var _data$deliveryDirecti2;
-    const {
-      level,
-      details
-    } = data;
-    const curLevel = data.levelInfo;
-    if (!curLevel) {
-      var _data$deliveryDirecti;
-      this.warn(`Invalid level index ${level}`);
-      if ((_data$deliveryDirecti = data.deliveryDirectives) != null && _data$deliveryDirecti.skip) {
-        details.deltaUpdateFailed = true;
-      }
-      return;
-    }
-
-    // only process level loaded events matching with expected level or prior to switch when media playlist is loaded directly
-    if (curLevel === this.currentLevel || data.withoutMultiVariant) {
-      // reset level load error counter on successful level loaded only if there is no issues with fragments
-      if (curLevel.fragmentError === 0) {
-        curLevel.loadError = 0;
-      }
-      // Ignore matching details populated by loading a Media Playlist directly
-      let previousDetails = curLevel.details;
-      if (previousDetails === data.details && previousDetails.advanced) {
-        previousDetails = undefined;
-      }
-      this.playlistLoaded(level, data, previousDetails);
-    } else if ((_data$deliveryDirecti2 = data.deliveryDirectives) != null && _data$deliveryDirecti2.skip) {
-      // received a delta playlist update that cannot be merged
-      details.deltaUpdateFailed = true;
-    }
-  }
-  loadPlaylist(hlsUrlParameters) {
-    super.loadPlaylist();
-    if (this.shouldLoadPlaylist(this.currentLevel)) {
-      this.scheduleLoading(this.currentLevel, hlsUrlParameters);
-    }
-  }
-  loadingPlaylist(currentLevel, hlsUrlParameters) {
-    super.loadingPlaylist(currentLevel, hlsUrlParameters);
-    const url = this.getUrlWithDirectives(currentLevel.uri, hlsUrlParameters);
-    const currentLevelIndex = this.currentLevelIndex;
-    const pathwayId = currentLevel.attrs['PATHWAY-ID'];
-    const details = currentLevel.details;
-    const age = details == null ? undefined : details.age;
-    this.log(`Loading level index ${currentLevelIndex}${(hlsUrlParameters == null ? undefined : hlsUrlParameters.msn) !== undefined ? ' at sn ' + hlsUrlParameters.msn + ' part ' + hlsUrlParameters.part : ''}${pathwayId ? ' Pathway ' + pathwayId : ''}${age && details.live ? ' age ' + age.toFixed(1) + (details.type ? ' ' + details.type || '' : '') : ''} ${url}`);
-    this.hls.trigger(Events.LEVEL_LOADING, {
-      url,
-      level: currentLevelIndex,
-      levelInfo: currentLevel,
-      pathwayId: currentLevel.attrs['PATHWAY-ID'],
-      id: 0,
-      // Deprecated Level urlId
-      deliveryDirectives: hlsUrlParameters || null
-    });
-  }
-  get nextLoadLevel() {
-    if (this.manualLevelIndex !== -1) {
-      return this.manualLevelIndex;
-    } else {
-      return this.hls.nextAutoLevel;
-    }
-  }
-  set nextLoadLevel(nextLevel) {
-    this.level = nextLevel;
-    if (this.manualLevelIndex === -1) {
-      this.hls.nextAutoLevel = nextLevel;
-    }
-  }
-  removeLevel(levelIndex) {
-    var _this$currentLevel;
-    if (this._levels.length === 1) {
-      return;
-    }
-    const levels = this._levels.filter((level, index) => {
-      if (index !== levelIndex) {
-        return true;
-      }
-      if (this.steering) {
-        this.steering.removeLevel(level);
-      }
-      if (level === this.currentLevel) {
-        this.currentLevel = null;
-        this.currentLevelIndex = -1;
-        if (level.details) {
-          level.details.fragments.forEach(f => f.level = -1);
-        }
-      }
-      return false;
-    });
-    reassignFragmentLevelIndexes(levels);
-    this._levels = levels;
-    if (this.currentLevelIndex > -1 && (_this$currentLevel = this.currentLevel) != null && _this$currentLevel.details) {
-      this.currentLevelIndex = this.currentLevel.details.fragments[0].level;
-    }
-    if (this.manualLevelIndex > -1) {
-      this.manualLevelIndex = this.currentLevelIndex;
-    }
-    const maxLevel = levels.length - 1;
-    this._firstLevel = Math.min(this._firstLevel, maxLevel);
-    if (this._startLevel) {
-      this._startLevel = Math.min(this._startLevel, maxLevel);
-    }
-    this.hls.trigger(Events.LEVELS_UPDATED, {
-      levels
-    });
-  }
-  onLevelsUpdated(event, {
-    levels
-  }) {
-    this._levels = levels;
-  }
-  checkMaxAutoUpdated() {
-    const {
-      autoLevelCapping,
-      maxAutoLevel,
-      maxHdcpLevel
-    } = this.hls;
-    if (this._maxAutoLevel !== maxAutoLevel) {
-      this._maxAutoLevel = maxAutoLevel;
-      this.hls.trigger(Events.MAX_AUTO_LEVEL_UPDATED, {
-        autoLevelCapping,
-        levels: this.levels,
-        maxAutoLevel,
-        minAutoLevel: this.hls.minAutoLevel,
-        maxHdcpLevel
-      });
-    }
-  }
-}
-function assignTrackIdsByGroup(tracks) {
-  const groups = {};
-  tracks.forEach(track => {
-    const groupId = track.groupId || '';
-    track.id = groups[groupId] = groups[groupId] || 0;
-    groups[groupId]++;
-  });
-}
-
-const MAX_START_GAP_JUMP = 2.0;
-const SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
-const SKIP_BUFFER_RANGE_START = 0.05;
-class GapController extends Logger {
-  constructor(media, fragmentTracker, hls) {
-    super('gap-controller', hls.logger);
-    this.media = null;
-    this.fragmentTracker = null;
-    this.hls = null;
-    this.nudgeRetry = 0;
-    this.stallReported = false;
-    this.stalled = null;
-    this.moved = false;
-    this.seeking = false;
-    this.ended = 0;
-    this.waiting = 0;
-    this.media = media;
-    this.fragmentTracker = fragmentTracker;
-    this.hls = hls;
-  }
-  destroy() {
-    this.media = this.hls = this.fragmentTracker = null;
+  get manualLevel() {
+    return this.manualLevelIndex;
   }
-
-  /**
-   * Checks if the playhead is stuck within a gap, and if so, attempts to free it.
-   * A gap is an unbuffered range between two buffered ranges (or the start and the first buffered range).
-   *
-   * @param lastCurrentTime - Previously read playhead position
-   */
-  poll(lastCurrentTime, activeFrag, levelDetails, state) {
-    var _this$hls;
-    const {
-      media,
-      stalled
-    } = this;
-    if (!media) {
-      return;
+  set manualLevel(newLevel) {
+    this.manualLevelIndex = newLevel;
+    if (this._startLevel === undefined) {
+      this._startLevel = newLevel;
     }
-    const {
-      currentTime,
-      seeking
-    } = media;
-    const seeked = this.seeking && !seeking;
-    const beginSeek = !this.seeking && seeking;
-    this.seeking = seeking;
-
-    // The playhead is moving, no-op
-    if (currentTime !== lastCurrentTime) {
-      if (lastCurrentTime) {
-        this.ended = 0;
-      }
-      this.moved = true;
-      if (!seeking) {
-        this.nudgeRetry = 0;
-      }
-      if (this.waiting === 0) {
-        this.stallResolved(currentTime);
-      }
-      return;
+    if (newLevel !== -1) {
+      this.level = newLevel;
     }
-
-    // Clear stalled state when beginning or finishing seeking so that we don't report stalls coming out of a seek
-    if (beginSeek || seeked) {
-      if (seeked) {
-        this.stallResolved(currentTime);
+  }
+  get firstLevel() {
+    return this._firstLevel;
+  }
+  set firstLevel(newLevel) {
+    this._firstLevel = newLevel;
+  }
+  get startLevel() {
+    // Setting hls.startLevel (this._startLevel) overrides config.startLevel
+    if (this._startLevel === undefined) {
+      const configStartLevel = this.hls.config.startLevel;
+      if (configStartLevel !== undefined) {
+        return configStartLevel;
       }
-      return;
+      return this.hls.firstAutoLevel;
     }
-
-    // The playhead should not be moving
-    if (media.paused && !seeking || media.ended || media.playbackRate === 0) {
-      this.nudgeRetry = 0;
-      this.stallResolved(currentTime);
-      // Fire MEDIA_ENDED to workaround event not being dispatched by browser
-      if (!this.ended && media.ended && this.hls) {
-        this.ended = currentTime || 1;
-        this.hls.trigger(Events.MEDIA_ENDED, {
-          stalled: false
-        });
+    return this._startLevel;
+  }
+  set startLevel(newLevel) {
+    this._startLevel = newLevel;
+  }
+  get pathwayPriority() {
+    if (this.steering) {
+      return this.steering.pathwayPriority;
+    }
+    return null;
+  }
+  set pathwayPriority(pathwayPriority) {
+    if (this.steering) {
+      const pathwaysList = this.steering.pathways();
+      const filteredPathwayPriority = pathwayPriority.filter(pathwayId => {
+        return pathwaysList.indexOf(pathwayId) !== -1;
+      });
+      if (pathwayPriority.length < 1) {
+        this.warn(`pathwayPriority ${pathwayPriority} should contain at least one pathway from list: ${pathwaysList}`);
+        return;
       }
-      return;
+      this.steering.pathwayPriority = filteredPathwayPriority;
     }
-    if (!BufferHelper.getBuffered(media).length) {
-      this.nudgeRetry = 0;
+  }
+  onError(event, data) {
+    if (data.fatal || !data.context) {
       return;
     }
-    const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
-    const nextStart = bufferInfo.nextStart || 0;
-    const fragmentTracker = this.fragmentTracker;
-    if (seeking && fragmentTracker) {
-      // Waiting for seeking in a buffered range to complete
-      const hasEnoughBuffer = bufferInfo.len > MAX_START_GAP_JUMP;
-      // Next buffered range is too far ahead to jump to while still seeking
-      const noBufferGap = !nextStart || activeFrag && activeFrag.start <= currentTime || nextStart - currentTime > MAX_START_GAP_JUMP && !fragmentTracker.getPartialFragment(currentTime);
-      if (hasEnoughBuffer || noBufferGap) {
-        return;
-      }
-      // Reset moved state when seeking to a point in or before a gap
-      this.moved = false;
+    if (data.context.type === PlaylistContextType.LEVEL && data.context.level === this.level) {
+      this.checkRetry(data);
     }
+  }
 
-    // Skip start gaps if we haven't played, but the last poll detected the start of a stall
-    // The addition poll gives the browser a chance to jump the gap for us
-    if (!this.moved && this.stalled !== null && fragmentTracker) {
-      // There is no playable buffer (seeked, waiting for buffer)
-      const isBuffered = bufferInfo.len > 0;
-      if (!isBuffered && !nextStart) {
+  // reset errors on the successful load of a fragment
+  onFragBuffered(event, {
+    frag
+  }) {
+    if (frag !== undefined && frag.type === PlaylistLevelType.MAIN) {
+      const el = frag.elementaryStreams;
+      if (!Object.keys(el).some(type => !!el[type])) {
         return;
       }
-      // Jump start gaps within jump threshold
-      const startJump = Math.max(nextStart, bufferInfo.start || 0) - currentTime;
-
-      // When joining a live stream with audio tracks, account for live playlist window sliding by allowing
-      // a larger jump over start gaps caused by the audio-stream-controller buffering a start fragment
-      // that begins over 1 target duration after the video start position.
-      const isLive = !!(levelDetails != null && levelDetails.live);
-      const maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
-      const partialOrGap = fragmentTracker.getPartialFragment(currentTime);
-      if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
-        if (!media.paused) {
-          this._trySkipBufferHole(partialOrGap);
-        }
-        return;
+      const level = this._levels[frag.level];
+      if (level != null && level.loadError) {
+        this.log(`Resetting level error count of ${level.loadError} on frag buffered`);
+        level.loadError = 0;
       }
     }
-
-    // Start tracking stall time
-    const config = (_this$hls = this.hls) == null ? undefined : _this$hls.config;
-    if (!config) {
-      return;
-    }
-    const detectStallWithCurrentTimeMs = config.detectStallWithCurrentTimeMs;
-    const tnow = self.performance.now();
-    const tWaiting = this.waiting;
-    if (stalled === null) {
-      // Use time of recent "waiting" event
-      if (tWaiting > 0 && tnow - tWaiting < detectStallWithCurrentTimeMs) {
-        this.stalled = tWaiting;
-      } else {
-        this.stalled = tnow;
+  }
+  onLevelLoaded(event, data) {
+    var _data$deliveryDirecti2;
+    const {
+      level,
+      details
+    } = data;
+    const curLevel = data.levelInfo;
+    if (!curLevel) {
+      var _data$deliveryDirecti;
+      this.warn(`Invalid level index ${level}`);
+      if ((_data$deliveryDirecti = data.deliveryDirectives) != null && _data$deliveryDirecti.skip) {
+        details.deltaUpdateFailed = true;
       }
       return;
     }
-    const stalledDuration = tnow - stalled;
-    if (!seeking && (stalledDuration >= detectStallWithCurrentTimeMs || tWaiting) && this.hls) {
-      // Dispatch MEDIA_ENDED when media.ended/ended event is not signalled at end of stream
-      if (state === State.ENDED && !(levelDetails != null && levelDetails.live) && Math.abs(currentTime - ((levelDetails == null ? undefined : levelDetails.edge) || 0)) < 1) {
-        if (this.ended) {
-          return;
-        }
-        this.ended = currentTime || 1;
-        this.hls.trigger(Events.MEDIA_ENDED, {
-          stalled: true
-        });
-        return;
+
+    // only process level loaded events matching with expected level or prior to switch when media playlist is loaded directly
+    if (curLevel === this.currentLevel || data.withoutMultiVariant) {
+      // reset level load error counter on successful level loaded only if there is no issues with fragments
+      if (curLevel.fragmentError === 0) {
+        curLevel.loadError = 0;
       }
-      // Report stalling after trying to fix
-      this._reportStall(bufferInfo);
-      if (!this.media || !this.hls) {
-        return;
+      // Ignore matching details populated by loading a Media Playlist directly
+      let previousDetails = curLevel.details;
+      if (previousDetails === data.details && previousDetails.advanced) {
+        previousDetails = undefined;
       }
+      this.playlistLoaded(level, data, previousDetails);
+    } else if ((_data$deliveryDirecti2 = data.deliveryDirectives) != null && _data$deliveryDirecti2.skip) {
+      // received a delta playlist update that cannot be merged
+      details.deltaUpdateFailed = true;
     }
-    const bufferedWithHoles = BufferHelper.bufferInfo(media, currentTime, config.maxBufferHole);
-    this._tryFixBufferStall(bufferedWithHoles, stalledDuration);
   }
-  stallResolved(currentTime) {
-    const stalled = this.stalled;
-    if (stalled && this.hls) {
-      this.stalled = null;
-      // The playhead is now moving, but was previously stalled
-      if (this.stallReported) {
-        const stalledDuration = self.performance.now() - stalled;
-        this.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(stalledDuration)}ms`);
-        this.stallReported = false;
-        this.waiting = 0;
-        this.hls.trigger(Events.STALL_RESOLVED, {});
-      }
+  loadPlaylist(hlsUrlParameters) {
+    super.loadPlaylist();
+    if (this.shouldLoadPlaylist(this.currentLevel)) {
+      this.scheduleLoading(this.currentLevel, hlsUrlParameters);
     }
   }
-
-  /**
-   * Detects and attempts to fix known buffer stalling issues.
-   * @param bufferInfo - The properties of the current buffer.
-   * @param stalledDurationMs - The amount of time Hls.js has been stalling for.
-   * @private
-   */
-  _tryFixBufferStall(bufferInfo, stalledDurationMs) {
-    var _this$hls2;
-    const {
-      fragmentTracker,
-      media
-    } = this;
-    const config = (_this$hls2 = this.hls) == null ? undefined : _this$hls2.config;
-    if (!media || !fragmentTracker || !config) {
-      return;
-    }
-    const currentTime = media.currentTime;
-    const partial = fragmentTracker.getPartialFragment(currentTime);
-    if (partial) {
-      // Try to skip over the buffer hole caused by a partial fragment
-      // This method isn't limited by the size of the gap between buffered ranges
-      const targetTime = this._trySkipBufferHole(partial);
-      // we return here in this case, meaning
-      // the branch below only executes when we haven't seeked to a new position
-      if (targetTime || !this.media) {
-        return;
-      }
-    }
-
-    // if we haven't had to skip over a buffer hole of a partial fragment
-    // we may just have to "nudge" the playlist as the browser decoding/rendering engine
-    // needs to cross some sort of threshold covering all source-buffers content
-    // to start playing properly.
-    const bufferedRanges = bufferInfo.buffered;
-    if ((bufferedRanges && bufferedRanges.length > 1 && bufferInfo.len > config.maxBufferHole || bufferInfo.nextStart && bufferInfo.nextStart - currentTime < config.maxBufferHole) && stalledDurationMs > config.highBufferWatchdogPeriod * 1000) {
-      this.warn('Trying to nudge playhead over buffer-hole');
-      // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
-      // We only try to jump the hole if it's under the configured size
-      this._tryNudgeBuffer(bufferInfo);
+  loadingPlaylist(currentLevel, hlsUrlParameters) {
+    super.loadingPlaylist(currentLevel, hlsUrlParameters);
+    const url = this.getUrlWithDirectives(currentLevel.uri, hlsUrlParameters);
+    const currentLevelIndex = this.currentLevelIndex;
+    const pathwayId = currentLevel.attrs['PATHWAY-ID'];
+    const details = currentLevel.details;
+    const age = details == null ? undefined : details.age;
+    this.log(`Loading level index ${currentLevelIndex}${(hlsUrlParameters == null ? undefined : hlsUrlParameters.msn) !== undefined ? ' at sn ' + hlsUrlParameters.msn + ' part ' + hlsUrlParameters.part : ''}${pathwayId ? ' Pathway ' + pathwayId : ''}${age && details.live ? ' age ' + age.toFixed(1) + (details.type ? ' ' + details.type || '' : '') : ''} ${url}`);
+    this.hls.trigger(Events.LEVEL_LOADING, {
+      url,
+      level: currentLevelIndex,
+      levelInfo: currentLevel,
+      pathwayId: currentLevel.attrs['PATHWAY-ID'],
+      id: 0,
+      // Deprecated Level urlId
+      deliveryDirectives: hlsUrlParameters || null
+    });
+  }
+  get nextLoadLevel() {
+    if (this.manualLevelIndex !== -1) {
+      return this.manualLevelIndex;
+    } else {
+      return this.hls.nextAutoLevel;
     }
   }
-
-  /**
-   * Triggers a BUFFER_STALLED_ERROR event, but only once per stall period.
-   * @param bufferLen - The playhead distance from the end of the current buffer segment.
-   * @private
-   */
-  _reportStall(bufferInfo) {
-    const {
-      hls,
-      media,
-      stallReported,
-      stalled
-    } = this;
-    if (!stallReported && stalled !== null && media && hls) {
-      // Report stalled error once
-      this.stallReported = true;
-      const error = new Error(`Playback stalling at @${media.currentTime} due to low buffer (${JSON.stringify(bufferInfo)})`);
-      this.warn(error.message);
-      hls.trigger(Events.ERROR, {
-        type: ErrorTypes.MEDIA_ERROR,
-        details: ErrorDetails.BUFFER_STALLED_ERROR,
-        fatal: false,
-        error,
-        buffer: bufferInfo.len,
-        bufferInfo,
-        stalled: {
-          start: stalled
-        }
-      });
+  set nextLoadLevel(nextLevel) {
+    this.level = nextLevel;
+    if (this.manualLevelIndex === -1) {
+      this.hls.nextAutoLevel = nextLevel;
     }
   }
-
-  /**
-   * Attempts to fix buffer stalls by jumping over known gaps caused by partial fragments
-   * @param partial - The partial fragment found at the current time (where playback is stalling).
-   * @private
-   */
-  _trySkipBufferHole(partial) {
-    var _this$hls3;
-    const {
-      fragmentTracker,
-      media
-    } = this;
-    const config = (_this$hls3 = this.hls) == null ? undefined : _this$hls3.config;
-    if (!media || !fragmentTracker || !config) {
-      return 0;
+  removeLevel(levelIndex) {
+    var _this$currentLevel;
+    if (this._levels.length === 1) {
+      return;
     }
-
-    // Check if currentTime is between unbuffered regions of partial fragments
-    const currentTime = media.currentTime;
-    const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
-    const startTime = currentTime < bufferInfo.start ? bufferInfo.start : bufferInfo.nextStart;
-    if (startTime) {
-      const bufferStarved = bufferInfo.len <= config.maxBufferHole;
-      const waiting = bufferInfo.len > 0 && bufferInfo.len < 1 && media.readyState < 3;
-      const gapLength = startTime - currentTime;
-      if (gapLength > 0 && (bufferStarved || waiting)) {
-        // Only allow large gaps to be skipped if it is a start gap, or all fragments in skip range are partial
-        if (gapLength > config.maxBufferHole) {
-          let startGap = false;
-          if (currentTime === 0) {
-            const startFrag = fragmentTracker.getAppendedFrag(0, PlaylistLevelType.MAIN);
-            if (startFrag && startTime < startFrag.end) {
-              startGap = true;
-            }
-          }
-          if (!startGap) {
-            const startProvisioned = partial || fragmentTracker.getAppendedFrag(currentTime, PlaylistLevelType.MAIN);
-            if (startProvisioned) {
-              let moreToLoad = false;
-              let pos = startProvisioned.end;
-              while (pos < startTime) {
-                const provisioned = fragmentTracker.getPartialFragment(pos);
-                if (provisioned) {
-                  pos += provisioned.duration;
-                } else {
-                  moreToLoad = true;
-                  break;
-                }
-              }
-              if (moreToLoad) {
-                return 0;
-              }
-            }
-          }
-        }
-        const targetTime = Math.max(startTime + SKIP_BUFFER_RANGE_START, currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS);
-        this.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
-        this.moved = true;
-        media.currentTime = targetTime;
-        if (partial && !partial.gap && this.hls) {
-          const error = new Error(`fragment loaded with buffer holes, seeking from ${currentTime} to ${targetTime}`);
-          this.hls.trigger(Events.ERROR, {
-            type: ErrorTypes.MEDIA_ERROR,
-            details: ErrorDetails.BUFFER_SEEK_OVER_HOLE,
-            fatal: false,
-            error,
-            reason: error.message,
-            frag: partial,
-            buffer: bufferInfo.len,
-            bufferInfo
-          });
+    const levels = this._levels.filter((level, index) => {
+      if (index !== levelIndex) {
+        return true;
+      }
+      if (this.steering) {
+        this.steering.removeLevel(level);
+      }
+      if (level === this.currentLevel) {
+        this.currentLevel = null;
+        this.currentLevelIndex = -1;
+        if (level.details) {
+          level.details.fragments.forEach(f => f.level = -1);
         }
-        return targetTime;
       }
+      return false;
+    });
+    reassignFragmentLevelIndexes(levels);
+    this._levels = levels;
+    if (this.currentLevelIndex > -1 && (_this$currentLevel = this.currentLevel) != null && _this$currentLevel.details) {
+      this.currentLevelIndex = this.currentLevel.details.fragments[0].level;
     }
-    return 0;
+    if (this.manualLevelIndex > -1) {
+      this.manualLevelIndex = this.currentLevelIndex;
+    }
+    const maxLevel = levels.length - 1;
+    this._firstLevel = Math.min(this._firstLevel, maxLevel);
+    if (this._startLevel) {
+      this._startLevel = Math.min(this._startLevel, maxLevel);
+    }
+    this.hls.trigger(Events.LEVELS_UPDATED, {
+      levels
+    });
   }
-
-  /**
-   * Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
-   * @private
-   */
-  _tryNudgeBuffer(bufferInfo) {
+  onLevelsUpdated(event, {
+    levels
+  }) {
+    this._levels = levels;
+  }
+  checkMaxAutoUpdated() {
     const {
-      hls,
-      media,
-      nudgeRetry
-    } = this;
-    const config = hls == null ? undefined : hls.config;
-    if (!media || !config) {
-      return 0;
-    }
-    const currentTime = media.currentTime;
-    this.nudgeRetry++;
-    if (nudgeRetry < config.nudgeMaxRetry) {
-      const targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
-      // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
-      const error = new Error(`Nudging 'currentTime' from ${currentTime} to ${targetTime}`);
-      this.warn(error.message);
-      media.currentTime = targetTime;
-      hls.trigger(Events.ERROR, {
-        type: ErrorTypes.MEDIA_ERROR,
-        details: ErrorDetails.BUFFER_NUDGE_ON_STALL,
-        error,
-        fatal: false,
-        buffer: bufferInfo.len,
-        bufferInfo
-      });
-    } else {
-      const error = new Error(`Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`);
-      this.error(error.message);
-      hls.trigger(Events.ERROR, {
-        type: ErrorTypes.MEDIA_ERROR,
-        details: ErrorDetails.BUFFER_STALLED_ERROR,
-        error,
-        fatal: true,
-        buffer: bufferInfo.len,
-        bufferInfo
+      autoLevelCapping,
+      maxAutoLevel,
+      maxHdcpLevel
+    } = this.hls;
+    if (this._maxAutoLevel !== maxAutoLevel) {
+      this._maxAutoLevel = maxAutoLevel;
+      this.hls.trigger(Events.MAX_AUTO_LEVEL_UPDATED, {
+        autoLevelCapping,
+        levels: this.levels,
+        maxAutoLevel,
+        minAutoLevel: this.hls.minAutoLevel,
+        maxHdcpLevel
       });
     }
   }
 }
+function assignTrackIdsByGroup(tracks) {
+  const groups = {};
+  tracks.forEach(track => {
+    const groupId = track.groupId || '';
+    track.id = groups[groupId] = groups[groupId] || 0;
+    groups[groupId]++;
+  });
+}
 
-const version = "1.6.0-beta.2.0.canary.10924";
+const version = "1.6.0-beta.2.0.canary.10926";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -19552,7 +19761,6 @@ class StreamController extends BaseStreamController {
   constructor(hls, fragmentTracker, keyLoader) {
     super(hls, fragmentTracker, keyLoader, 'stream-controller', PlaylistLevelType.MAIN);
     this.audioCodecSwap = false;
-    this.gapController = null;
     this.level = -1;
     this._forceStartLoad = false;
     this._hasEnoughToStart = false;
@@ -19564,19 +19772,8 @@ class StreamController extends BaseStreamController {
     this.backtrackFragment = null;
     this.audioCodecSwitch = false;
     this.videoBuffer = null;
-    this.onMediaWaiting = () => {
-      const gapController = this.gapController;
-      if (gapController) {
-        gapController.waiting = self.performance.now();
-      }
-    };
     this.onMediaPlaying = () => {
       // tick to speed up FRAG_CHANGED triggering
-      const gapController = this.gapController;
-      if (gapController) {
-        gapController.ended = 0;
-        gapController.waiting = 0;
-      }
       this.tick();
     };
     this.onMediaSeeked = () => {
@@ -19631,7 +19828,7 @@ class StreamController extends BaseStreamController {
   }
   onHandlerDestroying() {
     // @ts-ignore
-    this.onMediaPlaying = this.onMediaSeeked = this.onMediaWaiting = null;
+    this.onMediaPlaying = this.onMediaSeeked = null;
     this.unregisterListeners();
     super.onHandlerDestroying();
   }
@@ -19726,8 +19923,11 @@ class StreamController extends BaseStreamController {
     this.onTickEnd();
   }
   onTickEnd() {
+    var _this$media2;
     super.onTickEnd();
-    this.checkBuffer();
+    if ((_this$media2 = this.media) != null && _this$media2.readyState && this.media.seeking === false) {
+      this.lastCurrentTime = this.media.currentTime;
+    }
     this.checkFragmentChanged();
   }
   doTickIdle() {
@@ -19960,29 +20160,19 @@ class StreamController extends BaseStreamController {
   onMediaAttached(event, data) {
     super.onMediaAttached(event, data);
     const media = data.media;
-    media.removeEventListener('playing', this.onMediaPlaying);
-    media.removeEventListener('seeked', this.onMediaSeeked);
-    media.removeEventListener('waiting', this.onMediaWaiting);
-    media.addEventListener('playing', this.onMediaPlaying);
-    media.addEventListener('seeked', this.onMediaSeeked);
-    media.addEventListener('waiting', this.onMediaWaiting);
-    this.gapController = new GapController(media, this.fragmentTracker, this.hls);
+    addEventListener(media, 'playing', this.onMediaPlaying);
+    addEventListener(media, 'seeked', this.onMediaSeeked);
   }
   onMediaDetaching(event, data) {
     const {
       media
     } = this;
     if (media) {
-      media.removeEventListener('playing', this.onMediaPlaying);
-      media.removeEventListener('seeked', this.onMediaSeeked);
-      media.removeEventListener('waiting', this.onMediaWaiting);
+      removeEventListener(media, 'playing', this.onMediaPlaying);
+      removeEventListener(media, 'seeked', this.onMediaSeeked);
     }
     this.videoBuffer = null;
     this.fragPlaying = null;
-    if (this.gapController) {
-      this.gapController.destroy();
-      this.gapController = null;
-    }
     super.onMediaDetaching(event, data);
     const transferringMedia = !!data.transferMedia;
     if (transferringMedia) {
@@ -19990,19 +20180,6 @@ class StreamController extends BaseStreamController {
     }
     this._hasEnoughToStart = false;
   }
-  triggerEnded() {
-    const gapController = this.gapController;
-    if (gapController) {
-      var _this$media2;
-      if (gapController.ended) {
-        return;
-      }
-      gapController.ended = ((_this$media2 = this.media) == null ? undefined : _this$media2.currentTime) || 1;
-    }
-    this.hls.trigger(Events.MEDIA_ENDED, {
-      stalled: false
-    });
-  }
   onManifestLoading() {
     super.onManifestLoading();
     // reset buffer on manifest loading
@@ -20337,26 +20514,6 @@ class StreamController extends BaseStreamController {
         break;
     }
   }
-
-  // Checks the health of the buffer and attempts to resolve playback stalls.
-  checkBuffer() {
-    const {
-      media,
-      gapController
-    } = this;
-    if (!media || !gapController || !media.readyState) {
-      // Exit early if we don't have media or if the media hasn't buffered anything yet (readyState 0)
-      return;
-    }
-    if (this._hasEnoughToStart || !BufferHelper.getBuffered(media).length) {
-      // Resolve gaps using the main buffer, whose ranges are the intersections of the A/V sourcebuffers
-      const state = this.state;
-      const activeFrag = state !== State.IDLE ? this.fragCurrent : null;
-      const levelDetails = this.getLevelDetails();
-      gapController.poll(this.lastCurrentTime, activeFrag, levelDetails, state);
-    }
-    this.lastCurrentTime = media.currentTime;
-  }
   onFragLoadEmergencyAborted() {
     this.state = State.IDLE;
     // if loadedmetadata is not set, it means that we are emergency switch down on first frag
@@ -20372,8 +20529,10 @@ class StreamController extends BaseStreamController {
   }) {
     if (type !== ElementaryStreamTypes.AUDIO || !this.altAudio) {
       const mediaBuffer = (type === ElementaryStreamTypes.VIDEO ? this.videoBuffer : this.mediaBuffer) || this.media;
-      this.afterBufferFlushed(mediaBuffer, type, PlaylistLevelType.MAIN);
-      this.tick();
+      if (mediaBuffer) {
+        this.afterBufferFlushed(mediaBuffer, type, PlaylistLevelType.MAIN);
+        this.tick();
+      }
     }
   }
   onLevelsUpdated(event, data) {
@@ -21847,9 +22006,12 @@ class Hls {
     this.latencyController = undefined;
     this.levelController = undefined;
     this.streamController = undefined;
+    this.audioStreamController = undefined;
+    this.subtititleStreamController = undefined;
     this.audioTrackController = undefined;
     this.subtitleTrackController = undefined;
     this.interstitialsController = undefined;
+    this.gapController = undefined;
     this.emeController = undefined;
     this.cmcdController = undefined;
     this._media = null;
@@ -21889,6 +22051,7 @@ class Hls {
     const id3TrackController = new ID3TrackController(this);
     const keyLoader = new KeyLoader(this.config);
     const streamController = this.streamController = new StreamController(this, fragmentTracker, keyLoader);
+    const gapController = this.gapController = new GapController(this, fragmentTracker);
 
     // Cap level controller uses streamController to flush the buffer
     capLevelController.setStreamController(streamController);
@@ -21902,17 +22065,17 @@ class Hls {
       networkControllers.splice(1, 0, contentSteering);
     }
     this.networkControllers = networkControllers;
-    const coreComponents = [abrController, bufferController, capLevelController, fpsController, id3TrackController, fragmentTracker];
+    const coreComponents = [abrController, bufferController, gapController, capLevelController, fpsController, id3TrackController, fragmentTracker];
     this.audioTrackController = this.createController(config.audioTrackController, networkControllers);
     const AudioStreamControllerClass = config.audioStreamController;
     if (AudioStreamControllerClass) {
-      networkControllers.push(new AudioStreamControllerClass(this, fragmentTracker, keyLoader));
+      networkControllers.push(this.audioStreamController = new AudioStreamControllerClass(this, fragmentTracker, keyLoader));
     }
     // Instantiate subtitleTrackController before SubtitleStreamController to receive level events first
     this.subtitleTrackController = this.createController(config.subtitleTrackController, networkControllers);
     const SubtitleStreamControllerClass = config.subtitleStreamController;
     if (SubtitleStreamControllerClass) {
-      networkControllers.push(new SubtitleStreamControllerClass(this, fragmentTracker, keyLoader));
+      networkControllers.push(this.subtititleStreamController = new SubtitleStreamControllerClass(this, fragmentTracker, keyLoader));
     }
     this.createController(config.timelineController, coreComponents);
     keyLoader.emeController = this.emeController = this.createController(config.emeController, coreComponents);
@@ -22179,6 +22342,18 @@ class Hls {
       });
     }
   }
+  get inFlightFragments() {
+    const inFlightData = {
+      [PlaylistLevelType.MAIN]: this.streamController.inFlightFrag
+    };
+    if (this.audioStreamController) {
+      inFlightData[PlaylistLevelType.AUDIO] = this.audioStreamController.inFlightFrag;
+    }
+    if (this.subtititleStreamController) {
+      inFlightData[PlaylistLevelType.SUBTITLE] = this.subtititleStreamController.inFlightFrag;
+    }
+    return inFlightData;
+  }
 
   /**
    * Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
@@ -22228,10 +22403,21 @@ class Hls {
     const levels = this.levelController.levels;
     return levels ? levels : [];
   }
+
+  /**
+   * @returns LevelDetails of last loaded level (variant) or `null` prior to loading a media playlist.
+   */
   get latestLevelDetails() {
     return this.streamController.getLevelDetails() || null;
   }
 
+  /**
+   * @returns Level object of selected level (variant) or `null` prior to selecting a level or once the level is removed.
+   */
+  get loadLevelObj() {
+    return this.levelController.loadLevelObj;
+  }
+
   /**
    * Index of quality level (variant) currently played
    */