@tarojs/components 4.0.0-canary.4 → 4.0.0-canary.6

package/dist/components/hls.js

@@ -240,10 +240,17 @@ function _toPropertyKey(arg) {
   return typeof key === "symbol" ? key : String(key);
 }
 
+// https://caniuse.com/mdn-javascript_builtins_number_isfinite
 const isFiniteNumber = Number.isFinite || function (value) {
   return typeof value === 'number' && isFinite(value);
 };
 
+// https://caniuse.com/mdn-javascript_builtins_number_issafeinteger
+const isSafeInteger = Number.isSafeInteger || function (value) {
+  return typeof value === 'number' && Math.abs(value) <= MAX_SAFE_INTEGER;
+};
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+
 let Events = /*#__PURE__*/function (Events) {
   Events["MEDIA_ATTACHING"] = "hlsMediaAttaching";
   Events["MEDIA_ATTACHED"] = "hlsMediaAttached";
@@ -402,7 +409,7 @@ function enableLogs(debugConfig, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      exportedLogger.log(`Debug logs enabled for "${id}" in hls.js version ${"1.4.1"}`);
+      exportedLogger.log(`Debug logs enabled for "${id}" in hls.js version ${"1.4.13"}`);
     } catch (e) {
       exportedLogger = fakeLogger;
     }
@@ -927,7 +934,7 @@ class LevelDetails {
     }
     const partSnDiff = this.lastPartSn - previous.lastPartSn;
     const partIndexDiff = this.lastPartIndex - previous.lastPartIndex;
-    this.updated = this.endSN !== previous.endSN || !!partIndexDiff || !!partSnDiff;
+    this.updated = this.endSN !== previous.endSN || !!partIndexDiff || !!partSnDiff || !this.live;
     this.advanced = this.endSN > previous.endSN || partSnDiff > 0 || partSnDiff === 0 && partIndexDiff > 0;
     if (this.updated || this.advanced) {
       this.misses = Math.floor(previous.misses * 0.6);
@@ -1823,13 +1830,13 @@ function getStartDTS(initData, fmp4) {
         const scale = track.timescale || 90e3;
         // convert base time to seconds
         const startTime = baseTime / scale;
-        if (isFinite(startTime) && (result === null || startTime < result)) {
+        if (isFiniteNumber(startTime) && (result === null || startTime < result)) {
           return startTime;
         }
       }
       return result;
     }, null);
-    if (start !== null && isFinite(start) && (result === null || start < result)) {
+    if (start !== null && isFiniteNumber(start) && (result === null || start < result)) {
       return start;
     }
     return result;
@@ -2348,7 +2355,7 @@ function parseEmsg(data) {
     const rightPresentationTime = readUint32(data, offset);
     offset += 4;
     presentationTime = 2 ** 32 * leftPresentationTime + rightPresentationTime;
-    if (!Number.isSafeInteger(presentationTime)) {
+    if (!isSafeInteger(presentationTime)) {
       presentationTime = Number.MAX_SAFE_INTEGER;
       logger.warn('Presentation time exceeds safe integer limit and wrapped to max safe integer in parsing emsg box');
     }
@@ -3991,9 +3998,13 @@ function addCueToTrack(track, cue) {
       }
     } catch (err) {
       logger.debug(`[texttrack-utils]: ${err}`);
-      const textTrackCue = new self.TextTrackCue(cue.startTime, cue.endTime, cue.text);
-      textTrackCue.id = cue.id;
-      track.addCue(textTrackCue);
+      try {
+        const textTrackCue = new self.TextTrackCue(cue.startTime, cue.endTime, cue.text);
+        textTrackCue.id = cue.id;
+        track.addCue(textTrackCue);
+      } catch (err2) {
+        logger.debug(`[texttrack-utils]: Legacy TextTrackCue fallback failed: ${err2}`);
+      }
     }
   }
   if (mode === 'disabled') {
@@ -4089,11 +4100,21 @@ var MetadataSchema = {
 const MIN_CUE_DURATION = 0.25;
 function getCueClass() {
   if (typeof self === 'undefined') return undefined;
-
-  // Attempt to recreate Safari functionality by creating
-  // WebKitDataCue objects when available and store the decoded
-  // ID3 data in the value property of the cue
-  return self.WebKitDataCue || self.VTTCue || self.TextTrackCue;
+  return self.VTTCue || self.TextTrackCue;
+}
+function createCueWithDataFields(Cue, startTime, endTime, data, type) {
+  let cue = new Cue(startTime, endTime, '');
+  try {
+    cue.value = data;
+    if (type) {
+      cue.type = type;
+    }
+  } catch (e) {
+    cue = new Cue(startTime, endTime, JSON.stringify(type ? _objectSpread2({
+      type
+    }, data) : data));
+  }
+  return cue;
 }
 
 // VTTCue latest draft allows an infinite duration, fallback
@@ -4101,7 +4122,7 @@ function getCueClass() {
 const MAX_CUE_ENDTIME = (() => {
   const Cue = getCueClass();
   try {
-    new Cue(0, Number.POSITIVE_INFINITY, '');
+    Cue && new Cue(0, Number.POSITIVE_INFINITY, '');
   } catch (e) {
     return Number.MAX_VALUE;
   }
@@ -4213,6 +4234,9 @@ class ID3TrackController {
       this.id3Track = this.createTrack(this.media);
     }
     const Cue = getCueClass();
+    if (!Cue) {
+      return;
+    }
     for (let i = 0; i < samples.length; i++) {
       const type = samples[i].type;
       if (type === MetadataSchema.emsg && !enableEmsgMetadataCues || !enableID3MetadataCues) {
@@ -4234,25 +4258,23 @@ class ID3TrackController {
           // Safari doesn't put the timestamp frame in the TextTrack
           if (!isTimeStampFrame(frame)) {
             // add a bounds to any unbounded cues
-            this.updateId3CueEnds(startTime);
-            const cue = new Cue(startTime, endTime, '');
-            cue.value = frame;
-            if (type) {
-              cue.type = type;
+            this.updateId3CueEnds(startTime, type);
+            const cue = createCueWithDataFields(Cue, startTime, endTime, frame, type);
+            if (cue) {
+              this.id3Track.addCue(cue);
             }
-            this.id3Track.addCue(cue);
           }
         }
       }
     }
   }
-  updateId3CueEnds(startTime) {
+  updateId3CueEnds(startTime, type) {
     var _this$id3Track;
     const cues = (_this$id3Track = this.id3Track) == null ? void 0 : _this$id3Track.cues;
     if (cues) {
       for (let i = cues.length; i--;) {
         const cue = cues[i];
-        if (cue.startTime < startTime && cue.endTime === MAX_CUE_ENDTIME) {
+        if (cue.type === type && cue.startTime < startTime && cue.endTime === MAX_CUE_ENDTIME) {
           cue.endTime = startTime;
         }
       }
@@ -4354,25 +4376,25 @@ class ID3TrackController {
         if (!isDateRangeCueAttribute(key)) {
           continue;
         }
-        let cue = cues[key];
+        const cue = cues[key];
         if (cue) {
           if (durationKnown && !appendedDateRangeCues.durationKnown) {
             cue.endTime = endTime;
           }
-        } else {
+        } else if (Cue) {
           let data = dateRange.attr[key];
-          cue = new Cue(startTime, endTime, '');
           if (isSCTE35Attribute(key)) {
             data = hexToArrayBuffer(data);
           }
-          cue.value = {
+          const _cue = createCueWithDataFields(Cue, startTime, endTime, {
             key,
             data
-          };
-          cue.type = MetadataSchema.dateRange;
-          cue.id = id;
-          this.id3Track.addCue(cue);
-          cues[key] = cue;
+          }, MetadataSchema.dateRange);
+          if (_cue) {
+            _cue.id = id;
+            this.id3Track.addCue(_cue);
+            cues[key] = _cue;
+          }
         }
       }
       dateRangeCuesAppended[id] = {
@@ -5282,6 +5304,7 @@ class ErrorController {
     const hls = this.hls;
     hls.on(Events.ERROR, this.onError, this);
     hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
+    hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
   }
   unregisterListeners() {
     const hls = this.hls;
@@ -5291,6 +5314,7 @@ class ErrorController {
     hls.off(Events.ERROR, this.onError, this);
     hls.off(Events.ERROR, this.onErrorOut, this);
     hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
+    hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
   }
   destroy() {
     this.unregisterListeners();
@@ -5309,8 +5333,11 @@ class ErrorController {
     this.playlistError = 0;
     this.penalizedRenditions = {};
   }
+  onLevelUpdated() {
+    this.playlistError = 0;
+  }
   onError(event, data) {
-    var _data$level;
+    var _data$frag, _data$level;
     if (data.fatal) {
       return;
     }
@@ -5323,8 +5350,17 @@ class ErrorController {
       case ErrorDetails.KEY_LOAD_TIMEOUT:
         data.errorAction = this.getFragRetryOrSwitchAction(data);
         return;
-      case ErrorDetails.FRAG_GAP:
       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
+          };
+          return;
+        }
+      // falls through
+      case ErrorDetails.FRAG_GAP:
       case ErrorDetails.FRAG_DECRYPT_ERROR:
         {
           // Switch level if possible, otherwise allow retry count to reach max error retries
@@ -5409,7 +5445,7 @@ class ErrorController {
     }
   }
   getPlaylistRetryOrSwitchAction(data, levelIndex) {
-    var _data$response, _data$context2;
+    var _data$response;
     const hls = this.hls;
     const retryConfig = getRetryConfig(hls.config.playlistLoadPolicy, data);
     const retryCount = this.playlistError++;
@@ -5423,21 +5459,12 @@ class ErrorController {
         retryCount
       };
     }
-    // Do not perform level switch if an error occurred using delivery directives
-    // Allow reload without directives (handled in playlist-loader)
-    if ((_data$context2 = data.context) != null && _data$context2.deliveryDirectives) {
-      return {
-        action: NetworkErrorAction.DoNothing,
-        flags: ErrorActionFlags.None,
-        retryConfig: retryConfig || {
-          maxNumRetry: 0,
-          retryDelayMs: 0,
-          maxRetryDelayMs: 0
-        },
-        retryCount
-      };
+    const errorAction = this.getLevelSwitchAction(data, levelIndex);
+    if (retryConfig) {
+      errorAction.retryConfig = retryConfig;
+      errorAction.retryCount = retryCount;
     }
-    return this.getLevelSwitchAction(data, levelIndex);
+    return errorAction;
   }
   getFragRetryOrSwitchAction(data) {
     const hls = this.hls;
@@ -5487,18 +5514,23 @@ class ErrorController {
     if (level) {
       level.loadError++;
       if (hls.autoLevelEnabled) {
-        var _data$frag, _data$context3;
+        var _data$frag2, _data$context2;
         // Search for next level to retry
         let nextLevel = -1;
-        const levels = hls.levels;
-        const fragErrorType = (_data$frag = data.frag) == null ? void 0 : _data$frag.type;
+        const {
+          levels,
+          loadLevel,
+          minAutoLevel,
+          maxAutoLevel
+        } = hls;
+        const fragErrorType = (_data$frag2 = data.frag) == null ? void 0 : _data$frag2.type;
         const {
           type: playlistErrorType,
           groupId: playlistErrorGroupId
-        } = (_data$context3 = data.context) != null ? _data$context3 : {};
+        } = (_data$context2 = data.context) != null ? _data$context2 : {};
         for (let i = levels.length; i--;) {
-          const candidate = (i + hls.loadLevel) % levels.length;
-          if (candidate !== hls.loadLevel && levels[candidate].loadError === 0) {
+          const candidate = (i + loadLevel) % levels.length;
+          if (candidate !== loadLevel && candidate >= minAutoLevel && candidate <= maxAutoLevel && levels[candidate].loadError === 0) {
             const levelCandidate = levels[candidate];
             // Skip level switch if GAP tag is found in next level at same position
             if (data.details === ErrorDetails.FRAG_GAP && data.frag) {
@@ -5522,6 +5554,7 @@ class ErrorController {
         }
         if (nextLevel > -1 && hls.loadLevel !== nextLevel) {
           data.levelRetry = true;
+          this.playlistError = 0;
           return {
             action: NetworkErrorAction.SendAlternateToPenaltyBox,
             flags: ErrorActionFlags.None,
@@ -5762,7 +5795,7 @@ class BasePlaylistController {
     if (details.live || previousDetails != null && previousDetails.live) {
       details.reloaded(previousDetails);
       if (previousDetails) {
-        this.log(`live playlist ${index} ${details.advanced ? 'REFRESHED ' + details.lastPartSn + '-' + details.lastPartIndex : 'MISSED'}`);
+        this.log(`live playlist ${index} ${details.advanced ? 'REFRESHED ' + details.lastPartSn + '-' + details.lastPartIndex : details.updated ? 'UPDATED' : 'MISSED'}`);
       }
       // Merge live playlists to adjust fragment starts and fill in delta playlist skipped segments
       if (previousDetails && details.fragments.length > 0) {
@@ -5817,7 +5850,7 @@ class BasePlaylistController {
           this.loadPlaylist(deliveryDirectives);
           return;
         }
-      } else if (details.canBlockReload) {
+      } else if (details.canBlockReload || details.canSkipUntil) {
         deliveryDirectives = this.getDeliveryDirectives(details, data.deliveryDirectives, msn, part);
       }
       const bufferInfo = this.hls.mainForwardBufferInfo;
@@ -5880,6 +5913,9 @@ class BasePlaylistController {
     if (retry) {
       var _errorEvent$context;
       this.requestScheduled = -1;
+      if (retryCount >= retryConfig.maxNumRetry) {
+        return false;
+      }
       if (isTimeout && (_errorEvent$context = errorEvent.context) != null && _errorEvent$context.deliveryDirectives) {
         // The LL-HLS request already timed out so retry immediately
         this.warn(`Retrying playlist loading ${retryCount + 1}/${retryConfig.maxNumRetry} after "${errorDetails}" without delivery-directives`);
@@ -6499,7 +6535,7 @@ class FragmentTracker {
     }
     // Check if any flagged fragments have been unloaded
     // excluding anything newer than appendedPartSn
-    const appendedPartSn = (appendedPart == null ? void 0 : appendedPart.fragment.sn) || 0;
+    const appendedPartSn = (appendedPart == null ? void 0 : appendedPart.fragment.sn) || -1;
     Object.keys(this.fragments).forEach(key => {
       const fragmentEntity = this.fragments[key];
       if (!fragmentEntity) {
@@ -6544,7 +6580,7 @@ class FragmentTracker {
     }
     const fragKey = getFragmentKey(frag);
     const fragmentEntity = this.fragments[fragKey];
-    if (!fragmentEntity) {
+    if (!fragmentEntity || fragmentEntity.buffered && frag.gap) {
       return;
     }
     const isFragHint = !frag.relurl;
@@ -6560,7 +6596,8 @@ class FragmentTracker {
     fragmentEntity.loaded = null;
     if (Object.keys(fragmentEntity.range).length) {
       fragmentEntity.buffered = true;
-      if (fragmentEntity.body.endList) {
+      const endList = fragmentEntity.body.endList = frag.endList || fragmentEntity.body.endList;
+      if (endList) {
         this.endListFragments[fragmentEntity.body.type] = fragmentEntity;
       }
       if (!isPartial(fragmentEntity)) {
@@ -6799,8 +6836,8 @@ class FragmentTracker {
   }
 }
 function isPartial(fragmentEntity) {
-  var _fragmentEntity$range, _fragmentEntity$range2;
-  return fragmentEntity.buffered && (fragmentEntity.body.gap || ((_fragmentEntity$range = fragmentEntity.range.video) == null ? void 0 : _fragmentEntity$range.partial) || ((_fragmentEntity$range2 = fragmentEntity.range.audio) == null ? void 0 : _fragmentEntity$range2.partial));
+  var _fragmentEntity$range, _fragmentEntity$range2, _fragmentEntity$range3;
+  return fragmentEntity.buffered && (fragmentEntity.body.gap || ((_fragmentEntity$range = fragmentEntity.range.video) == null ? void 0 : _fragmentEntity$range.partial) || ((_fragmentEntity$range2 = fragmentEntity.range.audio) == null ? void 0 : _fragmentEntity$range2.partial) || ((_fragmentEntity$range3 = fragmentEntity.range.audiovideo) == null ? void 0 : _fragmentEntity$range3.partial));
 }
 function getFragmentKey(fragment) {
   return `${fragment.type}_${fragment.level}_${fragment.urlId}_${fragment.sn}`;
@@ -6848,8 +6885,13 @@ class FragmentLoader {
         this.loader.destroy();
       }
       if (frag.gap) {
-        reject(createGapLoadError(frag));
-        return;
+        if (frag.tagList.some(tags => tags[0] === 'GAP')) {
+          reject(createGapLoadError(frag));
+          return;
+        } else {
+          // Reset temporary treatment as GAP tag
+          frag.gap = false;
+        }
       }
       const loader = this.loader = frag.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
       const loaderContext = createLoaderContext(frag);
@@ -7482,6 +7524,7 @@ class TaskLoop {
  *
  * Also @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/buffered
  */
+
 const noopBuffered = {
   length: 0,
   start: () => 0,
@@ -8542,6 +8585,21 @@ class BaseStreamController extends TaskLoop {
       }
     }
   }
+  checkLiveUpdate(details) {
+    if (details.updated && !details.live) {
+      // Live stream ended, update fragment tracker
+      const lastFragment = details.fragments[details.fragments.length - 1];
+      this.fragmentTracker.detectPartialFragments({
+        frag: lastFragment,
+        part: null,
+        stats: lastFragment.stats,
+        id: lastFragment.type
+      });
+    }
+    if (!details.fragments[0]) {
+      details.deltaUpdateFailed = true;
+    }
+  }
   flushMainBuffer(startOffset, endOffset, type = null) {
     if (!(startOffset - endOffset)) {
       return;
@@ -8871,7 +8929,7 @@ class BaseStreamController extends TaskLoop {
       level
     };
   }
-  bufferFragmentData(data, frag, part, chunkMeta) {
+  bufferFragmentData(data, frag, part, chunkMeta, noBacktracking) {
     var _buffer;
     if (!data || this.state !== State.PARSING) {
       return;
@@ -8898,6 +8956,9 @@ class BaseStreamController extends TaskLoop {
     };
     this.hls.trigger(Events.BUFFER_APPENDING, segment);
     if (data.dropped && data.independent && !part) {
+      if (noBacktracking) {
+        return;
+      }
       // Clear buffer so that we reload previous segments sequentially if required
       this.flushBufferGap(frag);
     }
@@ -9314,10 +9375,8 @@ class BaseStreamController extends TaskLoop {
       retryConfig
     } = errorAction || {};
     if (errorAction && action === NetworkErrorAction.RetryRequest && retryConfig) {
-      if (!this.loadedmetadata) {
-        this.startFragRequested = false;
-        this.nextLoadPosition = this.startPosition;
-      }
+      var _this$levelLastLoaded;
+      this.resetStartWhenNotLoaded((_this$levelLastLoaded = this.levelLastLoaded) != null ? _this$levelLastLoaded : frag.level);
       const delay = getRetryDelay(retryConfig, retryCount);
       this.warn(`Fragment ${frag.sn} of ${filterType} ${frag.level} errored with ${data.details}, retrying loading ${retryCount + 1}/${retryConfig.maxNumRetry} in ${delay}ms`);
       errorAction.resolved = true;
@@ -9333,6 +9392,8 @@ class BaseStreamController extends TaskLoop {
       } else {
         logger.warn(`${data.details} reached or exceeded max retry (${retryCount})`);
       }
+    } else if ((errorAction == null ? void 0 : errorAction.action) === NetworkErrorAction.SendAlternateToPenaltyBox) {
+      this.state = State.WAITING_LEVEL;
     } else {
       this.state = State.ERROR;
     }
@@ -9415,9 +9476,10 @@ class BaseStreamController extends TaskLoop {
     }
   }
   resetWhenMissingContext(chunkMeta) {
+    var _this$levelLastLoaded2;
     this.warn(`The loading context changed while buffering fragment ${chunkMeta.sn} of level ${chunkMeta.level}. This chunk will not be buffered.`);
     this.removeUnbufferedFrags();
-    this.resetStartWhenNotLoaded(chunkMeta.level);
+    this.resetStartWhenNotLoaded((_this$levelLastLoaded2 = this.levelLastLoaded) != null ? _this$levelLastLoaded2 : chunkMeta.level);
     this.resetLoadingState();
   }
   removeUnbufferedFrags(start = 0) {
@@ -9458,7 +9520,14 @@ class BaseStreamController extends TaskLoop {
     if (parsed) {
       level.fragmentError = 0;
     } else if (((_this$transmuxer = this.transmuxer) == null ? void 0 : _this$transmuxer.error) === null) {
-      const error = new Error(`Found no media in fragment ${frag.sn} of level ${level.id} resetting transmuxer to fallback to playlist timing`);
+      const error = new Error(`Found no media in fragment ${frag.sn} of level ${frag.level} resetting transmuxer to fallback to playlist timing`);
+      if (level.fragmentError === 0) {
+        // Mark and track the odd empty segment as a gap to avoid reloading
+        level.fragmentError++;
+        frag.gap = true;
+        this.fragmentTracker.removeFragment(frag);
+        this.fragmentTracker.fragBuffered(frag, true);
+      }
       this.warn(error.message);
       this.hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
@@ -9489,7 +9558,10 @@ class BaseStreamController extends TaskLoop {
   }
   recoverWorkerError(data) {
     if (data.event === 'demuxerWorker') {
+      var _ref, _this$levelLastLoaded3, _this$fragCurrent3;
+      this.fragmentTracker.removeAllFragments();
       this.resetTransmuxer();
+      this.resetStartWhenNotLoaded((_ref = (_this$levelLastLoaded3 = this.levelLastLoaded) != null ? _this$levelLastLoaded3 : (_this$fragCurrent3 = this.fragCurrent) == null ? void 0 : _this$fragCurrent3.level) != null ? _ref : 0);
       this.resetLoadingState();
     }
   }
@@ -9536,6 +9608,7 @@ function changeTypeSupported() {
 }
 
 // ensure the worker ends up in the bundle
+// If the worker should not be included this gets aliased to empty.js
 function hasUMDWorker() {
   return typeof __HLS_WORKER_BUNDLE__ === 'function';
 }
@@ -10299,6 +10372,7 @@ function probe(data, offset) {
 /**
  * Parser for exponential Golomb codes, a variable-bitwidth number encoding scheme used by h264.
  */
+
 class ExpGolomb {
   constructor(data) {
     this.data = void 0;
@@ -10624,6 +10698,7 @@ class ExpGolomb {
 /**
  * SAMPLE-AES decrypter
  */
+
 class SampleAesDecrypter {
   constructor(observer, config, keyData) {
     this.keyData = void 0;
@@ -10758,19 +10833,33 @@ class TSDemuxer {
   }
   static syncOffset(data) {
     const length = data.length;
-    const scanwindow = Math.min(PACKET_LENGTH * 5, data.length - PACKET_LENGTH) + 1;
+    let scanwindow = Math.min(PACKET_LENGTH * 5, data.length - PACKET_LENGTH) + 1;
     let i = 0;
     while (i < scanwindow) {
       // a TS init segment should contain at least 2 TS packets: PAT and PMT, each starting with 0x47
       let foundPat = false;
+      let packetStart = -1;
+      let tsPackets = 0;
       for (let j = i; j < length; j += PACKET_LENGTH) {
         if (data[j] === 0x47) {
-          if (!foundPat && parsePID(data, j) === 0) {
-            foundPat = true;
+          tsPackets++;
+          if (packetStart === -1) {
+            packetStart = j;
+            // First sync word found at offset, increase scan length (#5251)
+            if (packetStart !== 0) {
+              scanwindow = Math.min(packetStart + PACKET_LENGTH * 99, data.length - PACKET_LENGTH) + 1;
+            }
+          }
+          if (!foundPat) {
+            foundPat = parsePID(data, j) === 0;
           }
-          if (foundPat && j + PACKET_LENGTH > scanwindow) {
-            return i;
+          // Sync word found at 0 with 3 packets, or found at offset least 2 packets up to scanwindow (#5501)
+          if (foundPat && tsPackets > 1 && (packetStart === 0 && tsPackets > 2 || j + PACKET_LENGTH > scanwindow)) {
+            return packetStart;
           }
+        } else if (tsPackets) {
+          // Exit if sync word found, but does not contain contiguous packets (#5501)
+          return -1;
         } else {
           break;
         }
@@ -11139,15 +11228,13 @@ class TSDemuxer {
       avcSample = this.avcSample = createAVCSample(false, pes.pts, pes.dts, '');
     }
     units.forEach(unit => {
+      var _avcSample2;
       switch (unit.type) {
         // NDR
         case 1:
           {
+            let iskey = false;
             push = true;
-            if (!avcSample) {
-              avcSample = this.avcSample = createAVCSample(true, pes.pts, pes.dts, '');
-            }
-            avcSample.frame = true;
             const data = unit.data;
             // only check slice type to detect KF in case SPS found in same packet (any keyframe is preceded by SPS ...)
             if (spsfound && data.length > 4) {
@@ -11159,9 +11246,22 @@ class TSDemuxer {
               // I slice: A slice that is not an SI slice that is decoded using intra prediction only.
               // if (sliceType === 2 || sliceType === 7) {
               if (sliceType === 2 || sliceType === 4 || sliceType === 7 || sliceType === 9) {
-                avcSample.key = true;
+                iskey = true;
+              }
+            }
+            if (iskey) {
+              var _avcSample;
+              // if we have non-keyframe data already, that cannot belong to the same frame as a keyframe, so force a push
+              if ((_avcSample = avcSample) != null && _avcSample.frame && !avcSample.key) {
+                pushAccessUnit(avcSample, track);
+                avcSample = this.avcSample = null;
               }
             }
+            if (!avcSample) {
+              avcSample = this.avcSample = createAVCSample(true, pes.pts, pes.dts, '');
+            }
+            avcSample.frame = true;
+            avcSample.key = iskey;
             break;
             // IDR
           }
@@ -11169,6 +11269,11 @@ class TSDemuxer {
         case 5:
           push = true;
           // handle PES not starting with AUD
+          // if we have non-keyframe data already, that cannot belong to the same frame as a keyframe, so force a push
+          if ((_avcSample2 = avcSample) != null && _avcSample2.frame && !avcSample.key) {
+            pushAccessUnit(avcSample, track);
+            avcSample = this.avcSample = null;
+          }
           if (!avcSample) {
             avcSample = this.avcSample = createAVCSample(true, pes.pts, pes.dts, '');
           }
@@ -11247,14 +11352,14 @@ class TSDemuxer {
     }
   }
   getLastNalUnit(samples) {
-    var _avcSample;
+    var _avcSample3;
     let avcSample = this.avcSample;
     let lastUnit;
     // try to fallback to previous sample if current one is empty
     if (!avcSample || avcSample.units.length === 0) {
       avcSample = samples[samples.length - 1];
     }
-    if ((_avcSample = avcSample) != null && _avcSample.units) {
+    if ((_avcSample3 = avcSample) != null && _avcSample3.units) {
       const units = avcSample.units;
       lastUnit = units[units.length - 1];
     }
@@ -12759,7 +12864,7 @@ class MP4Remuxer {
         } else {
           logger.warn(`AVC: ${toMsFromMpegTsClock(-delta, true)} ms (${delta}dts) overlapping between fragments detected`);
         }
-        if (!foundOverlap || nextAvcDts > inputSamples[0].pts) {
+        if (!foundOverlap || nextAvcDts >= inputSamples[0].pts) {
           firstDTS = nextAvcDts;
           const firstPTS = inputSamples[0].pts - delta;
           inputSamples[0].dts = firstDTS;
@@ -13212,8 +13317,8 @@ function flushTextTrackMetadataCueSamples(track, timeOffset, initPTS, initDTS) {
     const sample = track.samples[index];
     // setting id3 pts, dts to relative time
     // using this._initPTS and this._initDTS to calculate relative time
-    sample.pts = normalizePts(sample.pts - initPTS.baseTime * 90000 / initPTS.timescale, timeOffset * inputTimeScale) / inputTimeScale;
-    sample.dts = normalizePts(sample.dts - initDTS.baseTime * 90000 / initDTS.timescale, timeOffset * inputTimeScale) / inputTimeScale;
+    sample.pts = normalizePts(sample.pts - initPTS.baseTime * inputTimeScale / initPTS.timescale, timeOffset * inputTimeScale) / inputTimeScale;
+    sample.dts = normalizePts(sample.dts - initDTS.baseTime * inputTimeScale / initDTS.timescale, timeOffset * inputTimeScale) / inputTimeScale;
   }
   const samples = track.samples;
   track.samples = [];
@@ -13231,7 +13336,7 @@ function flushTextTrackUserdataCueSamples(track, timeOffset, initPTS) {
     const sample = track.samples[index];
     // setting text pts, dts to relative time
     // using this._initPTS and this._initDTS to calculate relative time
-    sample.pts = normalizePts(sample.pts - initPTS.baseTime * 90000 / initPTS.timescale, timeOffset * inputTimeScale) / inputTimeScale;
+    sample.pts = normalizePts(sample.pts - initPTS.baseTime * inputTimeScale / initPTS.timescale, timeOffset * inputTimeScale) / inputTimeScale;
   }
   track.samples.sort((a, b) => a.pts - b.pts);
   const samples = track.samples;
@@ -13380,16 +13485,19 @@ class PassThroughRemuxer {
       initSegment.tracks = this.initTracks;
       this.emitInitSegment = false;
     }
+    const duration = getDuration(data, initData);
     const startDTS = getStartDTS(initData, data);
     const decodeTime = startDTS === null ? timeOffset : startDTS;
-    if (isInvalidInitPts(initPTS, decodeTime, timeOffset) || initSegment.timescale !== initPTS.timescale && accurateTimeOffset) {
+    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}`);
+      }
       this.initPTS = initPTS = {
         baseTime: initSegment.initPTS,
         timescale: 1
       };
     }
-    const duration = getDuration(data, initData);
     const startTime = audioTrack ? decodeTime - initPTS.baseTime / initPTS.timescale : lastEndTime;
     const endTime = startTime + duration;
     offsetStartDTS(initData, data, initPTS.baseTime / initPTS.timescale);
@@ -13430,13 +13538,14 @@ class PassThroughRemuxer {
     return result;
   }
 }
-function isInvalidInitPts(initPTS, startDTS, timeOffset) {
+function isInvalidInitPts(initPTS, startDTS, timeOffset, duration) {
   if (initPTS === null) {
     return true;
   }
-  // InitPTS is invalid when it would cause start time to be negative, or distance from time offset to be more than 1 second
+  // InitPTS is invalid when distance from program would be more than segment duration or a minimum of one second
+  const minDuration = Math.max(duration, 1);
   const startTime = startDTS - initPTS.baseTime / initPTS.timescale;
-  return startTime < 0 && Math.abs(startTime - timeOffset) > 1;
+  return Math.abs(startTime - timeOffset) > minDuration;
 }
 function getParsedTrackCodec(track, type) {
   const parsedCodec = track == null ? void 0 : track.codec;
@@ -14911,6 +15020,9 @@ class StreamController extends BaseStreamController {
             }
             this.state = State.IDLE;
             break;
+          } else if (this.hls.nextLoadLevel !== this.level) {
+            this.state = State.IDLE;
+            break;
           }
           break;
         }
@@ -15279,9 +15391,7 @@ class StreamController extends BaseStreamController {
     }
     let sliding = 0;
     if (newDetails.live || (_curLevel$details = curLevel.details) != null && _curLevel$details.live) {
-      if (!newDetails.fragments[0]) {
-        newDetails.deltaUpdateFailed = true;
-      }
+      this.checkLiveUpdate(newDetails);
       if (newDetails.deltaUpdateFailed) {
         return;
       }
@@ -15665,8 +15775,11 @@ class StreamController extends BaseStreamController {
     }
 
     // Avoid buffering if backtracking this fragment
-    if (video && remuxResult.independent !== false) {
-      if (details) {
+    if (video && details && frag.sn !== 'initSegment') {
+      const prevFrag = details.fragments[frag.sn - 1 - details.startSN];
+      const isFirstFragment = frag.sn === details.startSN;
+      const isFirstInDiscontinuity = !prevFrag || frag.cc > prevFrag.cc;
+      if (remuxResult.independent !== false) {
         const {
           startPTS,
           endPTS,
@@ -15681,7 +15794,7 @@ class StreamController extends BaseStreamController {
             endDTS
           };
         } else {
-          if (video.firstKeyFrame && video.independent && chunkMeta.id === 1) {
+          if (video.firstKeyFrame && video.independent && chunkMeta.id === 1 && !isFirstInDiscontinuity) {
             this.couldBacktrack = true;
           }
           if (video.dropped && video.independent) {
@@ -15690,9 +15803,12 @@ class StreamController extends BaseStreamController {
             const bufferInfo = this.getMainFwdBufferInfo();
             const targetBufferTime = (bufferInfo ? bufferInfo.end : this.getLoadPosition()) + this.config.maxBufferHole;
             const startTime = video.firstKeyFramePTS ? video.firstKeyFramePTS : startPTS;
-            if (targetBufferTime < startTime - this.config.maxBufferHole) {
+            if (!isFirstFragment && targetBufferTime < startTime - this.config.maxBufferHole && !isFirstInDiscontinuity) {
               this.backtrack(frag);
               return;
+            } else if (isFirstInDiscontinuity) {
+              // Mark segment with a gap to avoid loop loading
+              frag.gap = true;
             }
             // Set video stream start to fragment start so that truncated samples do not distort the timeline, and mark it partial
             frag.setElementaryStreamInfo(video.type, frag.start, endPTS, frag.start, endDTS, true);
@@ -15702,11 +15818,14 @@ class StreamController extends BaseStreamController {
         if (this.backtrackFragment) {
           this.backtrackFragment = frag;
         }
-        this.bufferFragmentData(video, frag, part, chunkMeta);
+        this.bufferFragmentData(video, frag, part, chunkMeta, isFirstFragment || isFirstInDiscontinuity);
+      } else if (isFirstFragment || isFirstInDiscontinuity) {
+        // Mark segment with a gap to avoid loop loading
+        frag.gap = true;
+      } else {
+        this.backtrack(frag);
+        return;
       }
-    } else if (remuxResult.independent === false) {
-      this.backtrack(frag);
-      return;
     }
     if (audio) {
       const {
@@ -15963,6 +16082,7 @@ class EWMA {
  * Based on the minimum of two exponentially-weighted moving averages with
  * different half-lives.
  */
+
 class EwmaBandWidthEstimator {
   constructor(slow, fast, defaultEstimate, defaultTTFB = 100) {
     this.defaultEstimate_ = void 0;
@@ -16883,10 +17003,8 @@ class AudioStreamController extends BaseStreamController {
     const track = levels[trackId];
     let sliding = 0;
     if (newDetails.live || (_track$details = track.details) != null && _track$details.live) {
+      this.checkLiveUpdate(newDetails);
       const mainDetails = this.mainDetails;
-      if (!newDetails.fragments[0]) {
-        newDetails.deltaUpdateFailed = true;
-      }
       if (newDetails.deltaUpdateFailed || !mainDetails) {
         return;
       }
@@ -17003,9 +17121,12 @@ class AudioStreamController extends BaseStreamController {
     } = data;
     if (frag.type !== PlaylistLevelType.AUDIO) {
       if (!this.loadedmetadata && frag.type === PlaylistLevelType.MAIN) {
-        var _ref;
-        if ((_ref = this.videoBuffer || this.media) != null && _ref.buffered.length) {
-          this.loadedmetadata = true;
+        const bufferable = this.videoBuffer || this.media;
+        if (bufferable) {
+          const bufferedTimeRanges = BufferHelper.getBuffered(bufferable);
+          if (bufferedTimeRanges.length) {
+            this.loadedmetadata = true;
+          }
         }
       }
       return;
@@ -17570,16 +17691,7 @@ class SubtitleStreamController extends BaseStreamController {
       endOffset
     } = data;
     if (startOffset === 0 && endOffset !== Number.POSITIVE_INFINITY) {
-      const {
-        currentTrackId,
-        levels
-      } = this;
-      if (!levels.length || !levels[currentTrackId] || !levels[currentTrackId].details) {
-        return;
-      }
-      const trackDetails = levels[currentTrackId].details;
-      const targetDuration = trackDetails.targetduration;
-      const endOffsetSubtitles = endOffset - targetDuration;
+      const endOffsetSubtitles = endOffset - 1;
       if (endOffsetSubtitles <= 0) {
         return;
       }
@@ -17775,21 +17887,18 @@ class SubtitleStreamController extends BaseStreamController {
       if (!levels.length || !track || !track.details) {
         return;
       }
-
-      // Expand range of subs loaded by one target-duration in either direction to make up for misaligned playlists
-      const trackDetails = track.details;
-      const targetDuration = trackDetails.targetduration;
       const {
         config
       } = this;
       const currentTime = this.getLoadPosition();
-      const bufferedInfo = BufferHelper.bufferedInfo(this.tracksBuffered[this.currentTrackId] || [], currentTime - targetDuration, config.maxBufferHole);
+      const bufferedInfo = BufferHelper.bufferedInfo(this.tracksBuffered[this.currentTrackId] || [], currentTime, config.maxBufferHole);
       const {
         end: targetBufferTime,
         len: bufferLen
       } = bufferedInfo;
       const mainBufferInfo = this.getFwdBufferInfo(this.media, PlaylistLevelType.MAIN);
-      const maxBufLen = this.getMaxBufferLength(mainBufferInfo == null ? void 0 : mainBufferInfo.len) + targetDuration;
+      const trackDetails = track.details;
+      const maxBufLen = this.getMaxBufferLength(mainBufferInfo == null ? void 0 : mainBufferInfo.len) + trackDetails.levelTargetDuration;
       if (bufferLen > maxBufLen) {
         return;
       }
@@ -17799,10 +17908,9 @@ class SubtitleStreamController extends BaseStreamController {
       let foundFrag = null;
       const fragPrevious = this.fragPrevious;
       if (targetBufferTime < end) {
-        const {
-          maxFragLookUpTolerance
-        } = config;
-        foundFrag = findFragmentByPTS(fragPrevious, fragments, Math.max(fragments[0].start, targetBufferTime), maxFragLookUpTolerance);
+        const tolerance = config.maxFragLookUpTolerance;
+        const lookupTolerance = targetBufferTime > end - tolerance ? 0 : tolerance;
+        foundFrag = findFragmentByPTS(fragPrevious, fragments, Math.max(fragments[0].start, targetBufferTime), lookupTolerance);
         if (!foundFrag && fragPrevious && fragPrevious.start < fragments[0].start) {
           foundFrag = fragments[0];
         }
@@ -17813,6 +17921,14 @@ class SubtitleStreamController extends BaseStreamController {
         return;
       }
       foundFrag = this.mapToInitFragWhenRequired(foundFrag);
+      if (foundFrag.sn !== 'initSegment') {
+        // Load earlier fragment in same discontinuity to make up for misaligned playlists and cues that extend beyond end of segment
+        const curSNIdx = foundFrag.sn - trackDetails.startSN;
+        const prevFrag = fragments[curSNIdx - 1];
+        if (prevFrag && prevFrag.cc === foundFrag.cc && this.fragmentTracker.getState(prevFrag) === FragmentState.NOT_LOADED) {
+          foundFrag = prevFrag;
+        }
+      }
       if (this.fragmentTracker.getState(foundFrag) === FragmentState.NOT_LOADED) {
         // only load if fragment is not loaded
         this.loadFragment(foundFrag, track, targetBufferTime);
@@ -20674,6 +20790,7 @@ var VTTCue = (function () {
 /*
  * Source: https://github.com/mozilla/vtt.js/blob/master/dist/vtt.js
  */
+
 class StringDecoder {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   decode(data, options) {
@@ -21155,7 +21272,7 @@ function parseWebVTT(vttByteArray, initPTS, vttCCs, cc, timeOffset, callBack, er
   // Uint8Array.prototype.reduce is not implemented in IE11
   const vttLines = utf8ArrayToStr(new Uint8Array(vttByteArray)).trim().replace(LINEBREAKS, '\n').split('\n');
   const cues = [];
-  const init90kHz = toMpegTsClockFromTimescale(initPTS.baseTime, initPTS.timescale);
+  const init90kHz = initPTS ? toMpegTsClockFromTimescale(initPTS.baseTime, initPTS.timescale) : 0;
   let cueTime = '00:00.000';
   let timestampMapMPEGTS = 0;
   let timestampMapLOCAL = 0;
@@ -21179,6 +21296,10 @@ function parseWebVTT(vttByteArray, initPTS, vttCCs, cc, timeOffset, callBack, er
       }
     }
     if (webVttMpegTsMapOffset) {
+      if (!initPTS) {
+        parsingError = new Error('Missing initPTS for VTT MPEGTS');
+        return;
+      }
       // If we have MPEGTS, offset = presentation time + discontinuity offset
       cueOffset = webVttMpegTsMapOffset - vttCCs.presentationOffset;
     }
@@ -21674,7 +21795,7 @@ class TimelineController {
     this.captionsTracks = {};
     this.nonNativeCaptionsTracks = {};
     this.textTracks = [];
-    this.unparsedVttFrags = this.unparsedVttFrags || [];
+    this.unparsedVttFrags = [];
     this.initPTS = [];
     if (this.cea608Parser1 && this.cea608Parser2) {
       this.cea608Parser1.reset();
@@ -21818,26 +21939,9 @@ class TimelineController {
       frag,
       payload
     } = data;
-    const {
-      initPTS,
-      unparsedVttFrags
-    } = this;
     if (frag.type === PlaylistLevelType.SUBTITLE) {
       // If fragment is subtitle type, parse as WebVTT.
       if (payload.byteLength) {
-        // We need an initial synchronisation PTS. Store fragments as long as none has arrived.
-        if (!initPTS[frag.cc]) {
-          unparsedVttFrags.push(data);
-          if (initPTS.length) {
-            // finish unsuccessfully, otherwise the subtitle-stream-controller could be blocked from loading new frags.
-            this.hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
-              success: false,
-              frag,
-              error: new Error('Missing initial subtitle PTS')
-            });
-          }
-          return;
-        }
         const decryptData = frag.decryptdata;
         // fragment after decryption has a stats object
         const decrypted = ('stats' in data);
@@ -21856,7 +21960,7 @@ class TimelineController {
           if (trackPlaylistMedia && trackPlaylistMedia.textCodec === IMSC1_CODEC) {
             this._parseIMSC1(frag, payload);
           } else {
-            this._parseVTTs(frag, payload, vttCCs);
+            this._parseVTTs(data);
           }
         }
       } else {
@@ -21886,21 +21990,43 @@ class TimelineController {
       });
     });
   }
-  _parseVTTs(frag, payload, vttCCs) {
+  _parseVTTs(data) {
     var _frag$initSegment;
+    const {
+      frag,
+      payload
+    } = data;
+    // We need an initial synchronisation PTS. Store fragments as long as none has arrived
+    const {
+      initPTS,
+      unparsedVttFrags
+    } = this;
+    const maxAvCC = initPTS.length - 1;
+    if (!initPTS[frag.cc] && maxAvCC === -1) {
+      unparsedVttFrags.push(data);
+      return;
+    }
     const hls = this.hls;
     // Parse the WebVTT file contents.
     const payloadWebVTT = (_frag$initSegment = frag.initSegment) != null && _frag$initSegment.data ? appendUint8Array(frag.initSegment.data, new Uint8Array(payload)) : payload;
-    parseWebVTT(payloadWebVTT, this.initPTS[frag.cc], vttCCs, frag.cc, frag.start, cues => {
+    parseWebVTT(payloadWebVTT, this.initPTS[frag.cc], this.vttCCs, frag.cc, frag.start, cues => {
       this._appendCues(cues, frag.level);
       hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
         success: true,
         frag: frag
       });
     }, error => {
-      this._fallbackToIMSC1(frag, payload);
+      const missingInitPTS = error.message === 'Missing initPTS for VTT MPEGTS';
+      if (missingInitPTS) {
+        unparsedVttFrags.push(data);
+      } else {
+        this._fallbackToIMSC1(frag, payload);
+      }
       // Something went wrong while parsing. Trigger event with success false.
       logger.log(`Failed to parse VTT cue: ${error}`);
+      if (missingInitPTS && maxAvCC > frag.cc) {
+        return;
+      }
       hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
         success: false,
         frag: frag,
@@ -21950,10 +22076,6 @@ class TimelineController {
       frag
     } = data;
     if (frag.type === PlaylistLevelType.SUBTITLE) {
-      if (!this.initPTS[frag.cc]) {
-        this.unparsedVttFrags.push(data);
-        return;
-      }
       this.onFragLoaded(Events.FRAG_LOADED, data);
     }
   }
@@ -22062,6 +22184,7 @@ function newVTTCCs() {
 /*
  * cap stream level to media size dimension controller
  */
+
 class CapLevelController {
   constructor(hls) {
     this.hls = void 0;
@@ -24085,6 +24208,7 @@ class XhrLoader {
     const stats = this.stats;
     stats.loading.first = 0;
     stats.loaded = 0;
+    stats.aborted = false;
     const xhrSetup = this.xhrSetup;
     if (xhrSetup) {
       Promise.resolve().then(() => {
@@ -24956,7 +25080,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.4.1";
+    return "1.4.13";
   }
 
   /**