hls.js 1.5.12-0.canary.10366 → 1.5.12-0.canary.10367

package/dist/hls.mjs

@@ -420,7 +420,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.5.12-0.canary.10366"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.12-0.canary.10367"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -3937,10 +3937,9 @@ class PlaylistLoader {
       type
     } = context;
     const url = getResponseUrl(response, context);
-    const levelUrlId = 0;
     const levelId = isFiniteNumber(level) ? level : isFiniteNumber(id) ? id : 0;
     const levelType = mapContextToLevelType(context);
-    const levelDetails = M3U8Parser.parseLevelPlaylist(response.data, url, levelId, levelType, levelUrlId, this.variableList);
+    const levelDetails = M3U8Parser.parseLevelPlaylist(response.data, url, levelId, levelType, 0, this.variableList);
 
     // We have done our first request (Manifest-type) and receive
     // not a master playlist but a chunk-list (track/level)
@@ -5830,8 +5829,7 @@ function computeReloadInterval(newDetails, distanceToLiveEdgeMs = Infinity) {
   }
   return Math.round(reloadInterval);
 }
-function getFragmentWithSN(level, sn, fragCurrent) {
-  const details = level == null ? void 0 : level.details;
+function getFragmentWithSN(details, sn, fragCurrent) {
   if (!details) {
     return null;
   }
@@ -5848,12 +5846,11 @@ function getFragmentWithSN(level, sn, fragCurrent) {
   }
   return null;
 }
-function getPartWith(level, sn, partIndex) {
-  var _level$details;
-  if (!(level != null && level.details)) {
+function getPartWith(details, sn, partIndex) {
+  if (!details) {
     return null;
   }
-  return findPart((_level$details = level.details) == null ? void 0 : _level$details.partList, sn, partIndex);
+  return findPart(details.partList, sn, partIndex);
 }
 function findPart(partList, sn, partIndex) {
   if (partList) {
@@ -5997,12 +5994,15 @@ function findFragmentByPDT(fragments, PDTValue, maxFragLookUpTolerance) {
 function findFragmentByPTS(fragPrevious, fragments, bufferEnd = 0, maxFragLookUpTolerance = 0, nextFragLookupTolerance = 0.005) {
   let fragNext = null;
   if (fragPrevious) {
-    fragNext = fragments[fragPrevious.sn - fragments[0].sn + 1] || null;
+    fragNext = fragments[1 + fragPrevious.sn - fragments[0].sn] || null;
     // check for buffer-end rounding error
     const bufferEdgeError = fragPrevious.endDTS - bufferEnd;
     if (bufferEdgeError > 0 && bufferEdgeError < 0.0000015) {
       bufferEnd += 0.0000015;
     }
+    if (fragNext && fragPrevious.level !== fragNext.level && fragNext.end <= fragPrevious.end) {
+      fragNext = fragments[2 + fragPrevious.sn - fragments[0].sn] || null;
+    }
   } else if (bufferEnd === 0 && fragments[0].start === 0) {
     fragNext = fragments[0];
   }
@@ -6093,6 +6093,24 @@ function findFragWithCC(fragments, cc) {
     }
   });
 }
+function findNearestWithCC(details, cc, fragment) {
+  if (details) {
+    if (details.startCC <= cc && details.endCC >= cc) {
+      const start = fragment.start;
+      const end = fragment.end;
+      return BinarySearch.search(details.fragments, candidate => {
+        if (candidate.cc < cc || candidate.end <= start) {
+          return 1;
+        } else if (candidate.cc > cc || candidate.start >= end) {
+          return -1;
+        } else {
+          return 0;
+        }
+      });
+    }
+  }
+  return null;
+}
 
 var NetworkErrorAction = {
   DoNothing: 0,
@@ -6154,7 +6172,7 @@ class ErrorController extends Logger {
     this.playlistError = 0;
   }
   onError(event, data) {
-    var _data$frag, _data$level;
+    var _data$frag;
     if (data.fatal) {
       return;
     }
@@ -6170,10 +6188,7 @@ class ErrorController extends Logger {
       case ErrorDetails.FRAG_PARSING_ERROR:
         // ignore empty segment errors marked as gap
         if ((_data$frag = data.frag) != null && _data$frag.gap) {
-          data.errorAction = {
-            action: NetworkErrorAction.DoNothing,
-            flags: ErrorActionFlags.None
-          };
+          data.errorAction = createDoNothingErrorAction();
           return;
         }
       // falls through
@@ -6240,7 +6255,11 @@ class ErrorController extends Logger {
       case ErrorDetails.BUFFER_ADD_CODEC_ERROR:
       case ErrorDetails.REMUX_ALLOC_ERROR:
       case ErrorDetails.BUFFER_APPEND_ERROR:
-        data.errorAction = this.getLevelSwitchAction(data, (_data$level = data.level) != null ? _data$level : hls.loadLevel);
+        // Buffer-controller can set errorAction when append errors can be ignored or resolved locally
+        if (!data.errorAction) {
+          var _data$level;
+          data.errorAction = this.getLevelSwitchAction(data, (_data$level = data.level) != null ? _data$level : hls.loadLevel);
+        }
         return;
       case ErrorDetails.INTERNAL_EXCEPTION:
       case ErrorDetails.BUFFER_APPENDING_ERROR:
@@ -6249,10 +6268,7 @@ class ErrorController extends Logger {
       case ErrorDetails.BUFFER_STALLED_ERROR:
       case ErrorDetails.BUFFER_SEEK_OVER_HOLE:
       case ErrorDetails.BUFFER_NUDGE_ON_STALL:
-        data.errorAction = {
-          action: NetworkErrorAction.DoNothing,
-          flags: ErrorActionFlags.None
-        };
+        data.errorAction = createDoNothingErrorAction();
         return;
     }
     if (data.type === ErrorTypes.KEY_SYSTEM_ERROR) {
@@ -6465,6 +6481,13 @@ class ErrorController extends Logger {
     }
   }
 }
+function createDoNothingErrorAction(resolved) {
+  const errorAction = {
+    action: NetworkErrorAction.DoNothing,
+    flags: ErrorActionFlags.None
+  };
+  return errorAction;
+}
 
 class BasePlaylistController extends Logger {
   constructor(hls, logPrefix) {
@@ -7042,6 +7065,7 @@ function getStartCodecTier(codecTiers, currentVideoRange, currentBw, audioPrefer
   if (!hasCurrentVideoRange) {
     currentVideoRange = undefined;
   }
+  const hasMultipleSets = codecSets.length > 1;
   const codecSet = codecSets.reduce((selected, candidate) => {
     // Remove candiates which do not meet bitrate, default audio, stereo or channels preference, 1080p or lower, 30fps or lower, or SDR/HDR selection if present
     const candidateTier = codecTiers[candidate];
@@ -7049,46 +7073,48 @@ function getStartCodecTier(codecTiers, currentVideoRange, currentBw, audioPrefer
       return selected;
     }
     videoRanges = hasCurrentVideoRange ? allowedVideoRanges.filter(range => candidateTier.videoRanges[range] > 0) : [];
-    if (candidateTier.minBitrate > currentBw) {
-      logStartCodecCandidateIgnored(candidate, `min bitrate of ${candidateTier.minBitrate} > current estimate of ${currentBw}`);
-      return selected;
-    }
-    if (!candidateTier.hasDefaultAudio) {
-      logStartCodecCandidateIgnored(candidate, `no renditions with default or auto-select sound found`);
-      return selected;
-    }
-    if (audioCodecPreference && candidate.indexOf(audioCodecPreference.substring(0, 4)) % 5 !== 0) {
-      logStartCodecCandidateIgnored(candidate, `audio codec preference "${audioCodecPreference}" not found`);
-      return selected;
-    }
-    if (channelsPreference && !preferStereo) {
-      if (!candidateTier.channels[channelsPreference]) {
-        logStartCodecCandidateIgnored(candidate, `no renditions with ${channelsPreference} channel sound found (channels options: ${Object.keys(candidateTier.channels)})`);
+    if (hasMultipleSets) {
+      if (candidateTier.minBitrate > currentBw) {
+        logStartCodecCandidateIgnored(candidate, `min bitrate of ${candidateTier.minBitrate} > current estimate of ${currentBw}`);
+        return selected;
+      }
+      if (!candidateTier.hasDefaultAudio) {
+        logStartCodecCandidateIgnored(candidate, `no renditions with default or auto-select sound found`);
+        return selected;
+      }
+      if (audioCodecPreference && candidate.indexOf(audioCodecPreference.substring(0, 4)) % 5 !== 0) {
+        logStartCodecCandidateIgnored(candidate, `audio codec preference "${audioCodecPreference}" not found`);
+        return selected;
+      }
+      if (channelsPreference && !preferStereo) {
+        if (!candidateTier.channels[channelsPreference]) {
+          logStartCodecCandidateIgnored(candidate, `no renditions with ${channelsPreference} channel sound found (channels options: ${Object.keys(candidateTier.channels)})`);
+          return selected;
+        }
+      } else if ((!audioCodecPreference || preferStereo) && hasStereo && candidateTier.channels['2'] === 0) {
+        logStartCodecCandidateIgnored(candidate, `no renditions with stereo sound found`);
+        return selected;
+      }
+      if (candidateTier.minHeight > maxHeight) {
+        logStartCodecCandidateIgnored(candidate, `min resolution of ${candidateTier.minHeight} > maximum of ${maxHeight}`);
+        return selected;
+      }
+      if (candidateTier.minFramerate > maxFramerate) {
+        logStartCodecCandidateIgnored(candidate, `min framerate of ${candidateTier.minFramerate} > maximum of ${maxFramerate}`);
+        return selected;
+      }
+      if (!videoRanges.some(range => candidateTier.videoRanges[range] > 0)) {
+        logStartCodecCandidateIgnored(candidate, `no variants with VIDEO-RANGE of ${JSON.stringify(videoRanges)} found`);
+        return selected;
+      }
+      if (videoCodecPreference && candidate.indexOf(videoCodecPreference.substring(0, 4)) % 5 !== 0) {
+        logStartCodecCandidateIgnored(candidate, `video codec preference "${videoCodecPreference}" not found`);
+        return selected;
+      }
+      if (candidateTier.maxScore < selectedScore) {
+        logStartCodecCandidateIgnored(candidate, `max score of ${candidateTier.maxScore} < selected max of ${selectedScore}`);
         return selected;
       }
-    } else if ((!audioCodecPreference || preferStereo) && hasStereo && candidateTier.channels['2'] === 0) {
-      logStartCodecCandidateIgnored(candidate, `no renditions with stereo sound found`);
-      return selected;
-    }
-    if (candidateTier.minHeight > maxHeight) {
-      logStartCodecCandidateIgnored(candidate, `min resolution of ${candidateTier.minHeight} > maximum of ${maxHeight}`);
-      return selected;
-    }
-    if (candidateTier.minFramerate > maxFramerate) {
-      logStartCodecCandidateIgnored(candidate, `min framerate of ${candidateTier.minFramerate} > maximum of ${maxFramerate}`);
-      return selected;
-    }
-    if (!videoRanges.some(range => candidateTier.videoRanges[range] > 0)) {
-      logStartCodecCandidateIgnored(candidate, `no variants with VIDEO-RANGE of ${JSON.stringify(videoRanges)} found`);
-      return selected;
-    }
-    if (videoCodecPreference && candidate.indexOf(videoCodecPreference.substring(0, 4)) % 5 !== 0) {
-      logStartCodecCandidateIgnored(candidate, `video codec preference "${videoCodecPreference}" not found`);
-      return selected;
-    }
-    if (candidateTier.maxScore < selectedScore) {
-      logStartCodecCandidateIgnored(candidate, `max score of ${candidateTier.maxScore} < selected max of ${selectedScore}`);
-      return selected;
     }
     // Remove candiates with less preferred codecs or more errors
     if (selected && (codecsSetSelectionPreferenceValue(candidate) >= codecsSetSelectionPreferenceValue(selected) || candidateTier.fragmentError > codecTiers[selected].fragmentError)) {
@@ -7895,7 +7921,7 @@ class AbrController extends Logger {
           if (levelsSkipped.length) {
             this.trace(`Skipped level(s) ${levelsSkipped.join(',')} of ${maxAutoLevel} max with CODECS and VIDEO-RANGE:"${levels[levelsSkipped[0]].codecs}" ${levels[levelsSkipped[0]].videoRange}; not compatible with "${level.codecs}" ${currentVideoRange}`);
           }
-          this.info(`switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${level.codecSet} videoRange:${level.videoRange} hls.loadLevel:${loadLevel}`);
+          this.info(`switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${levelInfo.codecSet} videoRange:${levelInfo.videoRange} hls.loadLevel:${loadLevel}`);
         }
         if (firstSelection) {
           this.firstSelection = i;
@@ -8064,6 +8090,7 @@ class FragmentTracker {
     const {
       hls
     } = this;
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.BUFFER_APPENDED, this.onBufferAppended, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
     hls.on(Events.FRAG_LOADED, this.onFragLoaded, this);
@@ -8072,6 +8099,7 @@ class FragmentTracker {
     const {
       hls
     } = this;
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.off(Events.BUFFER_APPENDED, this.onBufferAppended, this);
     hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
     hls.off(Events.FRAG_LOADED, this.onFragLoaded, this);
@@ -8137,7 +8165,7 @@ class FragmentTracker {
    * The browser will unload parts of the buffer to free up memory for new buffer data
    * Fragments will need to be reloaded when the buffer is freed up, removing partial fragments will allow them to reload(since there might be parts that are still playable)
    */
-  detectEvictedFragments(elementaryStream, timeRange, playlistType, appendedPart) {
+  detectEvictedFragments(elementaryStream, timeRange, playlistType, appendedPart, removeAppending) {
     if (this.timeRanges) {
       this.timeRanges[elementaryStream] = timeRange;
     }
@@ -8152,7 +8180,7 @@ class FragmentTracker {
       if (appendedPartSn >= fragmentEntity.body.sn) {
         return;
       }
-      if (!fragmentEntity.buffered && !fragmentEntity.loaded) {
+      if (!fragmentEntity.buffered && (!fragmentEntity.loaded || removeAppending)) {
         if (fragmentEntity.body.type === playlistType) {
           this.removeFragment(fragmentEntity.body);
         }
@@ -8162,6 +8190,10 @@ class FragmentTracker {
       if (!esData) {
         return;
       }
+      if (esData.time.length === 0) {
+        this.removeFragment(fragmentEntity.body);
+        return;
+      }
       esData.time.some(time => {
         const isNotBuffered = !this.isTimeBuffered(time.startPTS, time.endPTS, timeRange);
         if (isNotBuffered) {
@@ -8348,6 +8380,9 @@ class FragmentTracker {
     }
     return false;
   }
+  onManifestLoading() {
+    this.removeAllFragments();
+  }
   onFragLoaded(event, data) {
     // don't track initsegment (for which sn is not a number)
     // don't track frags used for bitrateTest, they're irrelevant.
@@ -8396,6 +8431,22 @@ class FragmentTracker {
     const fragKey = getFragmentKey(fragment);
     return !!this.fragments[fragKey];
   }
+  hasFragments(type) {
+    const {
+      fragments
+    } = this;
+    const keys = Object.keys(fragments);
+    if (!type) {
+      return keys.length > 0;
+    }
+    for (let i = keys.length; i--;) {
+      const fragmentEntity = fragments[keys[i]];
+      if ((fragmentEntity == null ? void 0 : fragmentEntity.body.type) === type) {
+        return true;
+      }
+    }
+    return false;
+  }
   hasParts(type) {
     var _this$activePartLists;
     return !!((_this$activePartLists = this.activePartLists[type]) != null && _this$activePartLists.length);
@@ -8800,8 +8851,9 @@ class FragmentLoader {
           frag.gap = false;
         }
       }
-      const loader = this.loader = frag.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
+      const loader = this.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
       const loaderContext = createLoaderContext(frag);
+      frag.loader = loader;
       const loadPolicy = getLoaderConfigWithoutReties(config.fragLoadPolicy.default);
       const loaderConfig = {
         loadPolicy,
@@ -8894,8 +8946,9 @@ class FragmentLoader {
         reject(createGapLoadError(frag, part));
         return;
       }
-      const loader = this.loader = frag.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
+      const loader = this.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
       const loaderContext = createLoaderContext(frag, part);
+      frag.loader = loader;
       // Should we define another load policy for parts?
       const loadPolicy = getLoaderConfigWithoutReties(config.fragLoadPolicy.default);
       const loaderConfig = {
@@ -9590,6 +9643,7 @@ class BaseStreamController extends TaskLoop {
     this.initPTS = [];
     this.buffering = true;
     this.loadingParts = false;
+    this.loopSn = void 0;
     this.onMediaSeeking = () => {
       const {
         config,
@@ -9689,6 +9743,9 @@ class BaseStreamController extends TaskLoop {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   startLoad(startPosition) {}
   stopLoad() {
+    if (this.state === State.STOPPED) {
+      return;
+    }
     this.fragmentLoader.abort();
     this.keyLoader.abort(this.playlistType);
     const frag = this.fragCurrent;
@@ -9762,15 +9819,20 @@ class BaseStreamController extends TaskLoop {
       this.keyLoader.detach();
     }
     this.media = this.mediaBuffer = null;
-    this.loadedmetadata = false;
+    this.loopSn = undefined;
+    this.startFragRequested = this.loadedmetadata = this.loadingParts = false;
     this.fragmentTracker.removeAllFragments();
     this.stopLoad();
   }
-  onManifestLoading() {}
+  onManifestLoading() {
+    this.initPTS = [];
+    this.levels = this.levelLastLoaded = this.fragCurrent = null;
+    this.lastCurrentTime = this.startPosition = 0;
+    this.startFragRequested = false;
+  }
   onError(event, data) {}
   onManifestLoaded(event, data) {
     this.startTimeOffset = data.startTimeOffset;
-    this.initPTS = [];
   }
   onHandlerDestroying() {
     this.stopLoad();
@@ -9793,6 +9855,7 @@ class BaseStreamController extends TaskLoop {
     super.onHandlerDestroyed();
   }
   loadFragment(frag, level, targetBufferTime) {
+    this.startFragRequested = true;
     this._loadFragForPlayback(frag, level, targetBufferTime);
   }
   _loadFragForPlayback(frag, level, targetBufferTime) {
@@ -10021,6 +10084,7 @@ class BaseStreamController extends TaskLoop {
   _handleFragmentLoadProgress(frag) {}
   _doFragLoad(frag, level, targetBufferTime = null, progressCallback) {
     var _frag$decryptdata;
+    this.fragCurrent = frag;
     const details = level == null ? void 0 : level.details;
     if (!this.levels || !details) {
       throw new Error(`frag load aborted, missing level${details ? '' : ' detail'}s`);
@@ -10148,7 +10212,7 @@ class BaseStreamController extends TaskLoop {
           partsLoaded[part.index] = partLoadedData;
           const loadedPart = partLoadedData.part;
           this.hls.trigger(Events.FRAG_LOADED, partLoadedData);
-          const nextPart = getPartWith(level, frag.sn, part.index + 1) || findPart(initialPartList, frag.sn, part.index + 1);
+          const nextPart = getPartWith(level.details, frag.sn, part.index + 1) || findPart(initialPartList, frag.sn, part.index + 1);
           if (nextPart) {
             loadPart(nextPart);
           } else {
@@ -10243,8 +10307,9 @@ class BaseStreamController extends TaskLoop {
       return null;
     }
     const level = levels[levelIndex];
-    const part = partIndex > -1 ? getPartWith(level, sn, partIndex) : null;
-    const frag = part ? part.fragment : getFragmentWithSN(level, sn, fragCurrent);
+    const levelDetails = level.details;
+    const part = partIndex > -1 ? getPartWith(levelDetails, sn, partIndex) : null;
+    const frag = part ? part.fragment : getFragmentWithSN(levelDetails, sn, fragCurrent);
     if (!frag) {
       return null;
     }
@@ -10359,7 +10424,8 @@ class BaseStreamController extends TaskLoop {
     return false;
   }
   getAppendedFrag(position, playlistType = PlaylistLevelType.MAIN) {
-    const fragOrPart = this.fragmentTracker.getAppendedFrag(position, PlaylistLevelType.MAIN);
+    var _this$fragmentTracker;
+    const fragOrPart = (_this$fragmentTracker = this.fragmentTracker) == null ? void 0 : _this$fragmentTracker.getAppendedFrag(position, playlistType);
     if (fragOrPart && 'fragment' in fragOrPart) {
       return fragOrPart.fragment;
     }
@@ -10414,22 +10480,25 @@ class BaseStreamController extends TaskLoop {
     return (trackerState === FragmentState.OK || trackerState === FragmentState.PARTIAL && !!frag.gap) && this.nextLoadPosition > targetBufferTime;
   }
   getNextFragmentLoopLoading(frag, levelDetails, bufferInfo, playlistType, maxBufLen) {
-    const gapStart = frag.gap;
-    const nextFragment = this.getNextFragment(this.nextLoadPosition, levelDetails);
-    if (nextFragment === null) {
-      return nextFragment;
-    }
-    frag = nextFragment;
-    if (gapStart && frag && !frag.gap && bufferInfo.nextStart) {
-      // Media buffered after GAP tags should not make the next buffer timerange exceed forward buffer length
-      const nextbufferInfo = this.getFwdBufferInfoAtPos(this.mediaBuffer ? this.mediaBuffer : this.media, bufferInfo.nextStart, playlistType);
-      if (nextbufferInfo !== null && bufferInfo.len + nextbufferInfo.len >= maxBufLen) {
-        // Returning here might result in not finding an audio and video candiate to skip to
-        this.log(`buffer full after gaps in "${playlistType}" playlist starting at sn: ${frag.sn}`);
-        return null;
+    let nextFragment = null;
+    if (frag.gap) {
+      nextFragment = this.getNextFragment(this.nextLoadPosition, levelDetails);
+      if (nextFragment && !nextFragment.gap && bufferInfo.nextStart) {
+        // Media buffered after GAP tags should not make the next buffer timerange exceed forward buffer length
+        const nextbufferInfo = this.getFwdBufferInfoAtPos(this.mediaBuffer ? this.mediaBuffer : this.media, bufferInfo.nextStart, playlistType);
+        if (nextbufferInfo !== null && bufferInfo.len + nextbufferInfo.len >= maxBufLen) {
+          // Returning here might result in not finding an audio and video candiate to skip to
+          const sn = nextFragment.sn;
+          if (this.loopSn !== sn) {
+            this.log(`buffer full after gaps in "${playlistType}" playlist starting at sn: ${sn}`);
+            this.loopSn = sn;
+          }
+          return null;
+        }
       }
     }
-    return frag;
+    this.loopSn = undefined;
+    return nextFragment;
   }
   mapToInitFragWhenRequired(frag) {
     // If an initSegment is present, it must be buffered first
@@ -10638,7 +10707,7 @@ class BaseStreamController extends TaskLoop {
       if (startTimeOffset !== null && isFiniteNumber(startTimeOffset)) {
         startPosition = sliding + startTimeOffset;
         if (startTimeOffset < 0) {
-          startPosition += details.totalduration;
+          startPosition += details.edge;
         }
         startPosition = Math.min(Math.max(sliding, startPosition), sliding + details.totalduration);
         this.log(`Start time offset ${startTimeOffset} found in ${offsetInMultivariantPlaylist ? 'multivariant' : 'media'} playlist, adjust startPosition to ${startPosition}`);
@@ -14980,10 +15049,11 @@ class MP4Remuxer {
       if (this.ISGenerated) {
         var _videoTrack$pixelRati, _config$pixelRatio, _videoTrack$pixelRati2, _config$pixelRatio2;
         const config = this.videoTrackConfig;
-        if (config && (videoTrack.width !== config.width || videoTrack.height !== config.height || ((_videoTrack$pixelRati = videoTrack.pixelRatio) == null ? void 0 : _videoTrack$pixelRati[0]) !== ((_config$pixelRatio = config.pixelRatio) == null ? void 0 : _config$pixelRatio[0]) || ((_videoTrack$pixelRati2 = videoTrack.pixelRatio) == null ? void 0 : _videoTrack$pixelRati2[1]) !== ((_config$pixelRatio2 = config.pixelRatio) == null ? void 0 : _config$pixelRatio2[1]))) {
+        if (config && (videoTrack.width !== config.width || videoTrack.height !== config.height || ((_videoTrack$pixelRati = videoTrack.pixelRatio) == null ? void 0 : _videoTrack$pixelRati[0]) !== ((_config$pixelRatio = config.pixelRatio) == null ? void 0 : _config$pixelRatio[0]) || ((_videoTrack$pixelRati2 = videoTrack.pixelRatio) == null ? void 0 : _videoTrack$pixelRati2[1]) !== ((_config$pixelRatio2 = config.pixelRatio) == null ? void 0 : _config$pixelRatio2[1])) || !config && enoughVideoSamples || this.nextAudioPts === null && enoughAudioSamples) {
           this.resetInitSegment();
         }
-      } else {
+      }
+      if (!this.ISGenerated) {
         initSegment = this.generateIS(audioTrack, videoTrack, timeOffset, accurateTimeOffset);
       }
       const isVideoContiguous = this.isVideoContiguous;
@@ -15901,7 +15971,7 @@ class PassThroughRemuxer {
     if (isInvalidInitPts(initPTS, decodeTime, timeOffset, duration) || initSegment.timescale !== initPTS.timescale && accurateTimeOffset) {
       initSegment.initPTS = decodeTime - timeOffset;
       if (initPTS && initPTS.timescale === 1) {
-        logger.warn(`Adjusting initPTS by ${initSegment.initPTS - initPTS.baseTime}`);
+        logger.warn(`Adjusting initPTS @${timeOffset} from ${initPTS.baseTime / initPTS.timescale} to ${initSegment.initPTS}`);
       }
       this.initPTS = initPTS = {
         baseTime: initSegment.initPTS,
@@ -17035,9 +17105,8 @@ const TICK_INTERVAL$2 = 100; // how often to tick in ms
 class AudioStreamController extends BaseStreamController {
   constructor(hls, fragmentTracker, keyLoader) {
     super(hls, fragmentTracker, keyLoader, 'audio-stream-controller', PlaylistLevelType.AUDIO);
-    this.videoBuffer = null;
-    this.videoTrackCC = -1;
-    this.waitingVideoCC = -1;
+    this.videoAnchor = null;
+    this.mainFragLoading = null;
     this.bufferedTrack = null;
     this.switchingTrack = null;
     this.trackId = -1;
@@ -17069,6 +17138,7 @@ class AudioStreamController extends BaseStreamController {
     hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.on(Events.BUFFER_FLUSHED, this.onBufferFlushed, this);
     hls.on(Events.INIT_PTS_FOUND, this.onInitPtsFound, this);
+    hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
   unregisterListeners() {
@@ -17088,6 +17158,7 @@ class AudioStreamController extends BaseStreamController {
     hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.off(Events.BUFFER_FLUSHED, this.onBufferFlushed, this);
     hls.off(Events.INIT_PTS_FOUND, this.onInitPtsFound, this);
+    hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
     hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
 
@@ -17100,20 +17171,35 @@ class AudioStreamController extends BaseStreamController {
   }) {
     // Always update the new INIT PTS
     // Can change due level switch
-    if (id === 'main') {
+    if (id === PlaylistLevelType.MAIN) {
       const cc = frag.cc;
-      this.initPTS[frag.cc] = {
+      const inFlightFrag = this.fragCurrent;
+      this.initPTS[cc] = {
         baseTime: initPTS,
         timescale
       };
       this.log(`InitPTS for cc: ${cc} found from main: ${initPTS}/${timescale}`);
-      this.videoTrackCC = cc;
+      this.videoAnchor = frag;
       // If we are waiting, tick immediately to unblock audio fragment transmuxing
       if (this.state === State.WAITING_INIT_PTS) {
+        const waitingData = this.waitingData;
+        if (!waitingData || waitingData.frag.cc !== cc) {
+          this.nextLoadPosition = this.findSyncFrag(frag).start;
+        }
         this.tick();
+      } else if (!this.loadedmetadata && inFlightFrag && inFlightFrag.cc !== cc) {
+        this.startFragRequested = false;
+        this.nextLoadPosition = this.findSyncFrag(frag).start;
+        inFlightFrag.abortRequests();
+        this.resetLoadingState();
       }
     }
   }
+  findSyncFrag(mainFrag) {
+    const trackDetails = this.getLevelDetails();
+    const cc = mainFrag.cc;
+    return findNearestWithCC(trackDetails, cc, mainFrag) || trackDetails && findFragWithCC(trackDetails.fragments, cc) || mainFrag;
+  }
   startLoad(startPosition) {
     if (!this.levels) {
       this.startPosition = startPosition;
@@ -17183,9 +17269,9 @@ class AudioStreamController extends BaseStreamController {
               cache,
               complete
             } = waitingData;
+            const videoAnchor = this.videoAnchor;
             if (this.initPTS[frag.cc] !== undefined) {
               this.waitingData = null;
-              this.waitingVideoCC = -1;
               this.state = State.FRAG_LOADING;
               const payload = cache.flush();
               const data = {
@@ -17198,21 +17284,13 @@ class AudioStreamController extends BaseStreamController {
               if (complete) {
                 super._handleFragmentLoadComplete(data);
               }
-            } else if (this.videoTrackCC !== this.waitingVideoCC) {
+            } else if (videoAnchor && videoAnchor.cc !== waitingData.frag.cc) {
               // Drop waiting fragment if videoTrackCC has changed since waitingFragment was set and initPTS was not found
-              this.log(`Waiting fragment cc (${frag.cc}) cancelled because video is at cc ${this.videoTrackCC}`);
+              this.log(`Waiting fragment cc (${frag.cc}) cancelled because video is at cc ${videoAnchor.cc}`);
+              this.nextLoadPosition = this.findSyncFrag(videoAnchor).start;
               this.clearWaitingFragment();
-            } else {
-              // Drop waiting fragment if an earlier fragment is needed
-              const pos = this.getLoadPosition();
-              const bufferInfo = BufferHelper.bufferInfo(this.mediaBuffer, pos, this.config.maxBufferHole);
-              const waitingFragmentAtPosition = fragmentWithinToleranceTest(bufferInfo.end, this.config.maxFragLookUpTolerance, frag);
-              if (waitingFragmentAtPosition < 0) {
-                this.log(`Waiting fragment cc (${frag.cc}) @ ${frag.start} cancelled because another fragment at ${bufferInfo.end} is needed`);
-                this.clearWaitingFragment();
-              }
             }
-          } else {
+          } else if (this.state !== State.STOPPED) {
             this.state = State.IDLE;
           }
         }
@@ -17222,9 +17300,12 @@ class AudioStreamController extends BaseStreamController {
   clearWaitingFragment() {
     const waitingData = this.waitingData;
     if (waitingData) {
+      if (!this.loadedmetadata) {
+        // Load overlapping fragment on start when discontinuity start times are not aligned
+        this.startFragRequested = false;
+      }
       this.fragmentTracker.removeFragment(waitingData.frag);
       this.waitingData = null;
-      this.waitingVideoCC = -1;
       if (this.state !== State.STOPPED) {
         this.state = State.IDLE;
       }
@@ -17292,9 +17373,10 @@ class AudioStreamController extends BaseStreamController {
     const maxBufLen = hls.maxBufferLength;
     const fragments = trackDetails.fragments;
     const start = fragments[0].start;
-    let targetBufferTime = this.flushing ? this.getLoadPosition() : bufferInfo.end;
+    const loadPosition = this.getLoadPosition();
+    let targetBufferTime = this.flushing ? loadPosition : bufferInfo.end;
     if (switchingTrack && media) {
-      const pos = this.getLoadPosition();
+      const pos = loadPosition;
       // STABLE
       if (bufferedTrack && !mediaAttributesIdentical(switchingTrack.attrs, bufferedTrack.attrs)) {
         targetBufferTime = pos;
@@ -17314,37 +17396,26 @@ class AudioStreamController extends BaseStreamController {
       return;
     }
     let frag = this.getNextFragment(targetBufferTime, trackDetails);
-    let atGap = false;
     // Avoid loop loading by using nextLoadPosition set for backtracking and skipping consecutive GAP tags
     if (frag && this.isLoopLoading(frag, targetBufferTime)) {
-      atGap = !!frag.gap;
       frag = this.getNextFragmentLoopLoading(frag, trackDetails, bufferInfo, PlaylistLevelType.MAIN, maxBufLen);
     }
     if (!frag) {
       this.bufferFlushed = true;
       return;
     }
-    if (!trackDetails.live || targetBufferTime < this.hls.liveSyncPosition) {
+    if (this.startFragRequested && (!trackDetails.live || targetBufferTime < this.hls.liveSyncPosition)) {
       // Request audio segments up to one fragment ahead of main buffer
-      const mainBufferInfo = this.getFwdBufferInfo(this.videoBuffer ? this.videoBuffer : this.media, PlaylistLevelType.MAIN);
-      const atBufferSyncLimit = !!mainBufferInfo && frag.start > mainBufferInfo.end + frag.duration;
-      if (atBufferSyncLimit) {
-        // Check fragment-tracker for main fragments since GAP segments do not show up in bufferInfo
-        const mainFrag = this.fragmentTracker.getFragAtPos(frag.start, PlaylistLevelType.MAIN);
-        if (mainFrag === null) {
-          return;
-        }
-        // Bridge gaps in main buffer (also prevents loop loading at gaps)
-        atGap || (atGap = !!mainFrag.gap || mainBufferInfo.len === 0);
-        if (!atGap || bufferInfo.nextStart && bufferInfo.nextStart < mainFrag.end) {
-          return;
-        }
+      const mainFragLoading = this.mainFragLoading;
+      const mainTargetBufferEnd = mainFragLoading ? (mainFragLoading.part || mainFragLoading.frag).end : null;
+      const atBufferSyncLimit = mainTargetBufferEnd !== null && frag.start > mainTargetBufferEnd;
+      if (atBufferSyncLimit && !frag.endList) {
+        return;
       }
     }
     this.loadFragment(frag, levelInfo, targetBufferTime);
   }
   onMediaDetaching() {
-    this.videoBuffer = null;
     this.bufferFlushed = this.flushing = false;
     super.onMediaDetaching();
   }
@@ -17388,12 +17459,10 @@ class AudioStreamController extends BaseStreamController {
     }
   }
   onManifestLoading() {
-    this.fragmentTracker.removeAllFragments();
-    this.startPosition = this.lastCurrentTime = 0;
+    super.onManifestLoading();
     this.bufferFlushed = this.flushing = false;
-    this.levels = this.mainDetails = this.waitingData = this.bufferedTrack = this.cachedTrackLoadedData = this.switchingTrack = null;
-    this.startFragRequested = false;
-    this.trackId = this.videoTrackCC = this.waitingVideoCC = -1;
+    this.mainDetails = this.waitingData = this.videoAnchor = this.bufferedTrack = this.cachedTrackLoadedData = this.switchingTrack = null;
+    this.trackId = -1;
   }
   onLevelLoaded(event, data) {
     this.mainDetails = data.details;
@@ -17509,7 +17578,6 @@ class AudioStreamController extends BaseStreamController {
         complete: false
       };
       cache.push(new Uint8Array(payload));
-      this.waitingVideoCC = this.videoTrackCC;
       this.state = State.WAITING_INIT_PTS;
     }
   }
@@ -17523,7 +17591,7 @@ class AudioStreamController extends BaseStreamController {
   onBufferReset( /* event: Events.BUFFER_RESET */
   ) {
     // reset reference to sourcebuffers
-    this.mediaBuffer = this.videoBuffer = null;
+    this.mediaBuffer = null;
     this.loadedmetadata = false;
   }
   onBufferCreated(event, data) {
@@ -17531,8 +17599,13 @@ class AudioStreamController extends BaseStreamController {
     if (audioTrack) {
       this.mediaBuffer = audioTrack.buffer || null;
     }
-    if (data.tracks.video) {
-      this.videoBuffer = data.tracks.video.buffer || null;
+  }
+  onFragLoading(event, data) {
+    if (data.frag.type === PlaylistLevelType.MAIN && data.frag.sn !== 'initSegment') {
+      this.mainFragLoading = data;
+      if (this.state === State.IDLE) {
+        this.tick();
+      }
     }
   }
   onFragBuffered(event, data) {
@@ -17542,12 +17615,9 @@ class AudioStreamController extends BaseStreamController {
     } = data;
     if (frag.type !== PlaylistLevelType.AUDIO) {
       if (!this.loadedmetadata && frag.type === PlaylistLevelType.MAIN) {
-        const bufferable = this.videoBuffer || this.media;
-        if (bufferable) {
-          const bufferedTimeRanges = BufferHelper.getBuffered(bufferable);
-          if (bufferedTimeRanges.length) {
-            this.loadedmetadata = true;
-          }
+        const bufferedState = this.fragmentTracker.getState(frag);
+        if (bufferedState === FragmentState.OK || bufferedState === FragmentState.PARTIAL) {
+          this.loadedmetadata = true;
         }
       }
       return;
@@ -17728,12 +17798,15 @@ class AudioStreamController extends BaseStreamController {
     if (tracks.video) {
       delete tracks.video;
     }
+    if (tracks.audiovideo) {
+      delete tracks.audiovideo;
+    }
 
     // include levelCodec in audio and video tracks
-    const track = tracks.audio;
-    if (!track) {
+    if (!tracks.audio) {
       return;
     }
+    const track = tracks.audio;
     track.id = 'audio';
     const variantAudioCodecs = currentLevel.audioCodec;
     this.log(`Init audio buffer, container:${track.container}, codecs[level/parsed]=[${variantAudioCodecs}/${track.codec}]`);
@@ -17760,7 +17833,6 @@ class AudioStreamController extends BaseStreamController {
   loadFragment(frag, track, targetBufferTime) {
     // only load if fragment is not loaded or if in audio switch
     const fragState = this.fragmentTracker.getState(frag);
-    this.fragCurrent = frag;
 
     // we force a frag loading in audio switch as fragment tracker might not have evicted previous frags in case of quick audio switch
     if (this.switchingTrack || fragState === FragmentState.NOT_LOADED || fragState === FragmentState.PARTIAL) {
@@ -17775,7 +17847,6 @@ class AudioStreamController extends BaseStreamController {
           alignMediaPlaylistByPDT(track.details, mainDetails);
         }
       } else {
-        this.startFragRequested = true;
         super.loadFragment(frag, track, targetBufferTime);
       }
     } else {
@@ -18172,8 +18243,8 @@ class SubtitleStreamController extends BaseStreamController {
     this.tick();
   }
   onManifestLoading() {
+    super.onManifestLoading();
     this.mainDetails = null;
-    this.fragmentTracker.removeAllFragments();
   }
   onMediaDetaching() {
     this.tracksBuffered = [];
@@ -18187,7 +18258,9 @@ class SubtitleStreamController extends BaseStreamController {
       frag,
       success
     } = data;
-    this.fragPrevious = frag;
+    if (frag.sn !== 'initSegment') {
+      this.fragPrevious = frag;
+    }
     this.state = State.IDLE;
     if (!success) {
       return;
@@ -18480,11 +18553,9 @@ class SubtitleStreamController extends BaseStreamController {
     }
   }
   loadFragment(frag, level, targetBufferTime) {
-    this.fragCurrent = frag;
     if (frag.sn === 'initSegment') {
       this._loadInitSegment(frag, level);
     } else {
-      this.startFragRequested = true;
       super.loadFragment(frag, level, targetBufferTime);
     }
   }
@@ -19149,6 +19220,7 @@ class BufferController extends Logger {
     hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
     hls.on(Events.FRAG_PARSED, this.onFragParsed, this);
     hls.on(Events.FRAG_CHANGED, this.onFragChanged, this);
+    hls.on(Events.ERROR, this.onError, this);
   }
   unregisterListeners() {
     const {
@@ -19166,6 +19238,7 @@ class BufferController extends Logger {
     hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
     hls.off(Events.FRAG_PARSED, this.onFragParsed, this);
     hls.off(Events.FRAG_CHANGED, this.onFragChanged, this);
+    hls.off(Events.ERROR, this.onError, this);
   }
   _initSourceBuffer() {
     this.sourceBuffer = {};
@@ -19175,11 +19248,7 @@ class BufferController extends Logger {
       video: [],
       audiovideo: []
     };
-    this.appendErrors = {
-      audio: 0,
-      video: 0,
-      audiovideo: 0
-    };
+    this.resetAppendErrors();
     this.lastMpegAudioChunk = null;
     this.blockedAudioAppend = null;
     this.lastVideoAppendEnd = 0;
@@ -19716,6 +19785,22 @@ class BufferController extends Logger {
       this.updateMediaSource(durationAndRange);
     }
   }
+  onError(event, data) {
+    if (data.details === ErrorDetails.BUFFER_APPEND_ERROR && data.frag) {
+      var _data$errorAction;
+      const nextAutoLevel = (_data$errorAction = data.errorAction) == null ? void 0 : _data$errorAction.nextAutoLevel;
+      if (isFiniteNumber(nextAutoLevel) && nextAutoLevel !== data.frag.level) {
+        this.resetAppendErrors();
+      }
+    }
+  }
+  resetAppendErrors() {
+    this.appendErrors = {
+      audio: 0,
+      video: 0,
+      audiovideo: 0
+    };
+  }
   trimBuffers() {
     const {
       hls,
@@ -22542,7 +22627,7 @@ class TimelineController {
     const {
       unparsedVttFrags
     } = this;
-    if (id === 'main') {
+    if (id === PlaylistLevelType.MAIN) {
       this.initPTS[frag.cc] = {
         baseTime: initPTS,
         timescale
@@ -28289,7 +28374,6 @@ class StreamController extends BaseStreamController {
   loadFragment(frag, level, targetBufferTime) {
     // Check if fragment is not loaded
     const fragState = this.fragmentTracker.getState(frag);
-    this.fragCurrent = frag;
     if (fragState === FragmentState.NOT_LOADED || fragState === FragmentState.PARTIAL) {
       if (frag.sn === 'initSegment') {
         this._loadInitSegment(frag, level);
@@ -28297,7 +28381,6 @@ class StreamController extends BaseStreamController {
         this.log(`Fragment ${frag.sn} of level ${frag.level} is being downloaded to test bitrate and will not be buffered`);
         this._loadBitrateTestFrag(frag, level);
       } else {
-        this.startFragRequested = true;
         super.loadFragment(frag, level, targetBufferTime);
       }
     } else {
@@ -28431,14 +28514,14 @@ class StreamController extends BaseStreamController {
     super.onMediaDetaching();
   }
   onManifestLoading() {
+    super.onManifestLoading();
     // reset buffer on manifest loading
     this.log('Trigger BUFFER_RESET');
     this.hls.trigger(Events.BUFFER_RESET, undefined);
-    this.fragmentTracker.removeAllFragments();
     this.couldBacktrack = false;
-    this.startPosition = this.lastCurrentTime = this.fragLastKbps = 0;
-    this.levels = this.fragPlaying = this.backtrackFragment = this.levelLastLoaded = null;
-    this.altAudio = this.audioOnly = this.startFragRequested = false;
+    this.fragLastKbps = 0;
+    this.fragPlaying = this.backtrackFragment = null;
+    this.altAudio = this.audioOnly = false;
   }
   onManifestParsed(event, data) {
     // detect if we have different kind of audio codecs used amongst playlists
@@ -28734,7 +28817,7 @@ class StreamController extends BaseStreamController {
     // in that case, reset startFragRequested flag
     if (!this.loadedmetadata) {
       this.startFragRequested = false;
-      this.nextLoadPosition = this.startPosition;
+      this.nextLoadPosition = this.lastCurrentTime;
     }
     this.tickImmediate();
   }
@@ -28822,7 +28905,7 @@ class StreamController extends BaseStreamController {
   }
   _handleTransmuxComplete(transmuxResult) {
     var _id3$samples;
-    const id = 'main';
+    const id = this.playlistType;
     const {
       hls
     } = this;
@@ -29027,31 +29110,38 @@ class StreamController extends BaseStreamController {
       audio.levelCodec = audioCodec;
       audio.id = 'main';
       this.log(`Init audio buffer, container:${audio.container}, codecs[selected/level/parsed]=[${audioCodec || ''}/${currentLevel.audioCodec || ''}/${audio.codec}]`);
+      delete tracks.audiovideo;
     }
     if (video) {
       video.levelCodec = currentLevel.videoCodec;
       video.id = 'main';
       this.log(`Init video buffer, container:${video.container}, codecs[level/parsed]=[${currentLevel.videoCodec || ''}/${video.codec}]`);
+      delete tracks.audiovideo;
     }
     if (audiovideo) {
       this.log(`Init audiovideo buffer, container:${audiovideo.container}, codecs[level/parsed]=[${currentLevel.codecs}/${audiovideo.codec}]`);
+      delete tracks.video;
+      delete tracks.audio;
+    }
+    const trackTypes = Object.keys(tracks);
+    if (trackTypes.length) {
+      this.hls.trigger(Events.BUFFER_CODECS, tracks);
+      // loop through tracks that are going to be provided to bufferController
+      trackTypes.forEach(trackName => {
+        const track = tracks[trackName];
+        const initSegment = track.initSegment;
+        if (initSegment != null && initSegment.byteLength) {
+          this.hls.trigger(Events.BUFFER_APPENDING, {
+            type: trackName,
+            data: initSegment,
+            frag,
+            part: null,
+            chunkMeta,
+            parent: frag.type
+          });
+        }
+      });
     }
-    this.hls.trigger(Events.BUFFER_CODECS, tracks);
-    // loop through tracks that are going to be provided to bufferController
-    Object.keys(tracks).forEach(trackName => {
-      const track = tracks[trackName];
-      const initSegment = track.initSegment;
-      if (initSegment != null && initSegment.byteLength) {
-        this.hls.trigger(Events.BUFFER_APPENDING, {
-          type: trackName,
-          data: initSegment,
-          frag,
-          part: null,
-          chunkMeta,
-          parent: frag.type
-        });
-      }
-    });
     // trigger handler right now
     this.tickImmediate();
   }
@@ -29128,20 +29218,28 @@ class StreamController extends BaseStreamController {
     return -1;
   }
   get currentFrag() {
-    const media = this.media;
-    if (media) {
-      return this.fragPlaying || this.getAppendedFrag(media.currentTime);
+    var _this$media2;
+    if (this.fragPlaying) {
+      return this.fragPlaying;
+    }
+    const currentTime = ((_this$media2 = this.media) == null ? void 0 : _this$media2.currentTime) || this.lastCurrentTime;
+    if (isFiniteNumber(currentTime)) {
+      return this.getAppendedFrag(currentTime);
     }
     return null;
   }
   get currentProgramDateTime() {
-    const media = this.media;
-    if (media) {
-      const currentTime = media.currentTime;
-      const frag = this.currentFrag;
-      if (frag && isFiniteNumber(currentTime) && isFiniteNumber(frag.programDateTime)) {
-        const epocMs = frag.programDateTime + (currentTime - frag.start) * 1000;
-        return new Date(epocMs);
+    var _this$media3;
+    const currentTime = ((_this$media3 = this.media) == null ? void 0 : _this$media3.currentTime) || this.lastCurrentTime;
+    if (isFiniteNumber(currentTime)) {
+      const details = this.getLevelDetails();
+      const frag = this.currentFrag || (details ? findFragmentByPTS(null, details.fragments, currentTime) : null);
+      if (frag) {
+        const programDateTime = frag.programDateTime;
+        if (programDateTime !== null) {
+          const epocMs = programDateTime + (currentTime - frag.start) * 1000;
+          return new Date(epocMs);
+        }
       }
     }
     return null;
@@ -29174,7 +29272,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.12-0.canary.10366";
+    return "1.5.12-0.canary.10367";
   }
 
   /**
@@ -29305,7 +29403,7 @@ class Hls {
     if (AudioStreamControllerClass) {
       networkControllers.push(new AudioStreamControllerClass(this, fragmentTracker, keyLoader));
     }
-    // subtitleTrackController must be defined before subtitleStreamController because the order of event handling is important
+    // Instantiate subtitleTrackController before SubtitleStreamController to receive level events first
     this.subtitleTrackController = this.createController(config.subtitleTrackController, networkControllers);
     const SubtitleStreamControllerClass = config.subtitleStreamController;
     if (SubtitleStreamControllerClass) {