hls.js 1.6.0-beta.2.0.canary.10923 → 1.6.0-beta.2.0.canary.10925

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.10923"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.2.0.canary.10925"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -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;
   }
@@ -9575,7 +9596,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 +9612,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 +17187,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 +17299,6 @@ const hlsDefaultConfig = _objectSpread2(_objectSpread2({
   progressive: false,
   lowLatencyMode: true,
   cmcd: undefined,
-  detectStallWithCurrentTimeMs: 1250,
   enableDateRangeMetadataCues: true,
   enableEmsgMetadataCues: true,
   enableEmsgKLVMetadata: false,
@@ -17517,1627 +17540,1798 @@ 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 ids = Object.keys(dateRanges);
-    let dateRangeCuesAppended = this.dateRangeCuesAppended;
-    // Remove cues from track not found in details.dateRanges
-    if (id3Track && removeOldCues) {
-      var _id3Track$cues;
-      if ((_id3Track$cues = id3Track.cues) != null && _id3Track$cues.length) {
-        const idsToRemove = Object.keys(dateRangeCuesAppended).filter(id => !ids.includes(id));
-        for (let i = idsToRemove.length; i--;) {
-          const id = idsToRemove[i];
-          const cues = dateRangeCuesAppended[id].cues;
-          delete dateRangeCuesAppended[id];
-          Object.keys(cues).forEach(key => {
-            try {
-              const cue = cues[key];
-              cue.removeEventListener('enter', this.onEventCueEnter);
-              id3Track.removeCue(cue);
-            } catch (e) {
-              /* no-op */
-            }
-          });
-        }
-      } else {
-        dateRangeCuesAppended = this.dateRangeCuesAppended = {};
-      }
-    }
-    // Exit if the playlist does not have Date Ranges or does not have Program Date Time
-    const lastFragment = details.fragments[details.fragments.length - 1];
-    if (ids.length === 0 || !isFiniteNumber(lastFragment == null ? undefined : lastFragment.programDateTime)) {
+    const config = (_this$hls3 = this.hls) == null ? undefined : _this$hls3.config;
+    if (!media || !fragmentTracker || !config) {
       return;
     }
-    if (!this.id3Track) {
-      this.id3Track = this.createTrack(this.media);
-    }
-    const Cue = getCueClass();
-    for (let i = 0; i < ids.length; i++) {
-      const id = ids[i];
-      const dateRange = dateRanges[id];
-      const startTime = dateRange.startTime;
-
-      // Process DateRanges to determine end-time (known DURATION, END-DATE, or END-ON-NEXT)
-      const appendedDateRangeCues = dateRangeCuesAppended[id];
-      const cues = (appendedDateRangeCues == null ? undefined : appendedDateRangeCues.cues) || {};
-      let durationKnown = (appendedDateRangeCues == null ? undefined : appendedDateRangeCues.durationKnown) || false;
-      let endTime = MAX_CUE_ENDTIME;
-      const {
-        duration,
-        endDate
-      } = dateRange;
-      if (endDate && duration !== null) {
-        endTime = startTime + duration;
-        durationKnown = true;
-      } else if (dateRange.endOnNext && !durationKnown) {
-        const nextDateRangeWithSameClass = ids.reduce((candidateDateRange, id) => {
-          if (id !== dateRange.id) {
-            const otherDateRange = dateRanges[id];
-            if (otherDateRange.class === dateRange.class && otherDateRange.startDate > dateRange.startDate && (!candidateDateRange || dateRange.startDate < candidateDateRange.startDate)) {
-              return otherDateRange;
-            }
-          }
-          return candidateDateRange;
-        }, null);
-        if (nextDateRangeWithSameClass) {
-          endTime = nextDateRangeWithSameClass.startTime;
-          durationKnown = true;
-        }
-      }
-
-      // Create TextTrack Cues for each MetadataGroup Item (select DateRange attribute)
-      // This is to emulate Safari HLS playback handling of DateRange tags
-      const attributes = Object.keys(dateRange.attr);
-      for (let j = 0; j < attributes.length; j++) {
-        const key = attributes[j];
-        if (!isDateRangeCueAttribute(key)) {
-          continue;
-        }
-        const cue = cues[key];
-        if (cue) {
-          if (durationKnown && !appendedDateRangeCues.durationKnown) {
-            cue.endTime = endTime;
-          } else if (Math.abs(cue.startTime - startTime) > 0.01) {
-            cue.startTime = startTime;
-            cue.endTime = endTime;
-          }
-        } else if (Cue) {
-          let data = dateRange.attr[key];
-          if (isSCTE35Attribute(key)) {
-            data = hexToArrayBuffer(data);
-          }
-          const payload = {
-            key,
-            data
-          };
-          const _cue = createCueWithDataFields(Cue, startTime, endTime, payload, MetadataSchema.dateRange);
-          if (_cue) {
-            _cue.id = id;
-            this.id3Track.addCue(_cue);
-            cues[key] = _cue;
-          }
-        }
+    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;
       }
+    }
 
-      // Keep track of processed DateRanges by ID for updating cues with new DateRange tag attributes
-      dateRangeCuesAppended[id] = {
-        cues,
-        dateRange,
-        durationKnown
-      };
+    // 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);
     }
   }
-}
 
-class LatencyController {
-  constructor(hls) {
-    this.hls = undefined;
-    this.config = undefined;
-    this.media = null;
-    this.currentTime = 0;
-    this.stallCount = 0;
-    this._latency = null;
-    this._targetLatencyUpdated = false;
-    this.onTimeupdate = () => {
-      const {
-        media
-      } = this;
-      const levelDetails = this.hls.latestLevelDetails;
-      if (!media || !levelDetails) {
-        return;
-      }
-      this.currentTime = media.currentTime;
-      const latency = this.computeLatency();
-      if (latency === null) {
-        return;
-      }
-      this._latency = latency;
-
-      // Adapt playbackRate to meet target latency in low-latency mode
-      const {
-        lowLatencyMode,
-        maxLiveSyncPlaybackRate
-      } = this.config;
-      if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
-        return;
-      }
-      const targetLatency = this.targetLatency;
-      if (targetLatency === null) {
-        return;
-      }
-      const distanceFromTarget = latency - targetLatency;
-      // Only adjust playbackRate when within one target duration of targetLatency
-      // and more than one second from under-buffering.
-      // Playback further than one target duration from target can be considered DVR playback.
-      const liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
-      const inLiveRange = distanceFromTarget < liveMinLatencyDuration;
-      if (inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
-        const max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
-        const rate = Math.round(2 / (1 + Math.exp(-0.75 * distanceFromTarget - this.edgeStalled)) * 20) / 20;
-        media.playbackRate = Math.min(max, Math.max(1, rate));
-      } else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
-        media.playbackRate = 1;
-      }
-    };
-    this.hls = hls;
-    this.config = hls.config;
-    this.registerListeners();
-  }
-  get latency() {
-    return this._latency || 0;
-  }
-  get maxLatency() {
-    var _this$hls;
+  /**
+   * 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 {
-      config
+      hls,
+      media,
+      stallReported,
+      stalled
     } = this;
-    if (config.liveMaxLatencyDuration !== undefined) {
-      return config.liveMaxLatencyDuration;
+    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
+        }
+      });
     }
-    const levelDetails = (_this$hls = this.hls) == null ? undefined : _this$hls.latestLevelDetails;
-    return levelDetails ? config.liveMaxLatencyDurationCount * levelDetails.targetduration : 0;
   }
-  get targetLatency() {
-    const levelDetails = this.hls.latestLevelDetails;
-    if (levelDetails === null) {
-      return null;
-    }
-    const {
-      holdBack,
-      partHoldBack,
-      targetduration
-    } = levelDetails;
+
+  /**
+   * 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 {
-      liveSyncDuration,
-      liveSyncDurationCount,
-      lowLatencyMode
-    } = this.config;
-    const userConfig = this.hls.userConfig;
-    let targetLatency = lowLatencyMode ? partHoldBack || holdBack : holdBack;
-    if (this._targetLatencyUpdated || userConfig.liveSyncDuration || userConfig.liveSyncDurationCount || targetLatency === 0) {
-      targetLatency = liveSyncDuration !== undefined ? liveSyncDuration : liveSyncDurationCount * targetduration;
-    }
-    const maxLiveSyncOnStallIncrease = targetduration;
-    return targetLatency + Math.min(this.stallCount * this.config.liveSyncOnStallIncrease, maxLiveSyncOnStallIncrease);
-  }
-  set targetLatency(latency) {
-    this.stallCount = 0;
-    this.config.liveSyncDuration = latency;
-    this._targetLatencyUpdated = true;
-  }
-  get liveSyncPosition() {
-    const liveEdge = this.estimateLiveEdge();
-    const targetLatency = this.targetLatency;
-    if (liveEdge === null || targetLatency === null) {
-      return null;
-    }
-    const levelDetails = this.hls.latestLevelDetails;
-    if (levelDetails === null) {
-      return null;
-    }
-    const edge = levelDetails.edge;
-    const syncPosition = liveEdge - targetLatency - this.edgeStalled;
-    const min = edge - levelDetails.totalduration;
-    const max = edge - (this.config.lowLatencyMode && levelDetails.partTarget || levelDetails.targetduration);
-    return Math.min(Math.max(min, syncPosition), max);
-  }
-  get drift() {
-    const levelDetails = this.hls.latestLevelDetails;
-    if (levelDetails === null) {
-      return 1;
-    }
-    return levelDetails.drift;
-  }
-  get edgeStalled() {
-    const levelDetails = this.hls.latestLevelDetails;
-    if (levelDetails === null) {
+      fragmentTracker,
+      media
+    } = this;
+    const config = (_this$hls4 = this.hls) == null ? undefined : _this$hls4.config;
+    if (!media || !fragmentTracker || !config) {
       return 0;
     }
-    const maxLevelUpdateAge = (this.config.lowLatencyMode && levelDetails.partTarget || levelDetails.targetduration) * 3;
-    return Math.max(levelDetails.age - maxLevelUpdateAge, 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) {
+      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 != null && 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 || undefined,
+            buffer: bufferInfo.len,
+            bufferInfo
+          });
+        }
+        return targetTime;
+      }
+    }
+    return 0;
   }
-  get forwardBufferLength() {
+
+  /**
+   * Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
+   * @private
+   */
+  _tryNudgeBuffer(bufferInfo) {
     const {
-      media
+      hls,
+      media,
+      nudgeRetry
     } = this;
-    const levelDetails = this.hls.latestLevelDetails;
-    if (!media || !levelDetails) {
+    const config = hls == null ? undefined : hls.config;
+    if (!media || !config) {
       return 0;
     }
-    const bufferedRanges = media.buffered.length;
-    return (bufferedRanges ? media.buffered.end(bufferedRanges - 1) : levelDetails.edge) - this.currentTime;
+    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
+      });
+    }
   }
