hls.js 1.5.14-0.canary.10559 → 1.5.15

package/dist/hls.js.d.ts

@@ -6,7 +6,7 @@ export declare interface AbrComponentAPI extends ComponentAPI {
     resetEstimator(abrEwmaDefaultEstimate: number): any;
 }
 
-export declare class AbrController extends Logger implements AbrComponentAPI {
+export declare class AbrController implements AbrComponentAPI {
     protected hls: Hls;
     private lastLevelLoadSec;
     private lastLoadedFragLevel;
@@ -69,7 +69,7 @@ export declare type ABRControllerConfig = {
 
 export declare class AttrList {
     [key: string]: any;
-    constructor(attrs: string | Record<string, any>, parsed?: Pick<ParsedMultivariantPlaylist | LevelDetails, 'variableList' | 'hasVariableRefs' | 'playlistParsingError'>);
+    constructor(attrs: string | Record<string, any>);
     get clientAttrs(): string[];
     decimalInteger(attrName: string): number;
     hexadecimalInteger(attrName: string): Uint8Array | null;
@@ -77,17 +77,12 @@ export declare class AttrList {
     decimalFloatingPoint(attrName: string): number;
     optionalFloat(attrName: string, defaultValue: number): number;
     enumeratedString(attrName: string): string | undefined;
-    enumeratedStringList<T extends {
-        [key: string]: boolean;
-    }>(attrName: string, dict: T): {
-        [key in keyof T]: boolean;
-    };
     bool(attrName: string): boolean;
     decimalResolution(attrName: string): {
         width: number;
         height: number;
     } | undefined;
-    static parseAttrList(input: string, parsed?: Pick<ParsedMultivariantPlaylist | LevelDetails, 'variableList' | 'hasVariableRefs' | 'playlistParsingError'>): Record<string, string>;
+    static parseAttrList(input: string): Record<string, any>;
 }
 
 export declare type AudioPlaylistType = 'AUDIO';
@@ -104,8 +99,9 @@ export declare type AudioSelectionOption = {
 };
 
 export declare class AudioStreamController extends BaseStreamController implements NetworkComponentAPI {
-    private videoAnchor;
-    private mainFragLoading;
+    private videoBuffer;
+    private videoTrackCC;
+    private waitingVideoCC;
     private bufferedTrack;
     private switchingTrack;
     private trackId;
@@ -116,29 +112,28 @@ export declare class AudioStreamController extends BaseStreamController implemen
     private cachedTrackLoadedData;
     constructor(hls: Hls, fragmentTracker: FragmentTracker, keyLoader: KeyLoader);
     protected onHandlerDestroying(): void;
-    protected registerListeners(): void;
-    protected unregisterListeners(): void;
+    private _registerListeners;
+    private _unregisterListeners;
     onInitPtsFound(event: Events.INIT_PTS_FOUND, { frag, id, initPTS, timescale }: InitPTSFoundData): void;
-    private findSyncFrag;
     startLoad(startPosition: number): void;
     doTick(): void;
     clearWaitingFragment(): void;
     protected resetLoadingState(): void;
     protected onTickEnd(): void;
     private doTickIdle;
-    protected onMediaDetaching(): void;
-    private onAudioTracksUpdated;
-    private onAudioTrackSwitching;
-    protected onManifestLoading(): void;
-    private onLevelLoaded;
-    private onAudioTrackLoaded;
+    protected getMaxBufferLength(mainBufferLength?: number): number;
+    onMediaDetaching(): void;
+    onAudioTracksUpdated(event: Events.AUDIO_TRACKS_UPDATED, { audioTracks }: AudioTracksUpdatedData): void;
+    onAudioTrackSwitching(event: Events.AUDIO_TRACK_SWITCHING, data: AudioTrackSwitchingData): void;
+    onManifestLoading(): void;
+    onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData): void;
+    onAudioTrackLoaded(event: Events.AUDIO_TRACK_LOADED, data: TrackLoadedData): void;
     _handleFragmentLoadProgress(data: FragLoadedData): void;
     protected _handleFragmentLoadComplete(fragLoadedData: FragLoadedData): void;
-    private onBufferReset;
-    private onBufferCreated;
-    private onFragLoading;
-    private onFragBuffered;
-    protected onError(event: Events.ERROR, data: ErrorData): void;
+    onBufferReset(): void;
+    onBufferCreated(event: Events.BUFFER_CREATED, data: BufferCreatedData): void;
+    onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData): void;
+    private onError;
     private onBufferFlushing;
     private onBufferFlushed;
     private _handleTransmuxComplete;
@@ -193,11 +188,13 @@ export declare interface BackBufferData {
     bufferEnd: number;
 }
 
-export declare class BasePlaylistController extends Logger implements NetworkComponentAPI {
+export declare class BasePlaylistController implements NetworkComponentAPI {
     protected hls: Hls;
     protected timer: number;
     protected requestScheduled: number;
     protected canLoad: boolean;
+    protected log: (msg: any) => void;
+    protected warn: (msg: any) => void;
     constructor(hls: Hls, logPrefix: string);
     destroy(): void;
     protected clearTimer(): void;
@@ -229,7 +226,7 @@ export declare class BaseSegment {
 
 export declare class BaseStreamController extends TaskLoop implements NetworkComponentAPI {
     protected hls: Hls;
-    protected fragPrevious: MediaFragment | null;
+    protected fragPrevious: Fragment | null;
     protected fragCurrent: Fragment | null;
     protected fragmentTracker: FragmentTracker;
     protected transmuxer: TransmuxerInterface | null;
@@ -252,26 +249,22 @@ export declare class BaseStreamController extends TaskLoop implements NetworkCom
     protected startFragRequested: boolean;
     protected decrypter: Decrypter;
     protected initPTS: RationalTimestamp[];
-    protected buffering: boolean;
-    protected loadingParts: boolean;
-    private loopSn?;
+    protected onvseeking: EventListener | null;
+    protected onvended: EventListener | null;
+    private readonly logPrefix;
+    protected log: (msg: any) => void;
+    protected warn: (msg: any) => void;
     constructor(hls: Hls, fragmentTracker: FragmentTracker, keyLoader: KeyLoader, logPrefix: string, playlistType: PlaylistLevelType);
-    protected registerListeners(): void;
-    protected unregisterListeners(): void;
     protected doTick(): void;
     protected onTickEnd(): void;
     startLoad(startPosition: number): void;
     stopLoad(): void;
-    pauseBuffering(): void;
-    resumeBuffering(): void;
     protected _streamEnded(bufferInfo: BufferInfo, levelDetails: LevelDetails): boolean;
     protected getLevelDetails(): LevelDetails | undefined;
     protected onMediaAttached(event: Events.MEDIA_ATTACHED, data: MediaAttachedData): void;
     protected onMediaDetaching(): void;
-    protected onManifestLoading(): void;
-    protected onError(event: Events.ERROR, data: ErrorData): void;
-    protected onMediaSeeking: () => void;
-    protected onMediaEnded: () => void;
+    protected onMediaSeeking(): void;
+    protected onMediaEnded(): void;
     protected onManifestLoaded(event: Events.MANIFEST_LOADED, data: ManifestLoadedData): void;
     protected onHandlerDestroying(): void;
     protected onHandlerDestroyed(): void;
@@ -291,16 +284,15 @@ export declare class BaseStreamController extends TaskLoop implements NetworkCom
     private doFragPartsLoad;
     private handleFragLoadError;
     protected _handleTransmuxerFlush(chunkMeta: ChunkMetadata): void;
-    private shouldLoadParts;
     protected getCurrentContext(chunkMeta: ChunkMetadata): {
-        frag: MediaFragment;
+        frag: Fragment;
         part: Part | null;
         level: Level;
     } | null;
     protected bufferFragmentData(data: RemuxedTrack, frag: Fragment, part: Part | null, chunkMeta: ChunkMetadata, noBacktracking?: boolean): void;
     protected flushBufferGap(frag: Fragment): void;
     protected getFwdBufferInfo(bufferable: Bufferable | null, type: PlaylistLevelType): BufferInfo | null;
-    private getFwdBufferInfoAtPos;
+    protected getFwdBufferInfoAtPos(bufferable: Bufferable | null, pos: number, type: PlaylistLevelType): BufferInfo | null;
     protected getMaxBufferLength(levelBitrate?: number): number;
     protected reduceMaxBufferLength(threshold: number, fragDuration: number): boolean;
     protected getAppendedFrag(position: number, playlistType?: PlaylistLevelType): Fragment | null;
@@ -310,8 +302,8 @@ export declare class BaseStreamController extends TaskLoop implements NetworkCom
     mapToInitFragWhenRequired(frag: Fragment | null): typeof frag;
     getNextPart(partList: Part[], frag: Fragment, targetBufferTime: number): number;
     private loadedEndOfParts;
-    protected getInitialLiveFragment(levelDetails: LevelDetails, fragments: MediaFragment[]): MediaFragment | null;
-    protected getFragmentAtPosition(bufferEnd: number, end: number, levelDetails: LevelDetails): MediaFragment | null;
+    protected getInitialLiveFragment(levelDetails: LevelDetails, fragments: Array<Fragment>): Fragment | null;
+    protected getFragmentAtPosition(bufferEnd: number, end: number, levelDetails: LevelDetails): Fragment | null;
     protected synchronizeToLiveEdge(levelDetails: LevelDetails): void;
     protected alignPlaylists(details: LevelDetails, previousDetails: LevelDetails | undefined, switchDetails: LevelDetails | undefined): number;
     protected waitForCdnTuneIn(details: LevelDetails): boolean | 0;
@@ -328,8 +320,6 @@ export declare class BaseStreamController extends TaskLoop implements NetworkCom
     protected resetWhenMissingContext(chunkMeta: ChunkMetadata): void;
     protected removeUnbufferedFrags(start?: number): void;
     private updateLevelTiming;
-    private playlistLabel;
-    private fragInfo;
     protected resetTransmuxer(): void;
     protected recoverWorkerError(data: ErrorData): void;
     set state(nextState: string);
@@ -363,20 +353,17 @@ export declare interface BufferCodecsData {
     audio?: Track;
 }
 
-export declare class BufferController extends Logger implements ComponentAPI {
+export declare class BufferController implements ComponentAPI {
     private details;
     private _objectUrl;
     private operationQueue;
     private listeners;
     private hls;
-    private fragmentTracker;
     bufferCodecEventsExpected: number;
     private _bufferCodecEventsTotal;
     media: HTMLMediaElement | null;
     mediaSource: MediaSource | null;
     private lastMpegAudioChunk;
-    private blockedAudioAppend;
-    private lastVideoAppendEnd;
     private appendSource;
     appendErrors: {
         audio: number;
@@ -386,7 +373,10 @@ export declare class BufferController extends Logger implements ComponentAPI {
     tracks: TrackSet;
     pendingTracks: TrackSet;
     sourceBuffer: SourceBuffers;
-    constructor(hls: Hls, fragmentTracker: FragmentTracker);
+    protected log: (msg: any) => void;
+    protected warn: (msg: any, obj?: any) => void;
+    protected error: (msg: any, obj?: any) => void;
+    constructor(hls: Hls);
     hasSourceTypes(): boolean;
     destroy(): void;
     protected registerListeners(): void;
@@ -401,18 +391,13 @@ export declare class BufferController extends Logger implements ComponentAPI {
     protected onBufferReset(): void;
     private resetBuffer;
     protected onBufferCodecs(event: Events.BUFFER_CODECS, data: BufferCodecsData): void;
-    protected appendChangeType(type: SourceBufferName, mimeType: string): void;
-    private blockAudio;
-    private unblockAudio;
+    protected appendChangeType(type: any, mimeType: any): void;
     protected onBufferAppending(event: Events.BUFFER_APPENDING, eventData: BufferAppendingData): void;
-    private getFlushOp;
     protected onBufferFlushing(event: Events.BUFFER_FLUSHING, data: BufferFlushingData): void;
     protected onFragParsed(event: Events.FRAG_PARSED, data: FragParsedData): void;
     private onFragChanged;
     protected onBufferEos(event: Events.BUFFER_EOS, data: BufferEOSData): void;
     protected onLevelUpdated(event: Events.LEVEL_UPDATED, { details }: LevelUpdatedData): void;
-    private onError;
-    private resetAppendErrors;
     trimBuffers(): void;
     flushBackBuffer(currentTime: number, targetDuration: number, targetBackBufferPosition: number): void;
     flushFrontBuffer(currentTime: number, targetDuration: number, targetFrontBufferPosition: number): void;
@@ -421,8 +406,8 @@ export declare class BufferController extends Logger implements ComponentAPI {
      * 'liveDurationInfinity` is set to `true`
      * More details: https://github.com/video-dev/hls.js/issues/355
      */
-    private getDurationAndRange;
-    private updateMediaSource;
+    private updateMediaElementDuration;
+    updateSeekableRange(levelDetails: any): void;
     protected checkPendingTracks(): void;
     protected createSourceBuffers(tracks: TrackSet): void;
     private _onMediaSourceOpen;
@@ -617,8 +602,6 @@ export declare class CMCDController implements ComponentAPI {
      * Apply CMCD data to a segment request
      */
     private applyFragmentData;
-    private getNextFrag;
-    private getNextPart;
     /**
      * The CMCD object type.
      */
@@ -652,12 +635,13 @@ export declare interface ComponentAPI {
     destroy(): void;
 }
 
-export declare class ContentSteeringController extends Logger implements NetworkComponentAPI {
+export declare class ContentSteeringController implements NetworkComponentAPI {
     private readonly hls;
+    private log;
     private loader;
     private uri;
     private pathwayId;
-    private _pathwayPriority;
+    private pathwayPriority;
     private timeToLoad;
     private reloadTimer;
     private updated;
@@ -670,9 +654,6 @@ export declare class ContentSteeringController extends Logger implements Network
     constructor(hls: Hls);
     private registerListeners;
     private unregisterListeners;
-    pathways(): string[];
-    get pathwayPriority(): string[] | null;
-    set pathwayPriority(pathwayPriority: string[]);
     startLoad(): void;
     stopLoad(): void;
     clearTimeout(): void;
@@ -708,32 +689,20 @@ export declare interface CuesParsedData {
 
 export declare class DateRange {
     attr: AttrList;
-    tagAnchor: Fragment | null;
-    tagOrder: number;
     private _startDate;
     private _endDate?;
-    private _cue?;
     private _badValueForSameId?;
-    constructor(dateRangeAttr: AttrList, dateRangeWithSameId?: DateRange | undefined, tagCount?: number);
+    constructor(dateRangeAttr: AttrList, dateRangeWithSameId?: DateRange);
     get id(): string;
     get class(): string;
-    get cue(): DateRangeCue;
-    get startTime(): number;
     get startDate(): Date;
     get endDate(): Date | null;
     get duration(): number | null;
     get plannedDuration(): number | null;
     get endOnNext(): boolean;
-    get isInterstitial(): boolean;
     get isValid(): boolean;
 }
 
-export declare type DateRangeCue = {
-    pre: boolean;
-    post: boolean;
-    once: boolean;
-};
-
 declare interface DecryptData {
     uri: string;
     method: string;
@@ -758,7 +727,6 @@ declare class Decrypter {
     private currentIV;
     private currentResult;
     private useSoftware;
-    private enableSoftwareAES;
     constructor(config: HlsConfig, { removePKCS7Padding }?: {
         removePKCS7Padding?: boolean | undefined;
     });
@@ -766,19 +734,14 @@ declare class Decrypter {
     isSync(): boolean;
     flush(): Uint8Array | null;
     reset(): void;
-    decrypt(data: Uint8Array | ArrayBuffer, key: ArrayBuffer, iv: ArrayBuffer, aesMode: DecrypterAesMode): Promise<ArrayBuffer>;
-    softwareDecrypt(data: Uint8Array, key: ArrayBuffer, iv: ArrayBuffer, aesMode: DecrypterAesMode): ArrayBuffer | null;
-    webCryptoDecrypt(data: Uint8Array, key: ArrayBuffer, iv: ArrayBuffer, aesMode: DecrypterAesMode): Promise<ArrayBuffer>;
+    decrypt(data: Uint8Array | ArrayBuffer, key: ArrayBuffer, iv: ArrayBuffer): Promise<ArrayBuffer>;
+    softwareDecrypt(data: Uint8Array, key: ArrayBuffer, iv: ArrayBuffer): ArrayBuffer | null;
+    webCryptoDecrypt(data: Uint8Array, key: ArrayBuffer, iv: ArrayBuffer): Promise<ArrayBuffer>;
     private onWebCryptoError;
     private getValidChunk;
     private logOnce;
 }
 
-declare const enum DecrypterAesMode {
-    cbc = 0,
-    ctr = 1
-}
-
 declare type DRMSystemConfiguration = {
     licenseUrl: string;
     serverCertificateUrl?: string;
@@ -824,7 +787,7 @@ export declare const enum ElementaryStreamTypes {
  * @class
  * @constructor
  */
-export declare class EMEController extends Logger implements ComponentAPI {
+export declare class EMEController implements ComponentAPI {
     static CDMCleanupPromise: Promise<void> | void;
     private readonly hls;
     private readonly config;
@@ -835,6 +798,12 @@ export declare class EMEController extends Logger implements ComponentAPI {
     private mediaKeySessions;
     private keyIdToKeySessionPromise;
     private setMediaKeysQueue;
+    private onMediaEncrypted;
+    private onWaitingForKey;
+    private debug;
+    private log;
+    private warn;
+    private error;
     constructor(hls: Hls);
     destroy(): void;
     private registerListeners;
@@ -855,8 +824,8 @@ export declare class EMEController extends Logger implements ComponentAPI {
     private handleError;
     private getKeySystemForKeyPromise;
     private getKeySystemSelectionPromise;
-    private onMediaEncrypted;
-    private onWaitingForKey;
+    private _onMediaEncrypted;
+    private _onWaitingForKey;
     private attemptSetMediaKeys;
     private generateRequestWithPreferredKeySession;
     private onKeyStatusChange;
@@ -890,10 +859,13 @@ export declare const enum ErrorActionFlags {
     SwitchToSDR = 4
 }
 
-export declare class ErrorController extends Logger implements NetworkComponentAPI {
+export declare class ErrorController implements NetworkComponentAPI {
     private readonly hls;
     private playlistError;
     private penalizedRenditions;
+    private log;
+    private warn;
+    private error;
     constructor(hls: Hls);
     private registerListeners;
     private unregisterListeners;
@@ -987,7 +959,6 @@ export declare enum ErrorDetails {
     BUFFER_NUDGE_ON_STALL = "bufferNudgeOnStall",
     INTERNAL_EXCEPTION = "internalException",
     INTERNAL_ABORTED = "aborted",
-    ATTACH_MEDIA_ERROR = "attachMediaError",
     UNKNOWN = "unknown"
 }
 
@@ -1004,7 +975,6 @@ export declare enum Events {
     MEDIA_ATTACHED = "hlsMediaAttached",
     MEDIA_DETACHING = "hlsMediaDetaching",
     MEDIA_DETACHED = "hlsMediaDetached",
-    MEDIA_ENDED = "hlsMediaEnded",
     BUFFER_RESET = "hlsBufferReset",
     BUFFER_CODECS = "hlsBufferCodecs",
     BUFFER_CREATED = "hlsBufferCreated",
@@ -1098,7 +1068,6 @@ export declare class FPSController implements ComponentAPI {
     protected unregisterListeners(): void;
     destroy(): void;
     protected onMediaAttaching(event: Events.MEDIA_ATTACHING, data: MediaAttachingData): void;
-    private onMediaDetaching;
     checkFPS(video: HTMLVideoElement, decodedFrames: number, droppedFrames: number): void;
     checkFPSInterval(): void;
 }
@@ -1191,8 +1160,8 @@ export declare class Fragment extends BaseSegment {
     cc: number;
     startPTS?: number;
     endPTS?: number;
-    startDTS?: number;
-    endDTS?: number;
+    startDTS: number;
+    endDTS: number;
     start: number;
     deltaPTS?: number;
     maxStartPTS?: number;
@@ -1280,21 +1249,20 @@ declare class FragmentTracker implements ComponentAPI {
      * A buffered Fragment is one whose loading, parsing and appending is done (completed or "partial" meaning aborted).
      * If not found any Fragment, return null
      */
-    getBufferedFrag(position: number, levelType: PlaylistLevelType): MediaFragment | null;
-    getFragAtPos(position: number, levelType: PlaylistLevelType, buffered?: boolean): MediaFragment | null;
+    getBufferedFrag(position: number, levelType: PlaylistLevelType): Fragment | null;
     /**
      * Partial fragments effected by coded frame eviction will be removed
      * 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: SourceBufferName, timeRange: TimeRanges, playlistType: PlaylistLevelType, appendedPart?: Part | null, removeAppending?: boolean): void;
+    detectEvictedFragments(elementaryStream: SourceBufferName, timeRange: TimeRanges, playlistType: PlaylistLevelType, appendedPart?: Part | null): void;
     /**
      * Checks if the fragment passed in is loaded in the buffer properly
      * Partially loaded fragments will be registered as a partial fragment
      */
     detectPartialFragments(data: FragBufferedData): void;
     private removeParts;
-    fragBuffered(frag: MediaFragment, force?: true): void;
+    fragBuffered(frag: Fragment, force?: true): void;
     private getBufferedTimes;
     /**
      * Gets the partial fragment for a certain time
@@ -1303,12 +1271,10 @@ declare class FragmentTracker implements ComponentAPI {
     isEndListAppended(type: PlaylistLevelType): boolean;
     getState(fragment: Fragment): FragmentState;
     private isTimeBuffered;
-    private onManifestLoading;
     private onFragLoaded;
     private onBufferAppended;
     private onFragBuffered;
     private hasFragment;
-    hasFragments(type?: PlaylistLevelType): boolean;
     hasParts(type: PlaylistLevelType): boolean;
     removeFragmentsInRange(start: number, end: number, playlistType: PlaylistLevelType, withGapOnly?: boolean, unbufferedOnly?: boolean): void;
     removeFragment(fragment: Fragment): void;
@@ -1355,12 +1321,9 @@ declare class Hls implements HlsEventEmitter {
      * The configuration object provided on player instantiation.
      */
     readonly userConfig: Partial<HlsConfig>;
-    /**
-     * The logger functions used by this player instance, configured on player instantiation.
-     */
-    readonly logger: ILogger;
     private coreComponents;
     private networkControllers;
+    private started;
     private _emitter;
     private _autoLevelCapping;
     private _maxHdcpLevel;
@@ -1375,7 +1338,7 @@ declare class Hls implements HlsEventEmitter {
     private emeController;
     private cmcdController;
     private _media;
-    private _url;
+    private url;
     private triggeringException?;
     /**
      * Get the video-dev/hls.js package version.
@@ -1434,10 +1397,6 @@ declare class Hls implements HlsEventEmitter {
      * Set the source URL. Can be relative or absolute.
      */
     loadSource(url: string): void;
-    /**
-     * Gets the currently loaded URL
-     */
-    get url(): string | null;
     /**
      * Start loading data from the stream source.
      * Depending on default config, client starts loading automatically when a source is set.
@@ -1451,11 +1410,11 @@ declare class Hls implements HlsEventEmitter {
      */
     stopLoad(): void;
     /**
-     * Resumes stream controller segment loading after `pauseBuffering` has been called.
+     * Resumes stream controller segment loading if previously started.
      */
     resumeBuffering(): void;
     /**
-     * Prevents stream controller from loading new segments until `resumeBuffering` is called.
+     * Stops stream controller segment loading without changing 'started' state like stopLoad().
      * This allows for media buffering to be paused without interupting playlist loading.
      */
     pauseBuffering(): void;
@@ -1600,7 +1559,6 @@ declare class Hls implements HlsEventEmitter {
      */
     get playingDate(): Date | null;
     get mainForwardBufferInfo(): BufferInfo | null;
-    get maxBufferLength(): number;
     /**
      * Find and select the best matching audio track, making a level switch when a Group change is necessary.
      * Updates `hls.config.audioPreference`. Returns the selected track, or null when no matching track is found.
@@ -1680,7 +1638,6 @@ declare class Hls implements HlsEventEmitter {
      * target distance from the edge as calculated by the latency controller
      */
     get targetLatency(): number | null;
-    set targetLatency(latency: number);
     /**
      * the rate at which the edge of the current live playlist is advancing or 1 if there is none
      */
@@ -1689,11 +1646,6 @@ declare class Hls implements HlsEventEmitter {
      * set to true when startLoad is called before MANIFEST_PARSED event
      */
     get forceStartLoad(): boolean;
-    /**
-     * ContentSteering pathwayPriority getter/setter
-     */
-    get pathwayPriority(): string[] | null;
-    set pathwayPriority(pathwayPriority: string[]);
 }
 export default Hls;
 
@@ -1754,7 +1706,6 @@ export declare interface HlsListeners {
     [Events.MEDIA_ATTACHED]: (event: Events.MEDIA_ATTACHED, data: MediaAttachedData) => void;
     [Events.MEDIA_DETACHING]: (event: Events.MEDIA_DETACHING) => void;
     [Events.MEDIA_DETACHED]: (event: Events.MEDIA_DETACHED) => void;
-    [Events.MEDIA_ENDED]: (event: Events.MEDIA_ENDED, data: MediaEndedData) => void;
     [Events.BUFFER_RESET]: (event: Events.BUFFER_RESET) => void;
     [Events.BUFFER_CODECS]: (event: Events.BUFFER_CODECS, data: BufferCodecsData) => void;
     [Events.BUFFER_CREATED]: (event: Events.BUFFER_CREATED, data: BufferCreatedData) => void;
@@ -1865,8 +1816,8 @@ export declare interface ILogger {
 }
 
 export declare interface InitPTSFoundData {
-    id: PlaylistLevelType;
-    frag: MediaFragment;
+    id: string;
+    frag: Fragment;
     initPTS: number;
     timescale: number;
 }
@@ -1945,7 +1896,6 @@ export declare type LatencyControllerConfig = {
     liveSyncDuration?: number;
     liveMaxLatencyDuration?: number;
     maxLiveSyncPlaybackRate: number;
-    liveSyncOnStallIncrease: number;
 };
 
 export declare class Level {
@@ -2029,11 +1979,10 @@ export declare class LevelDetails {
     averagetargetduration?: number;
     endCC: number;
     endSN: number;
-    fragments: MediaFragment[];
-    fragmentHint?: MediaFragment;
+    fragments: Fragment[];
+    fragmentHint?: Fragment;
     partList: Part[] | null;
     dateRanges: Record<string, DateRange>;
-    dateRangeTagCount: number;
     live: boolean;
     ageHeader: number;
     advancedDateTime?: number;
@@ -2308,16 +2257,6 @@ export declare class LoadStats implements LoaderStats {
     buffering: HlsProgressivePerformanceTiming;
 }
 
-export declare class Logger implements ILogger {
-    trace: ILogFunction;
-    debug: ILogFunction;
-    log: ILogFunction;
-    warn: ILogFunction;
-    info: ILogFunction;
-    error: ILogFunction;
-    constructor(label: string, logger: ILogger);
-}
-
 export declare type MainPlaylistType = AudioPlaylistType | 'VIDEO';
 
 export declare interface ManifestLoadedData {
@@ -2393,14 +2332,6 @@ export declare type MediaDecodingInfo = {
     error?: Error;
 };
 
-export declare interface MediaEndedData {
-    stalled: boolean;
-}
-
-export declare interface MediaFragment extends Fragment {
-    sn: number;
-}
-
 export declare type MediaKeyFunc = (keySystem: KeySystems, supportedConfigurations: MediaKeySystemConfiguration[]) => Promise<MediaKeySystemAccess>;
 
 export declare interface MediaKeySessionContext {
@@ -2470,8 +2401,6 @@ export declare type MP4RemuxerConfig = {
 export declare interface NetworkComponentAPI extends ComponentAPI {
     startLoad(startPosition: number): void;
     stopLoad(): void;
-    pauseBuffering?(): void;
-    resumeBuffering?(): void;
 }
 
 export declare const enum NetworkErrorAction {
@@ -2504,17 +2433,6 @@ declare interface PACData {
     italics: boolean;
 }
 
-export declare type ParsedMultivariantPlaylist = {
-    contentSteering: ContentSteeringOptions | null;
-    levels: LevelParsed[];
-    playlistParsingError: Error | null;
-    sessionData: Record<string, AttrList> | null;
-    sessionKeys: LevelKey[] | null;
-    startTimeOffset: number | null;
-    variableList: VariableMap | null;
-    hasVariableRefs: boolean;
-};
-
 /**
  * Object representing parsed data from an HLS Partial Segment. Found in {@link hls.js#LevelDetails.partList}.
  */
@@ -2524,10 +2442,10 @@ export declare class Part extends BaseSegment {
     readonly gap: boolean;
     readonly independent: boolean;
     readonly relurl: string;
-    readonly fragment: MediaFragment;
+    readonly fragment: Fragment;
     readonly index: number;
     stats: LoadStats;
-    constructor(partAttrs: AttrList, frag: MediaFragment, baseurl: string, index: number, previous?: Part);
+    constructor(partAttrs: AttrList, frag: Fragment, baseurl: string, index: number, previous?: Part);
     get start(): number;
     get end(): number;
     get loaded(): boolean;
@@ -2722,14 +2640,16 @@ declare class StreamController extends BaseStreamController implements NetworkCo
     private altAudio;
     private audioOnly;
     private fragPlaying;
+    private onvplaying;
+    private onvseeked;
     private fragLastKbps;
     private couldBacktrack;
     private backtrackFragment;
     private audioCodecSwitch;
     private videoBuffer;
     constructor(hls: Hls, fragmentTracker: FragmentTracker, keyLoader: KeyLoader);
-    protected registerListeners(): void;
-    protected unregisterListeners(): void;
+    private _registerListeners;
+    protected _unregisterListeners(): void;
     protected onHandlerDestroying(): void;
     startLoad(startPosition: number): void;
     stopLoad(): void;
@@ -2753,7 +2673,7 @@ declare class StreamController extends BaseStreamController implements NetworkCo
     protected onMediaDetaching(): void;
     private onMediaPlaying;
     private onMediaSeeked;
-    protected onManifestLoading(): void;
+    private onManifestLoading;
     private onManifestParsed;
     private onLevelLoading;
     private onLevelLoaded;
@@ -2762,7 +2682,7 @@ declare class StreamController extends BaseStreamController implements NetworkCo
     private onAudioTrackSwitched;
     private onBufferCreated;
     private onFragBuffered;
-    protected onError(event: Events.ERROR, data: ErrorData): void;
+    private onError;
     private checkBuffer;
     private onFragLoadEmergencyAborted;
     private onBufferFlushed;
@@ -2777,14 +2697,13 @@ declare class StreamController extends BaseStreamController implements NetworkCo
     private _handleTransmuxComplete;
     private _bufferInitSegment;
     getMainFwdBufferInfo(): BufferInfo | null;
-    get maxBufferLength(): number;
     private backtrack;
     private checkFragmentChanged;
     get nextLevel(): number;
     get currentFrag(): Fragment | null;
     get currentProgramDateTime(): Date | null;
     get currentLevel(): number;
-    get nextBufferedFrag(): MediaFragment | null;
+    get nextBufferedFrag(): Fragment | null;
     get forceStartLoad(): boolean;
 }
 
@@ -2820,6 +2739,11 @@ declare class StyledUnicodeChar {
     isEmpty(): boolean;
 }
 
+declare interface SubtitleFragProcessed {
+    success: boolean;
+    frag: Fragment;
+}
+
 export declare interface SubtitleFragProcessedData {
     success: boolean;
     frag: Fragment;
@@ -2844,21 +2768,22 @@ export declare class SubtitleStreamController extends BaseStreamController imple
     private mainDetails;
     constructor(hls: Hls, fragmentTracker: FragmentTracker, keyLoader: KeyLoader);
     protected onHandlerDestroying(): void;
-    protected registerListeners(): void;
-    protected unregisterListeners(): void;
+    private _registerListeners;
+    private _unregisterListeners;
     startLoad(startPosition: number): void;
-    protected onManifestLoading(): void;
-    protected onMediaDetaching(): void;
-    private onLevelLoaded;
-    private onSubtitleFragProcessed;
-    private onBufferFlushing;
-    private onFragBuffered;
-    protected onError(event: Events.ERROR, data: ErrorData): void;
-    private onSubtitleTracksUpdated;
-    private onSubtitleTrackSwitch;
-    private onSubtitleTrackLoaded;
+    onManifestLoading(): void;
+    onMediaDetaching(): void;
+    onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData): void;
+    onSubtitleFragProcessed(event: Events.SUBTITLE_FRAG_PROCESSED, data: SubtitleFragProcessed): void;
+    onBufferFlushing(event: Events.BUFFER_FLUSHING, data: BufferFlushingData): void;
+    onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData): void;
+    onError(event: Events.ERROR, data: ErrorData): void;
+    onSubtitleTracksUpdated(event: Events.SUBTITLE_TRACKS_UPDATED, { subtitleTracks }: SubtitleTracksUpdatedData): void;
+    onSubtitleTrackSwitch(event: Events.SUBTITLE_TRACK_SWITCH, data: TrackSwitchedData): void;
+    onSubtitleTrackLoaded(event: Events.SUBTITLE_TRACK_LOADED, data: TrackLoadedData): void;
     _handleFragmentLoadComplete(fragLoadedData: FragLoadedData): void;
     doTick(): void;
+    protected getMaxBufferLength(mainBufferLength?: number): number;
     protected loadFragment(frag: Fragment, level: Level, targetBufferTime: number): void;
     get mediaBufferTimeRanges(): Bufferable;
 }
@@ -2872,10 +2797,10 @@ export declare class SubtitleTrackController extends BasePlaylistController {
     private currentTrack;
     private selectDefaultTrack;
     private queuedDefaultTrack;
+    private asyncPollTrackChange;
     private useTextTrackPolling;
     private subtitlePollingInterval;
     private _subtitleDisplay;
-    private asyncPollTrackChange;
     constructor(hls: Hls);
     destroy(): void;
     get subtitleDisplay(): boolean;
@@ -2960,12 +2885,12 @@ export declare interface SubtitleTrackSwitchData {
  * we are limiting the task execution per call stack to exactly one, but scheduling/post-poning further
  * task processing on the next main loop iteration (also known as "next tick" in the Node/JS runtime lingo).
  */
-declare class TaskLoop extends Logger {
+declare class TaskLoop {
     private readonly _boundTick;
     private _tickTimer;
     private _tickInterval;
     private _tickCallCount;
-    constructor(label: string, logger: ILogger);
+    constructor();
     destroy(): void;
     protected onHandlerDestroying(): void;
     protected onHandlerDestroyed(): void;
@@ -3096,29 +3021,31 @@ export declare interface TrackSet {
     audiovideo?: Track;
 }
 
+declare interface TrackSwitchedData {
+    id: number;
+}
+
 declare class TransmuxerInterface {
     error: Error | null;
     private hls;
     private id;
-    private instanceNo;
     private observer;
     private frag;
     private part;
     private useWorker;
     private workerContext;
+    private onwmsg?;
     private transmuxer;
     private onTransmuxComplete;
     private onFlush;
     constructor(hls: Hls, id: PlaylistLevelType, onTransmuxComplete: (transmuxResult: TransmuxerResult) => void, onFlush: (chunkMeta: ChunkMetadata) => void);
-    reset(): void;
-    private terminateWorker;
+    resetWorker(): void;
     destroy(): void;
-    push(data: ArrayBuffer, initSegmentData: Uint8Array | undefined, audioCodec: string | undefined, videoCodec: string | undefined, frag: MediaFragment, part: Part | null, duration: number, accurateTimeOffset: boolean, chunkMeta: ChunkMetadata, defaultInitPTS?: RationalTimestamp): void;
+    push(data: ArrayBuffer, initSegmentData: Uint8Array | undefined, audioCodec: string | undefined, videoCodec: string | undefined, frag: Fragment, part: Part | null, duration: number, accurateTimeOffset: boolean, chunkMeta: ChunkMetadata, defaultInitPTS?: RationalTimestamp): void;
     flush(chunkMeta: ChunkMetadata): void;
     private transmuxerError;
     private handleFlushResult;
     private onWorkerMessage;
-    private onWorkerError;
     private configureTransmuxer;
     private handleTransmuxComplete;
 }
@@ -3173,7 +3100,6 @@ declare const VideoRangeValues: readonly ["SDR", "PQ", "HLG"];
 export declare type VideoSelectionOption = {
     preferHDR?: boolean;
     allowedVideoRanges?: Array<VideoRange>;
-    videoCodec?: string;
 };
 
 export { }