hls.js 1.5.12-0.canary.10340 → 1.5.12-0.canary.10343

package/package.json

@@ -90,7 +90,7 @@
     "babel-plugin-transform-remove-console": "6.9.4",
     "chai": "4.4.1",
     "chart.js": "2.9.4",
-    "chromedriver": "125.0.2",
+    "chromedriver": "125.0.3",
     "doctoc": "2.2.1",
     "es-check": "7.2.1",
     "eslint": "8.57.0",
@@ -130,5 +130,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "3.59.0"
   },
-  "version": "1.5.12-0.canary.10340"
+  "version": "1.5.12-0.canary.10343"
 }

package/src/controller/audio-stream-controller.ts

@@ -4,7 +4,12 @@ import { Bufferable, BufferHelper } from '../utils/buffer-helper';
 import { FragmentState } from './fragment-tracker';
 import { Level } from '../types/level';
 import { PlaylistContextType, PlaylistLevelType } from '../types/loader';
-import { Fragment, ElementaryStreamTypes, Part } from '../loader/fragment';
+import {
+  Fragment,
+  ElementaryStreamTypes,
+  Part,
+  MediaFragment,
+} from '../loader/fragment';
 import ChunkCache from '../demux/chunk-cache';
 import TransmuxerInterface from '../demux/transmuxer-interface';
 import { ChunkMetadata } from '../types/transmuxer';
