hls.js

hls.js

Version 1.6.10
Published 8 days ago
24.5 MB
No dependencies
Apache-2.0 license

Install

npm i hls.js

yarn add hls.js

pnpm add hls.js

Overview

JavaScript HLS client using MediaSourceExtension

Index

Variables

variable Cues

const Cues: CuesInterface;

variable HdcpLevels

const HdcpLevels: readonly ['NONE', 'TYPE-0', 'TYPE-1', null];

variable State

const State: {
    STOPPED: string;
    IDLE: string;
    KEY_LOADING: string;
    FRAG_LOADING: string;
    FRAG_LOADING_WAITING_RETRY: string;
    WAITING_TRACK: string;
    PARSING: string;
    PARSED: string;
    ENDED: string;
    ERROR: string;
    WAITING_INIT_PTS: string;
    WAITING_LEVEL: string;
};

variable VideoRangeValues

const VideoRangeValues: readonly ['SDR', 'PQ', 'HLG'];

Classes

class AbrController

class AbrController extends Logger implements AbrComponentAPI {}

constructor

constructor(hls: Hls);

property bwEstimator

bwEstimator: EwmaBandWidthEstimator;

property firstAutoLevel

readonly firstAutoLevel: number;

property forcedAutoLevel

readonly forcedAutoLevel: number;

property hls

protected hls: Hls;

property nextAutoLevel

nextAutoLevel: number;

method clearTimer

clearTimer: () => void;

method deriveNextAutoLevel

protected deriveNextAutoLevel: (nextLevel: number) => number;

method destroy

destroy: () => void;

method onError

protected onError: (event: Events.ERROR, data: ErrorData) => void;

method onFragBuffered

protected onFragBuffered: (
    event: Events.FRAG_BUFFERED,
    data: FragBufferedData
) => void;

method onFragLoaded

protected onFragLoaded: (
    event: Events.FRAG_LOADED,
    { frag, part }: FragLoadedData
) => void;

method onFragLoading

protected onFragLoading: (
    event: Events.FRAG_LOADING,
    data: FragLoadingData
) => void;

method onLevelLoaded

protected onLevelLoaded: (
    event: Events.LEVEL_LOADED,
    data: LevelLoadedData
) => void;

method onLevelSwitching

protected onLevelSwitching: (
    event: Events.LEVEL_SWITCHING,
    data: LevelSwitchingData
) => void;

method onManifestLoading

protected onManifestLoading: (
    event: Events.MANIFEST_LOADING,
    data: ManifestLoadingData
) => void;

method registerListeners

protected registerListeners: () => void;

method resetEstimator

resetEstimator: (abrEwmaDefaultEstimate?: number) => void;

method unregisterListeners

protected unregisterListeners: () => void;

class AttrList

class AttrList {}

constructor

constructor(
    attrs: string | Record<string, any>,
    parsed?: Pick<
        ParsedMultivariantPlaylist | LevelDetails,
        'variableList' | 'hasVariableRefs' | 'playlistParsingError'
    >
);

property clientAttrs

readonly clientAttrs: string[];

method bool

bool: (attrName: string) => boolean;

method decimalFloatingPoint

decimalFloatingPoint: (attrName: string) => number;

method decimalInteger

decimalInteger: (attrName: string) => number;

method decimalResolution

decimalResolution: (
    attrName: string
) => { width: number; height: number } | undefined;

method enumeratedString

enumeratedString: (attrName: string) => string | undefined;

method enumeratedStringList

enumeratedStringList: <T extends { [key: string]: boolean }>(
    attrName: string,
    dict: T
) => { [key in keyof T]: boolean };

method hexadecimalInteger

hexadecimalInteger: (attrName: string) => Uint8Array<ArrayBuffer> | null;

method hexadecimalIntegerAsNumber

hexadecimalIntegerAsNumber: (attrName: string) => number;

method optionalFloat

optionalFloat: (attrName: string, defaultValue: number) => number;

method parseAttrList

static parseAttrList: (
    input: string,
    parsed?: Pick<
        ParsedMultivariantPlaylist | LevelDetails,
        'variableList' | 'hasVariableRefs' | 'playlistParsingError'
    >
) => Record<string, string>;

class AudioStreamController

class AudioStreamController
    extends BaseStreamController
    implements NetworkComponentAPI {}

constructor

constructor(hls: Hls, fragmentTracker: FragmentTracker, keyLoader: KeyLoader);

method doTick

doTick: () => void;

method getLoadPosition

protected getLoadPosition: () => number;

method loadFragment

protected loadFragment: (
    frag: Fragment,
    track: Level,
    targetBufferTime: number
) => void;

method onError

protected onError: (event: Events.ERROR, data: ErrorData) => void;

method onHandlerDestroying

protected onHandlerDestroying: () => void;

method onInitPtsFound

onInitPtsFound: (
    event: Events.INIT_PTS_FOUND,
    { frag, id, initPTS, timescale, trackId }: InitPTSFoundData
) => void;

method onManifestLoading

protected onManifestLoading: () => void;

method onMediaDetaching

protected onMediaDetaching: (
    event: Events.MEDIA_DETACHING,
    data: MediaDetachingData
) => void;

method onTickEnd

protected onTickEnd: () => void;

method registerListeners

protected registerListeners: () => void;

method resetLoadingState

protected resetLoadingState: () => void;

method startLoad

startLoad: (startPosition: number, skipSeekToStartPosition?: boolean) => void;

method unregisterListeners

protected unregisterListeners: () => void;

class AudioTrackController

class AudioTrackController extends BasePlaylistController {}

constructor

constructor(hls: Hls);

property allAudioTracks

readonly allAudioTracks: MediaPlaylist[];

property audioTrack

audioTrack: number;

property audioTracks

readonly audioTracks: MediaPlaylist[];

method destroy

destroy: () => void;

method loadingPlaylist

protected loadingPlaylist: (
    audioTrack: MediaPlaylist,
    hlsUrlParameters: HlsUrlParameters | undefined
) => void;

method loadPlaylist

protected loadPlaylist: (hlsUrlParameters?: HlsUrlParameters) => void;

method onAudioTrackLoaded

protected onAudioTrackLoaded: (
    event: Events.AUDIO_TRACK_LOADED,
    data: AudioTrackLoadedData
) => void;

method onError

protected onError: (event: Events.ERROR, data: ErrorData) => void;

method onLevelLoading

protected onLevelLoading: (
    event: Events.LEVEL_LOADING,
    data: LevelLoadingData
) => void;

method onLevelSwitching

protected onLevelSwitching: (
    event: Events.LEVEL_SWITCHING,
    data: LevelSwitchingData
) => void;

method onManifestLoading

protected onManifestLoading: () => void;

method onManifestParsed

protected onManifestParsed: (
    event: Events.MANIFEST_PARSED,
    data: ManifestParsedData
) => void;

method setAudioOption

setAudioOption: (
    audioOption: MediaPlaylist | AudioSelectionOption | undefined
) => MediaPlaylist | null;

class BasePlaylistController

class BasePlaylistController extends Logger implements NetworkComponentAPI {}

constructor

constructor(hls: Hls, logPrefix: string);

property canLoad

protected canLoad: boolean;

property hls

protected hls: Hls;

method checkRetry

protected checkRetry: (errorEvent: ErrorData) => boolean;

method destroy

destroy: () => void;

method getUrlWithDirectives

protected getUrlWithDirectives: (
    uri: string,
    hlsUrlParameters: HlsUrlParameters | undefined
) => string;

method loadingPlaylist

protected loadingPlaylist: (
    playlist: Level | MediaPlaylist,
    hlsUrlParameters?: HlsUrlParameters
) => void;

method loadPlaylist

protected loadPlaylist: (hlsUrlParameters?: HlsUrlParameters) => void;

method playlistLoaded

protected playlistLoaded: (
    index: number,
    data: LevelLoadedData | AudioTrackLoadedData | TrackLoadedData,
    previousDetails?: LevelDetails
) => void;

method scheduleLoading

protected scheduleLoading: (
    levelOrTrack: Level | MediaPlaylist,
    deliveryDirectives?: HlsUrlParameters,
    updatedDetails?: LevelDetails
) => void;

method shouldLoadPlaylist

protected shouldLoadPlaylist: (
    playlist: Level | MediaPlaylist | null | undefined
) => playlist is Level | MediaPlaylist;

method startLoad

startLoad: () => void;

method stopLoad

stopLoad: () => void;

method switchParams

protected switchParams: (
    playlistUri: string,
    previous: LevelDetails | undefined,
    current: LevelDetails | undefined
) => HlsUrlParameters | undefined;

class BaseSegment

class BaseSegment {}

constructor

constructor(base: string | Base);

property base

readonly base: Base;

property baseurl

readonly baseurl: string;

property byteRange

readonly byteRange: [number, number] | [];

property byteRangeEndOffset

readonly byteRangeEndOffset: number;

property byteRangeStartOffset

readonly byteRangeStartOffset: number;

property elementaryStreams

elementaryStreams: ElementaryStreams;

property hasStats

readonly hasStats: boolean;

property hasStreams

readonly hasStreams: boolean;

property relurl

relurl?: string;

property stats

stats: LoadStats;

property url

url: string;

method clearElementaryStreamInfo

clearElementaryStreamInfo: () => void;

method setByteRange

setByteRange: (value: string, previous?: BaseSegment) => void;

class BaseStreamController

class BaseStreamController extends TaskLoop implements NetworkComponentAPI {}

constructor

constructor(
    hls: Hls,
    fragmentTracker: FragmentTracker,
    keyLoader: KeyLoader,
    logPrefix: string,
    playlistType: PlaylistLevelType
);

property bitrateTest

protected bitrateTest: boolean;

property buffering

protected buffering: boolean;

property bufferingEnabled

readonly bufferingEnabled: boolean;

property config

protected config: HlsConfig;

property decrypter

protected decrypter: Decrypter;

property fragCurrent

protected fragCurrent: Fragment;

property fragmentLoader

protected fragmentLoader: FragmentLoader;

property fragmentTracker

protected fragmentTracker: FragmentTracker;

property fragPrevious

protected fragPrevious: MediaFragment;

property hls

protected hls: Hls;

property inFlightFrag

readonly inFlightFrag: InFlightData;

property initPTS

protected initPTS: TimestampOffset[];

property keyLoader

protected keyLoader: KeyLoader;

property lastCurrentTime

protected lastCurrentTime: number;

property levelLastLoaded

protected levelLastLoaded: Level;

property levels

protected levels: Level[];

property loadingParts

protected loadingParts: boolean;

property media

protected media: HTMLMediaElement;

property mediaBuffer

protected mediaBuffer: Bufferable;

property nextLoadPosition

protected nextLoadPosition: number;

property onMediaEnded

protected onMediaEnded: () => void;

property onMediaSeeking

protected onMediaSeeking: () => void;

property playlistType

protected playlistType: PlaylistLevelType;

property primaryPrefetch

readonly primaryPrefetch: boolean;

property retryDate

protected retryDate: number;

property startFragRequested

protected startFragRequested: boolean;

property startPosition

protected startPosition: number;

property startPositionValue

readonly startPositionValue: number;

property startTimeOffset

protected startTimeOffset: number;

property state

state: string;

property timelineOffset

readonly timelineOffset: number;

property transmuxer

protected transmuxer: TransmuxerInterface;

method afterBufferFlushed

protected afterBufferFlushed: (
    media: Bufferable,
    bufferType: SourceBufferName,
    playlistType: PlaylistLevelType
) => void;

method alignPlaylists

protected alignPlaylists: (
    details: LevelDetails,
    previousDetails: LevelDetails | undefined,
    switchDetails: LevelDetails | undefined
) => number;

method bufferFragmentData

protected bufferFragmentData: (
    data: RemuxedTrack,
    frag: Fragment,
    part: Part | null,
    chunkMeta: ChunkMetadata,
    noBacktracking?: boolean
) => void;

method checkLiveUpdate

protected checkLiveUpdate: (details: LevelDetails) => void;

method clearTrackerIfNeeded

protected clearTrackerIfNeeded: (frag: Fragment) => void;

method doTick

protected doTick: () => void;

method filterReplacedPrimary

protected filterReplacedPrimary: (
    frag: MediaFragment | null,
    details: LevelDetails | undefined
) => MediaFragment | null;

method flushBufferGap

protected flushBufferGap: (frag: Fragment) => void;

method flushMainBuffer

protected flushMainBuffer: (
    startOffset: number,
    endOffset: number,
    type?: SourceBufferName | null
) => void;

method fragBufferedComplete

protected fragBufferedComplete: (frag: Fragment, part: Part | null) => void;

method fragContextChanged

protected fragContextChanged: (frag: Fragment | null) => boolean;

method getAppendedFrag

protected getAppendedFrag: (
    position: number,
    playlistType?: PlaylistLevelType
) => Fragment | null;

method getCurrentContext

protected getCurrentContext: (
    chunkMeta: ChunkMetadata
) => { frag: MediaFragment; part: Part | null; level: Level } | null;

method getFragmentAtPosition

protected getFragmentAtPosition: (
    bufferEnd: number,
    end: number,
    levelDetails: LevelDetails
) => MediaFragment | null;

method getFwdBufferInfo

protected getFwdBufferInfo: (
    bufferable: Bufferable | null,
    type: PlaylistLevelType
) => BufferInfo | null;

method getFwdBufferInfoAtPos

protected getFwdBufferInfoAtPos: (
    bufferable: Bufferable | null,
    pos: number,
    type: PlaylistLevelType,
    maxBufferHole: number
) => BufferInfo | null;

method getInitialLiveFragment

protected getInitialLiveFragment: (
    levelDetails: LevelDetails
) => MediaFragment | null;

method getLevelDetails

getLevelDetails: () => LevelDetails | undefined;

method getLoadPosition

protected getLoadPosition: () => number;

method getMaxBufferLength

protected getMaxBufferLength: (levelBitrate?: number) => number;

method getNextFragment

protected getNextFragment: (
    pos: number,
    levelDetails: LevelDetails
) => Fragment | null;

method getNextFragmentLoopLoading

protected getNextFragmentLoopLoading: (
    frag: Fragment,
    levelDetails: LevelDetails,
    bufferInfo: BufferInfo,
    playlistType: PlaylistLevelType,
    maxBufLen: number
) => Fragment | null;

method getNextPart

getNextPart: (
    partList: Part[],
    frag: Fragment,
    targetBufferTime: number
) => number;

method isLoopLoading

protected isLoopLoading: (frag: Fragment, targetBufferTime: number) => boolean;

method loadFragment

protected loadFragment: (
    frag: MediaFragment,
    level: Level,
    targetBufferTime: number
) => void;

method mapToInitFragWhenRequired

mapToInitFragWhenRequired: (frag: Fragment | null) => typeof frag;

method onError

protected onError: (event: Events.ERROR, data: ErrorData) => void;

method onFragmentOrKeyLoadError

protected onFragmentOrKeyLoadError: (
    filterType: PlaylistLevelType,
    data: ErrorData
) => void;

method onHandlerDestroyed

protected onHandlerDestroyed: () => void;

method onHandlerDestroying

protected onHandlerDestroying: () => void;

method onManifestLoaded

protected onManifestLoaded: (
    event: Events.MANIFEST_LOADED,
    data: ManifestLoadedData
) => void;

method onManifestLoading

protected onManifestLoading: () => void;

method onMediaAttached

protected onMediaAttached: (
    event: Events.MEDIA_ATTACHED,
    data: MediaAttachedData
) => void;

method onMediaDetaching

protected onMediaDetaching: (
    event: Events.MEDIA_DETACHING,
    data: MediaDetachingData
) => void;

method onTickEnd

protected onTickEnd: () => void;

method pauseBuffering

pauseBuffering: () => void;

method recoverWorkerError

protected recoverWorkerError: (data: ErrorData) => void;

method reduceLengthAndFlushBuffer

protected reduceLengthAndFlushBuffer: (data: ErrorData) => boolean;

method reduceMaxBufferLength

protected reduceMaxBufferLength: (
    threshold: number,
    fragDuration: number
) => boolean;

method registerListeners

protected registerListeners: () => void;

method removeUnbufferedFrags

protected removeUnbufferedFrags: (start?: number) => void;

method resetFragmentErrors

protected resetFragmentErrors: (filterType: PlaylistLevelType) => void;

method resetFragmentLoading

protected resetFragmentLoading: (frag: Fragment) => void;

method resetLoadingState

protected resetLoadingState: () => void;

method resetStartWhenNotLoaded

protected resetStartWhenNotLoaded: (level: Level | null) => void;

method resetTransmuxer

protected resetTransmuxer: () => void;

method resetWhenMissingContext

protected resetWhenMissingContext: (chunkMeta: ChunkMetadata | Fragment) => void;

method resumeBuffering

resumeBuffering: () => void;

method setStartPosition

protected setStartPosition: (details: LevelDetails, sliding: number) => void;

method startLoad

startLoad: (startPosition: number) => void;

method stopLoad

stopLoad: () => void;

method unhandledEncryptionError

protected unhandledEncryptionError: (
    initSegment: InitSegmentData,
    frag: Fragment
) => boolean;

method unregisterListeners

protected unregisterListeners: () => void;

method waitForCdnTuneIn

protected waitForCdnTuneIn: (details: LevelDetails) => boolean | 0;

method waitForLive

protected waitForLive: (levelInfo: Level) => boolean | undefined;

class BufferController

class BufferController extends Logger implements ComponentAPI {}

constructor

constructor(hls: Hls, fragmentTracker: FragmentTracker);

property bufferedToEnd

readonly bufferedToEnd: boolean;

property sourceBufferTracks

readonly sourceBufferTracks: Partial<Record<SourceBufferName, BaseTrack>>;

method destroy

destroy: () => void;

method hasSourceTypes

hasSourceTypes: () => boolean;

method transferMedia

transferMedia: () => AttachMediaSourceData | null;

class CapLevelController

class CapLevelController implements ComponentAPI {}

constructor

constructor(hls: Hls);

property contentScaleFactor

readonly contentScaleFactor: number;

property mediaHeight

readonly mediaHeight: number;

property mediaWidth

readonly mediaWidth: number;

method destroy

destroy: () => void;

method detectPlayerSize

detectPlayerSize: () => void;

method getDimensions

getDimensions: () => { width: number; height: number };

method getMaxLevel

getMaxLevel: (capLevelIndex: number) => number;

method getMaxLevelByMediaSize

static getMaxLevelByMediaSize: (
    levels: Array<Level>,
    width: number,
    height: number
) => number;

method onBufferCodecs

protected onBufferCodecs: (
    event: Events.BUFFER_CODECS,
    data: BufferCodecsData
) => void;

method onFpsDropLevelCapping

protected onFpsDropLevelCapping: (
    event: Events.FPS_DROP_LEVEL_CAPPING,
    data: FPSDropLevelCappingData
) => void;

method onManifestParsed

protected onManifestParsed: (
    event: Events.MANIFEST_PARSED,
    data: ManifestParsedData
) => void;

method onMediaAttaching

protected onMediaAttaching: (
    event: Events.MEDIA_ATTACHING,
    data: MediaAttachingData
) => void;

method onMediaDetaching

protected onMediaDetaching: () => void;

method registerListeners

protected registerListeners: () => void;

method setStreamController

setStreamController: (streamController: StreamController) => void;

method startCapping

startCapping: () => void;

method stopCapping

stopCapping: () => void;

method unregisterListener

protected unregisterListener: () => void;

class CaptionScreen

class CaptionScreen {}

Keep a CEA-608 screen of 32x15 styled characters

constructor

constructor(logger: CaptionsLogger);

property currRow

currRow: number;

property lastOutputScreen

lastOutputScreen: CaptionScreen;

property logger

logger: CaptionsLogger;

property nrRollUpRows

nrRollUpRows: number;

property rows

rows: Row[];

method backSpace

backSpace: () => void;

method clearToEndOfRow

clearToEndOfRow: () => void;

method copy

copy: (other: CaptionScreen) => void;

method equals

equals: (other: CaptionScreen) => boolean;

method getDisplayText

getDisplayText: (asOneRow?: boolean) => string;

Get all non-empty rows with as unicode text.

method getTextAndFormat

getTextAndFormat: () => Row[];

method insertChar

insertChar: (char: number) => void;

Insert a character (without styling) in the current row.

method isEmpty

isEmpty: () => boolean;

method moveCursor

moveCursor: (relPos: number) => void;

method reset

reset: () => void;

method rollUp

