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

package/dist/hls.js

@@ -1059,7 +1059,7 @@
       // 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();
@@ -6504,38 +6504,55 @@
       }
       return false;
     };
+    BufferHelper.bufferedRanges = function bufferedRanges(media) {
+      if (media) {
+        var timeRanges = BufferHelper.getBuffered(media);
+        return BufferHelper.timeRangesToArray(timeRanges);
+      }
+      return [];
+    };
+    BufferHelper.timeRangesToArray = function timeRangesToArray(timeRanges) {
+      var buffered = [];
+      for (var i = 0; i < timeRanges.length; i++) {
+        buffered.push({
+          start: timeRanges.start(i),
+          end: timeRanges.end(i)
+        });
+      }
+      return buffered;
+    };
     BufferHelper.bufferInfo = function bufferInfo(media, pos, maxHoleDuration) {
       if (media) {
-        var vbuffered = BufferHelper.getBuffered(media);
-        if (vbuffered.length) {
-          var buffered = [];
-          for (var i = 0; i < vbuffered.length; i++) {
-            buffered.push({
-              start: vbuffered.start(i),
-              end: vbuffered.end(i)
-            });
-          }
+        var buffered = BufferHelper.bufferedRanges(media);
+        if (buffered.length) {
           return BufferHelper.bufferedInfo(buffered, pos, maxHoleDuration);
         }
       }
       return {
         len: 0,
         start: pos,
-        end: pos
+        end: pos,
+        bufferedIndex: -1
       };
     };
     BufferHelper.bufferedInfo = function 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(function (a, b) {
-        return a.start - b.start || b.end - a.end;
-      });
+      if (buffered.length > 1) {
+        buffered.sort(function (a, b) {
+          return a.start - b.start || b.end - a.end;
+        });
+      }
+      var bufferedIndex = -1;
       var 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 (var i = 0; i < buffered.length; i++) {
+          if (pos >= buffered[i].start && pos <= buffered[i].end) {
+            bufferedIndex = i;
+          }
           var buf2len = buffered2.length;
           if (buf2len) {
             var buf2end = buffered2[buf2len - 1].end;
@@ -6561,24 +6578,25 @@
         buffered2 = buffered;
       }
       var bufferLen = 0;
+      var nextStart;
 
-      // bufferStartNext can possibly be undefined based on the conditional logic below
-      var bufferStartNext;
-
-      // bufferStart and bufferEnd are buffer boundaries around current video position
+      // bufferStart and bufferEnd are buffer boundaries around current playback position (pos)
       var bufferStart = pos;
       var bufferEnd = pos;
       for (var _i = 0; _i < buffered2.length; _i++) {
         var start = buffered2[_i].start;
         var 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;
         }
       }
@@ -6586,8 +6604,9 @@
         len: bufferLen,
         start: bufferStart || 0,
         end: bufferEnd || 0,
-        nextStart: bufferStartNext,
-        buffered: buffered
+        nextStart: nextStart,
+        buffered: buffered,
+        bufferedIndex: bufferedIndex
       };
     }
 
@@ -8866,7 +8885,6 @@
         // 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;
@@ -9015,9 +9033,6 @@
       this.startFragRequested = false;
     };
     _proto.onError = function onError(event, data) {};
-    _proto.triggerEnded = function triggerEnded() {
-      /* overridden in stream-controller */
-    };
     _proto.onManifestLoaded = function onManifestLoaded(event, data) {
       this.startTimeOffset = data.startTimeOffset;
     };
@@ -10194,6 +10209,14 @@
       get: function get() {
         return this.buffering;
       }
+    }, {
+      key: "inFlightFrag",
+      get: function get() {
+        return {
+          frag: this.fragCurrent,
+          state: this.state
+        };
+      }
     }, {
       key: "state",
       get: function get() {
@@ -16311,7 +16334,7 @@
     return !remuxResult.audio && !remuxResult.video && !remuxResult.text && !remuxResult.id3 && !remuxResult.initSegment;
   }
 
-  var version = "1.6.0-beta.2.0.canary.10923";
+  var 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
@@ -16682,7 +16705,7 @@
     return TransmuxerInterface;
   }();
 
