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

package/dist/hls.js

@@ -732,10 +732,15 @@
   var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
 
   var 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;
   }({});
@@ -753,120 +758,236 @@
     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;
   }({});
 
   var 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;
   }({});
@@ -1073,7 +1194,7 @@
       // 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.11101");
       } catch (e) {
         /* log fn threw an exception. All logger methods are no-ops. */
         return createLogger();
@@ -16595,7 +16716,7 @@
     return !remuxResult.audio && !remuxResult.video && !remuxResult.text && !remuxResult.id3 && !remuxResult.initSegment;
   }
 
-  var version = "1.6.1-0.canary.11097";
+  var version = "1.6.1-0.canary.11101";
 
   // ensure the worker ends up in the bundle
   // If the worker should not be included this gets aliased to empty.js