@zenvor/hls.js 1.0.0

package/src/empty-es.js

@@ -0,0 +1,5 @@
+// This file is inserted as a shim for modules which we do not want to include into the distro.
+// This replacement is done in the "alias" plugin of the rollup config.
+// Use a ES dedicated file as Rollup assigns an object in the output
+// For example: "var KeySystemFormats = emptyEs.KeySystemFormats;"
+module.exports = {};

package/src/empty.js

@@ -0,0 +1,3 @@
+// This file is inserted as a shim for modules which we do not want to include into the distro.
+// This replacement is done in the "alias" plugin of the rollup config.
+module.exports = undefined;

package/src/errors.ts

@@ -0,0 +1,107 @@
+export enum ErrorTypes {
+  // Identifier for a network error (loading error / timeout ...)
+  NETWORK_ERROR = 'networkError',
+  // Identifier for a media Error (video/parsing/mediasource error)
+  MEDIA_ERROR = 'mediaError',
+  // EME (encrypted media extensions) errors
+  KEY_SYSTEM_ERROR = 'keySystemError',
+  // Identifier for a mux Error (demuxing/remuxing)
+  MUX_ERROR = 'muxError',
+  // Identifier for all other errors
+  OTHER_ERROR = 'otherError',
+}
+
+export 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',
+  // Identifier for a manifest load error - data: { url : faulty URL, response : { code: error code, text: error text }}
+  MANIFEST_LOAD_ERROR = 'manifestLoadError',
+  // Identifier for a manifest load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
+  MANIFEST_LOAD_TIMEOUT = 'manifestLoadTimeOut',
+  // Identifier for a manifest parsing error - data: { url : faulty URL, reason : error reason}
+  MANIFEST_PARSING_ERROR = 'manifestParsingError',
+  // Identifier for a manifest with only incompatible codecs error - data: { url : faulty URL, reason : error reason}
+  MANIFEST_INCOMPATIBLE_CODECS_ERROR = 'manifestIncompatibleCodecsError',
+  // Identifier for a level which contains no fragments - data: { url: faulty URL, reason: "no fragments found in level", level: index of the bad level }
+  LEVEL_EMPTY_ERROR = 'levelEmptyError',
+  // Identifier for a live level which hits N (configured value) unchanged refreshes - data: { url : faulty URL, response : { code: error code, text: error text }}
+  PLAYLIST_UNCHANGED_ERROR = 'playlistUnchangedError',
+  // Identifier for a level load error - data: { url : faulty URL, response : { code: error code, text: error text }}
+  LEVEL_LOAD_ERROR = 'levelLoadError',
+  // Identifier for a level load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
+  LEVEL_LOAD_TIMEOUT = 'levelLoadTimeOut',
+  // Identifier for a level parse error - data: { url : faulty URL, error: Error, reason: error message }
+  LEVEL_PARSING_ERROR = 'levelParsingError',
+  // Identifier for a level switch error - data: { level : faulty level Id, event : error description}
+  LEVEL_SWITCH_ERROR = 'levelSwitchError',
+  // Identifier for an audio track load error - data: { url : faulty URL, response : { code: error code, text: error text }}
+  AUDIO_TRACK_LOAD_ERROR = 'audioTrackLoadError',
+  // Identifier for an audio track load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
+  AUDIO_TRACK_LOAD_TIMEOUT = 'audioTrackLoadTimeOut',
+  // Identifier for a subtitle track load error - data: { url : faulty URL, response : { code: error code, text: error text }}
+  SUBTITLE_LOAD_ERROR = 'subtitleTrackLoadError',
+  // Identifier for a subtitle track load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
+  SUBTITLE_TRACK_LOAD_TIMEOUT = 'subtitleTrackLoadTimeOut',
+  // Identifier for fragment load error - data: { frag : fragment object, response : { code: error code, text: error text }}
+  FRAG_LOAD_ERROR = 'fragLoadError',
+  // Identifier for fragment load timeout error - data: { frag : fragment object}
+  FRAG_LOAD_TIMEOUT = 'fragLoadTimeOut',
+  // Identifier for a fragment decryption error event - data: {id : demuxer Id,frag: fragment object, reason : parsing error description }
+  FRAG_DECRYPT_ERROR = 'fragDecryptError',
+  // Identifier for a fragment parsing error event - data: { id : demuxer Id, reason : parsing error description }
+  // will be renamed DEMUX_PARSING_ERROR and switched to MUX_ERROR in the next major release
+  FRAG_PARSING_ERROR = 'fragParsingError',
+  // Identifier for a fragment or part load skipped because of a GAP tag or attribute
+  FRAG_GAP = 'fragGap',
+  // Identifier for a remux alloc error event - data: { id : demuxer Id, frag : fragment object, bytes : nb of bytes on which allocation failed , reason : error text }
+  REMUX_ALLOC_ERROR = 'remuxAllocError',
+  // Identifier for decrypt key load error - data: { frag : fragment object, response : { code: error code, text: error text }}
+  KEY_LOAD_ERROR = 'keyLoadError',
+  // Identifier for decrypt key load timeout error - data: { frag : fragment object}
+  KEY_LOAD_TIMEOUT = 'keyLoadTimeOut',
+  // Triggered when an exception occurs while adding a sourceBuffer to MediaSource - data : { error : exception , mimeType : mimeType }
+  BUFFER_ADD_CODEC_ERROR = 'bufferAddCodecError',
+  // Triggered when source buffer(s) could not be created using level (manifest CODECS attribute), parsed media, or best guess codec(s) - data: { reason : error reason }
+  BUFFER_INCOMPATIBLE_CODECS_ERROR = 'bufferIncompatibleCodecsError',
+  // Identifier for a buffer append error - data: append error description
+  BUFFER_APPEND_ERROR = 'bufferAppendError',
+  // Identifier for a buffer appending error event - data: appending error description
+  BUFFER_APPENDING_ERROR = 'bufferAppendingError',
+  // Identifier for a buffer stalled error event
+  BUFFER_STALLED_ERROR = 'bufferStalledError',
+  // Identifier for a buffer full event
+  BUFFER_FULL_ERROR = 'bufferFullError',
+  // Identifier for a buffer seek over hole event
+  BUFFER_SEEK_OVER_HOLE = 'bufferSeekOverHole',
+  // Identifier for a buffer nudge on stall (playback is stuck although currentTime is in a buffered area)
+  BUFFER_NUDGE_ON_STALL = 'bufferNudgeOnStall',
+  // Identifier for a Interstitial Asset List load error - data: { url: faulty URL, response: { code: error code, text: error text } }
+  ASSET_LIST_LOAD_ERROR = 'assetListLoadError',
+  // Identifier for a Interstitial Asset List load timeout - data: { url: faulty URL, response: { code: error code, text: error text } }
+  ASSET_LIST_LOAD_TIMEOUT = 'assetListLoadTimeout',
+  // Identifier for a Interstitial Asset List parsing error - data: { url : faulty URL, reason : error reason, response : { code: error code, text: error text }}
+  ASSET_LIST_PARSING_ERROR = 'assetListParsingError',
+  // Identifier for a Interstitial Asset List parsing error - data: { url : faulty URL, reason : error reason, response : { code: error code, text: error text }}
+  INTERSTITIAL_ASSET_ITEM_ERROR = 'interstitialAssetItemError',
+  // Identifier for an internal exception happening inside hls.js while handling an event
+  INTERNAL_EXCEPTION = 'internalException',
+  // Identifier for an internal call to abort a loader
+  INTERNAL_ABORTED = 'aborted',
+  // Triggered when attachMedia fails
+  ATTACH_MEDIA_ERROR = 'attachMediaError',
+  // Triggered when MediaSource enters an invalid state that requires a reset
+  MEDIA_SOURCE_REQUIRES_RESET = 'mediaSourceRequiresReset',
+  // Uncategorized error
+  UNKNOWN = 'unknown',
+}