-  var TICK_INTERVAL$2 = 100; // how often to tick in ms
+  var TICK_INTERVAL$3 = 100; // how often to tick in ms
   var AudioStreamController = /*#__PURE__*/function (_BaseStreamController) {
     function AudioStreamController(hls, fragmentTracker, keyLoader) {
       var _this;
@@ -16793,7 +16816,7 @@
       }
       var 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;
@@ -17025,7 +17048,7 @@
         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();
         }
@@ -18732,7 +18755,6 @@
         var sbTrack = transferredTrack != null && transferredTrack.buffer ? transferredTrack : track;
         var sbCodec = (sbTrack == null ? undefined : sbTrack.pendingCodec) || (sbTrack == null ? undefined : sbTrack.codec);
         var trackLevelCodec = sbTrack == null ? undefined : sbTrack.levelCodec;
-        var forceChangeType = !sbTrack || !!_this9.hls.config.assetPlayerId;
         if (!track) {
           track = tracks[trackName] = {
             buffer: undefined,
@@ -18749,7 +18771,7 @@
         var currentCodec = currentCodecFull == null ? undefined : currentCodecFull.replace(VIDEO_CODEC_PROFILE_REPLACE, '$1');
         var trackCodec = pickMostCompleteCodecName(codec, levelCodec);
         var 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, _this9.appendSource);
           }
@@ -21919,8 +21941,10 @@
     _inheritsLoose(EMEController, _Logger);
     var _proto = EMEController.prototype;
     _proto.destroy = function destroy() {
+      var media = this.media;
       this.unregisterListeners();
       this.onMediaDetached();
+      this._clear(media);
       // Remove any references that could be held in config options or callbacks
       var config = this.config;
       config.requestMediaKeySystemAccessFunc = null;
@@ -22592,15 +22616,17 @@
       media.addEventListener('waitingforkey', this.onWaitingForKey);
     };
     _proto.onMediaDetached = function onMediaDetached() {
-      var _this14 = this,
-        _media$setMediaKeys;
       var media = this.media;
-      var mediaKeysList = this.mediaKeySessions;
       if (media) {
         media.removeEventListener('encrypted', this.onMediaEncrypted);
         media.removeEventListener('waitingforkey', this.onWaitingForKey);
         this.media = null;
       }
+    };
+    _proto._clear = function _clear(media) {
+      var _this14 = this,
+        _media$setMediaKeys;
+      var mediaKeysList = this.mediaKeySessions;
       this._requestLicenseFailureCount = 0;
       this.setMediaKeysQueue = [];
       this.mediaKeySessions = [];
@@ -23835,6 +23861,14 @@
     return 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(function () {
       /* no-op */
@@ -24150,24 +24184,23 @@
       this.onScheduleUpdate = null;
     };
     _proto.onDestroying = function onDestroying() {
-      var media = this.primaryMedia;
+      var media = this.primaryMedia || this.media;
       if (media) {
         this.removeMediaListeners(media);
       }
     };
     _proto.removeMediaListeners = function 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);
     };
     _proto.onMediaAttaching = function onMediaAttaching(event, data) {
       var 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);
     };
     _proto.onMediaAttached = function onMediaAttached(event, data) {
       var playingItem = this.playingItem;
@@ -25672,7 +25705,7 @@
     }]);
   }(Logger);
 