rollUp: () => void;

method setBkgData

setBkgData: (bkgData: Partial<PenStyles>) => void;

Set background/extra foreground, but first do back_space, and then insert space (backwards compatibility).

method setCursor

setCursor: (absPos: number) => void;

method setPAC

setPAC: (pacData: PACData) => void;

method setPen

setPen: (styles: Partial<PenStyles>) => void;

method setRollUpRows

setRollUpRows: (nrRows: number | null) => void;

class ChunkMetadata

class ChunkMetadata {}

constructor

constructor(
    level: number,
    sn: number,
    id: number,
    size?: number,
    part?: number,
    partial?: boolean
);

property buffering

readonly buffering: {
    video: HlsChunkPerformanceTiming;
    audio: HlsChunkPerformanceTiming;
    audiovideo: HlsChunkPerformanceTiming;
};

property id

readonly id: number;

property level

readonly level: number;

property part

readonly part: number;

property partial

readonly partial: boolean;

property size

readonly size: number;

property sn

readonly sn: number;

property transmuxing

readonly transmuxing: HlsChunkPerformanceTiming;

class CMCDController

class CMCDController implements ComponentAPI {}

Controller to deal with Common Media Client Data (CMCD)
See Also
- https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf

constructor

constructor(hls: Hls);

method destroy

destroy: () => void;

class ContentSteeringController

class ContentSteeringController extends Logger implements NetworkComponentAPI {}

constructor

constructor(hls: Hls);

property pathwayPriority

pathwayPriority: string[];

method clearTimeout

clearTimeout: () => void;

method destroy

destroy: () => void;

method filterParsedLevels

filterParsedLevels: (levels: Level[]) => Level[];

method pathways

pathways: () => string[];

method removeLevel

removeLevel: (levelToRemove: Level) => void;

method startLoad

startLoad: () => void;

method stopLoad

stopLoad: () => void;

class DateRange

class DateRange {}

constructor

constructor(
    dateRangeAttr: AttrList,
    dateRangeWithSameId?: DateRange,
    tagCount?: number
);

property attr

attr: AttrList;

property class

readonly class: string;

property cue

readonly cue: DateRangeCue;

property duration

readonly duration: number;

property endDate

readonly endDate: Date;

property endOnNext

readonly endOnNext: boolean;

property id

readonly id: string;

property isInterstitial

readonly isInterstitial: boolean;

property isValid

readonly isValid: boolean;

property plannedDuration

readonly plannedDuration: number;

property startDate

readonly startDate: Date;

property startTime

readonly startTime: number;

property tagAnchor

tagAnchor: MediaFragmentRef;

property tagOrder

tagOrder: number;

class Decrypter

class Decrypter {}

constructor

constructor(
    config: HlsConfig,
    { removePKCS7Padding }?: { removePKCS7Padding?: boolean | undefined }
);

method decrypt

decrypt: (
    data: Uint8Array | ArrayBuffer,
    key: ArrayBuffer,
    iv: ArrayBuffer,
    aesMode: DecrypterAesMode
) => Promise<ArrayBuffer>;

method destroy

destroy: () => void;

method flush

flush: () => Uint8Array<ArrayBuffer> | null;

method isSync

isSync: () => boolean;

method reset

reset: () => void;

method softwareDecrypt

softwareDecrypt: (
    data: Uint8Array,
    key: ArrayBuffer,
    iv: ArrayBuffer,
    aesMode: DecrypterAesMode
) => ArrayBuffer | null;

method webCryptoDecrypt

webCryptoDecrypt: (
    data: any,
    key: ArrayBuffer,
    iv: ArrayBuffer,
    aesMode: DecrypterAesMode
) => Promise<ArrayBuffer>;

class EMEController

class EMEController extends Logger implements ComponentAPI {}

Controller to deal with encrypted media extensions (EME)
See Also
- https://developer.mozilla.org/en-US/docs/Web/API/Encrypted_Media_Extensions_API

constructor

constructor(hls: Hls);

property CDMCleanupPromise

static CDMCleanupPromise: void | Promise<void>;

method destroy

destroy: () => void;

method getKeySystemAccess

getKeySystemAccess: (keySystemsToAttempt: KeySystems[]) => Promise<void>;

method getSelectedKeySystemFormats

getSelectedKeySystemFormats: () => KeySystemFormats[];

method loadKey

loadKey: (data: KeyLoadedData) => Promise<MediaKeySessionContext>;

method selectKeySystem

selectKeySystem: (
    keySystemsToAttempt: KeySystems[]
) => Promise<KeySystemFormats>;

method selectKeySystemFormat

selectKeySystemFormat: (frag: Fragment) => Promise<KeySystemFormats>;

class ErrorController

class ErrorController extends Logger implements NetworkComponentAPI {}

constructor

constructor(hls: Hls);

method destroy

destroy: () => void;

method onErrorOut

onErrorOut: (event: Events.ERROR, data: ErrorData) => void;

method startLoad

startLoad: (startPosition: number) => void;

method stopLoad

stopLoad: () => void;

class EwmaBandWidthEstimator

class EwmaBandWidthEstimator {}

constructor

constructor(
    slow: number,
    fast: number,
    defaultEstimate: number,
    defaultTTFB?: number
);

property defaultEstimate

readonly defaultEstimate: number;

method canEstimate

canEstimate: () => boolean;

method destroy

destroy: () => void;

method getEstimate

getEstimate: () => number;

method getEstimateTTFB

getEstimateTTFB: () => number;

method sample

sample: (durationMs: number, numBytes: number) => void;

method sampleTTFB

sampleTTFB: (ttfb: number) => void;

method update

update: (slow: number, fast: number) => void;

class FetchLoader

class FetchLoader implements Loader<LoaderContext> {}

constructor

constructor(config: HlsConfig);

property context

context: LoaderContext;

property stats

stats: LoaderStats;

method abort

abort: () => void;

method abortInternal

abortInternal: () => void;

method destroy

destroy: () => void;

method getCacheAge

getCacheAge: () => number | null;

method getResponseHeader

getResponseHeader: (name: string) => string | null;

method load

load: (
    context: LoaderContext,
    config: LoaderConfiguration,
    callbacks: LoaderCallbacks<LoaderContext>
) => void;

class FPSController

class FPSController implements ComponentAPI {}

constructor

constructor(hls: Hls);

method checkFPS

checkFPS: (
    video: HTMLVideoElement,
    decodedFrames: number,
    droppedFrames: number
) => void;

method checkFPSInterval

checkFPSInterval: () => void;

method destroy

destroy: () => void;

method onMediaAttaching

protected onMediaAttaching: (
    event: Events.MEDIA_ATTACHING,
    data: MediaAttachingData
) => void;

method registerListeners

protected registerListeners: () => void;

method setStreamController

setStreamController: (streamController: StreamController) => void;

method unregisterListeners

protected unregisterListeners: () => void;

class Fragment

class Fragment extends BaseSegment {}

Object representing parsed data from an HLS Segment. Found in hls.js#LevelDetails.fragments.

constructor

constructor(type: PlaylistLevelType, base: string | Base);

property bitrate

bitrate: number;

property bitrateTest

bitrateTest: boolean;

property byteLength

readonly byteLength: number;

property cc

cc: number;

property data

data?: Uint8Array;

property decryptdata

readonly decryptdata: LevelKey;

property deltaPTS

deltaPTS?: number;

property duration

duration: number;

property encrypted

readonly encrypted: boolean;

property end

readonly end: number;

property endDTS

endDTS?: number;

property endList

endList?: boolean;

property endProgramDateTime

readonly endProgramDateTime: number;

property endPTS

endPTS?: number;

property gap

gap?: boolean;

property initSegment

initSegment: Fragment;

property keyLoader

keyLoader: Loader<KeyLoaderContext>;

property level

level: number;

property levelkeys

levelkeys?: { [key: string]: LevelKey };

property loader

loader: Loader<FragmentLoaderContext>;

property maxStartPTS

maxStartPTS?: number;

property minEndPTS

minEndPTS?: number;

property playlistOffset

playlistOffset: number;

property programDateTime

programDateTime: number;

property rawProgramDateTime

rawProgramDateTime: string;

property ref

readonly ref: MediaFragmentRef;

property sn

sn: number | 'initSegment';

property start

start: number;

property startDTS

startDTS?: number;

property startPTS

startPTS?: number;

tagList: string[][];

property title

title: string;

property type

readonly type: PlaylistLevelType;

property urlId

urlId: number;

method abortRequests

abortRequests: () => void;

method addStart

addStart: (value: number) => void;

method setDuration

setDuration: (value: number) => void;

method setElementaryStreamInfo

setElementaryStreamInfo: (
    type: ElementaryStreamTypes,
    startPTS: number,
    endPTS: number,
    startDTS: number,
    endDTS: number,
    partial?: boolean
) => void;

method setKeyFormat

setKeyFormat: (keyFormat: KeySystemFormats) => void;

method setStart

setStart: (value: number) => void;

class FragmentLoader

class FragmentLoader {}

constructor

constructor(config: HlsConfig);

method abort

abort: () => void;

method destroy

destroy: () => void;

method load

load: (
    frag: Fragment,
    onProgress?: FragmentLoadProgressCallback
) => Promise<FragLoadedData>;

method loadPart

loadPart: (
    frag: Fragment,
    part: Part,
    onProgress: FragmentLoadProgressCallback
) => Promise<FragLoadedData>;

class FragmentTracker

class FragmentTracker implements ComponentAPI {}

constructor

constructor(hls: Hls);

method destroy

destroy: () => void;

method detectEvictedFragments

detectEvictedFragments: (
    elementaryStream: SourceBufferName,
    timeRange: TimeRanges,
    playlistType: PlaylistLevelType,
    appendedPart?: Part | null,
    removeAppending?: boolean
) => void;

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)

method detectPartialFragments

detectPartialFragments: (data: FragBufferedData) => void;

Checks if the fragment passed in is loaded in the buffer properly Partially loaded fragments will be registered as a partial fragment

method fragBuffered

fragBuffered: (frag: MediaFragment, force?: true) => void;

method getAppendedFrag

getAppendedFrag: (
    position: number,
    levelType: PlaylistLevelType
) => MediaFragment | Part | null;

Return a Fragment or Part with an appended range that matches the position and levelType Otherwise, return null

method getBufferedFrag

getBufferedFrag: (
    position: number,
    levelType: PlaylistLevelType
) => MediaFragment | null;

Return a buffered Fragment that matches the position and levelType. A buffered Fragment is one whose loading, parsing and appending is done (completed or "partial" meaning aborted). If not found any Fragment, return null

method getFragAtPos

getFragAtPos: (
    position: number,
    levelType: PlaylistLevelType,
    buffered?: boolean
) => MediaFragment | null;

method getPartialFragment

getPartialFragment: (time: number) => MediaFragment | null;

Gets the partial fragment for a certain time

method getState

getState: (fragment: Fragment) => FragmentState;

method hasFragments

hasFragments: (type?: PlaylistLevelType) => boolean;

method hasParts

hasParts: (type: PlaylistLevelType) => boolean;

method isEndListAppended

isEndListAppended: (type: PlaylistLevelType) => boolean;

method removeAllFragments

removeAllFragments: () => void;

method removeFragment

removeFragment: (fragment: Fragment) => void;

method removeFragmentsInRange

removeFragmentsInRange: (
    start: number,
    end: number,
    playlistType: PlaylistLevelType,
    withGapOnly?: boolean,
    unbufferedOnly?: boolean
) => void;

class Hls

class Hls implements HlsEventEmitter {}

The Hls class is the core of the HLS.js library used to instantiate player instances.
Modifiers
- @public

constructor

constructor(userConfig?: Partial<HlsConfig>);

Creates an instance of an HLS client that can attach to exactly one HTMLMediaElement.
Parameter userConfig
Configuration options applied over Hls.DefaultConfig

property abrEwmaDefaultEstimate

readonly abrEwmaDefaultEstimate: number;

property allAudioTracks

readonly allAudioTracks: MediaPlaylist[];

Get the complete list of audio tracks across all media groups

property allSubtitleTracks

readonly allSubtitleTracks: MediaPlaylist[];

get the complete list of subtitle tracks across all media groups

property audioTrack

audioTrack: number;

index of the selected audio track (index in audio track lists)

property audioTracks

readonly audioTracks: MediaPlaylist[];

Get the list of selectable audio tracks

property autoLevelCapping

autoLevelCapping: number;

Capping/max level value that should be used by automatic level selection algorithm (ABRController)

property autoLevelEnabled

readonly autoLevelEnabled: boolean;

True when automatic level selection enabled

property bandwidthEstimate

bandwidthEstimate: number;

Returns the current bandwidth estimate in bits per second, when available. Otherwise, NaN is returned.

property bufferedToEnd

readonly bufferedToEnd: boolean;

returns true when all SourceBuffers are buffered to the end

property bufferingEnabled

readonly bufferingEnabled: boolean;

Returns state of fragment loading toggled by calling pauseBuffering() and resumeBuffering().

property capLevelToPlayerSize

capLevelToPlayerSize: boolean;

Whether level capping is enabled. Default value is set via config.capLevelToPlayerSize.

property config

readonly config: HlsConfig;

The runtime configuration used by the player. At instantiation this is combination of hls.userConfig merged over Hls.DefaultConfig.

property currentLevel

currentLevel: number;

Index of quality level (variant) currently played

property DefaultConfig

static DefaultConfig: HlsConfig;

Get the default configuration applied to new instances.

property drift

readonly drift: number;

the rate at which the edge of the current live playlist is advancing or 1 if there is none

property ErrorDetails

static readonly ErrorDetails: typeof ErrorDetails;

property ErrorTypes

static readonly ErrorTypes: typeof ErrorTypes;

property Events

static readonly Events: typeof Events;

property firstAutoLevel

readonly firstAutoLevel: number;

property firstLevel

firstLevel: number;

Return "first level": like a default level, if not set, falls back to index of first level referenced in manifest

property forceStartLoad

readonly forceStartLoad: boolean;

set to true when startLoad is called before MANIFEST_PARSED event

property hasEnoughToStart

readonly hasEnoughToStart: boolean;

Whether or not enough has been buffered to seek to start position or use media.currentTime to determine next load position

property inFlightFragments

readonly inFlightFragments: InFlightFragments;

property interstitialsManager

readonly interstitialsManager: InterstitialsManager;

returns Interstitials Program Manager

property latency

readonly latency: number;

Estimated position (in seconds) of live edge (ie edge of live playlist plus time sync playlist advanced)
Returns
0 before first playlist is loaded

property latestLevelDetails

readonly latestLevelDetails: LevelDetails;

Returns
LevelDetails of last loaded level (variant) or null prior to loading a media playlist.

property levels

readonly levels: Level[];

Returns
an array of levels (variants) sorted by HDCP-LEVEL, RESOLUTION (height), FRAME-RATE, CODECS, VIDEO-RANGE, and BANDWIDTH

property liveSyncPosition

readonly liveSyncPosition: number;

Position (in seconds) of live sync point (ie edge of live position minus safety delay defined by ```hls.config.liveSyncDuration```)
Returns
null prior to loading live Playlist

property loadingEnabled

readonly loadingEnabled: boolean;