@@ -40,7 +45,7 @@ import type { MediaPlaylist } from '../types/media-playlist';
 const TICK_INTERVAL = 100; // how often to tick in ms
 
 type WaitingForPTSData = {
-  frag: Fragment;
+  frag: MediaFragment;
   part: Part | null;
   cache: ChunkCache;
   complete: boolean;
@@ -128,7 +133,9 @@ class AudioStreamController
     if (id === 'main') {
       const cc = frag.cc;
       this.initPTS[frag.cc] = { baseTime: initPTS, timescale };
-      this.log(`InitPTS for cc: ${cc} found from main: ${initPTS}`);
+      this.log(
+        `InitPTS for cc: ${cc} found from main: ${initPTS}/${timescale}`,
+      );
       this.videoTrackCC = cc;
       // If we are waiting, tick immediately to unblock audio fragment transmuxing
       if (this.state === State.WAITING_INIT_PTS) {
@@ -561,7 +568,8 @@ class AudioStreamController
   }
 
   _handleFragmentLoadProgress(data: FragLoadedData) {
-    const { frag, part, payload } = data;
+    const frag = data.frag as MediaFragment;
+    const { part, payload } = data;
     const { config, trackId, levels } = this;
     if (!levels) {
       this.warn(
@@ -606,7 +614,7 @@ class AudioStreamController
       const partial = partIndex !== -1;
       const chunkMeta = new ChunkMetadata(
         frag.level,
-        frag.sn as number,
+        frag.sn,
         frag.stats.chunkCount,
         payload.byteLength,
         partIndex,

package/src/controller/base-stream-controller.ts

@@ -22,7 +22,7 @@ import {
   updateFragPTSDTS,
 } from '../utils/level-helper';
 import TransmuxerInterface from '../demux/transmuxer-interface';
-import { Fragment, Part } from '../loader/fragment';
+import { Fragment, MediaFragment, Part } from '../loader/fragment';
 import FragmentLoader, {
   FragmentLoadProgressCallback,
   LoadError,
@@ -954,22 +954,24 @@ export default class BaseStreamController
       part.stats.parsing.end = now;
     }
     // See if part loading should be disabled/enabled based on buffer and playback position.
-    if (frag.sn !== 'initSegment') {
-      const levelDetails = this.getLevelDetails();
-      const loadingPartsAtEdge = levelDetails && frag.sn > levelDetails.endSN;
-      const shouldLoadParts =
-        loadingPartsAtEdge || this.shouldLoadParts(levelDetails, frag.end);
-      if (shouldLoadParts !== this.loadingParts) {
-        this.log(
-          `LL-Part loading ${
-            shouldLoadParts ? 'ON' : 'OFF'
-          } after parsing segment ending @${frag.end.toFixed(2)}`,
-        );
-        this.loadingParts = shouldLoadParts;
-      }
+    const levelDetails = this.getLevelDetails();
+    const loadingPartsAtEdge = levelDetails && frag.sn > levelDetails.endSN;
+    const shouldLoadParts =
+      loadingPartsAtEdge || this.shouldLoadParts(levelDetails, frag.end);
+    if (shouldLoadParts !== this.loadingParts) {
+      this.log(
+        `LL-Part loading ${
+          shouldLoadParts ? 'ON' : 'OFF'
+        } after parsing segment ending @${frag.end.toFixed(2)}`,
+      );
+      this.loadingParts = shouldLoadParts;
     }
-
-    this.updateLevelTiming(frag, part, level, chunkMeta.partial);
+    this.updateLevelTiming(
+      frag as MediaFragment,
+      part,
+      level,
+      chunkMeta.partial,
+    );
   }
 
   private shouldLoadParts(
@@ -999,7 +1001,7 @@ export default class BaseStreamController
 
   protected getCurrentContext(
     chunkMeta: ChunkMetadata,
-  ): { frag: Fragment; part: Part | null; level: Level } | null {
+  ): { frag: MediaFragment; part: Part | null; level: Level } | null {
     const { levels, fragCurrent } = this;
     const { level: levelIndex, sn, part: partIndex } = chunkMeta;
     if (!levels?.[levelIndex]) {
@@ -1183,7 +1185,7 @@ export default class BaseStreamController
     const { config } = this;
     const start = fragments[0].start;
     const canLoadParts = config.lowLatencyMode && !!levelDetails.partList;
-    let frag: Fragment | null = null;
+    let frag: MediaFragment | null = null;
 
     if (levelDetails.live) {
       const initialLiveManifestSize = config.initialLiveManifestSize;
@@ -1326,10 +1328,10 @@ export default class BaseStreamController
   */
   protected getInitialLiveFragment(
     levelDetails: LevelDetails,
-    fragments: Array<Fragment>,
-  ): Fragment | null {
+    fragments: MediaFragment[],
+  ): MediaFragment | null {
     const fragPrevious = this.fragPrevious;
-    let frag: Fragment | null = null;
+    let frag: MediaFragment | null = null;
     if (fragPrevious) {
       if (levelDetails.hasProgramDateTime) {
         // Prefer using PDT, because it can be accurate enough to choose the correct fragment without knowing the level sliding
@@ -1393,7 +1395,7 @@ export default class BaseStreamController
     bufferEnd: number,
     end: number,
     levelDetails: LevelDetails,
-  ): Fragment | null {
+  ): MediaFragment | null {
     const { config } = this;
     let { fragPrevious } = this;
     let { fragments, endSN } = levelDetails;
@@ -1409,10 +1411,10 @@ export default class BaseStreamController
     if (loadingParts && fragmentHint && !this.bitrateTest) {
       // Include incomplete fragment with parts at end
       fragments = fragments.concat(fragmentHint);
-      endSN = fragmentHint.sn as number;
+      endSN = fragmentHint.sn;
     }
 
-    let frag;
+    let frag: MediaFragment | null;
     if (bufferEnd < end) {
       const lookupTolerance =
         bufferEnd > end - maxFragLookUpTolerance ? 0 : maxFragLookUpTolerance;
@@ -1649,7 +1651,7 @@ export default class BaseStreamController
     }
     const gapTagEncountered = data.details === ErrorDetails.FRAG_GAP;
     if (gapTagEncountered) {
-      this.fragmentTracker.fragBuffered(frag, true);
+      this.fragmentTracker.fragBuffered(frag as MediaFragment, true);
     }
     // keep retrying until the limit will be reached
     const errorAction = data.errorAction;
@@ -1813,7 +1815,7 @@ export default class BaseStreamController
   }
 
   private updateLevelTiming(
-    frag: Fragment,
+    frag: MediaFragment,
     part: Part | null,
     level: Level,
     partial: boolean,

package/src/controller/fragment-finders.ts

@@ -1,5 +1,5 @@
 import BinarySearch from '../utils/binary-search';
-import { Fragment } from '../loader/fragment';
+import type { Fragment, MediaFragment } from '../loader/fragment';
 
 /**
  * Returns first fragment whose endPdt value exceeds the given PDT, or null.
@@ -8,10 +8,10 @@ import { Fragment } from '../loader/fragment';
  * @param maxFragLookUpTolerance - The amount of time that a fragment's start/end can be within in order to be considered contiguous
  */
 export function findFragmentByPDT(
-  fragments: Array<Fragment>,
+  fragments: MediaFragment[],
   PDTValue: number | null,
   maxFragLookUpTolerance: number,
-): Fragment | null {
+): MediaFragment | null {
   if (
     PDTValue === null ||
     !Array.isArray(fragments) ||
@@ -55,19 +55,17 @@ export function findFragmentByPDT(
  */
 export function findFragmentByPTS(
   fragPrevious: Fragment | null,
-  fragments: Array<Fragment>,
+  fragments: MediaFragment[],
   bufferEnd: number = 0,
   maxFragLookUpTolerance: number = 0,
   nextFragLookupTolerance: number = 0.005,
-): Fragment | null {
-  let fragNext: Fragment | null = null;
+): MediaFragment | null {
+  let fragNext: MediaFragment | null = null;
   if (fragPrevious) {
     fragNext =
-      fragments[
-        (fragPrevious.sn as number) - (fragments[0].sn as number) + 1
-      ] || null;
+      fragments[(fragPrevious.sn as number) - fragments[0].sn + 1] || null;
     // check for buffer-end rounding error
-    const bufferEdgeError = fragPrevious.endDTS - bufferEnd;
+    const bufferEdgeError = (fragPrevious.endDTS as number) - bufferEnd;
     if (bufferEdgeError > 0 && bufferEdgeError < 0.0000015) {
       bufferEnd += 0.0000015;
     }
@@ -135,7 +133,7 @@ function fragmentWithinFastStartSwitch(
 export function fragmentWithinToleranceTest(
   bufferEnd = 0,
   maxFragLookUpTolerance = 0,
-  candidate: Fragment,
+  candidate: MediaFragment,
 ) {
   // eagerly accept an accurate match (no tolerance)
   if (
@@ -189,7 +187,7 @@ export function fragmentWithinToleranceTest(
 export function pdtWithinToleranceTest(
   pdtBufferEnd: number,
   maxFragLookUpTolerance: number,
-  candidate: Fragment,
+  candidate: MediaFragment,
 ): boolean {
   const candidateLookupTolerance =
     Math.min(
@@ -203,9 +201,9 @@ export function pdtWithinToleranceTest(
 }
 
 export function findFragWithCC(
-  fragments: Fragment[],
+  fragments: MediaFragment[],
   cc: number,
-): Fragment | null {
+): MediaFragment | null {
   return BinarySearch.search(fragments, (candidate) => {
     if (candidate.cc < cc) {
       return 1;

package/src/controller/fragment-tracker.ts

@@ -1,5 +1,5 @@
 import { Events } from '../events';
-import { Fragment, Part } from '../loader/fragment';
+import { Fragment, MediaFragment, Part } from '../loader/fragment';
 import { PlaylistLevelType } from '../types/loader';
 import type { SourceBufferName } from '../types/buffer';
 import type {
@@ -107,7 +107,7 @@ export class FragmentTracker implements ComponentAPI {
   public getBufferedFrag(
     position: number,
     levelType: PlaylistLevelType,
-  ): Fragment | null {
+  ): MediaFragment | null {
     return this.getFragAtPos(position, levelType, true);
   }
 
@@ -115,7 +115,7 @@ export class FragmentTracker implements ComponentAPI {
     position: number,
     levelType: PlaylistLevelType,
     buffered?: boolean,
-  ): Fragment | null {
+  ): MediaFragment | null {
     const { fragments } = this;
     const keys = Object.keys(fragments);
     for (let i = keys.length; i--; ) {
@@ -149,13 +149,13 @@ export class FragmentTracker implements ComponentAPI {
     }
     // Check if any flagged fragments have been unloaded
     // excluding anything newer than appendedPartSn
-    const appendedPartSn = (appendedPart?.fragment.sn || -1) as number;
+    const appendedPartSn = appendedPart?.fragment.sn || -1;
     Object.keys(this.fragments).forEach((key) => {
       const fragmentEntity = this.fragments[key];
       if (!fragmentEntity) {
         return;
       }
-      if (appendedPartSn >= (fragmentEntity.body.sn as number)) {
+      if (appendedPartSn >= fragmentEntity.body.sn) {
         return;
       }
       if (!fragmentEntity.buffered && !fragmentEntity.loaded) {
@@ -189,11 +189,11 @@ export class FragmentTracker implements ComponentAPI {
    */
   public detectPartialFragments(data: FragBufferedData) {
     const timeRanges = this.timeRanges;
-    const { frag, part } = data;
-    if (!timeRanges || frag.sn === 'initSegment') {
+    if (!timeRanges || data.frag.sn === 'initSegment') {
       return;
     }
 
+    const frag = data.frag as MediaFragment;
     const fragKey = getFragmentKey(frag);
     const fragmentEntity = this.fragments[fragKey];
     if (!fragmentEntity || (fragmentEntity.buffered && frag.gap)) {
@@ -209,7 +209,7 @@ export class FragmentTracker implements ComponentAPI {
       const partial = isFragHint || streamInfo.partial === true;
       fragmentEntity.range[elementaryStream] = this.getBufferedTimes(
         frag,
-        part,
+        data.part,
         partial,
         timeRange,
       );
@@ -224,7 +224,7 @@ export class FragmentTracker implements ComponentAPI {
       }
       if (!isPartial(fragmentEntity)) {
         // Remove older fragment parts from lookup after frag is tracked as buffered
-        this.removeParts((frag.sn as number) - 1, frag.type);
+        this.removeParts(frag.sn - 1, frag.type);
       }
     } else {
       // remove fragment if nothing was appended
@@ -238,11 +238,11 @@ export class FragmentTracker implements ComponentAPI {
       return;
     }
     this.activePartLists[levelType] = activeParts.filter(
-      (part) => (part.fragment.sn as number) >= snToKeep,
+      (part) => part.fragment.sn >= snToKeep,
     );
   }
 
-  public fragBuffered(frag: Fragment, force?: true) {
+  public fragBuffered(frag: MediaFragment, force?: true) {
     const fragKey = getFragmentKey(frag);
     let fragmentEntity = this.fragments[fragKey];
     if (!fragmentEntity && force) {
@@ -388,15 +388,15 @@ export class FragmentTracker implements ComponentAPI {
   }
 
   private onFragLoaded(event: Events.FRAG_LOADED, data: FragLoadedData) {
-    const { frag, part } = data;
     // don't track initsegment (for which sn is not a number)
     // don't track frags used for bitrateTest, they're irrelevant.
-    if (frag.sn === 'initSegment' || frag.bitrateTest) {
+    if (data.frag.sn === 'initSegment' || data.frag.bitrateTest) {
       return;
     }
 
+    const frag = data.frag as MediaFragment;
     // Fragment entity `loaded` FragLoadedData is null when loading parts
-    const loaded = part ? null : data;
+    const loaded = data.part ? null : data;
 
     const fragKey = getFragmentKey(frag);
     this.fragments[fragKey] = {

package/src/controller/id3-track-controller.ts

@@ -9,10 +9,12 @@ import {
   isDateRangeCueAttribute,
   isSCTE35Attribute,
 } from '../loader/date-range';
+import { LevelDetails } from '../loader/level-details';
 import { MetadataSchema } from '../types/demuxer';
 import type {
   BufferFlushingData,
   FragParsingMetadataData,
+  LevelPTSUpdatedData,
   LevelUpdatedData,
   MediaAttachedData,
 } from '../types/events';
@@ -69,10 +71,6 @@ const MAX_CUE_ENDTIME = (() => {
   return Number.POSITIVE_INFINITY;
 })();
 
-function dateRangeDateToTimelineSeconds(date: Date, offset: number): number {
-  return date.getTime() / 1000 - offset;
-}
-
 function hexToArrayBuffer(str): ArrayBuffer {
   return Uint8Array.from(
     str
@@ -100,7 +98,7 @@ class ID3TrackController implements ComponentAPI {
     this._registerListeners();
   }
 
-  destroy() {
+  public destroy() {
     this._unregisterListeners();
     this.id3Track = null;
     this.media = null;
@@ -117,6 +115,7 @@ class ID3TrackController implements ComponentAPI {
     hls.on(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
     hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
+    hls.on(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
   }
 
   private _unregisterListeners() {
@@ -127,17 +126,18 @@ class ID3TrackController implements ComponentAPI {
     hls.off(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
     hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
+    hls.off(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
   }
 
   // Add ID3 metatadata text track.
-  protected onMediaAttached(
+  private onMediaAttached(
     event: Events.MEDIA_ATTACHED,
     data: MediaAttachedData,
   ): void {
     this.media = data.media;
   }
 
-  protected onMediaDetaching(): void {
+  private onMediaDetaching(): void {
     if (this.id3Track) {
       clearCurrentCues(this.id3Track);
       this.id3Track = null;
@@ -150,13 +150,13 @@ class ID3TrackController implements ComponentAPI {
     this.dateRangeCuesAppended = {};
   }
 
-  createTrack(media: HTMLMediaElement): TextTrack {
+  private createTrack(media: HTMLMediaElement): TextTrack {
     const track = this.getID3Track(media.textTracks) as TextTrack;
     track.mode = 'hidden';
     return track;
   }
 
-  getID3Track(textTracks: TextTrackList): TextTrack | void {
+  private getID3Track(textTracks: TextTrackList): TextTrack | void {
     if (!this.media) {
       return;
     }
@@ -173,7 +173,7 @@ class ID3TrackController implements ComponentAPI {
     return this.media.addTextTrack('metadata', 'id3');
   }
 
-  onFragParsingMetadata(
+  private onFragParsingMetadata(
     event: Events.FRAG_PARSING_METADATA,
     data: FragParsingMetadataData,
   ) {
@@ -247,7 +247,7 @@ class ID3TrackController implements ComponentAPI {
     }
   }
 
-  updateId3CueEnds(startTime: number, type: MetadataSchema) {
+  private updateId3CueEnds(startTime: number, type: MetadataSchema) {
     const cues = this.id3Track?.cues;
     if (cues) {
       for (let i = cues.length; i--; ) {
@@ -263,7 +263,7 @@ class ID3TrackController implements ComponentAPI {
     }
   }
 
-  onBufferFlushing(
+  private onBufferFlushing(
     event: Events.BUFFER_FLUSHING,
     { startOffset, endOffset, type }: BufferFlushingData,
   ) {
@@ -295,7 +295,23 @@ class ID3TrackController implements ComponentAPI {
     }
   }
 
-  onLevelUpdated(event: Events.LEVEL_UPDATED, { details }: LevelUpdatedData) {
+  private onLevelUpdated(
+    event: Events.LEVEL_UPDATED,
+    { details }: LevelUpdatedData,
+  ) {
+    this.updateDateRangeCues(details, true);
+  }
+
+  private onLevelPtsUpdated(
+    event: Events.LEVEL_PTS_UPDATED,
+    data: LevelPTSUpdatedData,
+  ) {
+    if (Math.abs(data.drift) > 0.01) {
+      this.updateDateRangeCues(data.details);
+    }
+  }
+
+  private updateDateRangeCues(details: LevelDetails, removeOldCues?: true) {
     if (
       !this.media ||
       !details.hasProgramDateTime ||
@@ -307,7 +323,7 @@ class ID3TrackController implements ComponentAPI {
     const { dateRanges } = details;
     const ids = Object.keys(dateRanges);
     // Remove cues from track not found in details.dateRanges
-    if (id3Track) {
+    if (id3Track && removeOldCues) {
       const idsToRemove = Object.keys(dateRangeCuesAppended).filter(
         (id) => !ids.includes(id),
       );
@@ -329,26 +345,20 @@ class ID3TrackController implements ComponentAPI {
       this.id3Track = this.createTrack(this.media);
     }
 
-    const dateTimeOffset =
-      (lastFragment.programDateTime as number) / 1000 - lastFragment.start;
     const Cue = getCueClass();
-
     for (let i = 0; i < ids.length; i++) {
       const id = ids[i];
       const dateRange = dateRanges[id];
-      const startTime = dateRangeDateToTimelineSeconds(
-        dateRange.startDate,
-        dateTimeOffset,
-      );
+      const startTime = dateRange.startTime;
 
       // Process DateRanges to determine end-time (known DURATION, END-DATE, or END-ON-NEXT)
       const appendedDateRangeCues = dateRangeCuesAppended[id];
       const cues = appendedDateRangeCues?.cues || {};
       let durationKnown = appendedDateRangeCues?.durationKnown || false;
       let endTime = MAX_CUE_ENDTIME;
-      const endDate = dateRange.endDate;
-      if (endDate) {
-        endTime = dateRangeDateToTimelineSeconds(endDate, dateTimeOffset);
+      const { duration, endDate } = dateRange;
+      if (endDate && duration !== null) {
+        endTime = startTime + duration;
         durationKnown = true;
       } else if (dateRange.endOnNext && !durationKnown) {
         const nextDateRangeWithSameClass = ids.reduce(
@@ -369,10 +379,7 @@ class ID3TrackController implements ComponentAPI {
           null,
         );
         if (nextDateRangeWithSameClass) {
-          endTime = dateRangeDateToTimelineSeconds(
-            nextDateRangeWithSameClass.startDate,
-            dateTimeOffset,
-          );
+          endTime = nextDateRangeWithSameClass.startTime;
           durationKnown = true;
         }
       }
@@ -389,6 +396,9 @@ class ID3TrackController implements ComponentAPI {
         if (cue) {
           if (durationKnown && !appendedDateRangeCues.durationKnown) {
             cue.endTime = endTime;
+          } else if (Math.abs(cue.startTime - startTime) > 0.01) {
+            cue.startTime = startTime;
+            cue.endTime = endTime;
           }
         } else if (Cue) {
           let data = dateRange.attr[key];

package/src/controller/stream-controller.ts

@@ -4,7 +4,11 @@ import { Events } from '../events';
 import { BufferHelper, BufferInfo } from '../utils/buffer-helper';
 import { FragmentState } from './fragment-tracker';
 import { PlaylistContextType, PlaylistLevelType } from '../types/loader';
-import { ElementaryStreamTypes, Fragment } from '../loader/fragment';
+import {
+  ElementaryStreamTypes,
+  Fragment,
+  MediaFragment,
+} from '../loader/fragment';
 import TransmuxerInterface from '../demux/transmuxer-interface';
 import { ChunkMetadata } from '../types/transmuxer';
 import GapController, { MAX_START_GAP_JUMP } from './gap-controller';
@@ -691,7 +695,8 @@ export default class StreamController
   }
 
   protected _handleFragmentLoadProgress(data: FragLoadedData) {
-    const { frag, part, payload } = data;
+    const frag = data.frag as MediaFragment;
+    const { part, payload } = data;
     const { levels } = this;
     if (!levels) {
       this.warn(
@@ -729,7 +734,7 @@ export default class StreamController
     const partial = partIndex !== -1;
     const chunkMeta = new ChunkMetadata(
       frag.level,
-      frag.sn as number,
+      frag.sn,
       frag.stats.chunkCount,
       payload.byteLength,
       partIndex,
@@ -1113,7 +1118,7 @@ export default class StreamController
     }
 
     // Avoid buffering if backtracking this fragment
-    if (video && details && frag.sn !== 'initSegment') {
+    if (video && details) {
       const prevFrag = details.fragments[frag.sn - 1 - details.startSN];
       const isFirstFragment = frag.sn === details.startSN;
       const isFirstInDiscontinuity = !prevFrag || frag.cc > prevFrag.cc;

package/src/controller/subtitle-stream-controller.ts

@@ -18,7 +18,7 @@ import type Hls from '../hls';
 import type { FragmentTracker } from './fragment-tracker';
 import type KeyLoader from '../loader/key-loader';
 import type { LevelDetails } from '../loader/level-details';
-import type { Fragment } from '../loader/fragment';
+import type { Fragment, MediaFragment } from '../loader/fragment';
 import type {
   ErrorData,
   FragLoadedData,
@@ -156,7 +156,7 @@ export class SubtitleStreamController
       };
       buffered.push(timeRange);
     }
-    this.fragmentTracker.fragBuffered(frag);
+    this.fragmentTracker.fragBuffered(frag as MediaFragment);
     this.fragBufferedComplete(frag, null);
   }
 
@@ -206,7 +206,7 @@ export class SubtitleStreamController
 
     if (frag?.type === PlaylistLevelType.SUBTITLE) {
       if (data.details === ErrorDetails.FRAG_GAP) {
-        this.fragmentTracker.fragBuffered(frag, true);
+        this.fragmentTracker.fragBuffered(frag as MediaFragment, true);
       }
       if (this.fragCurrent) {
         this.fragCurrent.abortRequests();

package/src/demux/transmuxer-interface.ts

@@ -13,7 +13,7 @@ import Transmuxer, {
 import { logger } from '../utils/logger';
 import { ErrorTypes, ErrorDetails } from '../errors';
 import { EventEmitter } from 'eventemitter3';
-import { Fragment, Part } from '../loader/fragment';
+import { MediaFragment, Part } from '../loader/fragment';
 import { getM2TSSupportedAudioTypes } from '../utils/codecs';
 import type { ChunkMetadata, TransmuxerResult } from '../types/transmuxer';
 import type Hls from '../hls';
@@ -26,7 +26,7 @@ export default class TransmuxerInterface {
   private hls: Hls;
   private id: PlaylistLevelType;
   private observer: HlsEventEmitter;
-  private frag: Fragment | null = null;
+  private frag: MediaFragment | null = null;
   private part: Part | null = null;
   private useWorker: boolean;
   private workerContext: WorkerContext | null = null;
@@ -173,7 +173,7 @@ export default class TransmuxerInterface {
     initSegmentData: Uint8Array | undefined,
     audioCodec: string | undefined,
     videoCodec: string | undefined,
-    frag: Fragment,
+    frag: MediaFragment,
     part: Part | null,
     duration: number,
     accurateTimeOffset: boolean,
@@ -189,7 +189,7 @@ export default class TransmuxerInterface {
 
     const discontinuity = !(lastFrag && frag.cc === lastFrag.cc);
     const trackSwitch = !(lastFrag && chunkMeta.level === lastFrag.level);
-    const snDiff = lastFrag ? chunkMeta.sn - (lastFrag.sn as number) : -1;
+    const snDiff = lastFrag ? chunkMeta.sn - lastFrag.sn : -1;
     const partDiff = this.part ? chunkMeta.part - this.part.index : -1;
     const progressive =
       snDiff === 0 &&

package/src/hls.ts

@@ -1068,7 +1068,7 @@ export type {
   KeySystems,
   KeySystemFormats,
 } from './utils/mediakeys-helper';
-export type { DateRange } from './loader/date-range';
+export type { DateRange, DateRangeCue } from './loader/date-range';
 export type { LoadStats } from './loader/load-stats';
 export type { LevelKey } from './loader/level-key';
 export type { LevelDetails } from './loader/level-details';
@@ -1118,6 +1118,7 @@ export type { ChunkMetadata } from './types/transmuxer';
 export type {
   BaseSegment,
   Fragment,
+  MediaFragment,
   Part,
   ElementaryStreams,
   ElementaryStreamTypes,
@@ -1184,3 +1185,4 @@ export type {
   IErrorAction,
 } from './controller/error-controller';
 export type { AttrList } from './utils/attr-list';
+export type { ParsedMultivariantPlaylist } from './loader/m3u8-parser';