-  var TICK_INTERVAL$1 = 500; // how often to tick in ms
+  var TICK_INTERVAL$2 = 500; // how often to tick in ms
 
   var SubtitleStreamController = /*#__PURE__*/function (_BaseStreamController) {
     function SubtitleStreamController(hls, fragmentTracker, keyLoader) {
@@ -25714,7 +25747,7 @@
     _proto.startLoad = function 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();
     };
@@ -25850,7 +25883,7 @@
         this.mediaBuffer = null;
       }
       if (currentTrack && this.state !== State.STOPPED) {
-        this.setInterval(TICK_INTERVAL$1);
+        this.setInterval(TICK_INTERVAL$2);
       }
     }
 
@@ -30251,16 +30284,20 @@
     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,
@@ -30359,7 +30396,6 @@
     progressive: false,
     lowLatencyMode: true,
     cmcd: undefined,
-    detectStallWithCurrentTimeMs: 1250,
     enableDateRangeMetadataCues: true,
     enableEmsgMetadataCues: true,
     enableEmsgKLVMetadata: false,
@@ -30614,6 +30650,534 @@
     }
   }
 
+  var MAX_START_GAP_JUMP = 2.0;
+  var SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
+  var SKIP_BUFFER_RANGE_START = 0.05;
+  var TICK_INTERVAL$1 = 100;
+  var GapController = /*#__PURE__*/function (_TaskLoop) {
+    function GapController(hls, fragmentTracker) {
+      var _this;
+      _this = _TaskLoop.call(this, 'gap-controller', hls.logger) || this;
+      _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 = function () {
+        _this.ended = 0;
+        _this.waiting = 0;
+      };
+      _this.onMediaWaiting = function () {
+        var _this$media;
+        if ((_this$media = _this.media) != null && _this$media.seeking) {
+          return;
+        }
+        _this.waiting = self.performance.now();
+        _this.tick();
+      };
+      _this.onMediaEnded = function () {
+        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();
+      return _this;
+    }
+    _inheritsLoose(GapController, _TaskLoop);
+    var _proto = GapController.prototype;
+    _proto.registerListeners = function registerListeners() {
+      var hls = this.hls;
+      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);
+      }
+    };
+    _proto.unregisterListeners = function unregisterListeners() {
+      var hls = this.hls;
+      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);
+      }
+    };
+    _proto.destroy = function destroy() {
+      _TaskLoop.prototype.destroy.call(this);
+      this.unregisterListeners();
+      this.media = this.hls = this.fragmentTracker = null;
+      this.mediaSource = undefined;
+    };
+    _proto.onMediaAttached = function onMediaAttached(event, data) {
+      this.setInterval(TICK_INTERVAL$1);
+      this.mediaSource = data.mediaSource;
+      var media = this.media = data.media;
+      addEventListener(media, 'playing', this.onMediaPlaying);
+      addEventListener(media, 'waiting', this.onMediaWaiting);
+      addEventListener(media, 'ended', this.onMediaEnded);
+    };
+    _proto.onMediaDetaching = function onMediaDetaching(event, data) {
+      this.clearInterval();
+      var media = this.media;
+      if (media) {
+        removeEventListener(media, 'playing', this.onMediaPlaying);
+        removeEventListener(media, 'waiting', this.onMediaWaiting);
+        removeEventListener(media, 'ended', this.onMediaEnded);
+        this.media = null;
+      }
+      this.mediaSource = undefined;
+    };
+    _proto.onBufferAppended = function onBufferAppended(event, data) {
+      this.buffered = data.timeRanges;
+    };
+    _proto.tick = function tick() {
+      var _this$media3;
+      if (!((_this$media3 = this.media) != null && _this$media3.readyState) || !this.hasBuffered) {
+        return;
+      }
+      var 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
+     */;
+    _proto.poll = function poll(currentTime, lastCurrentTime) {
+      var _this$hls, _this$hls2;
+      var config = (_this$hls = this.hls) == null ? undefined : _this$hls.config;
+      if (!config) {
+        return;
+      }
+      var media = this.media,
+        stalled = this.stalled;
+      if (!media) {
+        return;
+      }
+      var seeking = media.seeking;
+      var seeked = this.seeking && !seeking;
+      var beginSeek = !this.seeking && seeking;
+      var 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
+      var bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
+      var nextStart = bufferInfo.nextStart || 0;
+      var fragmentTracker = this.fragmentTracker;
+      if (seeking && fragmentTracker && this.hls) {
+        // Is there a fragment loading/parsing/appending before currentTime?
+        var inFlightDependency = getInFlightDependency(this.hls.inFlightFragments, currentTime);
+
+        // Waiting for seeking in a buffered range to complete
+        var hasEnoughBuffer = bufferInfo.len > MAX_START_GAP_JUMP;
+        // Next buffered range is too far ahead to jump to while still seeking
+        var 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
+      var 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)
+        var isBuffered = bufferInfo.len > 0;
+        if (!isBuffered && !nextStart) {
+          return;
+        }
+        // Jump start gaps within jump threshold
+        var 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.
+        var isLive = !!(levelDetails != null && levelDetails.live);
+        var maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
+        var partialOrGap = fragmentTracker.getPartialFragment(currentTime);
+        if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
+          if (!media.paused) {
+            this._trySkipBufferHole(partialOrGap);
+          }
+          return;
+        }
+      }
+
+      // Start tracking stall time
+      var detectStallWithCurrentTimeMs = config.detectStallWithCurrentTimeMs;
+      var tnow = self.performance.now();
+      var 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;
+      }
+      var 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;
+        }
+      }
+      var bufferedWithHoles = BufferHelper.bufferInfo(media, currentTime, config.maxBufferHole);
+      this._tryFixBufferStall(bufferedWithHoles, stalledDuration);
+    };
+    _proto.stallResolved = function stallResolved(currentTime) {
+      var stalled = this.stalled;
+      if (stalled && this.hls) {
+        this.stalled = null;
+        // The playhead is now moving, but was previously stalled
+        if (this.stallReported) {
+          var 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, {});
+        }
+      }
+    };
+    _proto.nudgeOnVideoHole = function 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...
+      var 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
+        var audioBufferInfo = BufferHelper.bufferedInfo(BufferHelper.timeRangesToArray(this.buffered.audio), currentTime, 0);
+        if (audioBufferInfo.len > 1 && lastCurrentTime >= audioBufferInfo.start) {
+          var videoTimes = BufferHelper.timeRangesToArray(videoSourceBuffered);
+          var lastBufferedIndex = BufferHelper.bufferedInfo(videoTimes, lastCurrentTime, 0).bufferedIndex;
+          // nudge when crossing into another video buffered range (hole).
+          if (lastBufferedIndex > -1 && lastBufferedIndex < videoTimes.length - 1) {
+            var bufferedIndex = BufferHelper.bufferedInfo(videoTimes, currentTime, 0).bufferedIndex;
+            var holeStart = videoTimes[lastBufferedIndex].end;
+            var 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) {
+              var 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;
+              var frag = this.fragmentTracker.getPartialFragment(currentTime) || undefined;
+              var 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: error,
+                reason: error.message,
+                frag: frag,
+                buffer: bufferInfo.len,
+                bufferInfo: 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
+     */;
+    _proto._tryFixBufferStall = function _tryFixBufferStall(bufferInfo, stalledDurationMs) {
+      var _this$hls3;
+      var fragmentTracker = this.fragmentTracker,
+        media = this.media;
+      var config = (_this$hls3 = this.hls) == null ? undefined : _this$hls3.config;
+      if (!media || !fragmentTracker || !config) {
+        return;
+      }
+      var currentTime = media.currentTime;
+      var 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
+        var 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.
+      var 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
+     */;
+    _proto._reportStall = function _reportStall(bufferInfo) {
+      var hls = this.hls,
+        media = this.media,
+        stallReported = this.stallReported,
+        stalled = this.stalled;
+      if (!stallReported && stalled !== null && media && hls) {
+        // Report stalled error once
+        this.stallReported = true;
+        var 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: error,
+          buffer: bufferInfo.len,
+          bufferInfo: 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
+     */;
+    _proto._trySkipBufferHole = function _trySkipBufferHole(partial) {
+      var _this$hls4;
+      var fragmentTracker = this.fragmentTracker,
+        media = this.media;
+      var 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
+      var currentTime = media.currentTime;
+      var bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
+      var startTime = currentTime < bufferInfo.start ? bufferInfo.start : bufferInfo.nextStart;
+      if (startTime) {
+        var bufferStarved = bufferInfo.len <= config.maxBufferHole;
+        var waiting = bufferInfo.len > 0 && bufferInfo.len < 1 && media.readyState < 3;
+        var 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) {
+            var startGap = false;
+            if (currentTime === 0) {
+              var startFrag = fragmentTracker.getAppendedFrag(0, PlaylistLevelType.MAIN);
+              if (startFrag && startTime < startFrag.end) {
+                startGap = true;
+              }
+            }
+            if (!startGap) {
+              var startProvisioned = partial || fragmentTracker.getAppendedFrag(currentTime, PlaylistLevelType.MAIN);
+              if (startProvisioned) {
+                var moreToLoad = false;
+                var pos = startProvisioned.end;
+                while (pos < startTime) {
+                  var provisioned = fragmentTracker.getPartialFragment(pos);
+                  if (provisioned) {
+                    pos += provisioned.duration;
+                  } else {
+                    moreToLoad = true;
+                    break;
+                  }
+                }
+                if (moreToLoad) {
+                  return 0;
+                }
+              }
+            }
+          }
+          var 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) {
+            var 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: error,
+              reason: error.message,
+              frag: partial || undefined,
+              buffer: bufferInfo.len,
+              bufferInfo: bufferInfo
+            });
+          }
+          return targetTime;
+        }
+      }
+      return 0;
+    }
+
+    /**
+     * Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
+     * @private
+     */;
+    _proto._tryNudgeBuffer = function _tryNudgeBuffer(bufferInfo) {
+      var hls = this.hls,
+        media = this.media,
+        nudgeRetry = this.nudgeRetry;
+      var config = hls == null ? undefined : hls.config;
+      if (!media || !config) {
+        return 0;
+      }
+      var currentTime = media.currentTime;
+      this.nudgeRetry++;
+      if (nudgeRetry < config.nudgeMaxRetry) {
+        var targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
+        // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
+        var 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: error,
+          fatal: false,
+          buffer: bufferInfo.len,
+          bufferInfo: bufferInfo
+        });
+      } else {
+        var _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: _error,
+          fatal: true,
+          buffer: bufferInfo.len,
+          bufferInfo: bufferInfo
+        });
+      }
+    };
+    return _createClass(GapController, [{
+      key: "hasBuffered",
+      get: function get() {
+        return Object.keys(this.buffered).length > 0;
+      }
+    }]);
+  }(TaskLoop);
+  function getInFlightDependency(inFlightFragments, currentTime) {
+    var main = inFlight(inFlightFragments.main);
+    if (main && main.start <= currentTime) {
+      return main;
+    }
+    var 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;
+  }
+
   var MIN_CUE_DURATION = 0.25;
   function getCueClass() {
     if (typeof self === 'undefined') return undefined;
@@ -31785,375 +32349,6 @@
     });
   }
 
