hls.js 1.6.1-0.canary.11097 → 1.6.1-0.canary.11099

package/dist/hls.mjs

@@ -10,10 +10,15 @@ const isSafeInteger = Number.isSafeInteger || function (value) {
 const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
 
 let ErrorTypes = /*#__PURE__*/function (ErrorTypes) {
+  // Identifier for a network error (loading error / timeout ...)
   ErrorTypes["NETWORK_ERROR"] = "networkError";
+  // Identifier for a media Error (video/parsing/mediasource error)
   ErrorTypes["MEDIA_ERROR"] = "mediaError";
+  // EME (encrypted media extensions) errors
   ErrorTypes["KEY_SYSTEM_ERROR"] = "keySystemError";
+  // Identifier for a mux Error (demuxing/remuxing)
   ErrorTypes["MUX_ERROR"] = "muxError";
+  // Identifier for all other errors
   ErrorTypes["OTHER_ERROR"] = "otherError";
   return ErrorTypes;
 }({});
@@ -31,120 +36,236 @@ let ErrorDetails = /*#__PURE__*/function (ErrorDetails) {
   ErrorDetails["KEY_SYSTEM_DESTROY_MEDIA_KEYS_ERROR"] = "keySystemDestroyMediaKeysError";
   ErrorDetails["KEY_SYSTEM_DESTROY_CLOSE_SESSION_ERROR"] = "keySystemDestroyCloseSessionError";
   ErrorDetails["KEY_SYSTEM_DESTROY_REMOVE_SESSION_ERROR"] = "keySystemDestroyRemoveSessionError";
+  // Identifier for a manifest load error - data: { url : faulty URL, response : { code: error code, text: error text }}
   ErrorDetails["MANIFEST_LOAD_ERROR"] = "manifestLoadError";
+  // Identifier for a manifest load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
   ErrorDetails["MANIFEST_LOAD_TIMEOUT"] = "manifestLoadTimeOut";
+  // Identifier for a manifest parsing error - data: { url : faulty URL, reason : error reason}
   ErrorDetails["MANIFEST_PARSING_ERROR"] = "manifestParsingError";
+  // Identifier for a manifest with only incompatible codecs error - data: { url : faulty URL, reason : error reason}
   ErrorDetails["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 }
   ErrorDetails["LEVEL_EMPTY_ERROR"] = "levelEmptyError";
+  // Identifier for a level load error - data: { url : faulty URL, response : { code: error code, text: error text }}
   ErrorDetails["LEVEL_LOAD_ERROR"] = "levelLoadError";
+  // Identifier for a level load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
   ErrorDetails["LEVEL_LOAD_TIMEOUT"] = "levelLoadTimeOut";
+  // Identifier for a level parse error - data: { url : faulty URL, error: Error, reason: error message }
   ErrorDetails["LEVEL_PARSING_ERROR"] = "levelParsingError";
+  // Identifier for a level switch error - data: { level : faulty level Id, event : error description}
   ErrorDetails["LEVEL_SWITCH_ERROR"] = "levelSwitchError";
+  // Identifier for an audio track load error - data: { url : faulty URL, response : { code: error code, text: error text }}
   ErrorDetails["AUDIO_TRACK_LOAD_ERROR"] = "audioTrackLoadError";
+  // Identifier for an audio track load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
   ErrorDetails["AUDIO_TRACK_LOAD_TIMEOUT"] = "audioTrackLoadTimeOut";
+  // Identifier for a subtitle track load error - data: { url : faulty URL, response : { code: error code, text: error text }}
   ErrorDetails["SUBTITLE_LOAD_ERROR"] = "subtitleTrackLoadError";
+  // Identifier for a subtitle track load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
   ErrorDetails["SUBTITLE_TRACK_LOAD_TIMEOUT"] = "subtitleTrackLoadTimeOut";
+  // Identifier for fragment load error - data: { frag : fragment object, response : { code: error code, text: error text }}
   ErrorDetails["FRAG_LOAD_ERROR"] = "fragLoadError";
+  // Identifier for fragment load timeout error - data: { frag : fragment object}
   ErrorDetails["FRAG_LOAD_TIMEOUT"] = "fragLoadTimeOut";
+  // Identifier for a fragment decryption error event - data: {id : demuxer Id,frag: fragment object, reason : parsing error description }
   ErrorDetails["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
   ErrorDetails["FRAG_PARSING_ERROR"] = "fragParsingError";
+  // Identifier for a fragment or part load skipped because of a GAP tag or attribute
   ErrorDetails["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 }
   ErrorDetails["REMUX_ALLOC_ERROR"] = "remuxAllocError";
+  // Identifier for decrypt key load error - data: { frag : fragment object, response : { code: error code, text: error text }}
   ErrorDetails["KEY_LOAD_ERROR"] = "keyLoadError";
+  // Identifier for decrypt key load timeout error - data: { frag : fragment object}
   ErrorDetails["KEY_LOAD_TIMEOUT"] = "keyLoadTimeOut";
+  // Triggered when an exception occurs while adding a sourceBuffer to MediaSource - data : { error : exception , mimeType : mimeType }
   ErrorDetails["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 }
   ErrorDetails["BUFFER_INCOMPATIBLE_CODECS_ERROR"] = "bufferIncompatibleCodecsError";
+  // Identifier for a buffer append error - data: append error description
   ErrorDetails["BUFFER_APPEND_ERROR"] = "bufferAppendError";
+  // Identifier for a buffer appending error event - data: appending error description
   ErrorDetails["BUFFER_APPENDING_ERROR"] = "bufferAppendingError";
+  // Identifier for a buffer stalled error event
   ErrorDetails["BUFFER_STALLED_ERROR"] = "bufferStalledError";
+  // Identifier for a buffer full event
   ErrorDetails["BUFFER_FULL_ERROR"] = "bufferFullError";
+  // Identifier for a buffer seek over hole event
   ErrorDetails["BUFFER_SEEK_OVER_HOLE"] = "bufferSeekOverHole";
+  // Identifier for a buffer nudge on stall (playback is stuck although currentTime is in a buffered area)
   ErrorDetails["BUFFER_NUDGE_ON_STALL"] = "bufferNudgeOnStall";
+  // Identifier for a Interstitial Asset List load error - data: { url: faulty URL, response: { code: error code, text: error text } }
   ErrorDetails["ASSET_LIST_LOAD_ERROR"] = "assetListLoadError";
+  // Identifier for a Interstitial Asset List load timeout - data: { url: faulty URL, response: { code: error code, text: error text } }
   ErrorDetails["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 }}
   ErrorDetails["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 }}
   ErrorDetails["INTERSTITIAL_ASSET_ITEM_ERROR"] = "interstitialAssetItemError";
+  // Identifier for an internal exception happening inside hls.js while handling an event
   ErrorDetails["INTERNAL_EXCEPTION"] = "internalException";
+  // Identifier for an internal call to abort a loader
   ErrorDetails["INTERNAL_ABORTED"] = "aborted";
+  // Triggered when attachMedia fails
   ErrorDetails["ATTACH_MEDIA_ERROR"] = "attachMediaError";
+  // Uncategorized error
   ErrorDetails["UNKNOWN"] = "unknown";
   return ErrorDetails;
 }({});
 
 let Events = /*#__PURE__*/function (Events) {
+  // Fired before MediaSource is attaching to media element
   Events["MEDIA_ATTACHING"] = "hlsMediaAttaching";
+  // Fired when MediaSource has been successfully attached to media element
   Events["MEDIA_ATTACHED"] = "hlsMediaAttached";
+  // Fired before detaching MediaSource from media element
   Events["MEDIA_DETACHING"] = "hlsMediaDetaching";
+  // Fired when MediaSource has been detached from media element
   Events["MEDIA_DETACHED"] = "hlsMediaDetached";
+  // Fired when HTMLMediaElement dispatches "ended" event, or stalls at end of VOD program
   Events["MEDIA_ENDED"] = "hlsMediaEnded";
+  // Fired after playback stall is resolved with playing, seeked, or ended event following BUFFER_STALLED_ERROR
   Events["STALL_RESOLVED"] = "hlsStallResolved";
+  // Fired when the buffer is going to be reset
   Events["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 }}
   Events["BUFFER_CODECS"] = "hlsBufferCodecs";
+  // fired when sourcebuffers have been created - data: { tracks : tracks }
   Events["BUFFER_CREATED"] = "hlsBufferCreated";
+  // fired when we append a segment to the buffer - data: { segment: segment object }
   Events["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}
   Events["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: { }
   Events["BUFFER_EOS"] = "hlsBufferEos";
+  // fired when all buffers are full to the end of the program, after calling MediaSource.endOfStream() (unless restricted)
   Events["BUFFERED_TO_END"] = "hlsBufferedToEnd";
+  // fired when the media buffer should be flushed - data { startOffset, endOffset }
   Events["BUFFER_FLUSHING"] = "hlsBufferFlushing";
+  // fired when the media buffer has been flushed - data: { }
   Events["BUFFER_FLUSHED"] = "hlsBufferFlushed";
+  // fired to signal that a manifest loading starts - data: { url : manifestURL}
   Events["MANIFEST_LOADING"] = "hlsManifestLoading";
+  // fired after manifest has been loaded - data: { levels : [available quality levels], audioTracks : [ available audio tracks ], url : manifestURL, stats : LoaderStats }
   Events["MANIFEST_LOADED"] = "hlsManifestLoaded";
+  // fired after manifest has been parsed - data: { levels : [available quality levels], firstLevel : index of first quality level appearing in Manifest}
   Events["MANIFEST_PARSED"] = "hlsManifestParsed";
+  // fired when a level switch is requested - data: { level : id of new level }
   Events["LEVEL_SWITCHING"] = "hlsLevelSwitching";
+  // fired when a level switch is effective - data: { level : id of new level }
   Events["LEVEL_SWITCHED"] = "hlsLevelSwitched";
+  // fired when a level playlist loading starts - data: { url : level URL, level : id of level being loaded}
   Events["LEVEL_LOADING"] = "hlsLevelLoading";
+  // fired when a level playlist loading finishes - data: { details : levelDetails object, level : id of loaded level, stats : LoaderStats }
   Events["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 }
   Events["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 }
   Events["LEVEL_PTS_UPDATED"] = "hlsLevelPtsUpdated";
+  // fired to notify that levels have changed after removing a level - data: { levels : [available quality levels] }
   Events["LEVELS_UPDATED"] = "hlsLevelsUpdated";
+  // fired to notify that audio track lists has been updated - data: { audioTracks : audioTracks }
   Events["AUDIO_TRACKS_UPDATED"] = "hlsAudioTracksUpdated";
+  // fired when an audio track switching is requested - data: { id : audio track id }
   Events["AUDIO_TRACK_SWITCHING"] = "hlsAudioTrackSwitching";
+  // fired when an audio track switch actually occurs - data: { id : audio track id }
   Events["AUDIO_TRACK_SWITCHED"] = "hlsAudioTrackSwitched";
+  // fired when an audio track loading starts - data: { url : audio track URL, id : audio track id }
   Events["AUDIO_TRACK_LOADING"] = "hlsAudioTrackLoading";
+  // fired when an audio track loading finishes - data: { details : levelDetails object, id : audio track id, stats : LoaderStats }
   Events["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 }
   Events["AUDIO_TRACK_UPDATED"] = "hlsAudioTrackUpdated";
+  // fired to notify that subtitle track lists has been updated - data: { subtitleTracks : subtitleTracks }
   Events["SUBTITLE_TRACKS_UPDATED"] = "hlsSubtitleTracksUpdated";
+  // fired to notify that subtitle tracks were cleared as a result of stopping the media
   Events["SUBTITLE_TRACKS_CLEARED"] = "hlsSubtitleTracksCleared";
+  // fired when an subtitle track switch occurs - data: { id : subtitle track id }
   Events["SUBTITLE_TRACK_SWITCH"] = "hlsSubtitleTrackSwitch";
+  // fired when a subtitle track loading starts - data: { url : subtitle track URL, id : subtitle track id }
   Events["SUBTITLE_TRACK_LOADING"] = "hlsSubtitleTrackLoading";
+  // fired when a subtitle track loading finishes - data: { details : levelDetails object, id : subtitle track id, stats : LoaderStats }
   Events["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 }
   Events["SUBTITLE_TRACK_UPDATED"] = "hlsSubtitleTrackUpdated";
+  // fired when a subtitle fragment has been processed - data: { success : boolean, frag : the processed frag }
   Events["SUBTITLE_FRAG_PROCESSED"] = "hlsSubtitleFragProcessed";
+  // fired when a set of VTTCues to be managed externally has been parsed - data: { type: string, track: string, cues: [ VTTCue ] }
   Events["CUES_PARSED"] = "hlsCuesParsed";
+  // fired when a text track to be managed externally is found - data: { tracks: [ { label: string, kind: string, default: boolean } ] }
   Events["NON_NATIVE_TEXT_TRACKS_FOUND"] = "hlsNonNativeTextTracksFound";
+  // fired when the first timestamp is found - data: { id : demuxer id, initPTS: initPTS, timescale: timescale, frag : fragment object }
   Events["INIT_PTS_FOUND"] = "hlsInitPtsFound";
+  // fired when a fragment loading starts - data: { frag : fragment object }
   Events["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 }
   Events["FRAG_LOAD_EMERGENCY_ABORTED"] = "hlsFragLoadEmergencyAborted";
+  // fired when a fragment loading is completed - data: { frag : fragment object, payload : fragment payload, stats : LoaderStats }
   Events["FRAG_LOADED"] = "hlsFragLoaded";
+  // fired when a fragment has finished decrypting - data: { id : demuxer id, frag: fragment object, payload : fragment payload, stats : { tstart, tdecrypt } }
   Events["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 }
   Events["FRAG_PARSING_INIT_SEGMENT"] = "hlsFragParsingInitSegment";
+  // fired when parsing sei text is completed - data: { id : demuxer id, frag: fragment object, samples : [ sei samples pes ] }
   Events["FRAG_PARSING_USERDATA"] = "hlsFragParsingUserdata";
+  // fired when parsing id3 is completed - data: { id : demuxer id, frag: fragment object, samples : [ id3 samples pes ] }
   Events["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 }
   Events["FRAG_PARSED"] = "hlsFragParsed";
+  // fired when fragment remuxed MP4 boxes have all been appended into SourceBuffer - data: { id : demuxer id, frag : fragment object, stats : LoaderStats }
   Events["FRAG_BUFFERED"] = "hlsFragBuffered";
+  // fired when fragment matching with current media position is changing - data : { id : demuxer id, frag : fragment object }
   Events["FRAG_CHANGED"] = "hlsFragChanged";
+  // Identifier for a FPS drop event - data: { currentDropped, currentDecoded, totalDroppedFrames }
   Events["FPS_DROP"] = "hlsFpsDrop";
+  // triggered when FPS drop triggers auto level capping - data: { level, droppedLevel }
   Events["FPS_DROP_LEVEL_CAPPING"] = "hlsFpsDropLevelCapping";
+  // triggered when maxAutoLevel changes - data { autoLevelCapping, levels, maxAutoLevel, minAutoLevel, maxHdcpLevel }
   Events["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 }
   Events["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: { }
   Events["DESTROYING"] = "hlsDestroying";
+  // fired when a decrypt key loading starts - data: { frag : fragment object }
   Events["KEY_LOADING"] = "hlsKeyLoading";
+  // fired when a decrypt key loading is completed - data: { frag : fragment object, keyInfo : KeyLoaderInfo }
   Events["KEY_LOADED"] = "hlsKeyLoaded";
+  // deprecated; please use BACK_BUFFER_REACHED - data : { bufferEnd: number }
   Events["LIVE_BACK_BUFFER_REACHED"] = "hlsLiveBackBufferReached";
+  // fired when the back buffer is reached as defined by the backBufferLength config option - data : { bufferEnd: number }
   Events["BACK_BUFFER_REACHED"] = "hlsBackBufferReached";
+  // fired after steering manifest has been loaded - data: { steeringManifest: SteeringManifest object, url: steering manifest URL }
   Events["STEERING_MANIFEST_LOADED"] = "hlsSteeringManifestLoaded";
+  // fired when asset list has begun loading
   Events["ASSET_LIST_LOADING"] = "hlsAssetListLoading";
+  // fired when a valid asset list is loaded
   Events["ASSET_LIST_LOADED"] = "hlsAssetListLoaded";
+  // fired when the list of Interstitial Events and Interstitial Schedule is updated
   Events["INTERSTITIALS_UPDATED"] = "hlsInterstitialsUpdated";
+  // fired when the buffer reaches an Interstitial Schedule boundary (both Primary segments and Interstitial Assets)
   Events["INTERSTITIALS_BUFFERED_TO_BOUNDARY"] = "hlsInterstitialsBufferedToBoundary";
+  // fired when a player instance for an Interstitial Asset has been created
   Events["INTERSTITIAL_ASSET_PLAYER_CREATED"] = "hlsInterstitialAssetPlayerCreated";
+  // Interstitial playback started
   Events["INTERSTITIAL_STARTED"] = "hlsInterstitialStarted";
+  // InterstitialAsset playback started
   Events["INTERSTITIAL_ASSET_STARTED"] = "hlsInterstitialAssetStarted";
+  // InterstitialAsset playback ended
   Events["INTERSTITIAL_ASSET_ENDED"] = "hlsInterstitialAssetEnded";
+  // InterstitialAsset playback errored
   Events["INTERSTITIAL_ASSET_ERROR"] = "hlsInterstitialAssetError";
+  // Interstitial playback ended
   Events["INTERSTITIAL_ENDED"] = "hlsInterstitialEnded";
+  // Interstitial schedule resumed primary playback
   Events["INTERSTITIALS_PRIMARY_RESUMED"] = "hlsInterstitialsPrimaryResumed";
+  // Interstitial players dispatch this event when playout limit is reached
   Events["PLAYOUT_LIMIT_REACHED"] = "hlsPlayoutLimitReached";
+  // Event DateRange cue "enter" event dispatched
   Events["EVENT_CUE_ENTER"] = "hlsEventCueEnter";
   return Events;
 }({});
@@ -402,7 +523,7 @@ function enableLogs(debugConfig, context, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.1-0.canary.11097"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.1-0.canary.11099"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -10117,7 +10238,7 @@ function requireEventemitter3 () {
 var eventemitter3Exports = requireEventemitter3();
 var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
-const version = "1.6.1-0.canary.11097";
+const version = "1.6.1-0.canary.11099";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js