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

package/dist/hls.mjs

@@ -402,7 +402,7 @@ function enableLogs(debugConfig, context, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.2.0.canary.10924"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.2.0.canary.10926"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -1307,8 +1307,8 @@ function searchDownAndUpList(arr, searchIndex, predicate) {
   return -1;
 }
 function useAlternateAudio(audioTrackUrl, hls) {
-  var _hls$levels$hls$loadL;
-  return !!audioTrackUrl && audioTrackUrl !== ((_hls$levels$hls$loadL = hls.levels[hls.loadLevel]) == null ? undefined : _hls$levels$hls$loadL.uri);
+  var _hls$loadLevelObj;
+  return !!audioTrackUrl && audioTrackUrl !== ((_hls$loadLevelObj = hls.loadLevelObj) == null ? undefined : _hls$loadLevelObj.uri);
 }
 
 class AbrController extends Logger {
@@ -1802,8 +1802,8 @@ class AbrController extends Logger {
     }
     // If no matching level found, see if min auto level would be a better option
     const minLevel = hls.levels[minAutoLevel];
-    const autoLevel = hls.levels[hls.loadLevel];
-    if ((minLevel == null ? undefined : minLevel.bitrate) < (autoLevel == null ? undefined : autoLevel.bitrate)) {
+    const autoLevel = hls.loadLevelObj;
+    if (autoLevel && (minLevel == null ? undefined : minLevel.bitrate) < autoLevel.bitrate) {
       return minAutoLevel;
     }
     // or if bitrate is not lower, continue to use loadLevel
@@ -2344,7 +2344,7 @@ class ErrorController extends Logger {
       case ErrorDetails.SUBTITLE_LOAD_ERROR:
       case ErrorDetails.SUBTITLE_TRACK_LOAD_TIMEOUT:
         if (context) {
-          const level = hls.levels[hls.loadLevel];
+          const level = hls.loadLevelObj;
           if (level && (context.type === PlaylistContextType.AUDIO_TRACK && level.hasAudioGroup(context.groupId) || context.type === PlaylistContextType.SUBTITLE_TRACK && level.hasSubtitleGroup(context.groupId))) {
             // Perform Pathway switch or Redundant failover if possible for fastest recovery
             // otherwise allow playlist retry count to reach max error retries
@@ -2357,7 +2357,7 @@ class ErrorController extends Logger {
         return;
       case ErrorDetails.KEY_SYSTEM_STATUS_OUTPUT_RESTRICTED:
         {
-          const level = hls.levels[hls.loadLevel];
+          const level = hls.loadLevelObj;
           const restrictedHdcpLevel = level == null ? undefined : level.attrs['HDCP-LEVEL'];
           if (restrictedHdcpLevel) {
             data.errorAction = {
@@ -5845,36 +5845,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;
@@ -5900,24 +5917,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;
       }
     }
@@ -5925,8 +5943,9 @@ class BufferHelper {
       len: bufferLen,
       start: bufferStart || 0,
       end: bufferEnd || 0,
-      nextStart: bufferStartNext,
-      buffered
+      nextStart,
+      buffered,
+      bufferedIndex
     };
   }
 
@@ -8112,7 +8131,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;
@@ -8186,6 +8204,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) {
@@ -8274,9 +8298,6 @@ class BaseStreamController extends TaskLoop {
     this.startFragRequested = false;
   }
   onError(event, data) {}
-  triggerEnded() {
-    /* overridden in stream-controller */
-  }
   onManifestLoaded(event, data) {
     this.startTimeOffset = data.startTimeOffset;
   }
@@ -8871,7 +8892,8 @@ class BaseStreamController extends TaskLoop {
     if (bufferInfo.len === 0 && bufferInfo.nextStart !== undefined) {
       const bufferedFragAtPos = this.fragmentTracker.getBufferedFrag(pos, type);
       if (bufferedFragAtPos && (bufferInfo.nextStart <= bufferedFragAtPos.end || bufferedFragAtPos.gap)) {
-        return BufferHelper.bufferInfo(bufferable, pos, Math.max(bufferInfo.nextStart, maxBufferHole));
+        const gapDuration = Math.max(Math.min(bufferInfo.nextStart, bufferedFragAtPos.end) - pos, maxBufferHole);
+        return BufferHelper.bufferInfo(bufferable, pos, gapDuration);
       }
     }
     return bufferInfo;
@@ -9838,7 +9860,7 @@ var eventemitter3 = {exports: {}};
 var eventemitter3Exports = eventemitter3.exports;
 var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
-const version = "1.6.0-beta.2.0.canary.10924";
+const version = "1.6.0-beta.2.0.canary.10926";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -16085,7 +16107,7 @@ class TransmuxerInterface {
   }
 }
 
-const TICK_INTERVAL$2 = 100; // how often to tick in ms
+const TICK_INTERVAL$3 = 100; // how often to tick in ms
 
 class AudioStreamController extends BaseStreamController {
   constructor(hls, fragmentTracker, keyLoader) {
@@ -16197,7 +16219,7 @@ class AudioStreamController extends BaseStreamController {
     }
     const lastCurrentTime = this.lastCurrentTime;
     this.stopLoad();
-    this.setInterval(TICK_INTERVAL$2);
+    this.setInterval(TICK_INTERVAL$3);
     if (lastCurrentTime > 0 && startPosition === -1) {
       this.log(`Override startPosition with lastCurrentTime @${lastCurrentTime.toFixed(3)}`);
       startPosition = lastCurrentTime;
@@ -16440,7 +16462,7 @@ class AudioStreamController extends BaseStreamController {
       this.flushAudioIfNeeded(data);
       if (this.state !== State.STOPPED) {
         // switching to audio track, start timer if not already started
-        this.setInterval(TICK_INTERVAL$2);
+        this.setInterval(TICK_INTERVAL$3);
         this.state = State.IDLE;
         this.tick();
       }
@@ -18151,7 +18173,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,
@@ -18168,7 +18189,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);
         }
@@ -23623,6 +23644,14 @@ class AssetListLoader {
   }
 }
 
+function addEventListener(el, type, listener) {
+  removeEventListener(el, type, listener);
+  el.addEventListener(type, listener);
+}
+function removeEventListener(el, type, listener) {
+  el.removeEventListener(type, listener);
+}
+
 function playWithCatch(media) {
   media == null ? undefined : media.play().catch(() => {
     /* no-op */
@@ -23925,24 +23954,23 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))}`);
     this.onScheduleUpdate = null;
   }
   onDestroying() {
-    const media = this.primaryMedia;
+    const media = this.primaryMedia || this.media;
     if (media) {
       this.removeMediaListeners(media);
     }
   }
   removeMediaListeners(media) {
-    media.removeEventListener('play', this.onPlay);
-    media.removeEventListener('pause', this.onPause);
-    media.removeEventListener('seeking', this.onSeeking);
-    media.removeEventListener('timeupdate', this.onTimeupdate);
+    removeEventListener(media, 'play', this.onPlay);
+    removeEventListener(media, 'pause', this.onPause);
+    removeEventListener(media, 'seeking', this.onSeeking);
+    removeEventListener(media, 'timeupdate', this.onTimeupdate);
   }
   onMediaAttaching(event, data) {
     const media = this.media = data.media;
-    this.removeMediaListeners(media);
-    media.addEventListener('seeking', this.onSeeking);
-    media.addEventListener('timeupdate', this.onTimeupdate);
-    media.addEventListener('play', this.onPlay);
-    media.addEventListener('pause', this.onPause);
+    addEventListener(media, 'seeking', this.onSeeking);
+    addEventListener(media, 'timeupdate', this.onTimeupdate);
+    addEventListener(media, 'play', this.onPlay);
+    addEventListener(media, 'pause', this.onPause);
   }
   onMediaAttached(event, data) {
     const playingItem = this.playingItem;
@@ -25020,7 +25048,7 @@ MediaSource ${JSON.stringify(attachMediaSourceData)} from ${logFromSource}`);
     const primary = this.hls;
     const userConfig = primary.userConfig;
     let videoPreference = userConfig.videoPreference;
-    const currentLevel = primary.levels[primary.loadLevel] || primary.levels[primary.currentLevel];
+    const currentLevel = primary.loadLevelObj || primary.levels[primary.currentLevel];
     if (videoPreference || currentLevel) {
       videoPreference = _extends({}, videoPreference);
       if (currentLevel.videoCodec) {
@@ -25405,7 +25433,7 @@ MediaSource ${JSON.stringify(attachMediaSourceData)} from ${logFromSource}`);
   }
 }
 
-const TICK_INTERVAL$1 = 500; // how often to tick in ms
+const TICK_INTERVAL$2 = 500; // how often to tick in ms
 
 class SubtitleStreamController extends BaseStreamController {
   constructor(hls, fragmentTracker, keyLoader) {
@@ -25447,7 +25475,7 @@ class SubtitleStreamController extends BaseStreamController {
   startLoad(startPosition) {
     this.stopLoad();
     this.state = State.IDLE;
-    this.setInterval(TICK_INTERVAL$1);
+    this.setInterval(TICK_INTERVAL$2);
     this.nextLoadPosition = this.startPosition = this.lastCurrentTime = startPosition;
     this.tick();
   }
@@ -25583,7 +25611,7 @@ class SubtitleStreamController extends BaseStreamController {
       this.mediaBuffer = null;
     }
     if (currentTrack && this.state !== State.STOPPED) {
-      this.setInterval(TICK_INTERVAL$1);
+      this.setInterval(TICK_INTERVAL$2);
     }
   }
 
@@ -29333,16 +29361,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,
@@ -29441,7 +29473,6 @@ const hlsDefaultConfig = _objectSpread2(_objectSpread2({
   progressive: false,
   lowLatencyMode: true,
   cmcd: undefined,
-  detectStallWithCurrentTimeMs: 1250,
   enableDateRangeMetadataCues: true,
   enableEmsgMetadataCues: true,
   enableEmsgKLVMetadata: false,
@@ -29696,6 +29727,556 @@ function enableStreamingMode(config, logger) {
   }
 }
 
+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.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.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.fragmentTracker = fragmentTracker;
+    this.registerListeners();
+  }
+  registerListeners() {
+    const {
+      hls
+    } = 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() {
+    const {
+      hls
+    } = this;
+    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);
+    }
+  }
+  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.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.mediaSource = undefined;
+  }
+  onBufferAppended(event, data) {
+    this.buffered = data.timeRanges;
+  }
+  get hasBuffered() {
+    return Object.keys(this.buffered).length > 0;
+  }
+  tick() {
+    var _this$media3;
+    if (!((_this$media3 = this.media) != null && _this$media3.readyState) || !this.hasBuffered) {
+      return;
+    }
+    const currentTime = this.media.currentTime;
+    this.poll(currentTime, this.lastCurrentTime);
+    this.lastCurrentTime = currentTime;
+  }
+
+  /**
+   * 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 {
+      media,
+      stalled
+    } = this;
+    if (!media) {
+      return;
+    }
+    const {
+      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;
+
+    // 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;
+    }
+
+    // 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;
+    }
+
+    // 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
+        });
+      }
+      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;
+    }
+
+    // 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;
+      }
+    }
+
+    // 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 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;
+      }
+      // Report stalling after trying to fix
+      this._reportStall(bufferInfo);
+      if (!this.media || !this.hls) {
+        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.log(`playback not stuck anymore @${currentTime}, after ${Math.round(stalledDuration)}ms`);
+        this.stallReported = false;
+        this.waiting = 0;
+        this.hls.trigger(Events.STALL_RESOLVED, {});
+      }
+    }
+  }
+  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 {
+      fragmentTracker,
+      media
+    } = this;
+    const config = (_this$hls3 = this.hls) == null ? undefined : _this$hls3.config;
+    if (!media || !fragmentTracker || !config) {
+      return;
+    }
+    const currentTime = media.currentTime;
+    const partial = fragmentTracker.getPartialFragment(currentTime);
+    if (partial) {
+      // Try to skip over the buffer hole caused by a partial fragment
+      // This method isn't limited by the size of the gap between buffered ranges
+      const targetTime = this._trySkipBufferHole(partial);
+      // we return here in this case, meaning
+      // the branch below only executes when we haven't seeked to a new position
+      if (targetTime || !this.media) {
+        return;
+      }
+    }
+
+    // if we haven't had to skip over a buffer hole of a partial fragment
+    // we may just have to "nudge" the playlist as the browser decoding/rendering engine
+    // needs to cross some sort of threshold covering all source-buffers content
+    // to start playing properly.
+    const bufferedRanges = bufferInfo.buffered;
+    if ((bufferedRanges && bufferedRanges.length > 1 && bufferInfo.len > config.maxBufferHole || bufferInfo.nextStart && bufferInfo.nextStart - currentTime < config.maxBufferHole) && (stalledDurationMs > config.highBufferWatchdogPeriod * 1000 || this.waiting)) {
+      this.warn('Trying to nudge playhead over buffer-hole');
+      // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
+      // We only try to jump the hole if it's under the configured size
+      this._tryNudgeBuffer(bufferInfo);
+    }
+  }
+
+  /**
+   * Triggers a BUFFER_STALLED_ERROR event, but only once per stall period.
+   * @param bufferLen - The playhead distance from the end of the current buffer segment.
+   * @private
+   */
+  _reportStall(bufferInfo) {
+    const {
+      hls,
+      media,
+      stallReported,
+      stalled
+    } = this;
+    if (!stallReported && stalled !== null && media && hls) {
+      // Report stalled error once
+      this.stallReported = true;
+      const error = new Error(`Playback stalling at @${media.currentTime} due to low buffer (${JSON.stringify(bufferInfo)})`);
+      this.warn(error.message);
+      hls.trigger(Events.ERROR, {
+        type: ErrorTypes.MEDIA_ERROR,
+        details: ErrorDetails.BUFFER_STALLED_ERROR,
+        fatal: false,
+        error,
+        buffer: bufferInfo.len,
+        bufferInfo,
+        stalled: {
+          start: stalled
+        }
+      });
+    }
+  }
+
+  /**
+   * Attempts to fix buffer stalls by jumping over known gaps caused by partial fragments
+   * @param partial - The partial fragment found at the current time (where playback is stalling).
+   * @private
+   */
+  _trySkipBufferHole(partial) {
+    var _this$hls4;
+    const {
+      fragmentTracker,
+      media
+    } = this;
+    const config = (_this$hls4 = this.hls) == null ? undefined : _this$hls4.config;
+    if (!media || !fragmentTracker || !config) {
+      return 0;
+    }
+
+    // Check if currentTime is between unbuffered regions of partial fragments
+    const currentTime = media.currentTime;
+    const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
+    const startTime = currentTime < bufferInfo.start ? bufferInfo.start : bufferInfo.nextStart;
+    if (startTime && this.hls) {
+      const bufferStarved = bufferInfo.len <= config.maxBufferHole;
+      const waiting = bufferInfo.len > 0 && bufferInfo.len < 1 && media.readyState < 3;
+      const gapLength = startTime - currentTime;
+      if (gapLength > 0 && (bufferStarved || waiting)) {
+        // Only allow large gaps to be skipped if it is a start gap, or all fragments in skip range are partial
+        if (gapLength > config.maxBufferHole) {
+          let startGap = false;
+          if (currentTime === 0) {
+            const startFrag = fragmentTracker.getAppendedFrag(0, PlaylistLevelType.MAIN);
+            if (startFrag && startTime < startFrag.end) {
+              startGap = true;
+            }
+          }
+          if (!startGap) {
+            const startProvisioned = partial || fragmentTracker.getAppendedFrag(currentTime, PlaylistLevelType.MAIN);
+            if (startProvisioned) {
+              var _this$hls$loadLevelOb;
+              // Do not seek when selected variant playlist is unloaded
+              if (!((_this$hls$loadLevelOb = this.hls.loadLevelObj) != null && _this$hls$loadLevelOb.details)) {
+                return 0;
+              }
+              // Do not seek when required fragments are inflight or appending
+              const inFlightDependency = getInFlightDependency(this.hls.inFlightFragments, startTime);
+              if (inFlightDependency) {
+                return 0;
+              }
+              // Do not seek if we can't walk tracked fragments to end of gap
+              let moreToLoad = false;
+              let pos = startProvisioned.end;
+              while (pos < startTime) {
+                const provisioned = fragmentTracker.getPartialFragment(pos);
+                if (provisioned) {
+                  pos += provisioned.duration;
+                } else {
+                  moreToLoad = true;
+                  break;
+                }
+              }
+              if (moreToLoad) {
+                return 0;
+              }
+            }
+          }
+        }
+        const targetTime = Math.max(startTime + SKIP_BUFFER_RANGE_START, currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS);
+        this.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
+        this.moved = true;
+        media.currentTime = targetTime;
+        if (!(partial != null && partial.gap)) {
+          const error = new Error(`fragment loaded with buffer holes, seeking from ${currentTime} to ${targetTime}`);
+          this.hls.trigger(Events.ERROR, {
+            type: ErrorTypes.MEDIA_ERROR,
+            details: ErrorDetails.BUFFER_SEEK_OVER_HOLE,
+            fatal: false,
+            error,
+            reason: error.message,
+            frag: partial || undefined,
+            buffer: bufferInfo.len,
+            bufferInfo
+          });
+        }
+        return targetTime;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
+   * @private
+   */
+  _tryNudgeBuffer(bufferInfo) {
+    const {
+      hls,
+      media,
+      nudgeRetry
+    } = this;
+    const config = hls == null ? undefined : hls.config;
+    if (!media || !config) {
+      return 0;
+    }
+    const currentTime = media.currentTime;
+    this.nudgeRetry++;
+    if (nudgeRetry < config.nudgeMaxRetry) {
+      const targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
+      // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
+      const error = new Error(`Nudging 'currentTime' from ${currentTime} to ${targetTime}`);
+      this.warn(error.message);
+      media.currentTime = targetTime;
+      hls.trigger(Events.ERROR, {
+        type: ErrorTypes.MEDIA_ERROR,
+        details: ErrorDetails.BUFFER_NUDGE_ON_STALL,
+        error,
+        fatal: false,
+        buffer: bufferInfo.len,
+        bufferInfo
+      });
+    } else {
+      const error = new Error(`Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`);
+      this.error(error.message);
+      hls.trigger(Events.ERROR, {
+        type: ErrorTypes.MEDIA_ERROR,
+        details: ErrorDetails.BUFFER_STALLED_ERROR,
+        error,
+        fatal: true,
+        buffer: bufferInfo.len,
+        bufferInfo
+      });
+    }
+  }
+}
+function getInFlightDependency(inFlightFragments, currentTime) {
+  const main = inFlight(inFlightFragments.main);
+  if (main && main.start <= currentTime) {
+    return main;
+  }
+  const audio = inFlight(inFlightFragments.audio);
+  if (audio && audio.start <= currentTime) {
+    return audio;
+  }
+  return null;
+}
+function inFlight(inFlightData) {
+  if (!inFlightData) {
+    return null;
+  }
+  switch (inFlightData.state) {
+    case State.IDLE:
+    case State.STOPPED:
+    case State.ENDED:
+    case State.ERROR:
+      return null;
+  }
+  return inFlightData.frag;
+}
+
 const MIN_CUE_DURATION = 0.25;
 function getCueClass() {
   if (typeof self === 'undefined') return undefined;
@@ -30562,6 +31143,9 @@ class LevelController extends BasePlaylistController {
     }
     return this._levels;
   }
+  get loadLevelObj() {
+    return this.currentLevel;
+  }
   get level() {
     return this.currentLevelIndex;
   }
@@ -30850,382 +31434,6 @@ function assignTrackIdsByGroup(tracks) {
   });
 }
 
-const MAX_START_GAP_JUMP = 2.0;
-const SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
-const SKIP_BUFFER_RANGE_START = 0.05;
-class GapController extends Logger {
-  constructor(media, fragmentTracker, hls) {
-    super('gap-controller', hls.logger);
-    this.media = null;
-    this.fragmentTracker = null;
-    this.hls = null;
-    this.nudgeRetry = 0;
-    this.stallReported = false;
-    this.stalled = null;
-    this.moved = false;
-    this.seeking = false;
-    this.ended = 0;
-    this.waiting = 0;
-    this.media = media;
-    this.fragmentTracker = fragmentTracker;
-    this.hls = hls;
-  }
-  destroy() {
-    this.media = this.hls = this.fragmentTracker = null;
-  }
-
-  /**
-   * Checks if the playhead is stuck within a gap, and if so, attempts to free it.
-   * A gap is an unbuffered range between two buffered ranges (or the start and the first buffered range).
-   *
-   * @param lastCurrentTime - Previously read playhead position
-   */
-  poll(lastCurrentTime, activeFrag, levelDetails, state) {
-    var _this$hls;
-    const {
-      media,
-      stalled
-    } = this;
-    if (!media) {
-      return;
-    }
-    const {
-      currentTime,
-      seeking
-    } = media;
-    const seeked = this.seeking && !seeking;
-    const beginSeek = !this.seeking && seeking;
-    this.seeking = seeking;
-
-    // The playhead is moving, no-op
-    if (currentTime !== lastCurrentTime) {
-      if (lastCurrentTime) {
-        this.ended = 0;
-      }
-      this.moved = true;
-      if (!seeking) {
-        this.nudgeRetry = 0;
-      }
-      if (this.waiting === 0) {
-        this.stallResolved(currentTime);
-      }
-      return;
-    }
-
-    // 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;
-    }
-
-    // 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;
-    }
-    if (!BufferHelper.getBuffered(media).length) {
-      this.nudgeRetry = 0;
-      return;
-    }
-    const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
-    const nextStart = bufferInfo.nextStart || 0;
-    const fragmentTracker = this.fragmentTracker;
-    if (seeking && fragmentTracker) {
-      // Waiting for seeking in a buffered range to complete
-      const hasEnoughBuffer = bufferInfo.len > MAX_START_GAP_JUMP;
-      // Next buffered range is too far ahead to jump to while still seeking
-      const noBufferGap = !nextStart || activeFrag && activeFrag.start <= currentTime || nextStart - currentTime > MAX_START_GAP_JUMP && !fragmentTracker.getPartialFragment(currentTime);
-      if (hasEnoughBuffer || noBufferGap) {
-        return;
-      }
-      // Reset moved state when seeking to a point in or before a gap
-      this.moved = false;
-    }
-
-    // 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;
-      }
-    }
-
-    // Start tracking stall time
-    const config = (_this$hls = this.hls) == null ? undefined : _this$hls.config;
-    if (!config) {
-      return;
-    }
-    const detectStallWithCurrentTimeMs = config.detectStallWithCurrentTimeMs;
-    const tnow = self.performance.now();
-    const tWaiting = this.waiting;
-    if (stalled === null) {
-      // Use time of recent "waiting" event
-      if (tWaiting > 0 && tnow - tWaiting < detectStallWithCurrentTimeMs) {
-        this.stalled = tWaiting;
-      } else {
-        this.stalled = tnow;
-      }
-      return;
-    }
-    const stalledDuration = tnow - stalled;
-    if (!seeking && (stalledDuration >= detectStallWithCurrentTimeMs || tWaiting) && this.hls) {
-      // Dispatch MEDIA_ENDED when media.ended/ended event is not signalled at end of stream
-      if (state === State.ENDED && !(levelDetails != null && levelDetails.live) && Math.abs(currentTime - ((levelDetails == null ? undefined : levelDetails.edge) || 0)) < 1) {
-        if (this.ended) {
-          return;
-        }
-        this.ended = currentTime || 1;
-        this.hls.trigger(Events.MEDIA_ENDED, {
-          stalled: true
-        });
-        return;
-      }
-      // Report stalling after trying to fix
-      this._reportStall(bufferInfo);
-      if (!this.media || !this.hls) {
-        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, {});
-      }
-    }
-  }
-
-  /**
-   * Detects and attempts to fix known buffer stalling issues.
-   * @param bufferInfo - The properties of the current buffer.
-   * @param stalledDurationMs - The amount of time Hls.js has been stalling for.
-   * @private
-   */
-  _tryFixBufferStall(bufferInfo, stalledDurationMs) {
-    var _this$hls2;
-    const {
-      fragmentTracker,
-      media
-    } = this;
-    const config = (_this$hls2 = this.hls) == null ? undefined : _this$hls2.config;
-    if (!media || !fragmentTracker || !config) {
-      return;
-    }
-    const currentTime = media.currentTime;
-    const partial = fragmentTracker.getPartialFragment(currentTime);
-    if (partial) {
-      // Try to skip over the buffer hole caused by a partial fragment
-      // This method isn't limited by the size of the gap between buffered ranges
-      const targetTime = this._trySkipBufferHole(partial);
-      // we return here in this case, meaning
-      // the branch below only executes when we haven't seeked to a new position
-      if (targetTime || !this.media) {
-        return;
-      }
-    }
-
-    // if we haven't had to skip over a buffer hole of a partial fragment
-    // we may just have to "nudge" the playlist as the browser decoding/rendering engine
-    // needs to cross some sort of threshold covering all source-buffers content
-    // to start playing properly.
-    const bufferedRanges = bufferInfo.buffered;
-    if ((bufferedRanges && bufferedRanges.length > 1 && bufferInfo.len > config.maxBufferHole || bufferInfo.nextStart && bufferInfo.nextStart - currentTime < config.maxBufferHole) && stalledDurationMs > config.highBufferWatchdogPeriod * 1000) {
-      this.warn('Trying to nudge playhead over buffer-hole');
-      // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
-      // We only try to jump the hole if it's under the configured size
-      this._tryNudgeBuffer(bufferInfo);
-    }
-  }
-
-  /**
-   * Triggers a BUFFER_STALLED_ERROR event, but only once per stall period.
-   * @param bufferLen - The playhead distance from the end of the current buffer segment.
-   * @private
-   */
-  _reportStall(bufferInfo) {
-    const {
-      hls,
-      media,
-      stallReported,
-      stalled
-    } = this;
-    if (!stallReported && stalled !== null && media && hls) {
-      // Report stalled error once
-      this.stallReported = true;
-      const error = new Error(`Playback stalling at @${media.currentTime} due to low buffer (${JSON.stringify(bufferInfo)})`);
-      this.warn(error.message);
-      hls.trigger(Events.ERROR, {
-        type: ErrorTypes.MEDIA_ERROR,
-        details: ErrorDetails.BUFFER_STALLED_ERROR,
-        fatal: false,
-        error,
-        buffer: bufferInfo.len,
-        bufferInfo,
-        stalled: {
-          start: stalled
-        }
-      });
-    }
-  }
-
-  /**
-   * Attempts to fix buffer stalls by jumping over known gaps caused by partial fragments
-   * @param partial - The partial fragment found at the current time (where playback is stalling).
-   * @private
-   */
-  _trySkipBufferHole(partial) {
-    var _this$hls3;
-    const {
-      fragmentTracker,
-      media
-    } = this;
-    const config = (_this$hls3 = this.hls) == null ? undefined : _this$hls3.config;
-    if (!media || !fragmentTracker || !config) {
-      return 0;
-    }
-
-    // Check if currentTime is between unbuffered regions of partial fragments
-    const currentTime = media.currentTime;
-    const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
-    const startTime = currentTime < bufferInfo.start ? bufferInfo.start : bufferInfo.nextStart;
-    if (startTime) {
-      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
-          });
-        }
-        return targetTime;
-      }
-    }
-    return 0;
-  }
-
-  /**
-   * Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
-   * @private
-   */
-  _tryNudgeBuffer(bufferInfo) {
-    const {
-      hls,
-      media,
-      nudgeRetry
-    } = this;
-    const config = hls == null ? undefined : hls.config;
-    if (!media || !config) {
-      return 0;
-    }
-    const currentTime = media.currentTime;
-    this.nudgeRetry++;
-    if (nudgeRetry < config.nudgeMaxRetry) {
-      const targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
-      // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
-      const error = new Error(`Nudging 'currentTime' from ${currentTime} to ${targetTime}`);
-      this.warn(error.message);
-      media.currentTime = targetTime;
-      hls.trigger(Events.ERROR, {
-        type: ErrorTypes.MEDIA_ERROR,
-        details: ErrorDetails.BUFFER_NUDGE_ON_STALL,
-        error,
-        fatal: false,
-        buffer: bufferInfo.len,
-        bufferInfo
-      });
-    } else {
-      const error = new Error(`Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`);
-      this.error(error.message);
-      hls.trigger(Events.ERROR, {
-        type: ErrorTypes.MEDIA_ERROR,
-        details: ErrorDetails.BUFFER_STALLED_ERROR,
-        error,
-        fatal: true,
-        buffer: bufferInfo.len,
-        bufferInfo
-      });
-    }
-  }
-}
-
 function getSourceBuffer() {
   return self.SourceBuffer || self.WebKitSourceBuffer;
 }
@@ -31259,7 +31467,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;
@@ -31271,19 +31478,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 = () => {
@@ -31338,7 +31534,7 @@ class StreamController extends BaseStreamController {
   }
   onHandlerDestroying() {
     // @ts-ignore
-    this.onMediaPlaying = this.onMediaSeeked = this.onMediaWaiting = null;
+    this.onMediaPlaying = this.onMediaSeeked = null;
     this.unregisterListeners();
     super.onHandlerDestroying();
   }
@@ -31433,8 +31629,11 @@ class StreamController extends BaseStreamController {
     this.onTickEnd();
   }
   onTickEnd() {
+    var _this$media2;
     super.onTickEnd();
-    this.checkBuffer();
+    if ((_this$media2 = this.media) != null && _this$media2.readyState && this.media.seeking === false) {
+      this.lastCurrentTime = this.media.currentTime;
+    }
     this.checkFragmentChanged();
   }
   doTickIdle() {
@@ -31667,29 +31866,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) {
@@ -31697,19 +31886,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
@@ -32044,26 +32220,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
@@ -32079,8 +32235,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) {
@@ -33460,9 +33618,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;
@@ -33502,6 +33663,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);
@@ -33515,17 +33677,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);
@@ -33792,6 +33954,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)
@@ -33841,10 +34015,21 @@ class Hls {
     const levels = this.levelController.levels;
     return levels ? levels : [];
   }
+
+  /**
+   * @returns LevelDetails of last loaded level (variant) or `null` prior to loading a media playlist.
+   */
   get latestLevelDetails() {
     return this.streamController.getLevelDetails() || null;
   }
 
+  /**
+   * @returns Level object of selected level (variant) or `null` prior to selecting a level or once the level is removed.
+   */
+  get loadLevelObj() {
+    return this.levelController.loadLevelObj;
+  }
+
   /**
    * Index of quality level (variant) currently played
    */