-  var MAX_START_GAP_JUMP = 2.0;
-  var SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
-  var SKIP_BUFFER_RANGE_START = 0.05;
-  var GapController = /*#__PURE__*/function (_Logger) {
-    function GapController(media, fragmentTracker, hls) {
-      var _this;
-      _this = _Logger.call(this, 'gap-controller', hls.logger) || this;
-      _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;
-      return _this;
-    }
-    _inheritsLoose(GapController, _Logger);
-    var _proto = GapController.prototype;
-    _proto.destroy = function 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
-     */;
-    _proto.poll = function poll(lastCurrentTime, activeFrag, levelDetails, state) {
-      var _this$hls;
-      var media = this.media,
-        stalled = this.stalled;
-      if (!media) {
-        return;
-      }
-      var currentTime = media.currentTime,
-        seeking = media.seeking;
-      var seeked = this.seeking && !seeking;
-      var 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;
-      }
-      var bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
-      var nextStart = bufferInfo.nextStart || 0;
-      var fragmentTracker = this.fragmentTracker;
-      if (seeking && fragmentTracker) {
-        // Waiting for seeking in a buffered range to complete
-        var hasEnoughBuffer = bufferInfo.len > MAX_START_GAP_JUMP;
-        // Next buffered range is too far ahead to jump to while still seeking
-        var 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)
-        var isBuffered = bufferInfo.len > 0;
-        if (!isBuffered && !nextStart) {
-          return;
-        }
-        // Jump start gaps within jump threshold
-        var 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.
-        var isLive = !!(levelDetails != null && levelDetails.live);
-        var maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
-        var partialOrGap = fragmentTracker.getPartialFragment(currentTime);
-        if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
-          if (!media.paused) {
-            this._trySkipBufferHole(partialOrGap);
-          }
-          return;
-        }
-      }
-
-      // Start tracking stall time
-      var config = (_this$hls = this.hls) == null ? undefined : _this$hls.config;
-      if (!config) {
-        return;
-      }
-      var detectStallWithCurrentTimeMs = config.detectStallWithCurrentTimeMs;
-      var tnow = self.performance.now();
-      var 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;
-      }
-      var 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;
-        }
-      }
-      var bufferedWithHoles = BufferHelper.bufferInfo(media, currentTime, config.maxBufferHole);
-      this._tryFixBufferStall(bufferedWithHoles, stalledDuration);
-    };
-    _proto.stallResolved = function stallResolved(currentTime) {
-      var stalled = this.stalled;
-      if (stalled && this.hls) {
-        this.stalled = null;
-        // The playhead is now moving, but was previously stalled
-        if (this.stallReported) {
-          var 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
-     */;
-    _proto._tryFixBufferStall = function _tryFixBufferStall(bufferInfo, stalledDurationMs) {
-      var _this$hls2;
-      var fragmentTracker = this.fragmentTracker,
-        media = this.media;
-      var config = (_this$hls2 = this.hls) == null ? undefined : _this$hls2.config;
-      if (!media || !fragmentTracker || !config) {
-        return;
-      }
-      var currentTime = media.currentTime;
-      var 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
-        var 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.
-      var 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
-     */;
-    _proto._reportStall = function _reportStall(bufferInfo) {
-      var hls = this.hls,
-        media = this.media,
-        stallReported = this.stallReported,
-        stalled = this.stalled;
-      if (!stallReported && stalled !== null && media && hls) {
-        // Report stalled error once
-        this.stallReported = true;
-        var 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: error,
-          buffer: bufferInfo.len,
-          bufferInfo: 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
-     */;
-    _proto._trySkipBufferHole = function _trySkipBufferHole(partial) {
-      var _this$hls3;
-      var fragmentTracker = this.fragmentTracker,
-        media = this.media;
-      var 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
-      var currentTime = media.currentTime;
-      var bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
-      var startTime = currentTime < bufferInfo.start ? bufferInfo.start : bufferInfo.nextStart;
-      if (startTime) {
-        var bufferStarved = bufferInfo.len <= config.maxBufferHole;
-        var waiting = bufferInfo.len > 0 && bufferInfo.len < 1 && media.readyState < 3;
-        var 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) {
-            var startGap = false;
-            if (currentTime === 0) {
-              var startFrag = fragmentTracker.getAppendedFrag(0, PlaylistLevelType.MAIN);
-              if (startFrag && startTime < startFrag.end) {
-                startGap = true;
-              }
-            }
-            if (!startGap) {
-              var startProvisioned = partial || fragmentTracker.getAppendedFrag(currentTime, PlaylistLevelType.MAIN);
-              if (startProvisioned) {
-                var moreToLoad = false;
-                var pos = startProvisioned.end;
-                while (pos < startTime) {
-                  var provisioned = fragmentTracker.getPartialFragment(pos);
-                  if (provisioned) {
-                    pos += provisioned.duration;
-                  } else {
-                    moreToLoad = true;
-                    break;
-                  }
-                }
-                if (moreToLoad) {
-                  return 0;
-                }
-              }
-            }
-          }
-          var 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) {
-            var 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: error,
-              reason: error.message,
-              frag: partial,
-              buffer: bufferInfo.len,
-              bufferInfo: bufferInfo
-            });
-          }
-          return targetTime;
-        }
-      }
-      return 0;
-    }
-
-    /**
-     * Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
-     * @private
-     */;
-    _proto._tryNudgeBuffer = function _tryNudgeBuffer(bufferInfo) {
-      var hls = this.hls,
-        media = this.media,
-        nudgeRetry = this.nudgeRetry;
-      var config = hls == null ? undefined : hls.config;
-      if (!media || !config) {
-        return 0;
-      }
-      var currentTime = media.currentTime;
-      this.nudgeRetry++;
-      if (nudgeRetry < config.nudgeMaxRetry) {
-        var targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
-        // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
-        var 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: error,
-          fatal: false,
-          buffer: bufferInfo.len,
-          bufferInfo: bufferInfo
-        });
-      } else {
-        var _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: _error,
-          fatal: true,
-          buffer: bufferInfo.len,
-          bufferInfo: bufferInfo
-        });
-      }
-    };
-    return GapController;
-  }(Logger);
-
   function getSourceBuffer() {
     return self.SourceBuffer || self.WebKitSourceBuffer;
   }