package/src/events.ts

@@ -0,0 +1,548 @@
+import type {
+  AlgoDataErrorData,
+  AlgoDataLoadedData,
+  AlgoDataLoadingData,
+  AssetListLoadedData,
+  AssetListLoadingData,
+  AudioTrackLoadedData,
+  AudioTracksUpdatedData,
+  AudioTrackSwitchedData,
+  AudioTrackSwitchingData,
+  AudioTrackUpdatedData,
+  BackBufferData,
+  BufferAppendedData,
+  BufferAppendingData,
+  BufferCodecsData,
+  BufferCreatedData,
+  BufferEOSData,
+  BufferFlushedData,
+  BufferFlushingData,
+  CuesParsedData,
+  ErrorData,
+  FPSDropData,
+  FPSDropLevelCappingData,
+  FragBufferedData,
+  FragChangedData,
+  FragDecryptedData,
+  FragLoadedData,
+  FragLoadEmergencyAbortedData,
+  FragLoadingData,
+  FragParsedData,
+  FragParsingInitSegmentData,
+  FragParsingMetadataData,
+  FragParsingUserdataData,
+  InitPTSFoundData,
+  InterstitialAssetEndedData,
+  InterstitialAssetErrorData,
+  InterstitialAssetPlayerCreatedData,
+  InterstitialAssetStartedData,
+  InterstitialEndedData,
+  InterstitialsBufferedToBoundaryData,
+  InterstitialsPrimaryResumed,
+  InterstitialStartedData,
+  InterstitialsUpdatedData,
+  KeyLoadedData,
+  KeyLoadingData,
+  LevelLoadedData,
+  LevelLoadingData,
+  LevelPTSUpdatedData,
+  LevelsUpdatedData,
+  LevelSwitchedData,
+  LevelSwitchingData,
+  LevelUpdatedData,
+  LiveBackBufferData,
+  ManifestLoadedData,
+  ManifestLoadingData,
+  ManifestParsedData,
+  MaxAutoLevelUpdatedData,
+  MediaAttachedData,
+  MediaAttachingData,
+  MediaDetachedData,
+  MediaDetachingData,
+  MediaEndedData,
+  NonNativeTextTracksData,
+  SteeringManifestLoadedData,
+  SubtitleFragProcessedData,
+  SubtitleTrackLoadedData,
+  SubtitleTracksUpdatedData,
+  SubtitleTrackSwitchData,
+  SubtitleTrackUpdatedData,
+  TrackLoadingData,
+} from './types/events';
+
+export enum Events {
+  // Fired before MediaSource is attaching to media element
+  MEDIA_ATTACHING = 'hlsMediaAttaching',
+  // Fired when MediaSource has been successfully attached to media element
+  MEDIA_ATTACHED = 'hlsMediaAttached',
+  // Fired before detaching MediaSource from media element
+  MEDIA_DETACHING = 'hlsMediaDetaching',
+  // Fired when MediaSource has been detached from media element
+  MEDIA_DETACHED = 'hlsMediaDetached',
+  // Fired when HTMLMediaElement dispatches "ended" event, or stalls at end of VOD program
+  MEDIA_ENDED = 'hlsMediaEnded',
+  // Fired after playback stall is resolved with playing, seeked, or ended event following BUFFER_STALLED_ERROR
+  STALL_RESOLVED = 'hlsStallResolved',
+  // Fired when the buffer is going to be reset
+  BUFFER_RESET = 'hlsBufferReset',
+  // Fired when we know about the codecs that we need buffers for to push into - data: {tracks : { container, codec, levelCodec, initSegment, metadata }}
+  BUFFER_CODECS = 'hlsBufferCodecs',
+  // fired when sourcebuffers have been created - data: { tracks : tracks }
+  BUFFER_CREATED = 'hlsBufferCreated',
+  // fired when we append a segment to the buffer - data: { segment: segment object }
+  BUFFER_APPENDING = 'hlsBufferAppending',
+  // fired when we are done with appending a media segment to the buffer - data : { parent : segment parent that triggered BUFFER_APPENDING, pending : nb of segments waiting for appending for this segment parent}
+  BUFFER_APPENDED = 'hlsBufferAppended',
+  // fired when the stream is finished and we want to notify the media buffer that there will be no more data - data: { }
+  BUFFER_EOS = 'hlsBufferEos',
+  // fired when all buffers are full to the end of the program, after calling MediaSource.endOfStream() (unless restricted)
+  BUFFERED_TO_END = 'hlsBufferedToEnd',
+  // fired when the media buffer should be flushed - data { startOffset, endOffset }
+  BUFFER_FLUSHING = 'hlsBufferFlushing',
+  // fired when the media buffer has been flushed - data: { }
+  BUFFER_FLUSHED = 'hlsBufferFlushed',
+  // fired to signal that a manifest loading starts - data: { url : manifestURL}
+  MANIFEST_LOADING = 'hlsManifestLoading',
+  // fired after manifest has been loaded - data: { levels : [available quality levels], audioTracks : [ available audio tracks ], url : manifestURL, stats : LoaderStats }
+  MANIFEST_LOADED = 'hlsManifestLoaded',
+  // fired after manifest has been parsed - data: { levels : [available quality levels], firstLevel : index of first quality level appearing in Manifest}
+  MANIFEST_PARSED = 'hlsManifestParsed',
+  // fired when a level switch is requested - data: { level : id of new level }
+  LEVEL_SWITCHING = 'hlsLevelSwitching',
+  // fired when a level switch is effective - data: { level : id of new level }
+  LEVEL_SWITCHED = 'hlsLevelSwitched',
+  // fired when a level playlist loading starts - data: { url : level URL, level : id of level being loaded}
+  LEVEL_LOADING = 'hlsLevelLoading',
+  // fired when a level playlist loading finishes - data: { details : levelDetails object, level : id of loaded level, stats : LoaderStats }
+  LEVEL_LOADED = 'hlsLevelLoaded',
+  // fired when a level's details have been updated based on previous details, after it has been loaded - data: { details : levelDetails object, level : id of updated level }
+  LEVEL_UPDATED = 'hlsLevelUpdated',
+  // fired when a level's PTS information has been updated after parsing a fragment - data: { details : levelDetails object, level : id of updated level, drift: PTS drift observed when parsing last fragment }
+  LEVEL_PTS_UPDATED = 'hlsLevelPtsUpdated',
+  // fired to notify that levels have changed after removing a level - data: { levels : [available quality levels] }
+  LEVELS_UPDATED = 'hlsLevelsUpdated',
+  // fired to notify that audio track lists has been updated - data: { audioTracks : audioTracks }
+  AUDIO_TRACKS_UPDATED = 'hlsAudioTracksUpdated',
+  // fired when an audio track switching is requested - data: { id : audio track id }
+  AUDIO_TRACK_SWITCHING = 'hlsAudioTrackSwitching',
+  // fired when an audio track switch actually occurs - data: { id : audio track id }
+  AUDIO_TRACK_SWITCHED = 'hlsAudioTrackSwitched',
+  // fired when an audio track loading starts - data: { url : audio track URL, id : audio track id }
+  AUDIO_TRACK_LOADING = 'hlsAudioTrackLoading',
+  // fired when an audio track loading finishes - data: { details : levelDetails object, id : audio track id, stats : LoaderStats }
+  AUDIO_TRACK_LOADED = 'hlsAudioTrackLoaded',
+  // fired when an audio tracks's details have been updated based on previous details, after it has been loaded - data: { details : levelDetails object, id : track id }
+  AUDIO_TRACK_UPDATED = 'hlsAudioTrackUpdated',
+  // fired to notify that subtitle track lists has been updated - data: { subtitleTracks : subtitleTracks }
+  SUBTITLE_TRACKS_UPDATED = 'hlsSubtitleTracksUpdated',
+  // fired to notify that subtitle tracks were cleared as a result of stopping the media
+  SUBTITLE_TRACKS_CLEARED = 'hlsSubtitleTracksCleared',
+  // fired when an subtitle track switch occurs - data: { id : subtitle track id }
+  SUBTITLE_TRACK_SWITCH = 'hlsSubtitleTrackSwitch',
+  // fired when a subtitle track loading starts - data: { url : subtitle track URL, id : subtitle track id }
+  SUBTITLE_TRACK_LOADING = 'hlsSubtitleTrackLoading',
+  // fired when a subtitle track loading finishes - data: { details : levelDetails object, id : subtitle track id, stats : LoaderStats }
+  SUBTITLE_TRACK_LOADED = 'hlsSubtitleTrackLoaded',
+  // fired when a subtitle  racks's details have been updated based on previous details, after it has been loaded - data: { details : levelDetails object, id : track id }
+  SUBTITLE_TRACK_UPDATED = 'hlsSubtitleTrackUpdated',
+  // fired when a subtitle fragment has been processed - data: { success : boolean, frag : the processed frag }
+  SUBTITLE_FRAG_PROCESSED = 'hlsSubtitleFragProcessed',
+  // fired when a set of VTTCues to be managed externally has been parsed - data: { type: string, track: string, cues: [ VTTCue ] }
+  CUES_PARSED = 'hlsCuesParsed',
+  // fired when a text track to be managed externally is found - data: { tracks: [ { label: string, kind: string, default: boolean } ] }
+  NON_NATIVE_TEXT_TRACKS_FOUND = 'hlsNonNativeTextTracksFound',
+  // fired when the first timestamp is found - data: { id : demuxer id, initPTS: initPTS, timescale: timescale, frag : fragment object }
+  INIT_PTS_FOUND = 'hlsInitPtsFound',
+  // fired when a fragment loading starts - data: { frag : fragment object }
+  FRAG_LOADING = 'hlsFragLoading',
+  // fired when a fragment loading is progressing - data: { frag : fragment object, { trequest, tfirst, loaded } }
+  // FRAG_LOAD_PROGRESS = 'hlsFragLoadProgress',
+  // Identifier for fragment load aborting for emergency switch down - data: { frag : fragment object }
+  FRAG_LOAD_EMERGENCY_ABORTED = 'hlsFragLoadEmergencyAborted',
+  // fired when a fragment loading is completed - data: { frag : fragment object, payload : fragment payload, stats : LoaderStats }
+  FRAG_LOADED = 'hlsFragLoaded',
+  // fired when a fragment has finished decrypting - data: { id : demuxer id, frag: fragment object, payload : fragment payload, stats : { tstart, tdecrypt } }
+  FRAG_DECRYPTED = 'hlsFragDecrypted',
+  // fired when Init Segment has been extracted from fragment - data: { id : demuxer id, frag: fragment object, moov : moov MP4 box, codecs : codecs found while parsing fragment }
+  FRAG_PARSING_INIT_SEGMENT = 'hlsFragParsingInitSegment',
+  // fired when parsing sei text is completed - data: { id : demuxer id, frag: fragment object, samples : [ sei samples pes ] }
+  FRAG_PARSING_USERDATA = 'hlsFragParsingUserdata',
+  // fired when parsing id3 is completed - data: { id : demuxer id, frag: fragment object, samples : [ id3 samples pes ] }
+  FRAG_PARSING_METADATA = 'hlsFragParsingMetadata',
+  // fired when data have been extracted from fragment - data: { id : demuxer id, frag: fragment object, data1 : moof MP4 box or TS fragments, data2 : mdat MP4 box or null}
+  // FRAG_PARSING_DATA = 'hlsFragParsingData',
+  // fired when fragment parsing is completed - data: { id : demuxer id, frag: fragment object }
+  FRAG_PARSED = 'hlsFragParsed',
+  // fired when fragment remuxed MP4 boxes have all been appended into SourceBuffer - data: { id : demuxer id, frag : fragment object, stats : LoaderStats }
+  FRAG_BUFFERED = 'hlsFragBuffered',
+  // fired when fragment matching with current media position is changing - data : { id : demuxer id, frag : fragment object }
+  FRAG_CHANGED = 'hlsFragChanged',
+  // fired when an algo data segment loading starts - data: { frag: fragment object, url: string }
+  ALGO_DATA_LOADING = 'hlsAlgoDataLoading',
+  // fired when an algo data segment loading finishes - data: { frag: fragment object, url: string, chunk: AlgoChunk }
+  ALGO_DATA_LOADED = 'hlsAlgoDataLoaded',
+  // fired when an algo data segment loading fails - data: { frag: fragment object, url: string, error: Error }
+  ALGO_DATA_ERROR = 'hlsAlgoDataError',
+  // Identifier for a FPS drop event - data: { currentDropped, currentDecoded, totalDroppedFrames }
+  FPS_DROP = 'hlsFpsDrop',
+  // triggered when FPS drop triggers auto level capping - data: { level, droppedLevel }
+  FPS_DROP_LEVEL_CAPPING = 'hlsFpsDropLevelCapping',
+  // triggered when maxAutoLevel changes - data { autoLevelCapping, levels, maxAutoLevel, minAutoLevel, maxHdcpLevel }
+  MAX_AUTO_LEVEL_UPDATED = 'hlsMaxAutoLevelUpdated',
+  // Identifier for an error event - data: { type : error type, details : error details, fatal : if true, hls.js cannot/will not try to recover, if false, hls.js will try to recover,other error specific data }
+  ERROR = 'hlsError',
+  // fired when hls.js instance starts destroying. Different from MEDIA_DETACHED as one could want to detach and reattach a media to the instance of hls.js to handle mid-rolls for example - data: { }
+  DESTROYING = 'hlsDestroying',
+  // fired when a decrypt key loading starts - data: { frag : fragment object }
+  KEY_LOADING = 'hlsKeyLoading',
+  // fired when a decrypt key loading is completed - data: { frag : fragment object, keyInfo : KeyLoaderInfo }
+  KEY_LOADED = 'hlsKeyLoaded',
+  // deprecated; please use BACK_BUFFER_REACHED - data : { bufferEnd: number }
+  LIVE_BACK_BUFFER_REACHED = 'hlsLiveBackBufferReached',
+  // fired when the back buffer is reached as defined by the backBufferLength config option - data : { bufferEnd: number }
+  BACK_BUFFER_REACHED = 'hlsBackBufferReached',
+  // fired after steering manifest has been loaded - data: { steeringManifest: SteeringManifest object, url: steering manifest URL }
+  STEERING_MANIFEST_LOADED = 'hlsSteeringManifestLoaded',
+  // fired when asset list has begun loading
+  ASSET_LIST_LOADING = 'hlsAssetListLoading',
+  // fired when a valid asset list is loaded
+  ASSET_LIST_LOADED = 'hlsAssetListLoaded',
+  // fired when the list of Interstitial Events and Interstitial Schedule is updated
+  INTERSTITIALS_UPDATED = 'hlsInterstitialsUpdated',
+  // fired when the buffer reaches an Interstitial Schedule boundary (both Primary segments and Interstitial Assets)
+  INTERSTITIALS_BUFFERED_TO_BOUNDARY = 'hlsInterstitialsBufferedToBoundary',
+  // fired when a player instance for an Interstitial Asset has been created
+  INTERSTITIAL_ASSET_PLAYER_CREATED = 'hlsInterstitialAssetPlayerCreated',
+  // Interstitial playback started
+  INTERSTITIAL_STARTED = 'hlsInterstitialStarted',
+  // InterstitialAsset playback started
+  INTERSTITIAL_ASSET_STARTED = 'hlsInterstitialAssetStarted',
+  // InterstitialAsset playback ended
+  INTERSTITIAL_ASSET_ENDED = 'hlsInterstitialAssetEnded',
+  // InterstitialAsset playback errored
+  INTERSTITIAL_ASSET_ERROR = 'hlsInterstitialAssetError',
+  // Interstitial playback ended
+  INTERSTITIAL_ENDED = 'hlsInterstitialEnded',
+  // Interstitial schedule resumed primary playback
+  INTERSTITIALS_PRIMARY_RESUMED = 'hlsInterstitialsPrimaryResumed',
+  // Interstitial players dispatch this event when playout limit is reached
+  PLAYOUT_LIMIT_REACHED = 'hlsPlayoutLimitReached',
+  // Event DateRange cue "enter" event dispatched
+  EVENT_CUE_ENTER = 'hlsEventCueEnter',
+}
+
+/**
+ * Defines each Event type and payload by Event name. Used in {@link hls.js#HlsEventEmitter} to strongly type the event listener API.
+ */
+export interface HlsListeners {
+  [Events.MEDIA_ATTACHING]: (
+    event: Events.MEDIA_ATTACHING,
+    data: MediaAttachingData,
+  ) => void;
+  [Events.MEDIA_ATTACHED]: (
+    event: Events.MEDIA_ATTACHED,
+    data: MediaAttachedData,
+  ) => void;
+  [Events.MEDIA_DETACHING]: (
+    event: Events.MEDIA_DETACHING,
+    data: MediaDetachingData,
+  ) => void;
+  [Events.MEDIA_DETACHED]: (
+    event: Events.MEDIA_DETACHED,
+    data: MediaDetachedData,
+  ) => void;
+  [Events.MEDIA_ENDED]: (
+    event: Events.MEDIA_ENDED,
+    data: MediaEndedData,
+  ) => void;
+  [Events.STALL_RESOLVED]: (event: Events.STALL_RESOLVED, data: {}) => void;
+  [Events.BUFFER_RESET]: (event: Events.BUFFER_RESET) => void;
+  [Events.BUFFER_CODECS]: (
+    event: Events.BUFFER_CODECS,
+    data: BufferCodecsData,
+  ) => void;
+  [Events.BUFFER_CREATED]: (
+    event: Events.BUFFER_CREATED,
+    data: BufferCreatedData,
+  ) => void;
+  [Events.BUFFER_APPENDING]: (
+    event: Events.BUFFER_APPENDING,
+    data: BufferAppendingData,
+  ) => void;
+  [Events.BUFFER_APPENDED]: (
+    event: Events.BUFFER_APPENDED,
+    data: BufferAppendedData,
+  ) => void;
+  [Events.BUFFER_EOS]: (event: Events.BUFFER_EOS, data: BufferEOSData) => void;
+  [Events.BUFFERED_TO_END]: (event: Events.BUFFERED_TO_END) => void;
+  [Events.BUFFER_FLUSHING]: (
+    event: Events.BUFFER_FLUSHING,
+    data: BufferFlushingData,
+  ) => void;
+  [Events.BUFFER_FLUSHED]: (
+    event: Events.BUFFER_FLUSHED,
+    data: BufferFlushedData,
+  ) => void;
+  [Events.MANIFEST_LOADING]: (
+    event: Events.MANIFEST_LOADING,
+    data: ManifestLoadingData,
+  ) => void;
+  [Events.MANIFEST_LOADED]: (
+    event: Events.MANIFEST_LOADED,
+    data: ManifestLoadedData,
+  ) => void;
+  [Events.MANIFEST_PARSED]: (
+    event: Events.MANIFEST_PARSED,
+    data: ManifestParsedData,
+  ) => void;
+  [Events.LEVEL_SWITCHING]: (
+    event: Events.LEVEL_SWITCHING,
+    data: LevelSwitchingData,
+  ) => void;
+  [Events.LEVEL_SWITCHED]: (
+    event: Events.LEVEL_SWITCHED,
+    data: LevelSwitchedData,
+  ) => void;
+  [Events.LEVEL_LOADING]: (
+    event: Events.LEVEL_LOADING,
+    data: LevelLoadingData,
+  ) => void;
+  [Events.LEVEL_LOADED]: (
+    event: Events.LEVEL_LOADED,
+    data: LevelLoadedData,
+  ) => void;
+  [Events.LEVEL_UPDATED]: (
+    event: Events.LEVEL_UPDATED,
+    data: LevelUpdatedData,
+  ) => void;
+  [Events.LEVEL_PTS_UPDATED]: (
+    event: Events.LEVEL_PTS_UPDATED,
+    data: LevelPTSUpdatedData,
+  ) => void;
+  [Events.LEVELS_UPDATED]: (
+    event: Events.LEVELS_UPDATED,
+    data: LevelsUpdatedData,
+  ) => void;
+  [Events.AUDIO_TRACKS_UPDATED]: (
+    event: Events.AUDIO_TRACKS_UPDATED,
+    data: AudioTracksUpdatedData,
+  ) => void;
+  [Events.AUDIO_TRACK_SWITCHING]: (
+    event: Events.AUDIO_TRACK_SWITCHING,
+    data: AudioTrackSwitchingData,
+  ) => void;
+  [Events.AUDIO_TRACK_SWITCHED]: (
+    event: Events.AUDIO_TRACK_SWITCHED,
+    data: AudioTrackSwitchedData,
+  ) => void;
+  [Events.AUDIO_TRACK_LOADING]: (
+    event: Events.AUDIO_TRACK_LOADING,
+    data: TrackLoadingData,
+  ) => void;
+  [Events.AUDIO_TRACK_LOADED]: (
+    event: Events.AUDIO_TRACK_LOADED,
+    data: AudioTrackLoadedData,
+  ) => void;
+  [Events.AUDIO_TRACK_UPDATED]: (
+    event: Events.AUDIO_TRACK_UPDATED,
+    data: AudioTrackUpdatedData,
+  ) => void;
+  [Events.SUBTITLE_TRACKS_UPDATED]: (
+    event: Events.SUBTITLE_TRACKS_UPDATED,
+    data: SubtitleTracksUpdatedData,
+  ) => void;
+  [Events.SUBTITLE_TRACKS_CLEARED]: (
+    event: Events.SUBTITLE_TRACKS_CLEARED,
+  ) => void;
+  [Events.SUBTITLE_TRACK_SWITCH]: (
+    event: Events.SUBTITLE_TRACK_SWITCH,
+    data: SubtitleTrackSwitchData,
+  ) => void;
+  [Events.SUBTITLE_TRACK_LOADING]: (
+    event: Events.SUBTITLE_TRACK_LOADING,
+    data: TrackLoadingData,
+  ) => void;
+  [Events.SUBTITLE_TRACK_LOADED]: (
+    event: Events.SUBTITLE_TRACK_LOADED,
+    data: SubtitleTrackLoadedData,
+  ) => void;
+  [Events.SUBTITLE_TRACK_UPDATED]: (
+    event: Events.SUBTITLE_TRACK_UPDATED,
+    data: SubtitleTrackUpdatedData,
+  ) => void;
+  [Events.SUBTITLE_FRAG_PROCESSED]: (
+    event: Events.SUBTITLE_FRAG_PROCESSED,
+    data: SubtitleFragProcessedData,
+  ) => void;
+  [Events.CUES_PARSED]: (
+    event: Events.CUES_PARSED,
+    data: CuesParsedData,
+  ) => void;
+  [Events.NON_NATIVE_TEXT_TRACKS_FOUND]: (
+    event: Events.NON_NATIVE_TEXT_TRACKS_FOUND,
+    data: NonNativeTextTracksData,
+  ) => void;
+  [Events.INIT_PTS_FOUND]: (
+    event: Events.INIT_PTS_FOUND,
+    data: InitPTSFoundData,
+  ) => void;
+  [Events.FRAG_LOADING]: (
+    event: Events.FRAG_LOADING,
+    data: FragLoadingData,
+  ) => void;
+  // [Events.FRAG_LOAD_PROGRESS]: TodoEventType
+  [Events.FRAG_LOAD_EMERGENCY_ABORTED]: (
+    event: Events.FRAG_LOAD_EMERGENCY_ABORTED,
+    data: FragLoadEmergencyAbortedData,
+  ) => void;
+  [Events.FRAG_LOADED]: (
+    event: Events.FRAG_LOADED,
+    data: FragLoadedData,
+  ) => void;
+  [Events.FRAG_DECRYPTED]: (
+    event: Events.FRAG_DECRYPTED,
+    data: FragDecryptedData,
+  ) => void;
+  [Events.FRAG_PARSING_INIT_SEGMENT]: (
+    event: Events.FRAG_PARSING_INIT_SEGMENT,
+    data: FragParsingInitSegmentData,
+  ) => void;
+  [Events.FRAG_PARSING_USERDATA]: (
+    event: Events.FRAG_PARSING_USERDATA,
+    data: FragParsingUserdataData,
+  ) => void;
+  [Events.FRAG_PARSING_METADATA]: (
+    event: Events.FRAG_PARSING_METADATA,
+    data: FragParsingMetadataData,
+  ) => void;
+  // [Events.FRAG_PARSING_DATA]: TodoEventType
+  [Events.FRAG_PARSED]: (
+    event: Events.FRAG_PARSED,
+    data: FragParsedData,
+  ) => void;
+  [Events.FRAG_BUFFERED]: (
+    event: Events.FRAG_BUFFERED,
+    data: FragBufferedData,
+  ) => void;
+  [Events.FRAG_CHANGED]: (
+    event: Events.FRAG_CHANGED,
+    data: FragChangedData,
+  ) => void;
+  [Events.ALGO_DATA_LOADING]: (
+    event: Events.ALGO_DATA_LOADING,
+    data: AlgoDataLoadingData,
+  ) => void;
+  [Events.ALGO_DATA_LOADED]: (
+    event: Events.ALGO_DATA_LOADED,
+    data: AlgoDataLoadedData,
+  ) => void;
+  [Events.ALGO_DATA_ERROR]: (
+    event: Events.ALGO_DATA_ERROR,
+    data: AlgoDataErrorData,
+  ) => void;
+  [Events.FPS_DROP]: (event: Events.FPS_DROP, data: FPSDropData) => void;
+  [Events.FPS_DROP_LEVEL_CAPPING]: (
+    event: Events.FPS_DROP_LEVEL_CAPPING,
+    data: FPSDropLevelCappingData,
+  ) => void;
+  [Events.MAX_AUTO_LEVEL_UPDATED]: (
+    event: Events.MAX_AUTO_LEVEL_UPDATED,
+    data: MaxAutoLevelUpdatedData,
+  ) => void;
+  [Events.ERROR]: (event: Events.ERROR, data: ErrorData) => void;
+  [Events.DESTROYING]: (event: Events.DESTROYING) => void;
+  [Events.KEY_LOADING]: (
+    event: Events.KEY_LOADING,
+    data: KeyLoadingData,
+  ) => void;
+  [Events.KEY_LOADED]: (event: Events.KEY_LOADED, data: KeyLoadedData) => void;
+  [Events.LIVE_BACK_BUFFER_REACHED]: (
+    event: Events.LIVE_BACK_BUFFER_REACHED,
+    data: LiveBackBufferData,
+  ) => void;
+  [Events.BACK_BUFFER_REACHED]: (
+    event: Events.BACK_BUFFER_REACHED,
+    data: BackBufferData,
+  ) => void;
+  [Events.STEERING_MANIFEST_LOADED]: (
+    event: Events.STEERING_MANIFEST_LOADED,
+    data: SteeringManifestLoadedData,
+  ) => void;
+  [Events.ASSET_LIST_LOADING]: (
+    event: Events.ASSET_LIST_LOADING,
+    data: AssetListLoadingData,
+  ) => void;
+  [Events.ASSET_LIST_LOADED]: (
+    event: Events.ASSET_LIST_LOADED,
+    data: AssetListLoadedData,
+  ) => void;
+  [Events.INTERSTITIALS_UPDATED]: (
+    event: Events.INTERSTITIALS_UPDATED,
+    data: InterstitialsUpdatedData,
+  ) => void;
+  [Events.INTERSTITIALS_BUFFERED_TO_BOUNDARY]: (
+    event: Events.INTERSTITIALS_BUFFERED_TO_BOUNDARY,
+    data: InterstitialsBufferedToBoundaryData,
+  ) => void;
+  [Events.INTERSTITIAL_ASSET_PLAYER_CREATED]: (
+    event: Events.INTERSTITIAL_ASSET_PLAYER_CREATED,
+    data: InterstitialAssetPlayerCreatedData,
+  ) => void;
+  [Events.INTERSTITIAL_STARTED]: (
+    event: Events.INTERSTITIAL_STARTED,
+    data: InterstitialStartedData,
+  ) => void;
+  [Events.INTERSTITIAL_ASSET_STARTED]: (
+    event: Events.INTERSTITIAL_ASSET_STARTED,
+    data: InterstitialAssetStartedData,
+  ) => void;
+  [Events.INTERSTITIAL_ASSET_ENDED]: (
+    event: Events.INTERSTITIAL_ASSET_ENDED,
+    data: InterstitialAssetEndedData,
+  ) => void;
+  [Events.INTERSTITIAL_ASSET_ERROR]: (
+    event: Events.INTERSTITIAL_ASSET_ERROR,
+    data: InterstitialAssetErrorData,
+  ) => void;
+  [Events.INTERSTITIAL_ENDED]: (
+    event: Events.INTERSTITIAL_ENDED,
+    data: InterstitialEndedData,
+  ) => void;
+  [Events.INTERSTITIALS_PRIMARY_RESUMED]: (
+    event: Events.INTERSTITIALS_PRIMARY_RESUMED,
+    data: InterstitialsPrimaryResumed,
+  ) => void;
+  [Events.PLAYOUT_LIMIT_REACHED]: (
+    event: Events.PLAYOUT_LIMIT_REACHED,
+    data: {},
+  ) => void;
+  [Events.EVENT_CUE_ENTER]: (event: Events.EVENT_CUE_ENTER, data: {}) => void;
+}
+export interface HlsEventEmitter {
+  on<E extends keyof HlsListeners, Context = undefined>(
+    event: E,
+    listener: HlsListeners[E],
+    context?: Context,
+  ): void;
+  once<E extends keyof HlsListeners, Context = undefined>(
+    event: E,
+    listener: HlsListeners[E],
+    context?: Context,
+  ): void;
+
+  removeAllListeners<E extends keyof HlsListeners>(event?: E): void;
+  off<E extends keyof HlsListeners, Context = undefined>(
+    event: E,
+    listener?: HlsListeners[E],
+    context?: Context,
+    once?: boolean,
+  ): void;
+
+  listeners<E extends keyof HlsListeners>(event: E): HlsListeners[E][];
+  emit<E extends keyof HlsListeners>(
+    event: E,
+    name: E,
+    eventObject: Parameters<HlsListeners[E]>[1],
+  ): boolean;
+  listenerCount<E extends keyof HlsListeners>(event: E): number;
+}

package/src/exports-default.ts

@@ -0,0 +1,3 @@
+import Hls from './hls';
+
+export default Hls;