-  destroy() {
-    this.unregisterListeners();
-    this.onMediaDetaching();
-    // @ts-ignore
-    this.hls = null;
+}
+function getInFlightDependency(inFlightFragments, currentTime) {
+  const main = inFlight(inFlightFragments.main);
+  if (main && main.start <= currentTime) {
+    return main;
   }
-  registerListeners() {
-    this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    this.hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    this.hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
-    this.hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
-    this.hls.on(Events.ERROR, this.onError, this);
+  const audio = inFlight(inFlightFragments.audio);
+  if (audio && audio.start <= currentTime) {
+    return audio;
   }
-  unregisterListeners() {
-    this.hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    this.hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    this.hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
-    this.hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
-    this.hls.off(Events.ERROR, this.onError, this);
+  return null;
+}
+function inFlight(inFlightData) {
+  if (!inFlightData) {
+    return null;
   }
-  onMediaAttached(event, data) {
-    this.media = data.media;
-    this.media.addEventListener('timeupdate', this.onTimeupdate);
+  switch (inFlightData.state) {
+    case State.IDLE:
+    case State.STOPPED:
+    case State.ENDED:
+    case State.ERROR:
+      return null;
   }
-  onMediaDetaching() {
-    if (this.media) {
-      this.media.removeEventListener('timeupdate', this.onTimeupdate);
-      this.media = 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);
   }
-  onManifestLoading() {
-    this._latency = null;
-    this.stallCount = 0;
+  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';
   }
-  onLevelUpdated(event, {
-    details
-  }) {
-    if (details.advanced) {
-      this.onTimeupdate();
-    }
-    if (!details.live && this.media) {
-      this.media.removeEventListener('timeupdate', this.onTimeupdate);
+  if (track.cues) {
+    for (let i = track.cues.length; i--;) {
+      if (enterHandler) {
+        track.cues[i].removeEventListener('enter', enterHandler);
+      }
+      track.removeCue(track.cues[i]);
     }
   }
-  onError(event, data) {
-    var _this$hls$latestLevel;
-    if (data.details !== ErrorDetails.BUFFER_STALLED_ERROR) {
-      return;
+  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]);
+      }
     }
-    this.stallCount++;
-    if ((_this$hls$latestLevel = this.hls.latestLevelDetails) != null && _this$hls$latestLevel.live) {
-      this.hls.logger.warn('[latency-controller]: Stall detected, adjusting target latency');
+  }
+  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;
     }
   }
-  estimateLiveEdge() {
-    const levelDetails = this.hls.latestLevelDetails;
-    if (levelDetails === null) {
-      return null;
+  // 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 levelDetails.edge + levelDetails.age;
   }
-  computeLatency() {
-    const liveEdge = this.estimateLiveEdge();
-    if (liveEdge === null) {
-      return null;
+  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;
     }
-    return liveEdge - this.currentTime;
+  } catch (e) {
+    cue = new Cue(startTime, endTime, JSON.stringify(type ? _objectSpread2({
+      type
+    }, data) : data));
   }
+  return cue;
 }
 
-class LevelController extends BasePlaylistController {
-  constructor(hls, contentSteeringController) {
-    super(hls, 'level-controller');
-    this._levels = [];
-    this._firstLevel = -1;
-    this._maxAutoLevel = -1;
-    this._startLevel = undefined;
-    this.currentLevel = null;
-    this.currentLevelIndex = -1;
-    this.manualLevelIndex = -1;
-    this.steering = undefined;
-    this.onParsedComplete = undefined;
-    this.steering = contentSteeringController;
+// 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.MANIFEST_LOADED, this.onManifestLoaded, this);
-    hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
-    hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
-    hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
-    hls.on(Events.ERROR, this.onError, 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.MANIFEST_LOADED, this.onManifestLoaded, this);
-    hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
-    hls.off(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
-    hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
-    hls.off(Events.ERROR, this.onError, 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);
   }
-  destroy() {
-    this._unregisterListeners();
-    this.steering = null;
-    this.resetLevels();
-    super.destroy();
+  // 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;
+    }
   }
-  stopLoad() {
-    const levels = this._levels;
-
-    // clean up live level details to force reload them, and reset load errors
-    levels.forEach(level => {
-      level.loadError = 0;
-      level.fragmentError = 0;
-    });
-    super.stopLoad();
+  onMediaAttached() {
+    const details = this.hls.latestLevelDetails;
+    if (details) {
+      this.updateDateRangeCues(details);
+    }
   }
-  resetLevels() {
-    this._startLevel = undefined;
-    this.manualLevelIndex = -1;
-    this.currentLevelIndex = -1;
-    this.currentLevel = null;
-    this._levels = [];
-    this._maxAutoLevel = -1;
+  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(event, data) {
-    this.resetLevels();
+  onManifestLoading() {
+    this.dateRangeCuesAppended = {};
   }
-  onManifestLoaded(event, data) {
-    const preferManagedMediaSource = this.hls.config.preferManagedMediaSource;
-    const levels = [];
-    const redundantSet = {};
-    const generatePathwaySet = {};
-    let resolutionFound = false;
-    let videoCodecFound = false;
-    let audioCodecFound = false;
-    data.levels.forEach(levelParsed => {
-      var _videoCodec;
-      const attributes = levelParsed.attrs;
-      let {
-        audioCodec,
-        videoCodec
-      } = levelParsed;
-      if (audioCodec) {
-        // Returns empty and set to undefined for 'mp4a.40.34' with fallback to 'audio/mpeg' SourceBuffer
-        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource) || undefined;
+  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;
       }
-      if (((_videoCodec = videoCodec) == null ? undefined : _videoCodec.indexOf('avc1')) === 0) {
-        videoCodec = levelParsed.videoCodec = convertAVC1ToAVCOTI(videoCodec);
+    }
+    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;
 
-      // only keep levels with supported audio/video codecs
-      const {
-        width,
-        height,
-        unknownCodecs
-      } = levelParsed;
-      let unknownUnsupportedCodecCount = unknownCodecs ? unknownCodecs.length : 0;
-      if (unknownCodecs) {
-        // Treat unknown codec as audio or video codec based on passing `isTypeSupported` check
-        // (allows for playback of any supported codec even if not indexed in utils/codecs)
-        for (let i = unknownUnsupportedCodecCount; i--;) {
-          const unknownCodec = unknownCodecs[i];
-          if (this.isAudioSupported(unknownCodec)) {
-            levelParsed.audioCodec = audioCodec = audioCodec ? `${audioCodec},${unknownCodec}` : unknownCodec;
-            unknownUnsupportedCodecCount--;
-            sampleEntryCodesISO.audio[audioCodec.substring(0, 4)] = 2;
-          } else if (this.isVideoSupported(unknownCodec)) {
-            levelParsed.videoCodec = videoCodec = videoCodec ? `${videoCodec},${unknownCodec}` : unknownCodec;
-            unknownUnsupportedCodecCount--;
-            sampleEntryCodesISO.video[videoCodec.substring(0, 4)] = 2;
+    // 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);
+            }
           }
         }
       }
-      resolutionFound || (resolutionFound = !!(width && height));
-      videoCodecFound || (videoCodecFound = !!videoCodec);
-      audioCodecFound || (audioCodecFound = !!audioCodec);
-      if (unknownUnsupportedCodecCount || audioCodec && !this.isAudioSupported(audioCodec) || videoCodec && !this.isVideoSupported(videoCodec)) {
-        return;
+    }
+  }
+  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;
+        }
       }
-      const {
-        CODECS,
-        'FRAME-RATE': FRAMERATE,
-        'HDCP-LEVEL': HDCP,
-        'PATHWAY-ID': PATHWAY,
-        RESOLUTION,
-        'VIDEO-RANGE': VIDEO_RANGE
-      } = attributes;
-      const contentSteeringPrefix = `${PATHWAY || '.'}-`;
-      const levelKey = `${contentSteeringPrefix}${levelParsed.bitrate}-${RESOLUTION}-${FRAMERATE}-${CODECS}-${VIDEO_RANGE}-${HDCP}`;
-      if (!redundantSet[levelKey]) {
-        const level = new Level(levelParsed);
-        redundantSet[levelKey] = level;
-        generatePathwaySet[levelKey] = 1;
-        levels.push(level);
-      } else if (redundantSet[levelKey].uri !== levelParsed.url && !levelParsed.attrs['PATHWAY-ID']) {
-        // Assign Pathway IDs to Redundant Streams (default Pathways is ".". Redundant Streams "..", "...", and so on.)
-        // Content Steering controller to handles Pathway fallback on error
-        const pathwayCount = generatePathwaySet[levelKey] += 1;
-        levelParsed.attrs['PATHWAY-ID'] = new Array(pathwayCount + 1).join('.');
-        const level = new Level(levelParsed);
-        redundantSet[levelKey] = level;
-        levels.push(level);
+    }
+  }
+  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 {
-        redundantSet[levelKey].addGroupId('audio', attributes.AUDIO);
-        redundantSet[levelKey].addGroupId('text', attributes.SUBTITLES);
+        predicate = cue => cue.type === MetadataSchema.audioId3 && enableID3MetadataCues || cue.type === MetadataSchema.emsg && enableEmsgMetadataCues;
       }
-    });
-    this.filterAndSortMediaOptions(levels, data, resolutionFound, videoCodecFound, audioCodecFound);
+      removeCuesInRange(id3Track, startOffset, endOffset, predicate);
+    }
   }