@@ -32191,7 +32386,6 @@
       var _this;
       _this = _BaseStreamController.call(this, hls, fragmentTracker, keyLoader, 'stream-controller', PlaylistLevelType.MAIN) || this;
       _this.audioCodecSwap = false;
-      _this.gapController = null;
       _this.level = -1;
       _this._forceStartLoad = false;
       _this._hasEnoughToStart = false;
@@ -32203,19 +32397,8 @@
       _this.backtrackFragment = null;
       _this.audioCodecSwitch = false;
       _this.videoBuffer = null;
-      _this.onMediaWaiting = function () {
-        var gapController = _this.gapController;
-        if (gapController) {
-          gapController.waiting = self.performance.now();
-        }
-      };
       _this.onMediaPlaying = function () {
         // tick to speed up FRAG_CHANGED triggering
-        var gapController = _this.gapController;
-        if (gapController) {
-          gapController.ended = 0;
-          gapController.waiting = 0;
-        }
         _this.tick();
       };
       _this.onMediaSeeked = function () {
@@ -32269,7 +32452,7 @@
     };
     _proto.onHandlerDestroying = function onHandlerDestroying() {
       // @ts-ignore
-      this.onMediaPlaying = this.onMediaSeeked = this.onMediaWaiting = null;
+      this.onMediaPlaying = this.onMediaSeeked = null;
       this.unregisterListeners();
       _BaseStreamController.prototype.onHandlerDestroying.call(this);
     };