Returns whether loading, toggled with startLoad() and stopLoad(), is active or not`.

property loadLevel

loadLevel: number;

Return the quality level of the currently or last (of none is loaded currently) segment

property loadLevelObj

readonly loadLevelObj: Level;

Returns
Level object of selected level (variant) or null prior to selecting a level or once the level is removed.

property logger

readonly logger: ILogger;

The logger functions used by this player instance, configured on player instantiation.

property lowLatencyMode

lowLatencyMode: boolean;

get mode for Low-Latency HLS loading

property mainForwardBufferInfo

readonly mainForwardBufferInfo: BufferInfo;

property manualLevel

readonly manualLevel: number;

Level set manually (if any)

property maxAutoLevel

readonly maxAutoLevel: number;

max level selectable in auto mode according to autoLevelCapping

property maxBufferLength

readonly maxBufferLength: number;

property maxHdcpLevel

maxHdcpLevel: 'NONE' | 'TYPE-0' | 'TYPE-1';

property maxLatency

readonly maxLatency: number;

maximum distance from the edge before the player seeks forward to ```hls.liveSyncPosition``` configured using ```liveMaxLatencyDurationCount``` (multiple of target duration) or ```liveMaxLatencyDuration```
Returns
0 before first playlist is loaded

property media

readonly media: HTMLMediaElement;

property MetadataSchema

static readonly MetadataSchema: typeof MetadataSchema;

property minAutoLevel

readonly minAutoLevel: number;

min level selectable in auto mode according to config.minAutoBitrate

property nextAutoLevel

nextAutoLevel: number;

next automatically selected quality level

property nextLevel

nextLevel: number;

Index of next quality level loaded as scheduled by stream controller.

property nextLoadLevel

nextLoadLevel: number;

get next quality level loaded

property pathwayPriority

pathwayPriority: string[];

ContentSteering pathwayPriority getter/setter

property pathways

readonly pathways: string[];

ContentSteering pathways getter

property playingDate

readonly playingDate: Date;

get the datetime value relative to media.currentTime for the active level Program Date Time if present

property sessionId

readonly sessionId: string;

Returns
a UUID for this player instance

property startLevel

startLevel: number;

Return the desired start level for the first fragment that will be loaded. The default value of -1 indicates automatic start level selection. Setting hls.nextAutoLevel without setting a startLevel will result in the nextAutoLevel value being used for one fragment load.

property startPosition

readonly startPosition: number;

Get the startPosition set on startLoad(position) or on autostart with config.startPosition

property subtitleDisplay

subtitleDisplay: boolean;

Whether subtitle display is enabled or not

property subtitleTrack

subtitleTrack: number;

index of the selected subtitle track (index in subtitle track lists)

property subtitleTracks

readonly subtitleTracks: MediaPlaylist[];

get alternate subtitle tracks list from playlist

property targetLatency

targetLatency: number;

target distance from the edge as calculated by the latency controller

property ttfbEstimate

readonly ttfbEstimate: number;

get time to first byte estimate {number}

property url

readonly url: string;

Gets the currently loaded URL

property userConfig

readonly userConfig: Partial<HlsConfig>;

The configuration object provided on player instantiation.

property version

static readonly version: string;

Get the video-dev/hls.js package version.

method attachMedia

attachMedia: (data: HTMLMediaElement | MediaAttachingData) => void;

Attaches Hls.js to a media element

method createController

createController: (ControllerClass: any, components: any) => any;

method destroy

destroy: () => void;

Dispose of the instance

method detachMedia

detachMedia: () => void;

Detach Hls.js from the media

method emit

emit: <E extends keyof HlsListeners>(
    event: E,
    name: E,
    eventObject: Parameters<HlsListeners[E]>[1]
) => boolean;

method getMediaDecodingInfo

getMediaDecodingInfo: (
    level: Level,
    audioTracks?: MediaPlaylist[]
) => Promise<MediaDecodingInfo>;

returns mediaCapabilities.decodingInfo for a variant/rendition

method getMediaSource

static getMediaSource: () => typeof MediaSource | undefined;

Get the MediaSource global used for MSE playback (ManagedMediaSource, MediaSource, or WebKitMediaSource).

method isMSESupported

static isMSESupported: () => boolean;

Check if the required MediaSource Extensions are available.

method isSupported

static isSupported: () => boolean;

Check if MediaSource Extensions are available and isTypeSupported checks pass for any baseline codecs.

method listenerCount

listenerCount: <E extends keyof HlsListeners>(event: E) => number;

method listeners

listeners: <E extends keyof HlsListeners>(event: E) => HlsListeners[E][];

method loadSource

loadSource: (url: string) => void;

Set the source URL. Can be relative or absolute.

method off

off: <E extends keyof HlsListeners, Context = undefined>(
    event: E,
    listener?: HlsListeners[E] | undefined,
    context?: Context,
    once?: boolean | undefined
) => void;

method on

on: <E extends keyof HlsListeners, Context = undefined>(
    event: E,
    listener: HlsListeners[E],
    context?: Context
) => void;

method once

once: <E extends keyof HlsListeners, Context = undefined>(
    event: E,
    listener: HlsListeners[E],
    context?: Context
) => void;

method pauseBuffering

pauseBuffering: () => void;

Prevents stream controller from loading new segments until resumeBuffering is called. This allows for media buffering to be paused without interupting playlist loading.

method recoverMediaError

recoverMediaError: () => void;

When the media-element fails, this allows to detach and then re-attach it as one call (convenience method).
Automatic recovery of media-errors by this process is configurable.

method removeAllListeners

removeAllListeners: <E extends keyof HlsListeners>(
    event?: E | undefined
) => void;

method removeLevel

removeLevel: (levelIndex: number) => void;

method resumeBuffering

resumeBuffering: () => void;

Resumes stream controller segment loading after pauseBuffering has been called.

method setAudioOption

setAudioOption: (
    audioOption: MediaPlaylist | AudioSelectionOption | undefined
) => MediaPlaylist | null;

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.

method setSubtitleOption

setSubtitleOption: (
    subtitleOption: MediaPlaylist | SubtitleSelectionOption | undefined
) => MediaPlaylist | null;

Find and select the best matching subtitle track, making a level switch when a Group change is necessary. Updates hls.config.subtitlePreference. Returns the selected track, or null when no matching track is found.

method startLoad

startLoad: (startPosition?: number, skipSeekToStartPosition?: boolean) => void;

Start loading data from the stream source. Depending on default config, client starts loading automatically when a source is set.
Parameter startPosition
Set the start position to stream from. Defaults to -1 (None: starts from earliest point)

method stopLoad

stopLoad: () => void;

Stop loading of any stream data.

method swapAudioCodec

swapAudioCodec: () => void;

Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)

method transferMedia

transferMedia: () => AttachMediaSourceData | null;

Detach HTMLMediaElement, MediaSource, and SourceBuffers without reset, for attaching to another instance

method trigger

trigger: <E extends keyof HlsListeners>(
    event: E,
    eventObject: Parameters<HlsListeners[E]>[1]
) => boolean;

class HlsAssetPlayer

class HlsAssetPlayer {}

constructor

constructor(
    HlsPlayerClass: typeof Hls,
    userConfig: HlsAssetPlayerConfig,
    interstitial: InterstitialEvent,
    assetItem: InterstitialAssetItem
);

property appendInPlace

readonly appendInPlace: boolean;

property assetId

readonly assetId: string;

property assetItem

readonly assetItem: InterstitialAssetItem;

property bufferedEnd

readonly bufferedEnd: number;

property currentTime

readonly currentTime: number;

property destroyed

readonly destroyed: boolean;

property duration

readonly duration: number;

property hls

hls: Hls;

property interstitial

interstitial: InterstitialEvent;

property interstitialId

readonly interstitialId: string;

property media

readonly media: HTMLMediaElement;

property remaining

readonly remaining: number;

property startOffset

readonly startOffset: number;

property timelineOffset

timelineOffset: number;

property tracks

tracks: Partial<BufferCodecsData>;

method attachMedia

attachMedia: (data: HTMLMediaElement | MediaAttachingData) => void;

method bufferedInPlaceToEnd

bufferedInPlaceToEnd: (media?: HTMLMediaElement | null) => boolean;

method destroy

destroy: () => void;

method detachMedia

detachMedia: () => void;

method loadSource

loadSource: () => void;

method off

off: <E extends keyof HlsListeners, Context = undefined>(
    event: E,
    listener: HlsListeners[E],
    context?: Context
) => void;

method on

on: <E extends keyof HlsListeners, Context = undefined>(
    event: E,
    listener: HlsListeners[E],
    context?: Context
) => void;

method once

once: <E extends keyof HlsListeners, Context = undefined>(
    event: E,
    listener: HlsListeners[E],
    context?: Context
) => void;

method pauseBuffering

pauseBuffering: () => void;

method resetDetails

resetDetails: () => void;

method resumeBuffering

resumeBuffering: () => void;

method toString

toString: () => string;

method transferMedia

transferMedia: () => AttachMediaSourceData | null;

class HlsUrlParameters

class HlsUrlParameters {}

constructor

constructor(msn?: number, part?: number, skip?: HlsSkip);

property msn

msn?: number;

property part

part?: number;

property skip

skip?: HlsSkip;

method addDirectives

addDirectives: (uri: string) => string | never;

class InterstitialEvent

class InterstitialEvent {}

constructor

constructor(dateRange: DateRange, base: BaseData);

property appendInPlace

appendInPlace: boolean;

property appendInPlaceStarted

appendInPlaceStarted?: boolean;

property assetList

assetList: InterstitialAssetItem[];

property assetListLoaded

readonly assetListLoaded: boolean;

property assetListLoader

assetListLoader?: Loader<LoaderContext>;

property assetListResponse

assetListResponse: AssetListJSON;

property assetListUrl

readonly assetListUrl: string;

property assetUrl

readonly assetUrl: string;

property baseUrl

readonly baseUrl: string;

property contentMayVary

readonly contentMayVary: boolean;

property cue

readonly cue: DateRangeCue;

property cumulativeDuration

cumulativeDuration: number;

property dateRange

dateRange: DateRange;

property duration

duration: number;

property error

error?: Error;

property hasPlayed

hasPlayed: boolean;

property identifier

readonly identifier: string;

property playoutLimit

playoutLimit: number;

property resetOnResume

resetOnResume?: boolean;

property restrictions

restrictions: PlaybackRestrictions;

property resumeAnchor

resumeAnchor?: MediaFragmentRef;

property resumeOffset

resumeOffset: number;

property resumeTime

readonly resumeTime: number;

property resumptionOffset

readonly resumptionOffset: number;

property snapOptions

snapOptions: SnapOptions;

property startDate

readonly startDate: Date;

property startIsAligned

readonly startIsAligned: boolean;

property startOffset

readonly startOffset: number;

property startTime

readonly startTime: number;

property supplementsPrimary

readonly supplementsPrimary: boolean;

property timelineOccupancy

readonly timelineOccupancy: TimelineOccupancy;

property timelineStart

timelineStart: number;

method findAssetIndex

findAssetIndex: (asset: InterstitialAssetItem) => number;

method isAssetPastPlayoutLimit

isAssetPastPlayoutLimit: (assetIndex: number) => boolean;

method reset

reset: () => void;

method setDateRange

setDateRange: (dateRange: DateRange) => void;

method toString

toString: () => string;

class InterstitialsController

class InterstitialsController extends Logger implements NetworkComponentAPI {}

constructor

constructor(hls: Hls, HlsPlayerClass: typeof Hls);

property interstitialsManager

readonly interstitialsManager: InterstitialsManager;

method destroy

destroy: () => void;

method pauseBuffering

pauseBuffering: () => void;

method resumeBuffering

resumeBuffering: () => void;

method startLoad

startLoad: () => void;

method stopLoad

stopLoad: () => void;

class KeyLoader

class KeyLoader implements ComponentAPI {}

constructor

constructor(config: HlsConfig);

property emeController

emeController: EMEController;

property keyUriToKeyInfo

keyUriToKeyInfo: { [keyuri: string]: KeyLoaderInfo };

method abort

abort: (type?: PlaylistLevelType) => void;

method createKeyLoadError

createKeyLoadError: (
    frag: Fragment,
    details: ErrorDetails | undefined,
    error: Error,
    networkDetails?: any,
    response?: { url: string; data: undefined; code: number; text: string }
) => LoadError;

method destroy

destroy: () => void;

method detach

detach: () => void;

method load

load: (frag: Fragment) => Promise<KeyLoadedData>;

method loadClear

loadClear: (
    loadingFrag: Fragment,
    encryptedFragments: Fragment[],
    startFragRequested: boolean
) => null | Promise<void>;

method loadInternal

loadInternal: (
    frag: Fragment,
    keySystemFormat?: KeySystemFormats
) => Promise<KeyLoadedData>;

method loadKeyEME

loadKeyEME: (keyInfo: KeyLoaderInfo, frag: Fragment) => Promise<KeyLoadedData>;

method loadKeyHTTP

loadKeyHTTP: (keyInfo: KeyLoaderInfo, frag: Fragment) => Promise<KeyLoadedData>;

class Level

class Level {}

constructor

constructor(data: MediaPlaylist | LevelParsed);

property attrs

readonly attrs: LevelAttributes;

property audioCodec

readonly audioCodec: string;

property audioGroupId

readonly audioGroupId: string;

property audioGroupIds

readonly audioGroupIds: string[];

property audioGroups

readonly audioGroups: string[];

property averageBitrate

readonly averageBitrate: number;

property bitrate

readonly bitrate: number;

property codecs

readonly codecs: string;

property codecSet

readonly codecSet: string;

property details

details?: LevelDetails;

property fragmentError

fragmentError: number;

property frameRate

readonly frameRate: number;

property height

readonly height: number;

property id

readonly id: number;

property loaded

loaded?: { bytes: number; duration: number };

property loadError

loadError: number;

property maxBitrate

readonly maxBitrate: number;

property name

readonly name: string;

property pathwayId

readonly pathwayId: string;

property realBitrate

realBitrate: number;

property score

readonly score: number;

property subtitleGroups

readonly subtitleGroups: string[];

property supplemental

readonly supplemental: CodecsParsed;

property supportedPromise

supportedPromise?: Promise<MediaDecodingInfo>;

property supportedResult

supportedResult?: MediaDecodingInfo;

property textGroupId

readonly textGroupId: string;

property textGroupIds

readonly textGroupIds: string[];

property uri

readonly uri: string;

property url

readonly url: string[];

property urlId

urlId: number;

property videoCodec

readonly videoCodec: string;

property videoRange

readonly videoRange: 'SDR' | 'PQ' | 'HLG';

property width

readonly width: number;

method addFallback

addFallback: () => void;

method addGroupId

addGroupId: (type: string, groupId: string | undefined) => void;

method hasAudioGroup

hasAudioGroup: (groupId: string | undefined) => boolean;

method hasSubtitleGroup

hasSubtitleGroup: (groupId: string | undefined) => boolean;

class LevelDetails

class LevelDetails {}

Object representing parsed data from an HLS Media Playlist. Found in hls.js#Level.details.

constructor

constructor(baseUrl: string);

property advanced

advanced: boolean;

property advancedDateTime

advancedDateTime?: number;

property age

readonly age: number;

property ageHeader

ageHeader: number;

property alignedSliding

alignedSliding: boolean;

property appliedTimelineOffset

appliedTimelineOffset?: number;

property averagetargetduration

averagetargetduration?: number;

property canBlockReload

canBlockReload: boolean;

property canSkipDateRanges

canSkipDateRanges: boolean;

property canSkipUntil

canSkipUntil: number;

property dateRanges

dateRanges: Record<string, DateRange>;

property dateRangeTagCount

dateRangeTagCount: number;

property deltaUpdateFailed

deltaUpdateFailed?: boolean;

property drift

readonly drift: number;

property driftEnd

driftEnd: number;

property driftEndTime

driftEndTime: number;

property driftStart

driftStart: number;

property driftStartTime

driftStartTime: number;

property edge

readonly edge: number;

property encryptedFragments

encryptedFragments: Fragment[];

property endCC

endCC: number;

property endSN

endSN: number;

property expired

readonly expired: boolean;

property fragmentEnd

readonly fragmentEnd: number;

property fragmentHint

fragmentHint?: MediaFragment;

property fragments

fragments: MediaFragment[];

property fragmentStart

readonly fragmentStart: number;

property hasProgramDateTime

readonly hasProgramDateTime: boolean;

property hasVariableRefs

hasVariableRefs: boolean;

property holdBack

holdBack: number;

property lastPartIndex

readonly lastPartIndex: number;

property lastPartSn

readonly lastPartSn: number;

property levelTargetDuration

readonly levelTargetDuration: number;

property live

live: boolean;

property m3u8

m3u8: string;

property maxPartIndex

readonly maxPartIndex: number;

property misses

misses: number;

property partEnd

readonly partEnd: number;

property partHoldBack

partHoldBack: number;

property partList

partList: Part[];

property partTarget

partTarget: number;

property playlistParsingError

playlistParsingError: Error;

property preloadHint

preloadHint?: AttrList;

property PTSKnown

PTSKnown: boolean;

property recentlyRemovedDateranges

recentlyRemovedDateranges?: string[];

property renditionReports

renditionReports?: AttrList[];

property requestScheduled

requestScheduled: number;

property skippedSegments

skippedSegments: number;

property startCC

startCC: number;

property startSN

startSN: number;

property startTimeOffset

startTimeOffset: number;

property targetduration

targetduration: number;

property totalduration

totalduration: number;

property tuneInGoal

tuneInGoal: number;

property type

type: string;

property updated

updated: boolean;

property url

url: string;

property variableList

variableList: VariableMap;

property version

version: number;

method reloaded

reloaded: (previous: LevelDetails | undefined) => void;

class LevelKey

class LevelKey implements DecryptData {}

constructor

constructor(
    method: string,
    uri: string,
    format: string,
    formatversions?: number[],
    iv?: any,
    keyId?: string
);

property encrypted

readonly encrypted: boolean;

property isCommonEncryption

readonly isCommonEncryption: boolean;

property iv

iv: any;

property key

key: any;

property keyFormat

readonly keyFormat: string;

property keyFormatVersions

readonly keyFormatVersions: number[];

property keyId

keyId: any;

property method

readonly method: string;

property pssh

pssh: any;

property uri

readonly uri: string;

method clearKeyUriToKeyIdMap

static clearKeyUriToKeyIdMap: () => void;

method getDecryptData

getDecryptData: (sn: number | 'initSegment') => LevelKey | null;

method isSupported

isSupported: () => boolean;

method matches

matches: (key: LevelKey) => boolean;

class LoadError

class LoadError extends Error {}

constructor

constructor(data: FragLoadFailResult);

property data

readonly data: FragLoadFailResult;

class LoadStats

class LoadStats implements LoaderStats {}

property aborted

aborted: boolean;

property buffering

buffering: HlsProgressivePerformanceTiming;

property bwEstimate

bwEstimate: number;

property chunkCount

chunkCount: number;

property loaded

loaded: number;

property loading

loading: HlsProgressivePerformanceTiming;

property parsing

parsing: HlsPerformanceTiming;

property retry

retry: number;

property total

total: number;

class Logger

class Logger implements ILogger {}

constructor

constructor(label: string, logger: ILogger);

property debug

debug: ILogFunction;

property error

error: ILogFunction;

property info

info: ILogFunction;

property log

log: ILogFunction;

property trace

trace: ILogFunction;

property warn

warn: ILogFunction;

class M3U8Parser

class M3U8Parser {}

method findGroup

static findGroup: (
    groups: (
        | { id?: string; audioCodec?: string }
        | { id?: string; textCodec?: string }
    )[],
    mediaGroupId: string
) =>
    | { id?: string; audioCodec?: string }
    | { id?: string; textCodec?: string }
    | undefined;

method isMediaPlaylist

static isMediaPlaylist: (str: string) => boolean;

method parseLevelPlaylist

static parseLevelPlaylist: (
    string: string,
    baseurl: string,
    id: number,
    type: PlaylistLevelType,
    levelUrlId: number,
    multivariantVariableList: VariableMap | null
) => LevelDetails;

method parseMasterPlaylist

static parseMasterPlaylist: (
    string: string,
    baseurl: string
) => ParsedMultivariantPlaylist;

method parseMasterPlaylistMedia

static parseMasterPlaylistMedia: (
    string: string,
    baseurl: string,
    parsed: ParsedMultivariantPlaylist
) => ParsedMultivariantMediaOptions;

method resolve

static resolve: (url: any, baseUrl: any) => string;

class Part

class Part extends BaseSegment {}

Object representing parsed data from an HLS Partial Segment. Found in hls.js#LevelDetails.partList.

constructor

constructor(
    partAttrs: AttrList,
    frag: MediaFragment,
    base: string | Base,
    index: number,
    previous?: Part
);

property duration

readonly duration: number;

property end

readonly end: number;

property fragment

readonly fragment: MediaFragment;

property fragOffset

readonly fragOffset: number;

property gap

readonly gap: boolean;

property independent

readonly independent: boolean;

property index

readonly index: number;

property loaded

readonly loaded: boolean;

property relurl

readonly relurl: string;

property start

readonly start: number;

class StreamController

class StreamController extends BaseStreamController implements NetworkComponentAPI {}

constructor

constructor(hls: Hls, fragmentTracker: FragmentTracker, keyLoader: KeyLoader);

property currentFrag

readonly currentFrag: Fragment;

property currentLevel

readonly currentLevel: number;

property currentProgramDateTime

readonly currentProgramDateTime: Date;

property forceStartLoad

readonly forceStartLoad: boolean;

property hasEnoughToStart

readonly hasEnoughToStart: boolean;

property maxBufferLength

readonly maxBufferLength: number;

property nextBufferedFrag

readonly nextBufferedFrag: MediaFragment;

property nextLevel

readonly nextLevel: number;

method doTick

protected doTick: () => void;

method flushMainBuffer

protected flushMainBuffer: (startOffset: number, endOffset: number) => void;

method getMainFwdBufferInfo

getMainFwdBufferInfo: () => BufferInfo | null;

method immediateLevelSwitch

immediateLevelSwitch: () => void;

method loadFragment

protected loadFragment: (
    frag: Fragment,
    level: Level,
    targetBufferTime: number
) => void;

method nextLevelSwitch

nextLevelSwitch: () => void;

try to switch ASAP without breaking video playback: in order to ensure smooth but quick level switching, we need to find the next flushable buffer range we should take into account new segment fetch time

method onError

protected onError: (event: Events.ERROR, data: ErrorData) => void;

method onHandlerDestroying

protected onHandlerDestroying: () => void;

method onManifestLoading

protected onManifestLoading: () => void;

method onMediaAttached

protected onMediaAttached: (
    event: Events.MEDIA_ATTACHED,
    data: MediaAttachedData
) => void;

method onMediaDetaching

protected onMediaDetaching: (
    event: Events.MEDIA_DETACHING,
    data: MediaDetachingData
) => void;

method onTickEnd

protected onTickEnd: () => void;

method registerListeners

protected registerListeners: () => void;

method seekToStartPos

protected seekToStartPos: () => void;

Seeks to the set startPosition if not equal to the mediaElement's current time.

method startLoad

startLoad: (startPosition: number, skipSeekToStartPosition?: boolean) => void;

method stopLoad

stopLoad: () => void;

method swapAudioCodec

swapAudioCodec: () => void;

method unregisterListeners

protected unregisterListeners: () => void;

class SubtitleStreamController

class SubtitleStreamController
    extends BaseStreamController
    implements NetworkComponentAPI {}

constructor

constructor(hls: Hls, fragmentTracker: FragmentTracker, keyLoader: KeyLoader);

property mediaBufferTimeRanges

readonly mediaBufferTimeRanges: Bufferable;

method doTick

doTick: () => void;

method loadFragment

protected loadFragment: (
    frag: Fragment,
    level: Level,
    targetBufferTime: number
) => void;

method onError

protected onError: (event: Events.ERROR, data: ErrorData) => void;

method onHandlerDestroying

protected onHandlerDestroying: () => void;

method onManifestLoading

protected onManifestLoading: () => void;

method onMediaDetaching

protected onMediaDetaching: (
    event: Events.MEDIA_DETACHING,
    data: MediaDetachingData
) => void;

method registerListeners

protected registerListeners: () => void;

method startLoad

startLoad: (startPosition: number, skipSeekToStartPosition?: boolean) => void;

method unregisterListeners

protected unregisterListeners: () => void;

class SubtitleTrackController

class SubtitleTrackController extends BasePlaylistController {}

constructor

constructor(hls: Hls);

property allSubtitleTracks

readonly allSubtitleTracks: MediaPlaylist[];

property subtitleDisplay

subtitleDisplay: boolean;

property subtitleTrack

subtitleTrack: number;

get/set index of the selected subtitle track (based on index in subtitle track lists) *

property subtitleTracks

readonly subtitleTracks: MediaPlaylist[];

get alternate subtitle tracks list from playlist *

method destroy

destroy: () => void;

method loadingPlaylist

protected loadingPlaylist: (
    currentTrack: MediaPlaylist,
    hlsUrlParameters: HlsUrlParameters | undefined
) => void;

method loadPlaylist

protected loadPlaylist: (hlsUrlParameters?: HlsUrlParameters) => void;

method onError

protected onError: (event: Events.ERROR, data: ErrorData) => void;

method onLevelLoading

protected onLevelLoading: (
    event: Events.LEVEL_LOADING,
    data: LevelLoadingData
) => void;

method onLevelSwitching

protected onLevelSwitching: (
    event: Events.LEVEL_SWITCHING,
    data: LevelSwitchingData
) => void;

method onManifestLoading

protected onManifestLoading: () => void;

method onManifestParsed

protected onManifestParsed: (
    event: Events.MANIFEST_PARSED,
    data: ManifestParsedData
) => void;

method onMediaAttached

protected onMediaAttached: (
    event: Events.MEDIA_ATTACHED,
    data: MediaAttachedData
) => void;

method onMediaDetaching

protected onMediaDetaching: (
    event: Events.MEDIA_DETACHING,
    data: MediaDetachingData
) => void;

method onSubtitleTrackLoaded

protected onSubtitleTrackLoaded: (
    event: Events.SUBTITLE_TRACK_LOADED,
    data: TrackLoadedData
) => void;

method setSubtitleOption

setSubtitleOption: (
    subtitleOption: MediaPlaylist | SubtitleSelectionOption | undefined
) => MediaPlaylist | null;

class TaskLoop

class TaskLoop extends Logger {}

Sub-class specialization of EventHandler base class.
TaskLoop allows to schedule a task function being called (optionnaly repeatedly) on the main loop, scheduled asynchroneously, avoiding recursive calls in the same tick.
The task itself is implemented in doTick. It can be requested and called for single execution using the tick method.
It will be assured that the task execution method (tick) only gets called once per main loop "tick", no matter how often it gets requested for execution. Execution in further ticks will be scheduled accordingly.
If further execution requests have already been scheduled on the next tick, it can be checked with hasNextTick, and cancelled with clearNextTick.
The task can be scheduled as an interval repeatedly with a period as parameter (see setInterval, clearInterval).
Sub-classes need to implement the doTick method which will effectively have the task execution routine.
Further explanations:
The baseclass has a tick method that will schedule the doTick call. It may be called synchroneously only for a stack-depth of one. On re-entrant calls, sub-sequent calls are scheduled for next main loop ticks.
When the task execution (tick method) is called in re-entrant way this is detected and 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).

constructor

constructor(label: string, logger: ILogger);

method clearInterval

clearInterval: () => boolean;

Returns
True when interval was cleared, false when none was set (no effect)

method clearNextTick

clearNextTick: () => boolean;

Returns
True when timeout was cleared, false when none was set (no effect)

method destroy

destroy: () => void;

method doTick

protected doTick: () => void;

For subclass to implement task logic

method hasInterval

hasInterval: () => boolean;

method hasNextTick

hasNextTick: () => boolean;

method onHandlerDestroyed

protected onHandlerDestroyed: () => void;

method onHandlerDestroying

protected onHandlerDestroying: () => void;

method setInterval

setInterval: (millis: number) => boolean;

Parameter millis
Interval time (ms) True when interval has been scheduled, false when already scheduled (no effect)

method tick

tick: () => void;

Will call the subclass doTick implementation in this main loop tick or in the next one (via setTimeout(,0)) in case it has already been called in this tick (in case this is a re-entrant call).

method tickImmediate

tickImmediate: () => void;

class TimelineController

class TimelineController implements ComponentAPI {}

constructor

constructor(hls: Hls);

method addCues

addCues: (
    trackName: string,
    startTime: number,
    endTime: number,
    screen: CaptionScreen,
    cueRanges: Array<[number, number]>
) => void;

method createCaptionsTrack

createCaptionsTrack: (trackName: string) => void;

method destroy

destroy: () => void;

method onBufferFlushing

onBufferFlushing: (
    event: Events.BUFFER_FLUSHING,
    { startOffset, endOffset, endOffsetSubtitles, type }: BufferFlushingData
) => void;

class TransmuxerInterface

class TransmuxerInterface {}

constructor

constructor(
    hls: Hls,
    id: PlaylistLevelType,
    onTransmuxComplete: (transmuxResult: TransmuxerResult) => void,
    onFlush: (chunkMeta: ChunkMetadata) => void
);

property error

error: Error;

method destroy

destroy: () => void;

method flush

flush: (chunkMeta: ChunkMetadata) => void;

method push

push: (
    data: ArrayBuffer,
    initSegmentData: Uint8Array | undefined,
    audioCodec: string | undefined,
    videoCodec: string | undefined,
    frag: MediaFragment,
    part: Part | null,
    duration: number,
    accurateTimeOffset: boolean,
    chunkMeta: ChunkMetadata,
    defaultInitPTS?: TimestampOffset
) => void;

method reset

reset: () => void;

class XhrLoader

class XhrLoader implements Loader<LoaderContext> {}

constructor

constructor(config: HlsConfig);

property context

context: LoaderContext;

property stats

stats: LoaderStats;

method abort

abort: () => void;

method abortInternal

abortInternal: () => void;

method destroy

destroy: () => void;

method getCacheAge

getCacheAge: () => number | null;

method getResponseHeader

getResponseHeader: (name: string) => string | null;

method load

load: (
    context: LoaderContext,
    config: LoaderConfiguration,
    callbacks: LoaderCallbacks<LoaderContext>
) => void;

method loadInternal

loadInternal: () => void;

method loadprogress

loadprogress: (event: ProgressEvent) => void;

method loadtimeout

loadtimeout: () => void;

method openAndSendXhr

openAndSendXhr: (
    xhr: XMLHttpRequest,
    context: LoaderContext,
    config: LoaderConfiguration
) => void;

method readystatechange

readystatechange: () => void;

method retry

retry: (retryConfig: RetryConfig) => void;

Interfaces

interface AbrComponentAPI

interface AbrComponentAPI extends ComponentAPI {}

property bwEstimator

readonly bwEstimator?: EwmaBandWidthEstimator;

property firstAutoLevel

firstAutoLevel: number;

property forcedAutoLevel

forcedAutoLevel: number;

property nextAutoLevel

nextAutoLevel: number;

method resetEstimator

resetEstimator: (abrEwmaDefaultEstimate: number) => any;

interface AssetListLoadedData

interface AssetListLoadedData {}

property assetListResponse

assetListResponse: AssetListJSON;

property event

event: InterstitialEventWithAssetList;

property networkDetails

networkDetails: any;

interface AssetListLoadingData

interface AssetListLoadingData {}

property event

event: InterstitialEventWithAssetList;

interface AudioTrackLoadedData

interface AudioTrackLoadedData extends TrackLoadedData {}

interface AudioTracksUpdatedData

interface AudioTracksUpdatedData {}

property audioTracks

audioTracks: MediaPlaylist[];

interface AudioTrackSwitchedData

interface AudioTrackSwitchedData extends MediaPlaylist {}

interface AudioTrackSwitchingData

interface AudioTrackSwitchingData extends MediaPlaylist {}

interface AudioTrackUpdatedData

interface AudioTrackUpdatedData {}

property details

details: LevelDetails;

property groupId

groupId: string;

property id

id: number;

interface BackBufferData

interface BackBufferData {}

property bufferEnd

bufferEnd: number;

interface BaseTrack

interface BaseTrack {}

property codec

codec?: string;

property container

container: string;

property encrypted

encrypted?: boolean;

property id

id: 'audio' | 'main';

property levelCodec

levelCodec?: string;

property metadata

metadata?: {
    channelCount?: number;
    width?: number;
    height?: number;
};

property pendingCodec

pendingCodec?: string;

property supplemental

supplemental?: string;

interface BufferAppendedData

interface BufferAppendedData {}

property chunkMeta

chunkMeta: ChunkMetadata;

property frag

frag: Fragment;

property parent

parent: PlaylistLevelType;

property part

part: Part | null;

property timeRanges

timeRanges: Partial<Record<SourceBufferName, TimeRanges>>;

property type

type: SourceBufferName;

interface BufferAppendingData

interface BufferAppendingData {}

property chunkMeta

chunkMeta: ChunkMetadata;

property data

data: Uint8Array<ArrayBuffer>;

property frag

frag: Fragment;

property offset

offset?: number | undefined;

property parent

parent: PlaylistLevelType;

property part

part: Part | null;

property type

type: SourceBufferName;

interface BufferCodecsData

interface BufferCodecsData {}

property audio

audio?: ParsedTrack;

property audiovideo

audiovideo?: ParsedTrack;

property tracks

tracks?: BaseTrackSet;

property video

video?: ParsedTrack;

interface BufferCreatedData

interface BufferCreatedData {}

property tracks

tracks: BufferCreatedTrackSet;

interface BufferCreatedTrack

interface BufferCreatedTrack extends BaseTrack {}

property buffer

buffer: ExtendedSourceBuffer;

interface BufferEOSData

interface BufferEOSData {}

property type

type?: SourceBufferName;

interface BufferFlushedData

interface BufferFlushedData {}

property type

type: SourceBufferName;

interface BufferFlushingData

interface BufferFlushingData {}

property endOffset

endOffset: number;

property endOffsetSubtitles

endOffsetSubtitles?: number;

property startOffset

startOffset: number;

property type

type: SourceBufferName | null;

interface CodecsParsed

interface CodecsParsed {}

property audioCodec

audioCodec?: string;

property textCodec

textCodec?: string;

property unknownCodecs

unknownCodecs?: string[];

property videoCodec

videoCodec?: string;

interface ComponentAPI

interface ComponentAPI {}

method destroy

destroy: () => void;

interface CuesInterface

interface CuesInterface {}

method newCue

newCue: (
    track: TextTrack | null,
    startTime: number,
    endTime: number,
    captionScreen: CaptionScreen
) => VTTCue[];

interface CuesParsedData

interface CuesParsedData {}

property cues

cues: any;

property track

track: string;

property type

type: 'captions' | 'subtitles';

interface DecryptData

interface DecryptData {}

property encrypted

encrypted: boolean;

property isCommonEncryption

isCommonEncryption: boolean;

property iv

iv: Uint8Array<ArrayBuffer> | null;

property key

key: Uint8Array<ArrayBuffer> | null;

property keyFormat

keyFormat: string;

property keyFormatVersions

keyFormatVersions: number[];

property keyId

keyId: Uint8Array<ArrayBuffer> | null;

property method

method: string;

property pssh

pssh: Uint8Array<ArrayBuffer> | null;

property uri

uri: string;

interface ElementaryStreamInfo

interface ElementaryStreamInfo {}

property endDTS

endDTS: number;

property endPTS

endPTS: number;

property partial

partial?: boolean;

property startDTS

startDTS: number;

property startPTS

startPTS: number;

interface ErrorData

interface ErrorData {}

property buffer

buffer?: number;

property bufferInfo

bufferInfo?: BufferInfo;

property bytes

bytes?: number;

property chunkMeta

chunkMeta?: ChunkMetadata;

property context

context?: PlaylistLoaderContext;

property details

details: ErrorDetails;

property err

err?: {
    message: string;
};

Deprecated
Use ErrorData.error

property error

error: Error;

property errorAction

errorAction?: IErrorAction;

property event

event?: keyof HlsListeners | 'demuxerWorker';

property fatal

fatal: boolean;

property frag

frag?: Fragment;

property interstitial

interstitial?: InterstitialEvent;

property level

level?: number | undefined;

property levelRetry

levelRetry?: boolean;

property loader

loader?: Loader<LoaderContext>;

property mimeType

mimeType?: string;

property networkDetails

networkDetails?: any;

property parent

parent?: PlaylistLevelType;

property part

part?: Part | null;

property reason

reason?: string;

property response

response?: LoaderResponse;

property sourceBufferName

sourceBufferName?: SourceBufferName;

property stalled

stalled?: {
    start: number;
};

property stats

stats?: LoaderStats;

property type

type: ErrorTypes;

property url

url?: string;

interface FPSDropData

interface FPSDropData {}

property currentDecoded

currentDecoded: number;

property currentDropped

currentDropped: number;

property totalDroppedFrames

totalDroppedFrames: number;

interface FPSDropLevelCappingData

interface FPSDropLevelCappingData {}

property droppedLevel

droppedLevel: number;

property level

level: number;

interface FragBufferedData

interface FragBufferedData {}

property frag

frag: Fragment;

property id

id: string;

property part

part: Part | null;

property stats

stats: LoadStats;

interface FragChangedData

interface FragChangedData {}

property frag

frag: Fragment;

interface FragDecryptedData

interface FragDecryptedData {}

property frag

frag: Fragment;

property payload

payload: ArrayBuffer;

property stats

stats: {
    tstart: number;
    tdecrypt: number;
};

interface FragLoadedData

interface FragLoadedData {}

property frag

frag: Fragment;

property networkDetails

networkDetails: unknown;

property part

part: Part | null;

property payload

payload: ArrayBuffer;

interface FragLoadEmergencyAbortedData

interface FragLoadEmergencyAbortedData {}

property frag

frag: Fragment;

property part

part: Part | null;

property stats

stats: LoaderStats;

interface FragLoadFailResult

interface FragLoadFailResult extends ErrorData {}

property frag

frag: Fragment;

property networkDetails

networkDetails: any;

property part

part?: Part;

property response

response?: {
    data: any;
    code: number;
    text: string;
    url: string;
};

interface FragLoadingData

interface FragLoadingData {}

property frag

frag: Fragment;

property part

part?: Part;

property targetBufferTime

targetBufferTime: number | null;

interface FragmentLoaderConstructor

interface FragmentLoaderConstructor {}

construct signature

new (confg: HlsConfig): Loader<FragmentLoaderContext>;

interface FragmentLoaderContext

interface FragmentLoaderContext extends LoaderContext {}

property frag

frag: Fragment;

property part

part: Part | null;

property resetIV

resetIV?: boolean;

interface FragParsedData

interface FragParsedData {}

property frag

frag: Fragment;

property part

part: Part | null;

interface FragParsingInitSegmentData

interface FragParsingInitSegmentData {}

interface FragParsingMetadataData

interface FragParsingMetadataData {}

property details

details: LevelDetails;

property frag

frag: Fragment;

property id

id: string;

property samples

samples: MetadataSample[];

interface FragParsingUserdataData

interface FragParsingUserdataData {}

property details

details: LevelDetails;

property frag

frag: Fragment;

property id

id: string;

property samples

samples: UserdataSample[];

interface HlsChunkPerformanceTiming

interface HlsChunkPerformanceTiming extends HlsPerformanceTiming {}

property executeEnd

executeEnd: number;

property executeStart

executeStart: number;

interface HlsEventEmitter

interface HlsEventEmitter {}

method emit

emit: <E extends keyof HlsListeners>(
    event: E,
    name: E,
    eventObject: Parameters<HlsListeners[E]>[1]
) => boolean;

method listenerCount

listenerCount: <E extends keyof HlsListeners>(event: E) => number;

method listeners

listeners: <E extends keyof HlsListeners>(event: E) => HlsListeners[E][];

method off

off: <E extends keyof HlsListeners, Context = undefined>(
    event: E,
    listener?: HlsListeners[E],
    context?: Context,
    once?: boolean
) => void;

method on

on: <E extends keyof HlsListeners, Context = undefined>(
    event: E,
    listener: HlsListeners[E],
    context?: Context
) => void;

method once

once: <E extends keyof HlsListeners, Context = undefined>(
    event: E,
    listener: HlsListeners[E],
    context?: Context
) => void;

method removeAllListeners

removeAllListeners: <E extends keyof HlsListeners>(event?: E) => void;

interface HlsListeners

interface HlsListeners {}

Defines each Event type and payload by Event name. Used in hls.js#HlsEventEmitter to strongly type the event listener API.

property [Events.ASSET_LIST_LOADED]

[Events.ASSET_LIST_LOADED]: (
    event: Events.ASSET_LIST_LOADED,
    data: AssetListLoadedData
) => void;

property [Events.ASSET_LIST_LOADING]

[Events.ASSET_LIST_LOADING]: (
    event: Events.ASSET_LIST_LOADING,
    data: AssetListLoadingData
) => void;

property [Events.AUDIO_TRACK_LOADED]

[Events.AUDIO_TRACK_LOADED]: (
    event: Events.AUDIO_TRACK_LOADED,
    data: AudioTrackLoadedData
) => void;

property [Events.AUDIO_TRACK_LOADING]

[Events.AUDIO_TRACK_LOADING]: (
    event: Events.AUDIO_TRACK_LOADING,
    data: TrackLoadingData
) => void;

property [Events.AUDIO_TRACK_SWITCHED]

[Events.AUDIO_TRACK_SWITCHED]: (
    event: Events.AUDIO_TRACK_SWITCHED,
    data: AudioTrackSwitchedData
) => void;

property [Events.AUDIO_TRACK_SWITCHING]

[Events.AUDIO_TRACK_SWITCHING]: (
    event: Events.AUDIO_TRACK_SWITCHING,
    data: AudioTrackSwitchingData
) => void;

property [Events.AUDIO_TRACK_UPDATED]

[Events.AUDIO_TRACK_UPDATED]: (
    event: Events.AUDIO_TRACK_UPDATED,
    data: AudioTrackUpdatedData
) => void;

property [Events.AUDIO_TRACKS_UPDATED]

[Events.AUDIO_TRACKS_UPDATED]: (
    event: Events.AUDIO_TRACKS_UPDATED,
    data: AudioTracksUpdatedData
) => void;

property [Events.BACK_BUFFER_REACHED]

[Events.BACK_BUFFER_REACHED]: (
    event: Events.BACK_BUFFER_REACHED,
    data: BackBufferData
) => void;

property [Events.BUFFER_APPENDED]

[Events.BUFFER_APPENDED]: (
    event: Events.BUFFER_APPENDED,
    data: BufferAppendedData
) => void;

property [Events.BUFFER_APPENDING]

[Events.BUFFER_APPENDING]: (
    event: Events.BUFFER_APPENDING,
    data: BufferAppendingData
) => void;

property [Events.BUFFER_CODECS]

[Events.BUFFER_CODECS]: (
    event: Events.BUFFER_CODECS,
    data: BufferCodecsData
) => void;

property [Events.BUFFER_CREATED]

[Events.BUFFER_CREATED]: (
    event: Events.BUFFER_CREATED,
    data: BufferCreatedData
) => void;

property [Events.BUFFER_EOS]

[Events.BUFFER_EOS]: (event: Events.BUFFER_EOS, data: BufferEOSData) => void;

property [Events.BUFFER_FLUSHED]

[Events.BUFFER_FLUSHED]: (
    event: Events.BUFFER_FLUSHED,
    data: BufferFlushedData
) => void;

property [Events.BUFFER_FLUSHING]

[Events.BUFFER_FLUSHING]: (
    event: Events.BUFFER_FLUSHING,
    data: BufferFlushingData
) => void;

property [Events.BUFFER_RESET]

[Events.BUFFER_RESET]: (event: Events.BUFFER_RESET) => void;

property [Events.BUFFERED_TO_END]

[Events.BUFFERED_TO_END]: (event: Events.BUFFERED_TO_END) => void;

property [Events.CUES_PARSED]

[Events.CUES_PARSED]: (event: Events.CUES_PARSED, data: CuesParsedData) => void;

property [Events.DESTROYING]

[Events.DESTROYING]: (event: Events.DESTROYING) => void;

property [Events.ERROR]

[Events.ERROR]: (event: Events.ERROR, data: ErrorData) => void;

property [Events.EVENT_CUE_ENTER]

[Events.EVENT_CUE_ENTER]: (event: Events.EVENT_CUE_ENTER, data: {}) => void;

property [Events.FPS_DROP_LEVEL_CAPPING]

[Events.FPS_DROP_LEVEL_CAPPING]: (
    event: Events.FPS_DROP_LEVEL_CAPPING,
    data: FPSDropLevelCappingData
) => void;

property [Events.FPS_DROP]

[Events.FPS_DROP]: (event: Events.FPS_DROP, data: FPSDropData) => void;

property [Events.FRAG_BUFFERED]

[Events.FRAG_BUFFERED]: (
    event: Events.FRAG_BUFFERED,
    data: FragBufferedData
) => void;

property [Events.FRAG_CHANGED]

[Events.FRAG_CHANGED]: (
    event: Events.FRAG_CHANGED,
    data: FragChangedData
) => void;

property [Events.FRAG_DECRYPTED]

[Events.FRAG_DECRYPTED]: (
    event: Events.FRAG_DECRYPTED,
    data: FragDecryptedData
) => void;

property [Events.FRAG_LOAD_EMERGENCY_ABORTED]

[Events.FRAG_LOAD_EMERGENCY_ABORTED]: (
    event: Events.FRAG_LOAD_EMERGENCY_ABORTED,
    data: FragLoadEmergencyAbortedData
) => void;

property [Events.FRAG_LOADED]

[Events.FRAG_LOADED]: (event: Events.FRAG_LOADED, data: FragLoadedData) => void;

property [Events.FRAG_LOADING]

[Events.FRAG_LOADING]: (
    event: Events.FRAG_LOADING,
    data: FragLoadingData
) => void;

property [Events.FRAG_PARSED]

[Events.FRAG_PARSED]: (event: Events.FRAG_PARSED, data: FragParsedData) => void;

property [Events.FRAG_PARSING_INIT_SEGMENT]

[Events.FRAG_PARSING_INIT_SEGMENT]: (
    event: Events.FRAG_PARSING_INIT_SEGMENT,
    data: FragParsingInitSegmentData
) => void;

property [Events.FRAG_PARSING_METADATA]

[Events.FRAG_PARSING_METADATA]: (
    event: Events.FRAG_PARSING_METADATA,
    data: FragParsingMetadataData
) => void;

property [Events.FRAG_PARSING_USERDATA]

[Events.FRAG_PARSING_USERDATA]: (
    event: Events.FRAG_PARSING_USERDATA,
    data: FragParsingUserdataData
) => void;

property [Events.INIT_PTS_FOUND]

[Events.INIT_PTS_FOUND]: (
    event: Events.INIT_PTS_FOUND,
    data: InitPTSFoundData
) => void;

property [Events.INTERSTITIAL_ASSET_ENDED]

[Events.INTERSTITIAL_ASSET_ENDED]: (
    event: Events.INTERSTITIAL_ASSET_ENDED,
    data: InterstitialAssetEndedData
) => void;

property [Events.INTERSTITIAL_ASSET_ERROR]

[Events.INTERSTITIAL_ASSET_ERROR]: (
    event: Events.INTERSTITIAL_ASSET_ERROR,
    data: InterstitialAssetErrorData
) => void;

property [Events.INTERSTITIAL_ASSET_PLAYER_CREATED]

[Events.INTERSTITIAL_ASSET_PLAYER_CREATED]: (
    event: Events.INTERSTITIAL_ASSET_PLAYER_CREATED,
    data: InterstitialAssetPlayerCreatedData
) => void;

property [Events.INTERSTITIAL_ASSET_STARTED]

[Events.INTERSTITIAL_ASSET_STARTED]: (
    event: Events.INTERSTITIAL_ASSET_STARTED,
    data: InterstitialAssetStartedData
) => void;

property [Events.INTERSTITIAL_ENDED]

[Events.INTERSTITIAL_ENDED]: (
    event: Events.INTERSTITIAL_ENDED,
    data: InterstitialEndedData
) => void;

property [Events.INTERSTITIAL_STARTED]

[Events.INTERSTITIAL_STARTED]: (
    event: Events.INTERSTITIAL_STARTED,
    data: InterstitialStartedData
) => void;

property [Events.INTERSTITIALS_BUFFERED_TO_BOUNDARY]

[Events.INTERSTITIALS_BUFFERED_TO_BOUNDARY]: (
    event: Events.INTERSTITIALS_BUFFERED_TO_BOUNDARY,
    data: InterstitialsBufferedToBoundaryData
) => void;

property [Events.INTERSTITIALS_PRIMARY_RESUMED]

[Events.INTERSTITIALS_PRIMARY_RESUMED]: (
    event: Events.INTERSTITIALS_PRIMARY_RESUMED,
    data: InterstitialsPrimaryResumed
) => void;

property [Events.INTERSTITIALS_UPDATED]

[Events.INTERSTITIALS_UPDATED]: (
    event: Events.INTERSTITIALS_UPDATED,
    data: InterstitialsUpdatedData
) => void;

property [Events.KEY_LOADED]

[Events.KEY_LOADED]: (event: Events.KEY_LOADED, data: KeyLoadedData) => void;

property [Events.KEY_LOADING]

[Events.KEY_LOADING]: (event: Events.KEY_LOADING, data: KeyLoadingData) => void;

property [Events.LEVEL_LOADED]

[Events.LEVEL_LOADED]: (
    event: Events.LEVEL_LOADED,
    data: LevelLoadedData
) => void;

property [Events.LEVEL_LOADING]

[Events.LEVEL_LOADING]: (
    event: Events.LEVEL_LOADING,
    data: LevelLoadingData
) => void;

property [Events.LEVEL_PTS_UPDATED]

[Events.LEVEL_PTS_UPDATED]: (
    event: Events.LEVEL_PTS_UPDATED,
    data: LevelPTSUpdatedData
) => void;

property [Events.LEVEL_SWITCHED]

[Events.LEVEL_SWITCHED]: (
    event: Events.LEVEL_SWITCHED,
    data: LevelSwitchedData
) => void;

property [Events.LEVEL_SWITCHING]

[Events.LEVEL_SWITCHING]: (
    event: Events.LEVEL_SWITCHING,
    data: LevelSwitchingData
) => void;

property [Events.LEVEL_UPDATED]

[Events.LEVEL_UPDATED]: (
    event: Events.LEVEL_UPDATED,
    data: LevelUpdatedData
) => void;

property [Events.LEVELS_UPDATED]

[Events.LEVELS_UPDATED]: (
    event: Events.LEVELS_UPDATED,
    data: LevelsUpdatedData
) => void;

property [Events.LIVE_BACK_BUFFER_REACHED]

[Events.LIVE_BACK_BUFFER_REACHED]: (
    event: Events.LIVE_BACK_BUFFER_REACHED,
    data: LiveBackBufferData
) => void;

property [Events.MANIFEST_LOADED]

[Events.MANIFEST_LOADED]: (
    event: Events.MANIFEST_LOADED,
    data: ManifestLoadedData
) => void;

property [Events.MANIFEST_LOADING]

[Events.MANIFEST_LOADING]: (
    event: Events.MANIFEST_LOADING,
    data: ManifestLoadingData
) => void;

property [Events.MANIFEST_PARSED]

[Events.MANIFEST_PARSED]: (
    event: Events.MANIFEST_PARSED,
    data: ManifestParsedData
) => void;

property [Events.MAX_AUTO_LEVEL_UPDATED]

[Events.MAX_AUTO_LEVEL_UPDATED]: (
    event: Events.MAX_AUTO_LEVEL_UPDATED,
    data: MaxAutoLevelUpdatedData
) => void;

property [Events.MEDIA_ATTACHED]

[Events.MEDIA_ATTACHED]: (
    event: Events.MEDIA_ATTACHED,
    data: MediaAttachedData
) => void;

property [Events.MEDIA_ATTACHING]

[Events.MEDIA_ATTACHING]: (
    event: Events.MEDIA_ATTACHING,
    data: MediaAttachingData
) => void;

property [Events.MEDIA_DETACHED]

[Events.MEDIA_DETACHED]: (
    event: Events.MEDIA_DETACHED,
    data: MediaDetachedData
) => void;

property [Events.MEDIA_DETACHING]

[Events.MEDIA_DETACHING]: (
    event: Events.MEDIA_DETACHING,
    data: MediaDetachingData
) => void;

property [Events.MEDIA_ENDED]

[Events.MEDIA_ENDED]: (event: Events.MEDIA_ENDED, data: MediaEndedData) => void;

property [Events.NON_NATIVE_TEXT_TRACKS_FOUND]

[Events.NON_NATIVE_TEXT_TRACKS_FOUND]: (
    event: Events.NON_NATIVE_TEXT_TRACKS_FOUND,
    data: NonNativeTextTracksData
) => void;

property [Events.PLAYOUT_LIMIT_REACHED]

[Events.PLAYOUT_LIMIT_REACHED]: (
    event: Events.PLAYOUT_LIMIT_REACHED,
    data: {}
) => void;

property [Events.STALL_RESOLVED]

[Events.STALL_RESOLVED]: (event: Events.STALL_RESOLVED, data: {}) => void;

property [Events.STEERING_MANIFEST_LOADED]

[Events.STEERING_MANIFEST_LOADED]: (
    event: Events.STEERING_MANIFEST_LOADED,
    data: SteeringManifestLoadedData
) => void;

property [Events.SUBTITLE_FRAG_PROCESSED]

[Events.SUBTITLE_FRAG_PROCESSED]: (
    event: Events.SUBTITLE_FRAG_PROCESSED,
    data: SubtitleFragProcessedData
) => void;

property [Events.SUBTITLE_TRACK_LOADED]

[Events.SUBTITLE_TRACK_LOADED]: (
    event: Events.SUBTITLE_TRACK_LOADED,
    data: SubtitleTrackLoadedData
) => void;

property [Events.SUBTITLE_TRACK_LOADING]

[Events.SUBTITLE_TRACK_LOADING]: (
    event: Events.SUBTITLE_TRACK_LOADING,
    data: TrackLoadingData
) => void;

property [Events.SUBTITLE_TRACK_SWITCH]

[Events.SUBTITLE_TRACK_SWITCH]: (
    event: Events.SUBTITLE_TRACK_SWITCH,
    data: SubtitleTrackSwitchData
) => void;

property [Events.SUBTITLE_TRACK_UPDATED]

[Events.SUBTITLE_TRACK_UPDATED]: (
    event: Events.SUBTITLE_TRACK_UPDATED,
    data: SubtitleTrackUpdatedData
) => void;

property [Events.SUBTITLE_TRACKS_CLEARED]

[Events.SUBTITLE_TRACKS_CLEARED]: (
    event: Events.SUBTITLE_TRACKS_CLEARED
) => void;

property [Events.SUBTITLE_TRACKS_UPDATED]

[Events.SUBTITLE_TRACKS_UPDATED]: (
    event: Events.SUBTITLE_TRACKS_UPDATED,
    data: SubtitleTracksUpdatedData
) => void;

interface HlsPerformanceTiming

interface HlsPerformanceTiming {}

property end

end: number;

property start

start: number;

interface HlsProgressivePerformanceTiming

interface HlsProgressivePerformanceTiming extends HlsPerformanceTiming {}

property first

first: number;

interface ILogFunction

interface ILogFunction {}

call signature

(message?: any, ...optionalParams: any[]): void;

interface ILogger

interface ILogger {}

property debug

debug: ILogFunction;

property error

error: ILogFunction;

property info

info: ILogFunction;

property log

log: ILogFunction;

property trace

trace: ILogFunction;

property warn

warn: ILogFunction;

interface InitPTSFoundData

interface InitPTSFoundData {}

property frag

frag: MediaFragment;

property id

id: PlaylistLevelType;

property initPTS

initPTS: number;

property timescale

timescale: number;

property trackId

trackId: number;

interface InitSegmentData

interface InitSegmentData {}

property initPTS

initPTS: number | undefined;

property timescale

timescale: number | undefined;

property trackId

trackId: number | undefined;

property tracks

tracks?: TrackSet;

interface InterstitialAssetEndedData

interface InterstitialAssetEndedData {}

property asset

asset: InterstitialAssetItem;

property assetListIndex

assetListIndex: number;

property event

event: InterstitialEvent;

property player

player: HlsAssetPlayer;

property schedule

schedule: InterstitialScheduleItem[];

property scheduleIndex

scheduleIndex: number;

interface InterstitialAssetPlayerCreatedData

interface InterstitialAssetPlayerCreatedData {}

property asset

asset: InterstitialAssetItem;

property assetListIndex

assetListIndex: number;

property assetListResponse

assetListResponse?: AssetListJSON;

property event

event: InterstitialEvent;

property player

player: HlsAssetPlayer;

interface InterstitialAssetStartedData

interface InterstitialAssetStartedData {}

property asset

asset: InterstitialAssetItem;

property assetListIndex

assetListIndex: number;

property event

event: InterstitialEvent;

property player

player: HlsAssetPlayer;

property schedule

schedule: InterstitialScheduleItem[];

property scheduleIndex

scheduleIndex: number;

interface InterstitialEndedData

interface InterstitialEndedData {}

property event

event: InterstitialEvent;

property schedule

schedule: InterstitialScheduleItem[];

property scheduleIndex

scheduleIndex: number;

interface InterstitialEventWithAssetList

interface InterstitialEventWithAssetList extends InterstitialEvent {}

property assetListUrl

assetListUrl: string;

interface InterstitialPlayer

interface InterstitialPlayer {}

property assetPlayers

assetPlayers: (HlsAssetPlayer | null)[];

property bufferedEnd

bufferedEnd: number;

property currentTime

currentTime: number;

property duration

duration: number;

property playingIndex

playingIndex: number;

property scheduleItem

scheduleItem: InterstitialScheduleEventItem | null;

interface InterstitialsBufferedToBoundaryData

interface InterstitialsBufferedToBoundaryData {}

property bufferingIndex

bufferingIndex: number;

property events

events: InterstitialEvent[];

property playingIndex

playingIndex: number;

property schedule

schedule: InterstitialScheduleItem[];

interface InterstitialsManager

interface InterstitialsManager {}

property bufferingAsset

bufferingAsset: InterstitialAssetItem | null;

property bufferingIndex

bufferingIndex: number;

property bufferingItem

bufferingItem: InterstitialScheduleItem | null;

property events

events: InterstitialEvent[];

property integrated

integrated: PlayheadTimes;

property interstitialPlayer

interstitialPlayer: InterstitialPlayer | null;

property playerQueue

playerQueue: HlsAssetPlayer[];

property playingAsset

playingAsset: InterstitialAssetItem | null;

property playingIndex

playingIndex: number;

property playingItem

playingItem: InterstitialScheduleItem | null;

property primary

primary: PlayheadTimes;

property schedule

schedule: InterstitialScheduleItem[];

property skip

skip: () => void;

interface InterstitialsPrimaryResumed

interface InterstitialsPrimaryResumed {}

property schedule

schedule: InterstitialScheduleItem[];

property scheduleIndex

scheduleIndex: number;

interface InterstitialStartedData

interface InterstitialStartedData {}

property event

event: InterstitialEvent;

property schedule

schedule: InterstitialScheduleItem[];

property scheduleIndex

scheduleIndex: number;

interface InterstitialsUpdatedData

interface InterstitialsUpdatedData {}

property durations

durations: InterstitialScheduleDurations;

property events

events: InterstitialEvent[];

property removedIds

removedIds: string[];

property schedule

schedule: InterstitialScheduleItem[];

interface KeyLoadedData

interface KeyLoadedData {}

property frag

frag: Fragment;

property keyInfo

keyInfo: KeyLoaderInfo;

interface KeyLoaderContext

interface KeyLoaderContext extends LoaderContext {}

property frag

frag: Fragment;

property keyInfo

keyInfo: KeyLoaderInfo;

interface KeyLoaderInfo

interface KeyLoaderInfo {}

property decryptdata

decryptdata: LevelKey;

property keyLoadPromise

keyLoadPromise: Promise<KeyLoadedData> | null;

property loader

loader: Loader<KeyLoaderContext> | null;

property mediaKeySessionContext

mediaKeySessionContext: MediaKeySessionContext | null;

interface KeyLoadingData

interface KeyLoadingData {}

property frag

frag: Fragment;

interface LevelAttributes

interface LevelAttributes extends AttrList {}

property 'ALLOWED-CPC'

'ALLOWED-CPC'?: string;

property 'AVERAGE-BANDWIDTH'

'AVERAGE-BANDWIDTH'?: string;

property 'CLOSED-CAPTIONS'

'CLOSED-CAPTIONS'?: string;

property 'FRAME-RATE'

'FRAME-RATE'?: string;

property 'HDCP-LEVEL'

'HDCP-LEVEL'?: 'TYPE-0' | 'TYPE-1' | 'NONE';

property 'PATHWAY-ID'

'PATHWAY-ID'?: string;

property 'STABLE-VARIANT-ID'

'STABLE-VARIANT-ID'?: string;

property 'SUPPLEMENTAL-CODECS'

'SUPPLEMENTAL-CODECS'?: string;

property 'VIDEO-RANGE'

'VIDEO-RANGE'?: VideoRange;

property AUDIO

AUDIO?: string;

property BANDWIDTH

BANDWIDTH?: string;

property CODECS

CODECS?: string;

property RESOLUTION

RESOLUTION?: string;

property SCORE

SCORE?: string;

property SUBTITLES

SUBTITLES?: string;

property VIDEO

VIDEO?: string;

interface LevelLoadedData

interface LevelLoadedData {}

property deliveryDirectives

deliveryDirectives: HlsUrlParameters | null;

property details

details: LevelDetails;

property id

id: number;

property level

level: number;

property levelInfo

levelInfo: Level;

property networkDetails

networkDetails: any;

property stats

stats: LoaderStats;

property withoutMultiVariant

withoutMultiVariant?: boolean;

interface LevelLoadingData

interface LevelLoadingData {}

property deliveryDirectives

deliveryDirectives: HlsUrlParameters | null;

property id

id: number;

property level

level: number;

property levelInfo

levelInfo: Level;

property pathwayId

pathwayId: string | undefined;

property url

url: string;

interface LevelParsed

interface LevelParsed extends CodecsParsed {}

property attrs

attrs: LevelAttributes;

property bitrate

bitrate: number;

property details

details?: LevelDetails;

property height

height?: number;

property id

id?: number;

property name

name: string;

property supplemental

supplemental?: CodecsParsed;

property url

url: string;

property width

width?: number;

interface LevelPTSUpdatedData

interface LevelPTSUpdatedData {}

property details

details: LevelDetails;

property drift

drift: number;

property end

end: number;

property frag

frag: Fragment;

property level

level: Level;

property start

start: number;

property type

type: string;

interface LevelsUpdatedData

interface LevelsUpdatedData {}

property levels

levels: Array<Level>;

interface LevelSwitchedData

interface LevelSwitchedData {}

property level

level: number;

interface LevelSwitchingData

interface LevelSwitchingData {}

property attrs

attrs: LevelAttributes;

property audioCodec

audioCodec: string | undefined;

property audioGroupIds

audioGroupIds: (string | undefined)[] | undefined;

property audioGroups

audioGroups: (string | undefined)[] | undefined;

property averageBitrate

averageBitrate: number;

property bitrate

bitrate: number;

property codecSet

codecSet: string;

property details

details: LevelDetails | undefined;

property fragmentError

fragmentError: number;

property height

height: number;

property id

id: number;

property level

level: number;

property loaded

loaded:
    | {
          bytes: number;
          duration: number;
      }
    | undefined;

property loadError

loadError: number;

property maxBitrate

maxBitrate: number;

property name

name: string | undefined;

property realBitrate

realBitrate: number;

property subtitleGroups

subtitleGroups: (string | undefined)[] | undefined;

property textGroupIds

textGroupIds: (string | undefined)[] | undefined;

property uri

uri: string;

property url

url: string[];

property urlId

urlId: 0;

property videoCodec

videoCodec: string | undefined;

property width

width: number;

interface LevelUpdatedData

interface LevelUpdatedData {}

property details

details: LevelDetails;

property level

level: number;

interface LiveBackBufferData

interface LiveBackBufferData extends BackBufferData {}

Deprecated
Use BackBufferData

interface Loader

interface Loader<T extends LoaderContext> {}

property context

context: T | null;

property getCacheAge

getCacheAge?: () => number | null;

getCacheAge() is called by hls.js to get the duration that a given object has been sitting in a cache proxy when playing live. If implemented, this should return a value in seconds.
For HTTP based loaders, this should return the contents of the "age" header.
Returns
time object being lodaded

property getResponseHeader

getResponseHeader?: (name: string) => string | null;

property stats

stats: LoaderStats;

method abort

abort: () => void;

method destroy

destroy: () => void;

method load

load: (
    context: T,
    config: LoaderConfiguration,
    callbacks: LoaderCallbacks<T>
) => void;

interface LoaderCallbacks

interface LoaderCallbacks<T extends LoaderContext> {}

property onAbort

onAbort?: LoaderOnAbort<T>;

property onError

onError: LoaderOnError<T>;

property onProgress

onProgress?: LoaderOnProgress<T>;

property onSuccess

onSuccess: LoaderOnSuccess<T>;

property onTimeout

onTimeout: LoaderOnTimeout<T>;

interface LoaderConfiguration

interface LoaderConfiguration {}

property highWaterMark

highWaterMark?: number;

property loadPolicy

loadPolicy: LoaderConfig;

property maxRetry

maxRetry: number;

Deprecated
use LoaderConfig timeoutRetry and errorRetry maxNumRetry

property maxRetryDelay

maxRetryDelay: number;

Deprecated
use LoaderConfig timeoutRetry and errorRetry maxRetryDelayMs

property retryDelay

retryDelay: number;

Deprecated
use LoaderConfig timeoutRetry and errorRetry retryDelayMs

property timeout

timeout: number;

Deprecated
use LoaderConfig maxTimeToFirstByteMs and maxLoadTimeMs

interface LoaderContext

interface LoaderContext {}

property headers

headers?: Record<string, string>;

property progressData

progressData?: boolean;

property rangeEnd

rangeEnd?: number;

property rangeStart

rangeStart?: number;

property responseType

responseType: string;

property url

url: string;

interface LoaderResponse

interface LoaderResponse {}

property code

code?: number;

property data

data?: string | ArrayBuffer | Object;

property text

text?: string;

property url

url: string;

interface LoaderStats

interface LoaderStats {}

property aborted

aborted: boolean;

property buffering

buffering: HlsProgressivePerformanceTiming;

property bwEstimate

bwEstimate: number;

property chunkCount

chunkCount: number;

property loaded

loaded: number;

property loading

loading: HlsProgressivePerformanceTiming;

property parsing

parsing: HlsPerformanceTiming;

property retry

retry: number;

property total

total: number;

interface ManifestLoadedData

interface ManifestLoadedData {}

property audioTracks

audioTracks: MediaPlaylist[];

property captions

captions?: MediaPlaylist[];

property contentSteering

contentSteering: ContentSteeringOptions | null;

property levels

levels: LevelParsed[];

property networkDetails

networkDetails: any;

property sessionData

sessionData: Record<string, AttrList> | null;

property sessionKeys

sessionKeys: LevelKey[] | null;

property startTimeOffset

startTimeOffset: number | null;

property stats

stats: LoaderStats;

property subtitles

subtitles?: MediaPlaylist[];

property url

url: string;

property variableList

variableList: VariableMap | null;

interface ManifestLoadingData

interface ManifestLoadingData {}

property url

url: string;

interface ManifestParsedData

interface ManifestParsedData {}

property altAudio

altAudio: boolean;

property audio

audio: boolean;

property audioTracks

audioTracks: MediaPlaylist[];

property firstLevel

firstLevel: number;

property levels

levels: Level[];

property sessionData

sessionData: Record<string, AttrList> | null;

property sessionKeys

sessionKeys: LevelKey[] | null;

property stats

stats: LoaderStats;

property subtitleTracks

subtitleTracks: MediaPlaylist[];

property video

video: boolean;

interface MaxAutoLevelUpdatedData

interface MaxAutoLevelUpdatedData {}

property autoLevelCapping

autoLevelCapping: number;

property levels

levels: Level[] | null;

property maxAutoLevel

maxAutoLevel: number;

property maxHdcpLevel

maxHdcpLevel: HdcpLevel;

property minAutoLevel

minAutoLevel: number;

interface MediaAttachedData

interface MediaAttachedData {}

property media

media: HTMLMediaElement;

property mediaSource

mediaSource?: MediaSource;

interface MediaAttachingData

interface MediaAttachingData {}

property media

media: HTMLMediaElement;

property mediaSource

mediaSource?: MediaSource | null;

property overrides

overrides?: MediaOverrides;

property tracks

tracks?: SourceBufferTrackSet;

interface MediaAttributes

interface MediaAttributes extends AttrList {}

property 'ASSOC-LANGUAGE'

'ASSOC-LANGUAGE'?: string;

property 'GROUP-ID'

'GROUP-ID': string;

property 'INSTREAM-ID'

'INSTREAM-ID'?: string;

property 'PATHWAY-ID'

'PATHWAY-ID'?: string;

property 'STABLE-RENDITION-ID'

'STABLE-RENDITION-ID'?: string;

property AUTOSELECT

AUTOSELECT?: 'YES' | 'NO';

property CHANNELS

CHANNELS?: string;

property CHARACTERISTICS

CHARACTERISTICS?: string;

property DEFAULT

DEFAULT?: 'YES' | 'NO';

property FORCED

FORCED?: 'YES' | 'NO';

property LANGUAGE

LANGUAGE?: string;

property NAME

NAME: string;

property TYPE

TYPE?: 'AUDIO' | 'VIDEO' | 'SUBTITLES' | 'CLOSED-CAPTIONS';

property URI

URI?: string;

interface MediaDetachedData

interface MediaDetachedData {}

property transferMedia

transferMedia?: AttachMediaSourceData | null;

interface MediaDetachingData

interface MediaDetachingData {}

property transferMedia

transferMedia?: AttachMediaSourceData | null;

interface MediaEndedData

interface MediaEndedData {}

property stalled

stalled: boolean;

interface MediaFragment

interface MediaFragment extends Fragment {}

property ref

ref: MediaFragmentRef;

property sn

sn: number;

interface MediaKeySessionContext

interface MediaKeySessionContext {}

property decryptdata

decryptdata: LevelKey;

property keyStatus

keyStatus: MediaKeyStatus;

property keySystem

keySystem: KeySystems;

property licenseXhr

licenseXhr?: XMLHttpRequest;

property mediaKeys

mediaKeys: MediaKeys;

property mediaKeysSession

mediaKeysSession: MediaKeySession;

interface MediaPlaylist

interface MediaPlaylist {}

property assocLang

assocLang?: string;

property attrs

attrs: MediaAttributes;

property audioCodec

audioCodec?: string;

property autoselect

autoselect: boolean;

property bitrate

bitrate: number;

property channels

channels?: string;

property characteristics

characteristics?: string;

property default

default: boolean;

property details

details?: LevelDetails;

property forced

forced: boolean;

property groupId

groupId: string;

property height

height?: number;

property id

id: number;

property instreamId

instreamId?: string;

property lang

lang?: string;

property name

name: string;

property textCodec

textCodec?: string;

property type

type: MediaPlaylistType | 'main';

property unknownCodecs

unknownCodecs?: string[];

property url

url: string;

property videoCodec

videoCodec?: string;

property width

width?: number;

interface MetadataSample

interface MetadataSample {}

property data

data: Uint8Array;

property dts

dts: number;

property duration

duration: number;

property len

len?: number;

property pts

pts: number;

property type

type: MetadataSchema;

interface NetworkComponentAPI

interface NetworkComponentAPI extends ComponentAPI {}

method pauseBuffering

pauseBuffering: () => void;

method resumeBuffering

resumeBuffering: () => void;

method startLoad

startLoad: (startPosition: number, skipSeekToStartPosition?: boolean) => void;

method stopLoad

stopLoad: () => void;

interface NonNativeTextTrack

interface NonNativeTextTrack {}

property closedCaptions

closedCaptions?: MediaPlaylist;

property default

default: boolean;

property kind

kind: string;

property label

label: any;

property subtitleTrack

subtitleTrack?: MediaPlaylist;

interface NonNativeTextTracksData

interface NonNativeTextTracksData {}

property tracks

tracks: Array<NonNativeTextTrack>;

interface ParsedTrack

interface ParsedTrack extends BaseTrack {}

property initSegment

initSegment?: Uint8Array;

interface PartsLoadedData

interface PartsLoadedData {}

property frag

frag: Fragment;

property part

part: Part | null;

property partsLoaded

partsLoaded?: FragLoadedData[];

interface PlaylistLoaderConstructor

interface PlaylistLoaderConstructor {}

construct signature

new (confg: HlsConfig): Loader<PlaylistLoaderContext>;

interface PlaylistLoaderContext

interface PlaylistLoaderContext extends LoaderContext {}

property deliveryDirectives

deliveryDirectives: HlsUrlParameters | null;

property groupId

groupId?: string;

property id

id: number | null;

property level

level: number | null;

property levelDetails

levelDetails?: LevelDetails;

property levelOrTrack

levelOrTrack: Level | MediaPlaylist | null;

property pathwayId

pathwayId?: string;

property type

type: PlaylistContextType;

interface RemuxedMetadata

interface RemuxedMetadata {}

property samples

samples: MetadataSample[];

interface RemuxedTrack

interface RemuxedTrack {}

property data1

data1: Uint8Array<ArrayBuffer>;

property data2

data2?: Uint8Array<ArrayBuffer>;

property dropped

dropped?: number;

property encrypted

encrypted?: boolean;

property endDTS

endDTS: number;

property endPTS

endPTS: number;

property firstKeyFrame

firstKeyFrame?: number;

property firstKeyFramePTS

firstKeyFramePTS?: number;

property hasAudio

hasAudio: boolean;

property hasVideo

hasVideo: boolean;

property independent

independent?: boolean;

property nb

nb: number;

property startDTS

startDTS: number;

property startPTS

startPTS: number;

property transferredData1

transferredData1?: ArrayBuffer;

property transferredData2

transferredData2?: ArrayBuffer;

property type

type: SourceBufferName;

interface RemuxedUserdata

interface RemuxedUserdata {}

property samples

samples: UserdataSample[];

interface RemuxerResult

interface RemuxerResult {}

property audio

audio?: RemuxedTrack;

property id3

id3?: RemuxedMetadata;

property independent

independent?: boolean;

property initSegment

initSegment?: InitSegmentData;

property text

text?: RemuxedUserdata;

property video

video?: RemuxedTrack;

interface SourceBufferListener

interface SourceBufferListener {}

property event

event: string;

property listener

listener: EventListener;

interface SourceBufferTrack

interface SourceBufferTrack extends BaseTrack {}

property buffer

buffer?: ExtendedSourceBuffer;

property ended

ended?: boolean;

property ending

ending?: boolean;

property listeners

listeners: SourceBufferListener[];

interface SteeringManifestLoadedData

interface SteeringManifestLoadedData {}

property steeringManifest

steeringManifest: SteeringManifest;

property url

url: string;

interface SubtitleFragProcessedData

interface SubtitleFragProcessedData {}

property error

error?: Error;

property frag

frag: Fragment;

property success

success: boolean;

interface SubtitleTrackLoadedData

interface SubtitleTrackLoadedData extends TrackLoadedData {}

interface SubtitleTracksUpdatedData

interface SubtitleTracksUpdatedData {}

property subtitleTracks

subtitleTracks: MediaPlaylist[];

interface SubtitleTrackSwitchData

interface SubtitleTrackSwitchData {}

property groupId

groupId?: string;

property id

id: number;

property name

name?: string;

property type

type?: MediaPlaylistType | 'main';

property url

url?: string;

interface SubtitleTrackUpdatedData

interface SubtitleTrackUpdatedData {}

property details

details: LevelDetails;

property groupId

groupId: string;

property id

id: number;

interface Track

interface Track extends BaseTrack {}

property buffer

buffer?: SourceBuffer;

property initSegment

initSegment?: Uint8Array;

interface TrackLoadedData

interface TrackLoadedData {}

property deliveryDirectives

deliveryDirectives: HlsUrlParameters | null;

property details

details: LevelDetails;

property groupId

groupId: string;

property id

id: number;

property networkDetails

networkDetails: any;

property stats

stats: LoaderStats;

property track

track: MediaPlaylist;

interface TrackLoadingData

interface TrackLoadingData {}

property deliveryDirectives

deliveryDirectives: HlsUrlParameters | null;

property groupId

groupId: string;

property id

id: number;

property track

track: MediaPlaylist;

property url

url: string;

interface TrackSet

interface TrackSet {}

property audio

audio?: Track;

property audiovideo

audiovideo?: Track;

property video

video?: Track;

interface TransmuxerResult

interface TransmuxerResult {}

property chunkMeta

chunkMeta: ChunkMetadata;

property remuxResult

remuxResult: RemuxerResult;

interface UserdataSample

interface UserdataSample {}

property bytes

bytes?: Uint8Array;

property payloadType

payloadType?: number;

property pts

pts: number;

property type

type?: number;

property userData

userData?: string;

property userDataBytes

userDataBytes?: Uint8Array;

property uuid

uuid?: string;

Enums

enum DecrypterAesMode

const enum DecrypterAesMode {
    cbc = 0,
    ctr = 1,
}

member cbc

cbc = 0

member ctr

ctr = 1

enum ElementaryStreamTypes

const enum ElementaryStreamTypes {
    AUDIO = 'audio',
    VIDEO = 'video',
    AUDIOVIDEO = 'audiovideo',
}

member AUDIO

AUDIO = 'audio'

member AUDIOVIDEO

AUDIOVIDEO = 'audiovideo'

member VIDEO

VIDEO = 'video'

enum ErrorActionFlags

const enum ErrorActionFlags {
    None = 0,
    MoveAllAlternatesMatchingHost = 1,
    MoveAllAlternatesMatchingHDCP = 2,
    SwitchToSDR = 4,
}

member MoveAllAlternatesMatchingHDCP

MoveAllAlternatesMatchingHDCP = 2

member MoveAllAlternatesMatchingHost

MoveAllAlternatesMatchingHost = 1

member None

None = 0

member SwitchToSDR

SwitchToSDR = 4

enum ErrorDetails

enum ErrorDetails {
    KEY_SYSTEM_NO_KEYS = 'keySystemNoKeys',
    KEY_SYSTEM_NO_ACCESS = 'keySystemNoAccess',
    KEY_SYSTEM_NO_SESSION = 'keySystemNoSession',
    KEY_SYSTEM_NO_CONFIGURED_LICENSE = 'keySystemNoConfiguredLicense',
    KEY_SYSTEM_LICENSE_REQUEST_FAILED = 'keySystemLicenseRequestFailed',
    KEY_SYSTEM_SERVER_CERTIFICATE_REQUEST_FAILED = 'keySystemServerCertificateRequestFailed',
    KEY_SYSTEM_SERVER_CERTIFICATE_UPDATE_FAILED = 'keySystemServerCertificateUpdateFailed',
    KEY_SYSTEM_SESSION_UPDATE_FAILED = 'keySystemSessionUpdateFailed',
    KEY_SYSTEM_STATUS_OUTPUT_RESTRICTED = 'keySystemStatusOutputRestricted',
    KEY_SYSTEM_STATUS_INTERNAL_ERROR = 'keySystemStatusInternalError',
    KEY_SYSTEM_DESTROY_MEDIA_KEYS_ERROR = 'keySystemDestroyMediaKeysError',
    KEY_SYSTEM_DESTROY_CLOSE_SESSION_ERROR = 'keySystemDestroyCloseSessionError',
    KEY_SYSTEM_DESTROY_REMOVE_SESSION_ERROR = 'keySystemDestroyRemoveSessionError',
    MANIFEST_LOAD_ERROR = 'manifestLoadError',
    MANIFEST_LOAD_TIMEOUT = 'manifestLoadTimeOut',
    MANIFEST_PARSING_ERROR = 'manifestParsingError',
    MANIFEST_INCOMPATIBLE_CODECS_ERROR = 'manifestIncompatibleCodecsError',
    LEVEL_EMPTY_ERROR = 'levelEmptyError',
    LEVEL_LOAD_ERROR = 'levelLoadError',
    LEVEL_LOAD_TIMEOUT = 'levelLoadTimeOut',
    LEVEL_PARSING_ERROR = 'levelParsingError',
    LEVEL_SWITCH_ERROR = 'levelSwitchError',
    AUDIO_TRACK_LOAD_ERROR = 'audioTrackLoadError',
    AUDIO_TRACK_LOAD_TIMEOUT = 'audioTrackLoadTimeOut',
    SUBTITLE_LOAD_ERROR = 'subtitleTrackLoadError',
    SUBTITLE_TRACK_LOAD_TIMEOUT = 'subtitleTrackLoadTimeOut',
    FRAG_LOAD_ERROR = 'fragLoadError',
    FRAG_LOAD_TIMEOUT = 'fragLoadTimeOut',
    FRAG_DECRYPT_ERROR = 'fragDecryptError',
    FRAG_PARSING_ERROR = 'fragParsingError',
    FRAG_GAP = 'fragGap',
    REMUX_ALLOC_ERROR = 'remuxAllocError',
    KEY_LOAD_ERROR = 'keyLoadError',
    KEY_LOAD_TIMEOUT = 'keyLoadTimeOut',
    BUFFER_ADD_CODEC_ERROR = 'bufferAddCodecError',
    BUFFER_INCOMPATIBLE_CODECS_ERROR = 'bufferIncompatibleCodecsError',
    BUFFER_APPEND_ERROR = 'bufferAppendError',
    BUFFER_APPENDING_ERROR = 'bufferAppendingError',
    BUFFER_STALLED_ERROR = 'bufferStalledError',
    BUFFER_FULL_ERROR = 'bufferFullError',
    BUFFER_SEEK_OVER_HOLE = 'bufferSeekOverHole',
    BUFFER_NUDGE_ON_STALL = 'bufferNudgeOnStall',
    ASSET_LIST_LOAD_ERROR = 'assetListLoadError',
    ASSET_LIST_LOAD_TIMEOUT = 'assetListLoadTimeout',
    ASSET_LIST_PARSING_ERROR = 'assetListParsingError',
    INTERSTITIAL_ASSET_ITEM_ERROR = 'interstitialAssetItemError',
    INTERNAL_EXCEPTION = 'internalException',
    INTERNAL_ABORTED = 'aborted',
    ATTACH_MEDIA_ERROR = 'attachMediaError',
    UNKNOWN = 'unknown',
}

member ASSET_LIST_LOAD_ERROR

ASSET_LIST_LOAD_ERROR = 'assetListLoadError'

member ASSET_LIST_LOAD_TIMEOUT

ASSET_LIST_LOAD_TIMEOUT = 'assetListLoadTimeout'

member ASSET_LIST_PARSING_ERROR

ASSET_LIST_PARSING_ERROR = 'assetListParsingError'

member ATTACH_MEDIA_ERROR

ATTACH_MEDIA_ERROR = 'attachMediaError'

member AUDIO_TRACK_LOAD_ERROR

AUDIO_TRACK_LOAD_ERROR = 'audioTrackLoadError'

member AUDIO_TRACK_LOAD_TIMEOUT

AUDIO_TRACK_LOAD_TIMEOUT = 'audioTrackLoadTimeOut'

member BUFFER_ADD_CODEC_ERROR

BUFFER_ADD_CODEC_ERROR = 'bufferAddCodecError'

member BUFFER_APPEND_ERROR

BUFFER_APPEND_ERROR = 'bufferAppendError'

member BUFFER_APPENDING_ERROR

BUFFER_APPENDING_ERROR = 'bufferAppendingError'

member BUFFER_FULL_ERROR

BUFFER_FULL_ERROR = 'bufferFullError'

member BUFFER_INCOMPATIBLE_CODECS_ERROR

BUFFER_INCOMPATIBLE_CODECS_ERROR = 'bufferIncompatibleCodecsError'

member BUFFER_NUDGE_ON_STALL

BUFFER_NUDGE_ON_STALL = 'bufferNudgeOnStall'

member BUFFER_SEEK_OVER_HOLE

BUFFER_SEEK_OVER_HOLE = 'bufferSeekOverHole'

member BUFFER_STALLED_ERROR

BUFFER_STALLED_ERROR = 'bufferStalledError'

member FRAG_DECRYPT_ERROR

FRAG_DECRYPT_ERROR = 'fragDecryptError'

member FRAG_GAP

FRAG_GAP = 'fragGap'

member FRAG_LOAD_ERROR

FRAG_LOAD_ERROR = 'fragLoadError'

member FRAG_LOAD_TIMEOUT

FRAG_LOAD_TIMEOUT = 'fragLoadTimeOut'

member FRAG_PARSING_ERROR

FRAG_PARSING_ERROR = 'fragParsingError'

member INTERNAL_ABORTED

INTERNAL_ABORTED = 'aborted'

member INTERNAL_EXCEPTION

INTERNAL_EXCEPTION = 'internalException'

member INTERSTITIAL_ASSET_ITEM_ERROR

INTERSTITIAL_ASSET_ITEM_ERROR = 'interstitialAssetItemError'

member KEY_LOAD_ERROR

KEY_LOAD_ERROR = 'keyLoadError'

member KEY_LOAD_TIMEOUT

KEY_LOAD_TIMEOUT = 'keyLoadTimeOut'

member KEY_SYSTEM_DESTROY_CLOSE_SESSION_ERROR

KEY_SYSTEM_DESTROY_CLOSE_SESSION_ERROR = 'keySystemDestroyCloseSessionError'

member KEY_SYSTEM_DESTROY_MEDIA_KEYS_ERROR

KEY_SYSTEM_DESTROY_MEDIA_KEYS_ERROR = 'keySystemDestroyMediaKeysError'

member KEY_SYSTEM_DESTROY_REMOVE_SESSION_ERROR

KEY_SYSTEM_DESTROY_REMOVE_SESSION_ERROR = 'keySystemDestroyRemoveSessionError'

member KEY_SYSTEM_LICENSE_REQUEST_FAILED

KEY_SYSTEM_LICENSE_REQUEST_FAILED = 'keySystemLicenseRequestFailed'

member KEY_SYSTEM_NO_ACCESS

KEY_SYSTEM_NO_ACCESS = 'keySystemNoAccess'

member KEY_SYSTEM_NO_CONFIGURED_LICENSE

KEY_SYSTEM_NO_CONFIGURED_LICENSE = 'keySystemNoConfiguredLicense'

member KEY_SYSTEM_NO_KEYS

KEY_SYSTEM_NO_KEYS = 'keySystemNoKeys'

member KEY_SYSTEM_NO_SESSION

KEY_SYSTEM_NO_SESSION = 'keySystemNoSession'

member KEY_SYSTEM_SERVER_CERTIFICATE_REQUEST_FAILED

KEY_SYSTEM_SERVER_CERTIFICATE_REQUEST_FAILED = 'keySystemServerCertificateRequestFailed'

member KEY_SYSTEM_SERVER_CERTIFICATE_UPDATE_FAILED

KEY_SYSTEM_SERVER_CERTIFICATE_UPDATE_FAILED = 'keySystemServerCertificateUpdateFailed'

member KEY_SYSTEM_SESSION_UPDATE_FAILED

KEY_SYSTEM_SESSION_UPDATE_FAILED = 'keySystemSessionUpdateFailed'

member KEY_SYSTEM_STATUS_INTERNAL_ERROR

KEY_SYSTEM_STATUS_INTERNAL_ERROR = 'keySystemStatusInternalError'

member KEY_SYSTEM_STATUS_OUTPUT_RESTRICTED

KEY_SYSTEM_STATUS_OUTPUT_RESTRICTED = 'keySystemStatusOutputRestricted'

member LEVEL_EMPTY_ERROR

LEVEL_EMPTY_ERROR = 'levelEmptyError'

member LEVEL_LOAD_ERROR

LEVEL_LOAD_ERROR = 'levelLoadError'

member LEVEL_LOAD_TIMEOUT

LEVEL_LOAD_TIMEOUT = 'levelLoadTimeOut'

member LEVEL_PARSING_ERROR

LEVEL_PARSING_ERROR = 'levelParsingError'

member LEVEL_SWITCH_ERROR

LEVEL_SWITCH_ERROR = 'levelSwitchError'

member MANIFEST_INCOMPATIBLE_CODECS_ERROR

MANIFEST_INCOMPATIBLE_CODECS_ERROR = 'manifestIncompatibleCodecsError'

member MANIFEST_LOAD_ERROR

MANIFEST_LOAD_ERROR = 'manifestLoadError'

member MANIFEST_LOAD_TIMEOUT

MANIFEST_LOAD_TIMEOUT = 'manifestLoadTimeOut'

member MANIFEST_PARSING_ERROR

MANIFEST_PARSING_ERROR = 'manifestParsingError'

member REMUX_ALLOC_ERROR

REMUX_ALLOC_ERROR = 'remuxAllocError'

member SUBTITLE_LOAD_ERROR

SUBTITLE_LOAD_ERROR = 'subtitleTrackLoadError'

member SUBTITLE_TRACK_LOAD_TIMEOUT

SUBTITLE_TRACK_LOAD_TIMEOUT = 'subtitleTrackLoadTimeOut'

member UNKNOWN

UNKNOWN = 'unknown'

enum ErrorTypes

enum ErrorTypes {
    NETWORK_ERROR = 'networkError',
    MEDIA_ERROR = 'mediaError',
    KEY_SYSTEM_ERROR = 'keySystemError',
    MUX_ERROR = 'muxError',
    OTHER_ERROR = 'otherError',
}

member KEY_SYSTEM_ERROR

KEY_SYSTEM_ERROR = 'keySystemError'

member MEDIA_ERROR

MEDIA_ERROR = 'mediaError'

member MUX_ERROR

MUX_ERROR = 'muxError'

member NETWORK_ERROR

NETWORK_ERROR = 'networkError'

member OTHER_ERROR

OTHER_ERROR = 'otherError'

enum Events

enum Events {
    MEDIA_ATTACHING = 'hlsMediaAttaching',
    MEDIA_ATTACHED = 'hlsMediaAttached',
    MEDIA_DETACHING = 'hlsMediaDetaching',
    MEDIA_DETACHED = 'hlsMediaDetached',
    MEDIA_ENDED = 'hlsMediaEnded',
    STALL_RESOLVED = 'hlsStallResolved',
    BUFFER_RESET = 'hlsBufferReset',
    BUFFER_CODECS = 'hlsBufferCodecs',
    BUFFER_CREATED = 'hlsBufferCreated',
    BUFFER_APPENDING = 'hlsBufferAppending',
    BUFFER_APPENDED = 'hlsBufferAppended',
    BUFFER_EOS = 'hlsBufferEos',
    BUFFERED_TO_END = 'hlsBufferedToEnd',
    BUFFER_FLUSHING = 'hlsBufferFlushing',
    BUFFER_FLUSHED = 'hlsBufferFlushed',
    MANIFEST_LOADING = 'hlsManifestLoading',
    MANIFEST_LOADED = 'hlsManifestLoaded',
    MANIFEST_PARSED = 'hlsManifestParsed',
    LEVEL_SWITCHING = 'hlsLevelSwitching',
    LEVEL_SWITCHED = 'hlsLevelSwitched',
    LEVEL_LOADING = 'hlsLevelLoading',
    LEVEL_LOADED = 'hlsLevelLoaded',
    LEVEL_UPDATED = 'hlsLevelUpdated',
    LEVEL_PTS_UPDATED = 'hlsLevelPtsUpdated',
    LEVELS_UPDATED = 'hlsLevelsUpdated',
    AUDIO_TRACKS_UPDATED = 'hlsAudioTracksUpdated',
    AUDIO_TRACK_SWITCHING = 'hlsAudioTrackSwitching',
    AUDIO_TRACK_SWITCHED = 'hlsAudioTrackSwitched',
    AUDIO_TRACK_LOADING = 'hlsAudioTrackLoading',
    AUDIO_TRACK_LOADED = 'hlsAudioTrackLoaded',
    AUDIO_TRACK_UPDATED = 'hlsAudioTrackUpdated',
    SUBTITLE_TRACKS_UPDATED = 'hlsSubtitleTracksUpdated',
    SUBTITLE_TRACKS_CLEARED = 'hlsSubtitleTracksCleared',
    SUBTITLE_TRACK_SWITCH = 'hlsSubtitleTrackSwitch',
    SUBTITLE_TRACK_LOADING = 'hlsSubtitleTrackLoading',
    SUBTITLE_TRACK_LOADED = 'hlsSubtitleTrackLoaded',
    SUBTITLE_TRACK_UPDATED = 'hlsSubtitleTrackUpdated',
    SUBTITLE_FRAG_PROCESSED = 'hlsSubtitleFragProcessed',
    CUES_PARSED = 'hlsCuesParsed',
    NON_NATIVE_TEXT_TRACKS_FOUND = 'hlsNonNativeTextTracksFound',
    INIT_PTS_FOUND = 'hlsInitPtsFound',
    FRAG_LOADING = 'hlsFragLoading',
    FRAG_LOAD_EMERGENCY_ABORTED = 'hlsFragLoadEmergencyAborted',
    FRAG_LOADED = 'hlsFragLoaded',
    FRAG_DECRYPTED = 'hlsFragDecrypted',
    FRAG_PARSING_INIT_SEGMENT = 'hlsFragParsingInitSegment',
    FRAG_PARSING_USERDATA = 'hlsFragParsingUserdata',
    FRAG_PARSING_METADATA = 'hlsFragParsingMetadata',
    FRAG_PARSED = 'hlsFragParsed',
    FRAG_BUFFERED = 'hlsFragBuffered',
    FRAG_CHANGED = 'hlsFragChanged',
    FPS_DROP = 'hlsFpsDrop',
    FPS_DROP_LEVEL_CAPPING = 'hlsFpsDropLevelCapping',
    MAX_AUTO_LEVEL_UPDATED = 'hlsMaxAutoLevelUpdated',
    ERROR = 'hlsError',
    DESTROYING = 'hlsDestroying',
    KEY_LOADING = 'hlsKeyLoading',
    KEY_LOADED = 'hlsKeyLoaded',
    LIVE_BACK_BUFFER_REACHED = 'hlsLiveBackBufferReached',
    BACK_BUFFER_REACHED = 'hlsBackBufferReached',
    STEERING_MANIFEST_LOADED = 'hlsSteeringManifestLoaded',
    ASSET_LIST_LOADING = 'hlsAssetListLoading',
    ASSET_LIST_LOADED = 'hlsAssetListLoaded',
    INTERSTITIALS_UPDATED = 'hlsInterstitialsUpdated',
    INTERSTITIALS_BUFFERED_TO_BOUNDARY = 'hlsInterstitialsBufferedToBoundary',
    INTERSTITIAL_ASSET_PLAYER_CREATED = 'hlsInterstitialAssetPlayerCreated',
    INTERSTITIAL_STARTED = 'hlsInterstitialStarted',
    INTERSTITIAL_ASSET_STARTED = 'hlsInterstitialAssetStarted',
    INTERSTITIAL_ASSET_ENDED = 'hlsInterstitialAssetEnded',
    INTERSTITIAL_ASSET_ERROR = 'hlsInterstitialAssetError',
    INTERSTITIAL_ENDED = 'hlsInterstitialEnded',
    INTERSTITIALS_PRIMARY_RESUMED = 'hlsInterstitialsPrimaryResumed',
    PLAYOUT_LIMIT_REACHED = 'hlsPlayoutLimitReached',
    EVENT_CUE_ENTER = 'hlsEventCueEnter',
}

member ASSET_LIST_LOADED

ASSET_LIST_LOADED = 'hlsAssetListLoaded'

member ASSET_LIST_LOADING

ASSET_LIST_LOADING = 'hlsAssetListLoading'

member AUDIO_TRACK_LOADED

AUDIO_TRACK_LOADED = 'hlsAudioTrackLoaded'

member AUDIO_TRACK_LOADING

AUDIO_TRACK_LOADING = 'hlsAudioTrackLoading'

member AUDIO_TRACK_SWITCHED

AUDIO_TRACK_SWITCHED = 'hlsAudioTrackSwitched'

member AUDIO_TRACK_SWITCHING

AUDIO_TRACK_SWITCHING = 'hlsAudioTrackSwitching'

member AUDIO_TRACK_UPDATED

AUDIO_TRACK_UPDATED = 'hlsAudioTrackUpdated'

member AUDIO_TRACKS_UPDATED

AUDIO_TRACKS_UPDATED = 'hlsAudioTracksUpdated'

member BACK_BUFFER_REACHED

BACK_BUFFER_REACHED = 'hlsBackBufferReached'

member BUFFER_APPENDED

BUFFER_APPENDED = 'hlsBufferAppended'

member BUFFER_APPENDING

BUFFER_APPENDING = 'hlsBufferAppending'

member BUFFER_CODECS

BUFFER_CODECS = 'hlsBufferCodecs'

member BUFFER_CREATED

BUFFER_CREATED = 'hlsBufferCreated'

member BUFFER_EOS

BUFFER_EOS = 'hlsBufferEos'

member BUFFER_FLUSHED

BUFFER_FLUSHED = 'hlsBufferFlushed'

member BUFFER_FLUSHING

BUFFER_FLUSHING = 'hlsBufferFlushing'

member BUFFER_RESET

BUFFER_RESET = 'hlsBufferReset'

member BUFFERED_TO_END

BUFFERED_TO_END = 'hlsBufferedToEnd'

member CUES_PARSED

CUES_PARSED = 'hlsCuesParsed'

member DESTROYING

DESTROYING = 'hlsDestroying'

member ERROR

ERROR = 'hlsError'

member EVENT_CUE_ENTER

EVENT_CUE_ENTER = 'hlsEventCueEnter'

member FPS_DROP

FPS_DROP = 'hlsFpsDrop'

member FPS_DROP_LEVEL_CAPPING

FPS_DROP_LEVEL_CAPPING = 'hlsFpsDropLevelCapping'

member FRAG_BUFFERED

FRAG_BUFFERED = 'hlsFragBuffered'

member FRAG_CHANGED

FRAG_CHANGED = 'hlsFragChanged'

member FRAG_DECRYPTED

FRAG_DECRYPTED = 'hlsFragDecrypted'

member FRAG_LOAD_EMERGENCY_ABORTED

FRAG_LOAD_EMERGENCY_ABORTED = 'hlsFragLoadEmergencyAborted'

member FRAG_LOADED

FRAG_LOADED = 'hlsFragLoaded'

member FRAG_LOADING

FRAG_LOADING = 'hlsFragLoading'

member FRAG_PARSED

FRAG_PARSED = 'hlsFragParsed'

member FRAG_PARSING_INIT_SEGMENT

FRAG_PARSING_INIT_SEGMENT = 'hlsFragParsingInitSegment'

member FRAG_PARSING_METADATA

FRAG_PARSING_METADATA = 'hlsFragParsingMetadata'

member FRAG_PARSING_USERDATA

FRAG_PARSING_USERDATA = 'hlsFragParsingUserdata'

member INIT_PTS_FOUND

INIT_PTS_FOUND = 'hlsInitPtsFound'

member INTERSTITIAL_ASSET_ENDED

INTERSTITIAL_ASSET_ENDED = 'hlsInterstitialAssetEnded'

member INTERSTITIAL_ASSET_ERROR

INTERSTITIAL_ASSET_ERROR = 'hlsInterstitialAssetError'

member INTERSTITIAL_ASSET_PLAYER_CREATED

INTERSTITIAL_ASSET_PLAYER_CREATED = 'hlsInterstitialAssetPlayerCreated'

member INTERSTITIAL_ASSET_STARTED

INTERSTITIAL_ASSET_STARTED = 'hlsInterstitialAssetStarted'

member INTERSTITIAL_ENDED

INTERSTITIAL_ENDED = 'hlsInterstitialEnded'

member INTERSTITIAL_STARTED

INTERSTITIAL_STARTED = 'hlsInterstitialStarted'

member INTERSTITIALS_BUFFERED_TO_BOUNDARY

INTERSTITIALS_BUFFERED_TO_BOUNDARY = 'hlsInterstitialsBufferedToBoundary'

member INTERSTITIALS_PRIMARY_RESUMED

INTERSTITIALS_PRIMARY_RESUMED = 'hlsInterstitialsPrimaryResumed'

member INTERSTITIALS_UPDATED

INTERSTITIALS_UPDATED = 'hlsInterstitialsUpdated'

member KEY_LOADED

KEY_LOADED = 'hlsKeyLoaded'

member KEY_LOADING

KEY_LOADING = 'hlsKeyLoading'

member LEVEL_LOADED

LEVEL_LOADED = 'hlsLevelLoaded'

member LEVEL_LOADING

LEVEL_LOADING = 'hlsLevelLoading'

member LEVEL_PTS_UPDATED

LEVEL_PTS_UPDATED = 'hlsLevelPtsUpdated'

member LEVEL_SWITCHED

LEVEL_SWITCHED = 'hlsLevelSwitched'

member LEVEL_SWITCHING

LEVEL_SWITCHING = 'hlsLevelSwitching'

member LEVEL_UPDATED

LEVEL_UPDATED = 'hlsLevelUpdated'

member LEVELS_UPDATED

LEVELS_UPDATED = 'hlsLevelsUpdated'

member LIVE_BACK_BUFFER_REACHED

LIVE_BACK_BUFFER_REACHED = 'hlsLiveBackBufferReached'

member MANIFEST_LOADED

MANIFEST_LOADED = 'hlsManifestLoaded'

member MANIFEST_LOADING

MANIFEST_LOADING = 'hlsManifestLoading'

member MANIFEST_PARSED

MANIFEST_PARSED = 'hlsManifestParsed'

member MAX_AUTO_LEVEL_UPDATED

MAX_AUTO_LEVEL_UPDATED = 'hlsMaxAutoLevelUpdated'

member MEDIA_ATTACHED

MEDIA_ATTACHED = 'hlsMediaAttached'

member MEDIA_ATTACHING

MEDIA_ATTACHING = 'hlsMediaAttaching'

member MEDIA_DETACHED

MEDIA_DETACHED = 'hlsMediaDetached'

member MEDIA_DETACHING

MEDIA_DETACHING = 'hlsMediaDetaching'

member MEDIA_ENDED

MEDIA_ENDED = 'hlsMediaEnded'

member NON_NATIVE_TEXT_TRACKS_FOUND

NON_NATIVE_TEXT_TRACKS_FOUND = 'hlsNonNativeTextTracksFound'

member PLAYOUT_LIMIT_REACHED

PLAYOUT_LIMIT_REACHED = 'hlsPlayoutLimitReached'

member STALL_RESOLVED

STALL_RESOLVED = 'hlsStallResolved'

member STEERING_MANIFEST_LOADED

STEERING_MANIFEST_LOADED = 'hlsSteeringManifestLoaded'

member SUBTITLE_FRAG_PROCESSED

SUBTITLE_FRAG_PROCESSED = 'hlsSubtitleFragProcessed'

member SUBTITLE_TRACK_LOADED

SUBTITLE_TRACK_LOADED = 'hlsSubtitleTrackLoaded'

member SUBTITLE_TRACK_LOADING

SUBTITLE_TRACK_LOADING = 'hlsSubtitleTrackLoading'

member SUBTITLE_TRACK_SWITCH

SUBTITLE_TRACK_SWITCH = 'hlsSubtitleTrackSwitch'

member SUBTITLE_TRACK_UPDATED

SUBTITLE_TRACK_UPDATED = 'hlsSubtitleTrackUpdated'

member SUBTITLE_TRACKS_CLEARED

SUBTITLE_TRACKS_CLEARED = 'hlsSubtitleTracksCleared'

member SUBTITLE_TRACKS_UPDATED

SUBTITLE_TRACKS_UPDATED = 'hlsSubtitleTracksUpdated'

enum FragmentState

const enum FragmentState {
    NOT_LOADED = 'NOT_LOADED',
    APPENDING = 'APPENDING',
    PARTIAL = 'PARTIAL',
    OK = 'OK',
}

member APPENDING

APPENDING = 'APPENDING'

member NOT_LOADED

NOT_LOADED = 'NOT_LOADED'

member OK

OK = 'OK'

member PARTIAL

PARTIAL = 'PARTIAL'

enum HlsSkip

const enum HlsSkip {
    No = '',
    Yes = 'YES',
    v2 = 'v2',
}

member No

No = ''

member v2

v2 = 'v2'

member Yes

Yes = 'YES'

enum KeySystemFormats

const enum KeySystemFormats {
    CLEARKEY = 'org.w3.clearkey',
    FAIRPLAY = 'com.apple.streamingkeydelivery',
    PLAYREADY = 'com.microsoft.playready',
    WIDEVINE = 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed',
}

member CLEARKEY

CLEARKEY = 'org.w3.clearkey'

member FAIRPLAY

FAIRPLAY = 'com.apple.streamingkeydelivery'

member PLAYREADY

PLAYREADY = 'com.microsoft.playready'

member WIDEVINE

WIDEVINE = 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed'

enum KeySystems

const enum KeySystems {
    CLEARKEY = 'org.w3.clearkey',
    FAIRPLAY = 'com.apple.fps',
    PLAYREADY = 'com.microsoft.playready',
    WIDEVINE = 'com.widevine.alpha',
}

See Also
- https://developer.mozilla.org/en-US/docs/Web/API/Navigator/requestMediaKeySystemAccess

member CLEARKEY

CLEARKEY = 'org.w3.clearkey'

member FAIRPLAY

FAIRPLAY = 'com.apple.fps'

member PLAYREADY

PLAYREADY = 'com.microsoft.playready'

member WIDEVINE

WIDEVINE = 'com.widevine.alpha'

enum MetadataSchema

enum MetadataSchema {
    audioId3 = 'org.id3',
    dateRange = 'com.apple.quicktime.HLS',
    emsg = 'https://aomedia.org/emsg/ID3',
    misbklv = 'urn:misb:KLV:bin:1910.1',
}

member audioId3

audioId3 = 'org.id3'

member dateRange

dateRange = 'com.apple.quicktime.HLS'

member emsg

emsg = 'https://aomedia.org/emsg/ID3'

member misbklv

misbklv = 'urn:misb:KLV:bin:1910.1'

enum NetworkErrorAction

const enum NetworkErrorAction {
    DoNothing = 0,
    SendEndCallback = 1,
    SendAlternateToPenaltyBox = 2,
    RemoveAlternatePermanently = 3,
    InsertDiscontinuity = 4,
    RetryRequest = 5,
}

member DoNothing

DoNothing = 0

member InsertDiscontinuity

InsertDiscontinuity = 4

member RemoveAlternatePermanently

RemoveAlternatePermanently = 3

member RetryRequest

RetryRequest = 5

member SendAlternateToPenaltyBox

SendAlternateToPenaltyBox = 2

member SendEndCallback

SendEndCallback = 1

enum PlaylistContextType

const enum PlaylistContextType {
    MANIFEST = 'manifest',
    LEVEL = 'level',
    AUDIO_TRACK = 'audioTrack',
    SUBTITLE_TRACK = 'subtitleTrack',
}

member AUDIO_TRACK

AUDIO_TRACK = 'audioTrack'

member LEVEL

LEVEL = 'level'

member MANIFEST

MANIFEST = 'manifest'

member SUBTITLE_TRACK

SUBTITLE_TRACK = 'subtitleTrack'

enum PlaylistLevelType

const enum PlaylistLevelType {
    MAIN = 'main',
    AUDIO = 'audio',
    SUBTITLE = 'subtitle',
}

member AUDIO

AUDIO = 'audio'

member MAIN

MAIN = 'main'

member SUBTITLE

SUBTITLE = 'subtitle'

enum TimelineOccupancy

enum TimelineOccupancy {
    Point = 0,
    Range = 1,
}

member Point

Point = 0

member Range

Range = 1

Type Aliases

type ABRControllerConfig

type ABRControllerConfig = {
    abrEwmaFastLive: number;
    abrEwmaSlowLive: number;
    abrEwmaFastVoD: number;
    abrEwmaSlowVoD: number;
    /**
     * Default bandwidth estimate in bits/s prior to collecting fragment bandwidth samples
     */
    abrEwmaDefaultEstimate: number;
    abrEwmaDefaultEstimateMax: number;
    abrBandWidthFactor: number;
    abrBandWidthUpFactor: number;
    abrMaxWithRealBitrate: boolean;
    maxStarvationDelay: number;
    maxLoadingDelay: number;
};

type AssetListJSON

type AssetListJSON = {
    ASSETS: Array<{
        URI: string;
        DURATION: string;
    }>;
};

type AttachMediaSourceData

type AttachMediaSourceData = {
    media: HTMLMediaElement;
    mediaSource: MediaSource | null;
    tracks: SourceBufferTrackSet;
};

type AudioPlaylistType

type AudioPlaylistType = 'AUDIO';

type AudioSelectionOption

type AudioSelectionOption = {
    lang?: string;
    assocLang?: string;
    characteristics?: string;
    channels?: string;
    name?: string;
    audioCodec?: string;
    groupId?: string;
    default?: boolean;
};

type BaseData

type BaseData = {
    url: string;
};

type BaseTrackSet

type BaseTrackSet = Partial<Record<SourceBufferName, BaseTrack>>;

type Bufferable

type Bufferable = {
    buffered: TimeRanges;
};

type BufferControllerConfig

type BufferControllerConfig = {
    appendErrorMaxRetry: number;
    backBufferLength: number;
    frontBufferFlushThreshold: number;
    liveDurationInfinity: boolean;
    /**
     * @deprecated use backBufferLength
     */
    liveBackBufferLength: number | null;
};

type BufferCreatedTrackSet

type BufferCreatedTrackSet = Partial<Record<SourceBufferName, BufferCreatedTrack>>;

type BufferInfo

type BufferInfo = {
    len: number;
    start: number;
    end: number;
    nextStart?: number;
    buffered?: BufferTimeRange[];
    bufferedIndex: number;
};

type BufferTimeRange

type BufferTimeRange = {
    start: number;
    end: number;
};

Provides methods dealing with buffer length retrieval for example.
In general, a helper around HTML5 MediaElement TimeRanges gathered from buffered property.
Also
See Also
- https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/buffered

type CapLevelControllerConfig

type CapLevelControllerConfig = {
    capLevelToPlayerSize: boolean;
};

type CMCDControllerConfig

type CMCDControllerConfig = {
    sessionId?: string;
    contentId?: string;
    useHeaders?: boolean;
    includeKeys?: string[];
};

type ContentSteeringOptions

type ContentSteeringOptions = {
    uri: string;
    pathwayId: string;
};

type DateRangeCue

type DateRangeCue = {
    pre: boolean;
    post: boolean;
    once: boolean;
};

type DRMSystemConfiguration

type DRMSystemConfiguration = {
    licenseUrl: string;
    serverCertificateUrl?: string;
    generateRequest?: (
        this: Hls,
        initDataType: string,
        initData: ArrayBuffer | null,
        keyContext: MediaKeySessionContext
    ) =>
        | {
              initDataType: string;
              initData: ArrayBuffer | null;
          }
        | undefined
        | never;
};

type DRMSystemOptions

type DRMSystemOptions = {
    audioRobustness?: string;
    videoRobustness?: string;
    audioEncryptionScheme?: string | null;
    videoEncryptionScheme?: string | null;
    persistentState?: MediaKeysRequirement;
    distinctiveIdentifier?: MediaKeysRequirement;
    sessionTypes?: string[];
    sessionType?: string;
};

type DRMSystemsConfiguration

type DRMSystemsConfiguration = Partial<Record<KeySystems, DRMSystemConfiguration>>;

type ElementaryStreams

type ElementaryStreams = Record<ElementaryStreamTypes, ElementaryStreamInfo | null>;

type EMEControllerConfig

type EMEControllerConfig = {
    licenseXhrSetup?: (
        this: Hls,
        xhr: XMLHttpRequest,
        url: string,
        keyContext: MediaKeySessionContext,
        licenseChallenge: Uint8Array
    ) => void | Uint8Array | Promise<Uint8Array | void>;
    licenseResponseCallback?: (
        this: Hls,
        xhr: XMLHttpRequest,
        url: string,
        keyContext: MediaKeySessionContext
    ) => ArrayBuffer;
    emeEnabled: boolean;
    widevineLicenseUrl?: string;
    drmSystems: DRMSystemsConfiguration;
    drmSystemOptions: DRMSystemOptions;
    requestMediaKeySystemAccessFunc: MediaKeyFunc | null;
    requireKeySystemAccessOnStart: boolean;
};

type ExtendedSourceBuffer

type ExtendedSourceBuffer = SourceBuffer & {
    onbufferedchange?: ((this: SourceBuffer, ev: Event) => any) | null;
};

type FPSControllerConfig

type FPSControllerConfig = {
    capLevelOnFPSDrop: boolean;
    fpsDroppedMonitoringPeriod: number;
    fpsDroppedMonitoringThreshold: number;
};

type FragmentLoaderConfig

type FragmentLoaderConfig = {
    fragLoadingTimeOut: number;
    fragLoadingMaxRetry: number;
    fragLoadingRetryDelay: number;
    fragLoadingMaxRetryTimeout: number;
};

Deprecated
use fragLoadPolicy.default

type FragmentLoadProgressCallback

type FragmentLoadProgressCallback = (
    result: FragLoadedData | PartsLoadedData
) => void;

type GapControllerConfig

type GapControllerConfig = {
    detectStallWithCurrentTimeMs: number;
    highBufferWatchdogPeriod: number;
    nudgeOffset: number;
    nudgeMaxRetry: number;
    nudgeOnVideoHole: boolean;
};

type HdcpLevel

type HdcpLevel = (typeof HdcpLevels)[number];

type HlsAssetPlayerConfig

type HlsAssetPlayerConfig = Partial<HlsConfig> &
    Required<Pick<HlsConfig, 'assetPlayerId' | 'primarySessionId'>>;

type HlsConfig

type HlsConfig = {
    debug: boolean | ILogger;
    enableWorker: boolean;
    workerPath: null | string;
    enableSoftwareAES: boolean;
    minAutoBitrate: number;
    ignoreDevicePixelRatio: boolean;
    maxDevicePixelRatio: number;
    preferManagedMediaSource: boolean;
    preserveManualLevelOnError: boolean;
    timelineOffset?: number;
    ignorePlaylistParsingErrors: boolean;
    loader: {
        new (confg: HlsConfig): Loader<LoaderContext>;
    };
    fLoader?: FragmentLoaderConstructor;
    pLoader?: PlaylistLoaderConstructor;
    fetchSetup?: (
        context: LoaderContext,
        initParams: any
    ) => Promise<Request> | Request;
    xhrSetup?: (xhr: XMLHttpRequest, url: string) => Promise<void> | void;
    audioStreamController?: typeof AudioStreamController;
    audioTrackController?: typeof AudioTrackController;
    subtitleStreamController?: typeof SubtitleStreamController;
    subtitleTrackController?: typeof SubtitleTrackController;
    timelineController?: typeof TimelineController;
    emeController?: typeof EMEController;
    cmcd?: CMCDControllerConfig;
    cmcdController?: typeof CMCDController;
    contentSteeringController?: typeof ContentSteeringController;
    interstitialsController?: typeof InterstitialsController;
    enableInterstitialPlayback: boolean;
    interstitialAppendInPlace: boolean;
    interstitialLiveLookAhead: number;
    assetPlayerId?: string;
    useMediaCapabilities: boolean;
    abrController: typeof AbrController;
    bufferController: typeof BufferController;
    capLevelController: typeof CapLevelController;
    errorController: typeof ErrorController;
    fpsController: typeof FPSController;
    progressive: boolean;
    lowLatencyMode: boolean;
    primarySessionId?: string;
} & ABRControllerConfig &
    BufferControllerConfig &
    CapLevelControllerConfig &
    EMEControllerConfig &
    FPSControllerConfig &
    GapControllerConfig &
    LevelControllerConfig &
    MP4RemuxerConfig &
    StreamControllerConfig &
    SelectionPreferences &
    LatencyControllerConfig &
    MetadataControllerConfig &
    TimelineControllerConfig &
    TSDemuxerConfig &
    HlsLoadPolicies &
    FragmentLoaderConfig &
    PlaylistLoaderConfig;

type HlsLoadPolicies

type HlsLoadPolicies = {
    fragLoadPolicy: LoadPolicy;
    keyLoadPolicy: LoadPolicy;
    certLoadPolicy: LoadPolicy;
    playlistLoadPolicy: LoadPolicy;
    manifestLoadPolicy: LoadPolicy;
    steeringManifestLoadPolicy: LoadPolicy;
    interstitialAssetListLoadPolicy: LoadPolicy;
};

type IErrorAction

type IErrorAction = {
    action: NetworkErrorAction;
    flags: ErrorActionFlags;
    retryCount?: number;
    retryConfig?: RetryConfig;
    hdcpLevel?: HdcpLevel;
    nextAutoLevel?: number;
    resolved?: boolean;
};

type InFlightData

type InFlightData = {
    frag: Fragment | null;
    state: (typeof State)[keyof typeof State];
};

type InFlightFragments

type InFlightFragments = {
    [PlaylistLevelType.MAIN]: InFlightData;
    [PlaylistLevelType.AUDIO]?: InFlightData;
    [PlaylistLevelType.SUBTITLE]?: InFlightData;
};

type InterstitialAssetErrorData

type InterstitialAssetErrorData = {
    asset: InterstitialAssetItem | null;
    assetListIndex: number;
    event: InterstitialEvent | null;
    schedule: InterstitialScheduleItem[] | null;
    scheduleIndex: number;
    player: HlsAssetPlayer | null;
} & ErrorData;

type InterstitialAssetId

type InterstitialAssetId = string;

type InterstitialAssetItem

type InterstitialAssetItem = {
    parentIdentifier: InterstitialId;
    identifier: InterstitialAssetId;
    duration: number | null;
    startOffset: number;
    timelineStart: number;
    uri: string;
    error?: Error;
};

type InterstitialId

type InterstitialId = string;

type InterstitialScheduleDurations

type InterstitialScheduleDurations = {
    primary: number;
    playout: number;
    integrated: number;
};

type InterstitialScheduleEventItem

type InterstitialScheduleEventItem = {
    event: InterstitialEvent;
    start: number;
    end: number;
    playout: {
        start: number;
        end: number;
    };
    integrated: {
        start: number;
        end: number;
    };
};

type InterstitialScheduleItem

type InterstitialScheduleItem =
    | InterstitialScheduleEventItem
    | InterstitialSchedulePrimaryItem;

type InterstitialSchedulePrimaryItem

type InterstitialSchedulePrimaryItem = {
    nextEvent: InterstitialEvent | null;
    previousEvent: InterstitialEvent | null;
    event?: undefined;
    start: number;
    end: number;
    playout: {
        start: number;
        end: number;
    };
    integrated: {
        start: number;
        end: number;
    };
};

type LatencyControllerConfig

type LatencyControllerConfig = {
    liveSyncDurationCount: number;
    liveMaxLatencyDurationCount: number;
    liveSyncDuration?: number;
    liveMaxLatencyDuration?: number;
    maxLiveSyncPlaybackRate: number;
    liveSyncOnStallIncrease: number;
};

type LevelControllerConfig

type LevelControllerConfig = {
    startLevel?: number;
};

type LoaderConfig

type LoaderConfig = {
    maxTimeToFirstByteMs: number;
    maxLoadTimeMs: number;
    timeoutRetry: RetryConfig | null;
    errorRetry: RetryConfig | null;
};

type LoaderOnAbort

type LoaderOnAbort<T extends LoaderContext> = (
    stats: LoaderStats,
    context: T,
    networkDetails: any
) => void;

type LoaderOnError

type LoaderOnError<T extends LoaderContext> = (
    error: {
        code: number;
        text: string;
    },
    context: T,
    networkDetails: any,
    stats: LoaderStats
) => void;

type LoaderOnProgress

type LoaderOnProgress<T extends LoaderContext> = (
    stats: LoaderStats,
    context: T,
    data: string | ArrayBuffer,
    networkDetails: any
) => void;

type LoaderOnSuccess

type LoaderOnSuccess<T extends LoaderContext> = (
    response: LoaderResponse,
    stats: LoaderStats,
    context: T,
    networkDetails: any
) => void;

type LoaderOnTimeout

type LoaderOnTimeout<T extends LoaderContext> = (
    stats: LoaderStats,
    context: T,
    networkDetails: any
) => void;

type LoadPolicy

type LoadPolicy = {
    default: LoaderConfig;
};

type MainPlaylistType

type MainPlaylistType = AudioPlaylistType | 'VIDEO';

type MediaDecodingInfo

type MediaDecodingInfo = {
    supported: boolean;
    configurations: readonly MediaDecodingConfiguration[];
    decodingInfoResults: readonly MediaCapabilitiesDecodingInfo[];
    error?: Error;
};

type MediaKeyFunc

type MediaKeyFunc = (
    keySystem: KeySystems,
    supportedConfigurations: MediaKeySystemConfiguration[]
) => Promise<MediaKeySystemAccess>;

type MediaOverrides

type MediaOverrides = {
    duration?: number;
    endOfStream?: boolean;
    cueRemoval?: boolean;
};

type MediaPlaylistType

type MediaPlaylistType = MainPlaylistType | SubtitlePlaylistType;

type MetadataControllerConfig

type MetadataControllerConfig = {
    enableDateRangeMetadataCues: boolean;
    enableEmsgMetadataCues: boolean;
    enableEmsgKLVMetadata: boolean;
    enableID3MetadataCues: boolean;
};

type MP4RemuxerConfig

type MP4RemuxerConfig = {
    stretchShortVideoTrack: boolean;
    maxAudioFramesDrift: number;
};

type ParsedMultivariantPlaylist

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;
};

type PathwayClone

type PathwayClone = {
    'BASE-ID': string;
    ID: string;
    'URI-REPLACEMENT': UriReplacement;
};

type PlaybackRestrictions

type PlaybackRestrictions = {
    skip: boolean;
    jump: boolean;
};

type PlayheadTimes

type PlayheadTimes = {
    bufferedEnd: number;
    currentTime: number;
    duration: number;
    seekableStart: number;
};

type PlaylistLoaderConfig

type PlaylistLoaderConfig = {
    manifestLoadingTimeOut: number;
    manifestLoadingMaxRetry: number;
    manifestLoadingRetryDelay: number;
    manifestLoadingMaxRetryTimeout: number;
    levelLoadingTimeOut: number;
    levelLoadingMaxRetry: number;
    levelLoadingRetryDelay: number;
    levelLoadingMaxRetryTimeout: number;
};

Deprecated
use manifestLoadPolicy.default and playlistLoadPolicy.default

type RationalTimestamp

type RationalTimestamp = {
    baseTime: number;
    timescale: number;
};

type RetryConfig

type RetryConfig = {
    maxNumRetry: number;
    retryDelayMs: number;
    maxRetryDelayMs: number;
    backoff?: 'exponential' | 'linear';
    shouldRetry?: (
        retryConfig: RetryConfig | null | undefined,
        retryCount: number,
        isTimeout: boolean,
        loaderResponse: LoaderResponse | undefined,
        retry: boolean
    ) => boolean;
};

type SelectionPreferences

type SelectionPreferences = {
    videoPreference?: VideoSelectionOption;
    audioPreference?: AudioSelectionOption;
    subtitlePreference?: SubtitleSelectionOption;
};

type SnapOptions

type SnapOptions = {
    out: boolean;
    in: boolean;
};

type SourceBufferName

type SourceBufferName = 'video' | 'audio' | 'audiovideo';

type SourceBufferTrackSet

type SourceBufferTrackSet = Partial<Record<SourceBufferName, SourceBufferTrack>>;

type SteeringManifest

type SteeringManifest = {
    VERSION: 1;
    TTL: number;
    'RELOAD-URI'?: string;
    'PATHWAY-PRIORITY': string[];
    'PATHWAY-CLONES'?: PathwayClone[];
};

type StreamControllerConfig

type StreamControllerConfig = {
    autoStartLoad: boolean;
    startPosition: number;
    defaultAudioCodec?: string;
    initialLiveManifestSize: number;
    maxBufferLength: number;
    maxBufferSize: number;
    maxBufferHole: number;
    maxFragLookUpTolerance: number;
    maxMaxBufferLength: number;
    startFragPrefetch: boolean;
    testBandwidth: boolean;
    liveSyncMode?: 'edge' | 'buffered';
    startOnSegmentBoundary: boolean;
};

type SubtitlePlaylistType

type SubtitlePlaylistType = 'SUBTITLES' | 'CLOSED-CAPTIONS';

type SubtitleSelectionOption

type SubtitleSelectionOption = {
    id?: number;
    lang?: string;
    assocLang?: string;
    characteristics?: string;
    name?: string;
    groupId?: string;
    default?: boolean;
    forced?: boolean;
};

type TimelineControllerConfig

type TimelineControllerConfig = {
    cueHandler: CuesInterface;
    enableWebVTT: boolean;
    enableIMSC1: boolean;
    enableCEA708Captions: boolean;
    captionsTextTrack1Label: string;
    captionsTextTrack1LanguageCode: string;
    captionsTextTrack2Label: string;
    captionsTextTrack2LanguageCode: string;
    captionsTextTrack3Label: string;
    captionsTextTrack3LanguageCode: string;
    captionsTextTrack4Label: string;
    captionsTextTrack4LanguageCode: string;
    renderTextTracksNatively: boolean;
};

type TimestampOffset

type TimestampOffset = RationalTimestamp & {
    trackId: number;
};

type TSDemuxerConfig

type TSDemuxerConfig = {
    forceKeyFrameOnDiscontinuity: boolean;
};

type UriReplacement

type UriReplacement = {
    HOST?: string;
    PARAMS?: {
        [queryParameter: string]: string;
    };
    'PER-VARIANT-URIS'?: {
        [stableVariantId: string]: string;
    };
    'PER-RENDITION-URIS'?: {
        [stableRenditionId: string]: string;
    };
};

type VariableMap

type VariableMap = Record<string, string>;

type VideoRange

type VideoRange = (typeof VideoRangeValues)[number];

type VideoSelectionOption

type VideoSelectionOption = {
    preferHDR?: boolean;
    allowedVideoRanges?: Array<VideoRange>;
    videoCodec?: string;
};

Package Files (1)

dist/hls.d.ts

Dependencies (0)

No dependencies.

Dev Dependencies (69)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/hls.js.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/hls.js)

HTML

<a href="https://www.jsdocs.io/package/hls.js"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 8 days ago.
Package analyzed in 19838 ms.
Missing or incorrect documentation? Open an issue for this package.