-  isAudioSupported(codec) {
-    return areCodecsMediaSourceSupported(codec, 'audio', this.hls.config.preferManagedMediaSource);
+  onLevelUpdated(event, {
+    details
+  }) {
+    this.updateDateRangeCues(details, true);
   }
-  isVideoSupported(codec) {
-    return areCodecsMediaSourceSupported(codec, 'video', this.hls.config.preferManagedMediaSource);
+  onLevelPtsUpdated(event, data) {
+    if (Math.abs(data.drift) > 0.01) {
+      this.updateDateRangeCues(data.details);
+    }
   }
-  filterAndSortMediaOptions(filteredLevels, data, resolutionFound, videoCodecFound, audioCodecFound) {
-    let audioTracks = [];
-    let subtitleTracks = [];
-    let levels = filteredLevels;
-
-    // remove audio-only and invalid video-range levels if we also have levels with video codecs or RESOLUTION signalled
-    if ((resolutionFound || videoCodecFound) && audioCodecFound) {
-      levels = levels.filter(({
-        videoCodec,
-        videoRange,
-        width,
-        height
-      }) => (!!videoCodec || !!(width && height)) && isVideoRange(videoRange));
+  updateDateRangeCues(details, removeOldCues) {
+    if (!this.media || !details.hasProgramDateTime || !this.hls.config.enableDateRangeMetadataCues) {
+      return;
     }
-    if (levels.length === 0) {
-      // Dispatch error after MANIFEST_LOADED is done propagating
-      Promise.resolve().then(() => {
-        if (this.hls) {
-          if (data.levels.length) {
-            this.warn(`One or more CODECS in variant not supported: ${JSON.stringify(data.levels[0].attrs)}`);
-          }
-          const error = new Error('no level with compatible codecs found in manifest');
-          this.hls.trigger(Events.ERROR, {
-            type: ErrorTypes.MEDIA_ERROR,
-            details: ErrorDetails.MANIFEST_INCOMPATIBLE_CODECS_ERROR,
-            fatal: true,
-            url: data.url,
-            error,
-            reason: error.message
+    const {
+      id3Track
+    } = this;
+    const {
+      dateRanges
+    } = details;
+    const ids = Object.keys(dateRanges);
+    let dateRangeCuesAppended = this.dateRangeCuesAppended;
+    // Remove cues from track not found in details.dateRanges
+    if (id3Track && removeOldCues) {
+      var _id3Track$cues;
+      if ((_id3Track$cues = id3Track.cues) != null && _id3Track$cues.length) {
+        const idsToRemove = Object.keys(dateRangeCuesAppended).filter(id => !ids.includes(id));
+        for (let i = idsToRemove.length; i--;) {
+          const id = idsToRemove[i];
+          const cues = dateRangeCuesAppended[id].cues;
+          delete dateRangeCuesAppended[id];
+          Object.keys(cues).forEach(key => {
+            try {
+              const cue = cues[key];
+              cue.removeEventListener('enter', this.onEventCueEnter);
+              id3Track.removeCue(cue);
+            } catch (e) {
+              /* no-op */
+            }
           });
         }
-      });
-      return;
+      } else {
+        dateRangeCuesAppended = this.dateRangeCuesAppended = {};
+      }
     }
-    if (data.audioTracks) {
-      audioTracks = data.audioTracks.filter(track => !track.audioCodec || this.isAudioSupported(track.audioCodec));
-      // Assign ids after filtering as array indices by group-id
-      assignTrackIdsByGroup(audioTracks);
+    // Exit if the playlist does not have Date Ranges or does not have Program Date Time
+    const lastFragment = details.fragments[details.fragments.length - 1];
+    if (ids.length === 0 || !isFiniteNumber(lastFragment == null ? undefined : lastFragment.programDateTime)) {
+      return;
     }
-    if (data.subtitles) {
-      subtitleTracks = data.subtitles;
-      assignTrackIdsByGroup(subtitleTracks);
+    if (!this.id3Track) {
+      this.id3Track = this.createTrack(this.media);
     }
-    // start bitrate is the first bitrate of the manifest
-    const unsortedLevels = levels.slice(0);
-    // sort levels from lowest to highest
-    levels.sort((a, b) => {
-      if (a.attrs['HDCP-LEVEL'] !== b.attrs['HDCP-LEVEL']) {
-        return (a.attrs['HDCP-LEVEL'] || '') > (b.attrs['HDCP-LEVEL'] || '') ? 1 : -1;
-      }
-      // sort on height before bitrate for cap-level-controller
-      if (resolutionFound && a.height !== b.height) {
-        return a.height - b.height;
-      }
-      if (a.frameRate !== b.frameRate) {
-        return a.frameRate - b.frameRate;
-      }
-      if (a.videoRange !== b.videoRange) {
-        return VideoRangeValues.indexOf(a.videoRange) - VideoRangeValues.indexOf(b.videoRange);
-      }
-      if (a.videoCodec !== b.videoCodec) {
-        const valueA = videoCodecPreferenceValue(a.videoCodec);
-        const valueB = videoCodecPreferenceValue(b.videoCodec);
-        if (valueA !== valueB) {
-          return valueB - valueA;
+    const Cue = getCueClass();
+    for (let i = 0; i < ids.length; i++) {
+      const id = ids[i];
+      const dateRange = dateRanges[id];
+      const startTime = dateRange.startTime;
+
+      // Process DateRanges to determine end-time (known DURATION, END-DATE, or END-ON-NEXT)
+      const appendedDateRangeCues = dateRangeCuesAppended[id];
+      const cues = (appendedDateRangeCues == null ? undefined : appendedDateRangeCues.cues) || {};
+      let durationKnown = (appendedDateRangeCues == null ? undefined : appendedDateRangeCues.durationKnown) || false;
+      let endTime = MAX_CUE_ENDTIME;
+      const {
+        duration,
+        endDate
+      } = dateRange;
+      if (endDate && duration !== null) {
+        endTime = startTime + duration;
+        durationKnown = true;
+      } else if (dateRange.endOnNext && !durationKnown) {
+        const nextDateRangeWithSameClass = ids.reduce((candidateDateRange, id) => {
+          if (id !== dateRange.id) {
+            const otherDateRange = dateRanges[id];
+            if (otherDateRange.class === dateRange.class && otherDateRange.startDate > dateRange.startDate && (!candidateDateRange || dateRange.startDate < candidateDateRange.startDate)) {
+              return otherDateRange;
+            }
+          }
+          return candidateDateRange;
+        }, null);
+        if (nextDateRangeWithSameClass) {
+          endTime = nextDateRangeWithSameClass.startTime;
+          durationKnown = true;
         }
       }
-      if (a.uri === b.uri && a.codecSet !== b.codecSet) {
-        const valueA = codecsSetSelectionPreferenceValue(a.codecSet);
-        const valueB = codecsSetSelectionPreferenceValue(b.codecSet);
-        if (valueA !== valueB) {
-          return valueB - valueA;
+
+      // Create TextTrack Cues for each MetadataGroup Item (select DateRange attribute)
+      // This is to emulate Safari HLS playback handling of DateRange tags
+      const attributes = Object.keys(dateRange.attr);
+      for (let j = 0; j < attributes.length; j++) {
+        const key = attributes[j];
+        if (!isDateRangeCueAttribute(key)) {
+          continue;
         }
-      }
-      if (a.averageBitrate !== b.averageBitrate) {
-        return a.averageBitrate - b.averageBitrate;
-      }
-      return 0;
-    });
-    let firstLevelInPlaylist = unsortedLevels[0];
-    if (this.steering) {
-      levels = this.steering.filterParsedLevels(levels);
-      if (levels.length !== unsortedLevels.length) {
-        for (let i = 0; i < unsortedLevels.length; i++) {
-          if (unsortedLevels[i].pathwayId === levels[0].pathwayId) {
-            firstLevelInPlaylist = unsortedLevels[i];
-            break;
+        const cue = cues[key];
+        if (cue) {
+          if (durationKnown && !appendedDateRangeCues.durationKnown) {
+            cue.endTime = endTime;
+          } else if (Math.abs(cue.startTime - startTime) > 0.01) {
+            cue.startTime = startTime;
+            cue.endTime = endTime;
+          }
+        } else if (Cue) {
+          let data = dateRange.attr[key];
+          if (isSCTE35Attribute(key)) {
+            data = hexToArrayBuffer(data);
+          }
+          const payload = {
+            key,
+            data
+          };
+          const _cue = createCueWithDataFields(Cue, startTime, endTime, payload, MetadataSchema.dateRange);
+          if (_cue) {
+            _cue.id = id;
+            this.id3Track.addCue(_cue);
+            cues[key] = _cue;
           }
         }
       }
+
+      // Keep track of processed DateRanges by ID for updating cues with new DateRange tag attributes
+      dateRangeCuesAppended[id] = {
+        cues,
+        dateRange,
+        durationKnown
+      };
     }
-    this._levels = levels;
+  }
+}
 
-    // find index of first level in sorted levels
-    for (let i = 0; i < levels.length; i++) {
-      if (levels[i] === firstLevelInPlaylist) {
-        var _this$hls$userConfig;
-        this._firstLevel = i;
-        const firstLevelBitrate = firstLevelInPlaylist.bitrate;
-        const bandwidthEstimate = this.hls.bandwidthEstimate;
-        this.log(`manifest loaded, ${levels.length} level(s) found, first bitrate: ${firstLevelBitrate}`);
-        // Update default bwe to first variant bitrate as long it has not been configured or set
-        if (((_this$hls$userConfig = this.hls.userConfig) == null ? undefined : _this$hls$userConfig.abrEwmaDefaultEstimate) === undefined) {
-          const startingBwEstimate = Math.min(firstLevelBitrate, this.hls.config.abrEwmaDefaultEstimateMax);
-          if (startingBwEstimate > bandwidthEstimate && bandwidthEstimate === this.hls.abrEwmaDefaultEstimate) {
-            this.hls.bandwidthEstimate = startingBwEstimate;
-          }
-        }
-        break;
+class LatencyController {
+  constructor(hls) {
+    this.hls = undefined;
+    this.config = undefined;
+    this.media = null;
+    this.currentTime = 0;
+    this.stallCount = 0;
+    this._latency = null;
+    this._targetLatencyUpdated = false;
+    this.onTimeupdate = () => {
+      const {
+        media
+      } = this;
+      const levelDetails = this.hls.latestLevelDetails;
+      if (!media || !levelDetails) {
+        return;
+      }
+      this.currentTime = media.currentTime;
+      const latency = this.computeLatency();
+      if (latency === null) {
+        return;
       }
-    }
+      this._latency = latency;
 
-    // Audio is only alternate if manifest include a URI along with the audio group tag,
-    // and this is not an audio-only stream where levels contain audio-only
-    const audioOnly = audioCodecFound && !videoCodecFound;
-    const edata = {
-      levels,
-      audioTracks,
-      subtitleTracks,
-      sessionData: data.sessionData,
-      sessionKeys: data.sessionKeys,
-      firstLevel: this._firstLevel,
-      stats: data.stats,
-      audio: audioCodecFound,
-      video: videoCodecFound,
-      altAudio: !audioOnly && audioTracks.some(t => !!t.url)
+      // Adapt playbackRate to meet target latency in low-latency mode
+      const {
+        lowLatencyMode,
+        maxLiveSyncPlaybackRate
+      } = this.config;
+      if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
+        return;
+      }
+      const targetLatency = this.targetLatency;
+      if (targetLatency === null) {
+        return;
+      }
+      const distanceFromTarget = latency - targetLatency;
+      // Only adjust playbackRate when within one target duration of targetLatency
+      // and more than one second from under-buffering.
+      // Playback further than one target duration from target can be considered DVR playback.
+      const liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
+      const inLiveRange = distanceFromTarget < liveMinLatencyDuration;
+      if (inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
+        const max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
+        const rate = Math.round(2 / (1 + Math.exp(-0.75 * distanceFromTarget - this.edgeStalled)) * 20) / 20;
+        media.playbackRate = Math.min(max, Math.max(1, rate));
+      } else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
+        media.playbackRate = 1;
+      }
     };
-    this.hls.trigger(Events.MANIFEST_PARSED, edata);
+    this.hls = hls;
+    this.config = hls.config;
+    this.registerListeners();
   }
-  get levels() {
-    if (this._levels.length === 0) {
-      return null;
-    }
-    return this._levels;
+  get latency() {
+    return this._latency || 0;
   }
-  get level() {
-    return this.currentLevelIndex;
+  get maxLatency() {
+    var _this$hls;
+    const {
+      config
+    } = this;
+    if (config.liveMaxLatencyDuration !== undefined) {
+      return config.liveMaxLatencyDuration;
+    }
+    const levelDetails = (_this$hls = this.hls) == null ? undefined : _this$hls.latestLevelDetails;
+    return levelDetails ? config.liveMaxLatencyDurationCount * levelDetails.targetduration : 0;
   }
-  set level(newLevel) {
-    const levels = this._levels;
-    if (levels.length === 0) {
-      return;
+  get targetLatency() {
+    const levelDetails = this.hls.latestLevelDetails;
+    if (levelDetails === null) {
+      return null;
     }
-    // check if level idx is valid
-    if (newLevel < 0 || newLevel >= levels.length) {
-      // invalid level id given, trigger error
-      const error = new Error('invalid level idx');
-      const fatal = newLevel < 0;
-      this.hls.trigger(Events.ERROR, {
-        type: ErrorTypes.OTHER_ERROR,
-        details: ErrorDetails.LEVEL_SWITCH_ERROR,
-        level: newLevel,
-        fatal,
-        error,
-        reason: error.message
-      });
-      if (fatal) {
-        return;
-      }
-      newLevel = Math.min(newLevel, levels.length - 1);
+    const {
+      holdBack,
+      partHoldBack,
+      targetduration
+    } = levelDetails;
+    const {
+      liveSyncDuration,
+      liveSyncDurationCount,
+      lowLatencyMode
+    } = this.config;
+    const userConfig = this.hls.userConfig;
+    let targetLatency = lowLatencyMode ? partHoldBack || holdBack : holdBack;
+    if (this._targetLatencyUpdated || userConfig.liveSyncDuration || userConfig.liveSyncDurationCount || targetLatency === 0) {
+      targetLatency = liveSyncDuration !== undefined ? liveSyncDuration : liveSyncDurationCount * targetduration;
     }
-    const lastLevelIndex = this.currentLevelIndex;
-    const lastLevel = this.currentLevel;
-    const lastPathwayId = lastLevel ? lastLevel.attrs['PATHWAY-ID'] : undefined;
-    const level = levels[newLevel];
-    const pathwayId = level.attrs['PATHWAY-ID'];
-    this.currentLevelIndex = newLevel;
-    this.currentLevel = level;
-    if (lastLevelIndex === newLevel && lastLevel && lastPathwayId === pathwayId) {
-      return;
+    const maxLiveSyncOnStallIncrease = targetduration;
+    return targetLatency + Math.min(this.stallCount * this.config.liveSyncOnStallIncrease, maxLiveSyncOnStallIncrease);
+  }
+  set targetLatency(latency) {
+    this.stallCount = 0;
+    this.config.liveSyncDuration = latency;
+    this._targetLatencyUpdated = true;
+  }
+  get liveSyncPosition() {
+    const liveEdge = this.estimateLiveEdge();
+    const targetLatency = this.targetLatency;
+    if (liveEdge === null || targetLatency === null) {
+      return null;
     }
-    this.log(`Switching to level ${newLevel} (${level.height ? level.height + 'p ' : ''}${level.videoRange ? level.videoRange + ' ' : ''}${level.codecSet ? level.codecSet + ' ' : ''}@${level.bitrate})${pathwayId ? ' with Pathway ' + pathwayId : ''} from level ${lastLevelIndex}${lastPathwayId ? ' with Pathway ' + lastPathwayId : ''}`);
-    const levelSwitchingData = {
-      level: newLevel,
-      attrs: level.attrs,
-      details: level.details,
-      bitrate: level.bitrate,
-      averageBitrate: level.averageBitrate,
-      maxBitrate: level.maxBitrate,
-      realBitrate: level.realBitrate,
-      width: level.width,
-      height: level.height,
-      codecSet: level.codecSet,
-      audioCodec: level.audioCodec,
-      videoCodec: level.videoCodec,
-      audioGroups: level.audioGroups,
-      subtitleGroups: level.subtitleGroups,
-      loaded: level.loaded,
-      loadError: level.loadError,
-      fragmentError: level.fragmentError,
-      name: level.name,
-      id: level.id,
-      uri: level.uri,
-      url: level.url,
-      urlId: 0,
-      audioGroupIds: level.audioGroupIds,
-      textGroupIds: level.textGroupIds
-    };
-    this.hls.trigger(Events.LEVEL_SWITCHING, levelSwitchingData);
-    // check if we need to load playlist for this level
-    const levelDetails = level.details;
-    if (!levelDetails || levelDetails.live) {
-      // level not retrieved yet, or live playlist we need to (re)load it
-      const hlsUrlParameters = this.switchParams(level.uri, lastLevel == null ? undefined : lastLevel.details, levelDetails);
-      this.loadPlaylist(hlsUrlParameters);
+    const levelDetails = this.hls.latestLevelDetails;
+    if (levelDetails === null) {
+      return null;
     }
+    const edge = levelDetails.edge;
+    const syncPosition = liveEdge - targetLatency - this.edgeStalled;
+    const min = edge - levelDetails.totalduration;
+    const max = edge - (this.config.lowLatencyMode && levelDetails.partTarget || levelDetails.targetduration);
+    return Math.min(Math.max(min, syncPosition), max);
   }
-  get manualLevel() {
-    return this.manualLevelIndex;
+  get drift() {
+    const levelDetails = this.hls.latestLevelDetails;
+    if (levelDetails === null) {
+      return 1;
+    }
+    return levelDetails.drift;
   }
-  set manualLevel(newLevel) {
-    this.manualLevelIndex = newLevel;
-    if (this._startLevel === undefined) {
-      this._startLevel = newLevel;
+  get edgeStalled() {
+    const levelDetails = this.hls.latestLevelDetails;
+    if (levelDetails === null) {
+      return 0;
     }
-    if (newLevel !== -1) {
-      this.level = newLevel;
+    const maxLevelUpdateAge = (this.config.lowLatencyMode && levelDetails.partTarget || levelDetails.targetduration) * 3;
+    return Math.max(levelDetails.age - maxLevelUpdateAge, 0);
+  }
+  get forwardBufferLength() {
+    const {
+      media
+    } = this;
+    const levelDetails = this.hls.latestLevelDetails;
+    if (!media || !levelDetails) {
+      return 0;
     }
+    const bufferedRanges = media.buffered.length;
+    return (bufferedRanges ? media.buffered.end(bufferedRanges - 1) : levelDetails.edge) - this.currentTime;
   }
-  get firstLevel() {
-    return this._firstLevel;
+  destroy() {
+    this.unregisterListeners();
+    this.onMediaDetaching();
+    // @ts-ignore
+    this.hls = null;
   }
-  set firstLevel(newLevel) {
-    this._firstLevel = newLevel;
+  registerListeners() {
+    this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    this.hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    this.hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
+    this.hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
+    this.hls.on(Events.ERROR, this.onError, this);
   }
-  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;
+  unregisterListeners() {
+    this.hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    this.hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    this.hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
+    this.hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
+    this.hls.off(Events.ERROR, this.onError, this);
   }
-  set startLevel(newLevel) {
-    this._startLevel = newLevel;
+  onMediaAttached(event, data) {
+    this.media = data.media;
+    this.media.addEventListener('timeupdate', this.onTimeupdate);
   }
-  get pathwayPriority() {
-    if (this.steering) {
-      return this.steering.pathwayPriority;
+  onMediaDetaching() {
+    if (this.media) {
+      this.media.removeEventListener('timeupdate', this.onTimeupdate);
+      this.media = null;
     }
-    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;
+  onManifestLoading() {
+    this._latency = null;
+    this.stallCount = 0;
+  }
+  onLevelUpdated(event, {
+    details
+  }) {
+    if (details.advanced) {
+      this.onTimeupdate();
+    }
+    if (!details.live && this.media) {
+      this.media.removeEventListener('timeupdate', this.onTimeupdate);
     }
   }
   onError(event, data) {
-    if (data.fatal || !data.context) {
+    var _this$hls$latestLevel;
+    if (data.details !== ErrorDetails.BUFFER_STALLED_ERROR) {
       return;
     }
-    if (data.context.type === PlaylistContextType.LEVEL && data.context.level === this.level) {
-      this.checkRetry(data);
+    this.stallCount++;
+    if ((_this$hls$latestLevel = this.hls.latestLevelDetails) != null && _this$hls$latestLevel.live) {
+      this.hls.logger.warn('[latency-controller]: Stall detected, adjusting target latency');
     }
   }
-
-  // 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;
-      }
+  estimateLiveEdge() {
+    const levelDetails = this.hls.latestLevelDetails;
+    if (levelDetails === null) {
+      return null;
     }
+    return levelDetails.edge + levelDetails.age;
   }
-  onLevelLoaded(event, data) {
-    var _data$deliveryDirecti2;
+  computeLatency() {
+    const liveEdge = this.estimateLiveEdge();
+    if (liveEdge === null) {
+      return null;
+    }
+    return liveEdge - this.currentTime;
+  }
+}
+
+class LevelController extends BasePlaylistController {
+  constructor(hls, contentSteeringController) {
+    super(hls, 'level-controller');
+    this._levels = [];
+    this._firstLevel = -1;
+    this._maxAutoLevel = -1;
+    this._startLevel = undefined;
+    this.currentLevel = null;
+    this.currentLevelIndex = -1;
+    this.manualLevelIndex = -1;
+    this.steering = undefined;
+    this.onParsedComplete = undefined;
+    this.steering = contentSteeringController;
+    this._registerListeners();
+  }
+  _registerListeners() {
     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;
+      hls
+    } = this;
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
+    hls.on(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
+    hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
+    hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
+    hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
+    hls.on(Events.ERROR, this.onError, this);
+  }
+  _unregisterListeners() {
+    const {
+      hls
+    } = this;
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
+    hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
+    hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
+    hls.off(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
+    hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
+    hls.off(Events.ERROR, this.onError, this);
+  }
+  destroy() {
+    this._unregisterListeners();
+    this.steering = null;
+    this.resetLevels();
+    super.destroy();
+  }
+  stopLoad() {
+    const levels = this._levels;
+
+    // clean up live level details to force reload them, and reset load errors
+    levels.forEach(level => {
+      level.loadError = 0;
+      level.fragmentError = 0;
+    });
+    super.stopLoad();
+  }
+  resetLevels() {
+    this._startLevel = undefined;
+    this.manualLevelIndex = -1;
+    this.currentLevelIndex = -1;
+    this.currentLevel = null;
+    this._levels = [];
+    this._maxAutoLevel = -1;
+  }
+  onManifestLoading(event, data) {
+    this.resetLevels();
+  }
+  onManifestLoaded(event, data) {
+    const preferManagedMediaSource = this.hls.config.preferManagedMediaSource;
+    const levels = [];
+    const redundantSet = {};
+    const generatePathwaySet = {};
+    let resolutionFound = false;
+    let videoCodecFound = false;
+    let audioCodecFound = false;
+    data.levels.forEach(levelParsed => {
+      var _videoCodec;
+      const attributes = levelParsed.attrs;
+      let {
+        audioCodec,
+        videoCodec
+      } = levelParsed;
+      if (audioCodec) {
+        // Returns empty and set to undefined for 'mp4a.40.34' with fallback to 'audio/mpeg' SourceBuffer
+        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource) || undefined;
+      }
+      if (((_videoCodec = videoCodec) == null ? undefined : _videoCodec.indexOf('avc1')) === 0) {
+        videoCodec = levelParsed.videoCodec = convertAVC1ToAVCOTI(videoCodec);
       }
-      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;
+      // only keep levels with supported audio/video codecs
+      const {
+        width,
+        height,
+        unknownCodecs
+      } = levelParsed;
+      let unknownUnsupportedCodecCount = unknownCodecs ? unknownCodecs.length : 0;
+      if (unknownCodecs) {
+        // Treat unknown codec as audio or video codec based on passing `isTypeSupported` check
+        // (allows for playback of any supported codec even if not indexed in utils/codecs)
+        for (let i = unknownUnsupportedCodecCount; i--;) {
+          const unknownCodec = unknownCodecs[i];
+          if (this.isAudioSupported(unknownCodec)) {
+            levelParsed.audioCodec = audioCodec = audioCodec ? `${audioCodec},${unknownCodec}` : unknownCodec;
+            unknownUnsupportedCodecCount--;
+            sampleEntryCodesISO.audio[audioCodec.substring(0, 4)] = 2;
+          } else if (this.isVideoSupported(unknownCodec)) {
+            levelParsed.videoCodec = videoCodec = videoCodec ? `${videoCodec},${unknownCodec}` : unknownCodec;
+            unknownUnsupportedCodecCount--;
+            sampleEntryCodesISO.video[videoCodec.substring(0, 4)] = 2;
+          }
+        }
       }
-      // Ignore matching details populated by loading a Media Playlist directly
-      let previousDetails = curLevel.details;
-      if (previousDetails === data.details && previousDetails.advanced) {
-        previousDetails = undefined;
+      resolutionFound || (resolutionFound = !!(width && height));
+      videoCodecFound || (videoCodecFound = !!videoCodec);
+      audioCodecFound || (audioCodecFound = !!audioCodec);
+      if (unknownUnsupportedCodecCount || audioCodec && !this.isAudioSupported(audioCodec) || videoCodec && !this.isVideoSupported(videoCodec)) {
+        return;
+      }
+      const {
+        CODECS,
+        'FRAME-RATE': FRAMERATE,
+        'HDCP-LEVEL': HDCP,
+        'PATHWAY-ID': PATHWAY,
+        RESOLUTION,
+        'VIDEO-RANGE': VIDEO_RANGE
+      } = attributes;
+      const contentSteeringPrefix = `${PATHWAY || '.'}-`;
+      const levelKey = `${contentSteeringPrefix}${levelParsed.bitrate}-${RESOLUTION}-${FRAMERATE}-${CODECS}-${VIDEO_RANGE}-${HDCP}`;
+      if (!redundantSet[levelKey]) {
+        const level = new Level(levelParsed);
+        redundantSet[levelKey] = level;
+        generatePathwaySet[levelKey] = 1;
+        levels.push(level);
+      } else if (redundantSet[levelKey].uri !== levelParsed.url && !levelParsed.attrs['PATHWAY-ID']) {
+        // Assign Pathway IDs to Redundant Streams (default Pathways is ".". Redundant Streams "..", "...", and so on.)
+        // Content Steering controller to handles Pathway fallback on error
+        const pathwayCount = generatePathwaySet[levelKey] += 1;
+        levelParsed.attrs['PATHWAY-ID'] = new Array(pathwayCount + 1).join('.');
+        const level = new Level(levelParsed);
+        redundantSet[levelKey] = level;
+        levels.push(level);
+      } else {
+        redundantSet[levelKey].addGroupId('audio', attributes.AUDIO);
+        redundantSet[levelKey].addGroupId('text', attributes.SUBTITLES);
       }
-      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
     });
+    this.filterAndSortMediaOptions(levels, data, resolutionFound, videoCodecFound, audioCodecFound);
   }
-  get nextLoadLevel() {
-    if (this.manualLevelIndex !== -1) {
-      return this.manualLevelIndex;
-    } else {
-      return this.hls.nextAutoLevel;
-    }
+  isAudioSupported(codec) {
+    return areCodecsMediaSourceSupported(codec, 'audio', this.hls.config.preferManagedMediaSource);
   }
-  set nextLoadLevel(nextLevel) {
-    this.level = nextLevel;
-    if (this.manualLevelIndex === -1) {
-      this.hls.nextAutoLevel = nextLevel;
+  isVideoSupported(codec) {
+    return areCodecsMediaSourceSupported(codec, 'video', this.hls.config.preferManagedMediaSource);
+  }
+  filterAndSortMediaOptions(filteredLevels, data, resolutionFound, videoCodecFound, audioCodecFound) {
+    let audioTracks = [];
+    let subtitleTracks = [];
+    let levels = filteredLevels;
+
+    // remove audio-only and invalid video-range levels if we also have levels with video codecs or RESOLUTION signalled
+    if ((resolutionFound || videoCodecFound) && audioCodecFound) {
+      levels = levels.filter(({
+        videoCodec,
+        videoRange,
+        width,
+        height
+      }) => (!!videoCodec || !!(width && height)) && isVideoRange(videoRange));
     }
-  }
-  removeLevel(levelIndex) {
-    var _this$currentLevel;
-    if (this._levels.length === 1) {
+    if (levels.length === 0) {
+      // Dispatch error after MANIFEST_LOADED is done propagating
+      Promise.resolve().then(() => {
+        if (this.hls) {
+          if (data.levels.length) {
+            this.warn(`One or more CODECS in variant not supported: ${JSON.stringify(data.levels[0].attrs)}`);
+          }
+          const error = new Error('no level with compatible codecs found in manifest');
+          this.hls.trigger(Events.ERROR, {
+            type: ErrorTypes.MEDIA_ERROR,
+            details: ErrorDetails.MANIFEST_INCOMPATIBLE_CODECS_ERROR,
+            fatal: true,
+            url: data.url,
+            error,
+            reason: error.message
+          });
+        }
+      });
       return;
     }
-    const levels = this._levels.filter((level, index) => {
-      if (index !== levelIndex) {
-        return true;
+    if (data.audioTracks) {
+      audioTracks = data.audioTracks.filter(track => !track.audioCodec || this.isAudioSupported(track.audioCodec));
+      // Assign ids after filtering as array indices by group-id
+      assignTrackIdsByGroup(audioTracks);
+    }
+    if (data.subtitles) {
+      subtitleTracks = data.subtitles;
+      assignTrackIdsByGroup(subtitleTracks);
+    }
+    // start bitrate is the first bitrate of the manifest
+    const unsortedLevels = levels.slice(0);
+    // sort levels from lowest to highest
+    levels.sort((a, b) => {
+      if (a.attrs['HDCP-LEVEL'] !== b.attrs['HDCP-LEVEL']) {
+        return (a.attrs['HDCP-LEVEL'] || '') > (b.attrs['HDCP-LEVEL'] || '') ? 1 : -1;
       }
-      if (this.steering) {
-        this.steering.removeLevel(level);
+      // sort on height before bitrate for cap-level-controller
+      if (resolutionFound && a.height !== b.height) {
+        return a.height - b.height;
       }
-      if (level === this.currentLevel) {
-        this.currentLevel = null;
-        this.currentLevelIndex = -1;
-        if (level.details) {
-          level.details.fragments.forEach(f => f.level = -1);
+      if (a.frameRate !== b.frameRate) {
+        return a.frameRate - b.frameRate;
+      }
+      if (a.videoRange !== b.videoRange) {
+        return VideoRangeValues.indexOf(a.videoRange) - VideoRangeValues.indexOf(b.videoRange);
+      }
+      if (a.videoCodec !== b.videoCodec) {
+        const valueA = videoCodecPreferenceValue(a.videoCodec);
+        const valueB = videoCodecPreferenceValue(b.videoCodec);
+        if (valueA !== valueB) {
+          return valueB - valueA;
         }
       }
-      return false;
+      if (a.uri === b.uri && a.codecSet !== b.codecSet) {
+        const valueA = codecsSetSelectionPreferenceValue(a.codecSet);
+        const valueB = codecsSetSelectionPreferenceValue(b.codecSet);
+        if (valueA !== valueB) {
+          return valueB - valueA;
+        }
+      }
+      if (a.averageBitrate !== b.averageBitrate) {
+        return a.averageBitrate - b.averageBitrate;
+      }
+      return 0;
     });
-    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);
+    let firstLevelInPlaylist = unsortedLevels[0];
+    if (this.steering) {
+      levels = this.steering.filterParsedLevels(levels);
+      if (levels.length !== unsortedLevels.length) {
+        for (let i = 0; i < unsortedLevels.length; i++) {
+          if (unsortedLevels[i].pathwayId === levels[0].pathwayId) {
+            firstLevelInPlaylist = unsortedLevels[i];
+            break;
+          }
+        }
+      }
     }
-    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
-      });
+
+    // find index of first level in sorted levels
+    for (let i = 0; i < levels.length; i++) {
+      if (levels[i] === firstLevelInPlaylist) {
+        var _this$hls$userConfig;
+        this._firstLevel = i;
+        const firstLevelBitrate = firstLevelInPlaylist.bitrate;
+        const bandwidthEstimate = this.hls.bandwidthEstimate;
+        this.log(`manifest loaded, ${levels.length} level(s) found, first bitrate: ${firstLevelBitrate}`);
+        // Update default bwe to first variant bitrate as long it has not been configured or set
+        if (((_this$hls$userConfig = this.hls.userConfig) == null ? undefined : _this$hls$userConfig.abrEwmaDefaultEstimate) === undefined) {
+          const startingBwEstimate = Math.min(firstLevelBitrate, this.hls.config.abrEwmaDefaultEstimateMax);
+          if (startingBwEstimate > bandwidthEstimate && bandwidthEstimate === this.hls.abrEwmaDefaultEstimate) {
+            this.hls.bandwidthEstimate = startingBwEstimate;
+          }
+        }
+        break;
+      }
     }
-  }
-}
-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;
+    // Audio is only alternate if manifest include a URI along with the audio group tag,
+    // and this is not an audio-only stream where levels contain audio-only
+    const audioOnly = audioCodecFound && !videoCodecFound;
+    const edata = {
+      levels,
+      audioTracks,
+      subtitleTracks,
+      sessionData: data.sessionData,
+      sessionKeys: data.sessionKeys,
+      firstLevel: this._firstLevel,
+      stats: data.stats,
+      audio: audioCodecFound,
+      video: videoCodecFound,
+      altAudio: !audioOnly && audioTracks.some(t => !!t.url)
+    };
+    this.hls.trigger(Events.MANIFEST_PARSED, edata);
   }
-  destroy() {
-    this.media = this.hls = this.fragmentTracker = null;
+  get levels() {
+    if (this._levels.length === 0) {
+      return null;
+    }
+    return this._levels;
   }
-
-  /**
-   * 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) {
+  get level() {
+    return this.currentLevelIndex;
+  }
+  set level(newLevel) {
+    const levels = this._levels;
+    if (levels.length === 0) {
       return;
     }
-    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);
+    // check if level idx is valid
+    if (newLevel < 0 || newLevel >= levels.length) {
+      // invalid level id given, trigger error
+      const error = new Error('invalid level idx');
+      const fatal = newLevel < 0;
+      this.hls.trigger(Events.ERROR, {
+        type: ErrorTypes.OTHER_ERROR,
+        details: ErrorDetails.LEVEL_SWITCH_ERROR,
+        level: newLevel,
+        fatal,
+        error,
+        reason: error.message
+      });
+      if (fatal) {
+        return;
       }
+      newLevel = Math.min(newLevel, levels.length - 1);
+    }
+    const lastLevelIndex = this.currentLevelIndex;
+    const lastLevel = this.currentLevel;
+    const lastPathwayId = lastLevel ? lastLevel.attrs['PATHWAY-ID'] : undefined;
+    const level = levels[newLevel];
+    const pathwayId = level.attrs['PATHWAY-ID'];
+    this.currentLevelIndex = newLevel;
+    this.currentLevel = level;
+    if (lastLevelIndex === newLevel && lastLevel && lastPathwayId === pathwayId) {
       return;
     }
-
-    // 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;
+    this.log(`Switching to level ${newLevel} (${level.height ? level.height + 'p ' : ''}${level.videoRange ? level.videoRange + ' ' : ''}${level.codecSet ? level.codecSet + ' ' : ''}@${level.bitrate})${pathwayId ? ' with Pathway ' + pathwayId : ''} from level ${lastLevelIndex}${lastPathwayId ? ' with Pathway ' + lastPathwayId : ''}`);
+    const levelSwitchingData = {
+      level: newLevel,
+      attrs: level.attrs,
+      details: level.details,
+      bitrate: level.bitrate,
+      averageBitrate: level.averageBitrate,
+      maxBitrate: level.maxBitrate,
+      realBitrate: level.realBitrate,
+      width: level.width,
+      height: level.height,
+      codecSet: level.codecSet,
+      audioCodec: level.audioCodec,
+      videoCodec: level.videoCodec,
+      audioGroups: level.audioGroups,
+      subtitleGroups: level.subtitleGroups,
+      loaded: level.loaded,
+      loadError: level.loadError,
+      fragmentError: level.fragmentError,
+      name: level.name,
+      id: level.id,
+      uri: level.uri,
+      url: level.url,
+      urlId: 0,
+      audioGroupIds: level.audioGroupIds,
+      textGroupIds: level.textGroupIds
+    };
+    this.hls.trigger(Events.LEVEL_SWITCHING, levelSwitchingData);
+    // check if we need to load playlist for this level
+    const levelDetails = level.details;
+    if (!levelDetails || levelDetails.live) {
+      // level not retrieved yet, or live playlist we need to (re)load it
+      const hlsUrlParameters = this.switchParams(level.uri, lastLevel == null ? undefined : lastLevel.details, levelDetails);
+      this.loadPlaylist(hlsUrlParameters);
     }
-
-    // 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;
+  }
+  get manualLevel() {
+    return this.manualLevelIndex;
+  }
+  set manualLevel(newLevel) {
+    this.manualLevelIndex = newLevel;
+    if (this._startLevel === undefined) {
+      this._startLevel = newLevel;
     }
-    if (!BufferHelper.getBuffered(media).length) {
-      this.nudgeRetry = 0;
-      return;
+    if (newLevel !== -1) {
+      this.level = newLevel;
     }
-    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;
+  }
+  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;
       }
-      // Reset moved state when seeking to a point in or before a gap
-      this.moved = false;
+      return this.hls.firstAutoLevel;
     }
-
-    // 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) {
-        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 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;
     }
-
-    // Start tracking stall time
-    const config = (_this$hls = this.hls) == null ? undefined : _this$hls.config;
-    if (!config) {
+  }
+  onError(event, data) {
+    if (data.fatal || !data.context) {
       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;
-      }
-      return;
+    if (data.context.type === PlaylistContextType.LEVEL && data.context.level === this.level) {
+      this.checkRetry(data);
     }
-    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;
-      }
-      // Report stalling after trying to fix
-      this._reportStall(bufferInfo);
-      if (!this.media || !this.hls) {
+  }
+
+  // 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 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, {});
+      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;
       }
     }
   }
-
-  /**
-   * 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;
+  onLevelLoaded(event, data) {
+    var _data$deliveryDirecti2;
     const {
-      fragmentTracker,
-      media
-    } = this;
-    const config = (_this$hls2 = this.hls) == null ? undefined : _this$hls2.config;
-    if (!media || !fragmentTracker || !config) {
+      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 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;
+
+    // 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;
     }
-
-    // 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);
+  }
+  loadPlaylist(hlsUrlParameters) {
+    super.loadPlaylist();
+    if (this.shouldLoadPlaylist(this.currentLevel)) {
+      this.scheduleLoading(this.currentLevel, hlsUrlParameters);
     }
   }
-
-  /**
-   * 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
-        }
-      });
+  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;
     }
   }
-
-  /**
-   * 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;
+  set nextLoadLevel(nextLevel) {
+    this.level = nextLevel;
+    if (this.manualLevelIndex === -1) {
+      this.hls.nextAutoLevel = nextLevel;
     }
-
-    // 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
-          });
+  }
+  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 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.10923";
+const version = "1.6.0-beta.2.0.canary.10925";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -19552,7 +19746,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 +19757,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 +19813,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 +19908,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.lastCurrentTime = this.media.currentTime;
+    }
     this.checkFragmentChanged();
   }
   doTickIdle() {
@@ -19960,29 +20145,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 +20165,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 +20499,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 +20514,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 +21991,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 +22036,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 +22050,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 +22327,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)