@@ -32358,8 +32541,11 @@
       this.onTickEnd();
     };
     _proto.onTickEnd = function onTickEnd() {
+      var _this$media2;
       _BaseStreamController.prototype.onTickEnd.call(this);
-      this.checkBuffer();
+      if ((_this$media2 = this.media) != null && _this$media2.readyState) {
+        this.lastCurrentTime = this.media.currentTime;
+      }
       this.checkFragmentChanged();
     };
     _proto.doTickIdle = function doTickIdle() {
@@ -32588,27 +32774,17 @@
     _proto.onMediaAttached = function onMediaAttached(event, data) {
       _BaseStreamController.prototype.onMediaAttached.call(this, event, data);
       var 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);
     };
     _proto.onMediaDetaching = function onMediaDetaching(event, data) {
       var media = this.media;
       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;
-      }
       _BaseStreamController.prototype.onMediaDetaching.call(this, event, data);
       var transferringMedia = !!data.transferMedia;
       if (transferringMedia) {
@@ -32616,19 +32792,6 @@
       }
       this._hasEnoughToStart = false;
     };
-    _proto.triggerEnded = function triggerEnded() {
-      var 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
-      });
-    };
     _proto.onManifestLoading = function onManifestLoading() {
       _BaseStreamController.prototype.onManifestLoading.call(this);
       // reset buffer on manifest loading
@@ -32948,25 +33111,6 @@
           this.recoverWorkerError(data);
           break;
       }
-    }
-
-    // Checks the health of the buffer and attempts to resolve playback stalls.
-    ;
-    _proto.checkBuffer = function checkBuffer() {
-      var media = this.media,
-        gapController = this.gapController;
-      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
-        var state = this.state;
-        var activeFrag = state !== State.IDLE ? this.fragCurrent : null;
-        var levelDetails = this.getLevelDetails();
-        gapController.poll(this.lastCurrentTime, activeFrag, levelDetails, state);
-      }
-      this.lastCurrentTime = media.currentTime;
     };
     _proto.onFragLoadEmergencyAborted = function onFragLoadEmergencyAborted() {
       this.state = State.IDLE;
@@ -32982,8 +33126,10 @@
       var type = _ref.type;
       if (type !== ElementaryStreamTypes.AUDIO || !this.altAudio) {
         var 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();
+        }
       }
     };
     _proto.onLevelsUpdated = function onLevelsUpdated(event, data) {
@@ -34302,9 +34448,12 @@
       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;
@@ -34342,6 +34491,7 @@
       var id3TrackController = new ID3TrackController(this);
       var keyLoader = new KeyLoader(this.config);
       var streamController = this.streamController = new StreamController(this, fragmentTracker, keyLoader);
+      var gapController = this.gapController = new GapController(this, fragmentTracker);
 
       // Cap level controller uses streamController to flush the buffer
       capLevelController.setStreamController(streamController);
@@ -34355,17 +34505,17 @@
         networkControllers.splice(1, 0, contentSteering);
       }
       this.networkControllers = networkControllers;
-      var coreComponents = [abrController, bufferController, capLevelController, fpsController, id3TrackController, fragmentTracker];
+      var coreComponents = [abrController, bufferController, gapController, capLevelController, fpsController, id3TrackController, fragmentTracker];
       this.audioTrackController = this.createController(config.audioTrackController, networkControllers);
       var 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);
       var 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);
@@ -34640,11 +34790,10 @@
           }
         });
       }
-    }
-
+    };
     /**
      * Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
-     */;
+     */
     _proto.swapAudioCodec = function swapAudioCodec() {
       this.logger.log('swapAudioCodec');
       this.streamController.swapAudioCodec();
@@ -34742,6 +34891,19 @@
       get: function get() {
         return this.streamController.bufferingEnabled;
       }
+    }, {
+      key: "inFlightFragments",
+      get: function get() {
+        var _inFlightData;
+        var inFlightData = (_inFlightData = {}, _inFlightData[PlaylistLevelType.MAIN] = this.streamController.inFlightFrag, _inFlightData);
+        if (this.audioStreamController) {
+          inFlightData[PlaylistLevelType.AUDIO] = this.audioStreamController.inFlightFrag;
+        }
+        if (this.subtititleStreamController) {
+          inFlightData[PlaylistLevelType.SUBTITLE] = this.subtititleStreamController.inFlightFrag;
+        }
+        return inFlightData;
+      }
     }, {
       key: "sessionId",
       get: function get() {