https://pro-demo.safehs.ai/_next/static/chunks/e217e3ef-4a7896cbb909a77c.js

10
11// https://caniuse.com/mdn-javascript_builtins_number_isfinite
12const isFiniteNumber = Number.isFinite || function (value) {
13  return typeof value === 'number' && isFinite(value);
14};
15
16// https://caniuse.com/mdn-javascript_builtins_number_issafeinteger
17const isSafeInteger = Number.isSafeInteger || function (value) {
18  return typeof value === 'number' && Math.abs(value) <= MAX_SAFE_INTEGER;
19};
20const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
21
22let ErrorTypes = /*#__PURE__*/function (ErrorTypes) {
23  // Identifier for a network error (loading error / timeout ...)
24  ErrorTypes["NETWORK_ERROR"] = "networkError";
25  // Identifier for a media Error (video/parsing/mediasource error)
26  ErrorTypes["MEDIA_ERROR"] = "mediaError";
27  // EME (encrypted media extensions) errors
28  ErrorTypes["KEY_SYSTEM_ERROR"] = "keySystemError";
29  // Identifier for a mux Error (demuxing/remuxing)
30  ErrorTypes["MUX_ERROR"] = "muxError";
31  // Identifier for all other errors
32  ErrorTypes["OTHER_ERROR"] = "otherError";
33  return ErrorTypes;
34}({});
35let ErrorDetails = /*#__PURE__*/function (ErrorDetails) {
36  ErrorDetails["KEY_SYSTEM_NO_KEYS"] = "keySystemNoKeys";
37  ErrorDetails["KEY_SYSTEM_NO_ACCESS"] = "keySystemNoAccess";
38  ErrorDetails["KEY_SYSTEM_NO_SESSION"] = "keySystemNoSession";
39  ErrorDetails["KEY_SYSTEM_NO_CONFIGURED_LICENSE"] = "keySystemNoConfiguredLicense";
40  ErrorDetails["KEY_SYSTEM_LICENSE_REQUEST_FAILED"] = "keySystemLicenseRequestFailed";
41  ErrorDetails["KEY_SYSTEM_SERVER_CERTIFICATE_REQUEST_FAILED"] = "keySystemServerCertificateRequestFailed";
42  ErrorDetails["KEY_SYSTEM_SERVER_CERTIFICATE_UPDATE_FAILED"] = "keySystemServerCertificateUpdateFailed";
43  ErrorDetails["KEY_SYSTEM_SESSION_UPDATE_FAILED"] = "keySystemSessionUpdateFailed";
44  ErrorDetails["KEY_SYSTEM_STATUS_OUTPUT_RESTRICTED"] = "keySystemStatusOutputRestricted";
45  ErrorDetails["KEY_SYSTEM_STATUS_INTERNAL_ERROR"] = "keySystemStatusInternalError";
46  ErrorDetails["KEY_SYSTEM_DESTROY_MEDIA_KEYS_ERROR"] = "keySystemDestroyMediaKeysError";
47  ErrorDetails["KEY_SYSTEM_DESTROY_CLOSE_SESSION_ERROR"] = "keySystemDestroyCloseSessionError";
48  ErrorDetails["KEY_SYSTEM_DESTROY_REMOVE_SESSION_ERROR"] = "keySystemDestroyRemoveSessionError";
49  // Identifier for a manifest load error - data: { url : faulty URL, response : { code: error code, text: error text }}
50  ErrorDetails["MANIFEST_LOAD_ERROR"] = "manifestLoadError";
51  // Identifier for a manifest load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
52  ErrorDetails["MANIFEST_LOAD_TIMEOUT"] = "manifestLoadTimeOut";
53  // Identifier for a manifest parsing error - data: { url : faulty URL, reason : error reason}
54  ErrorDetails["MANIFEST_PARSING_ERROR"] = "manifestParsingError";
55  // Identifier for a manifest with only incompatible codecs error - data: { url : faulty URL, reason : error reason}
56  ErrorDetails["MANIFEST_INCOMPATIBLE_CODECS_ERROR"] = "manifestIncompatibleCodecsError";
57  // Identifier for a level which contains no fragments - data: { url: faulty URL, reason: "no fragments found in level", level: index of the bad level }
58  ErrorDetails["LEVEL_EMPTY_ERROR"] = "levelEmptyError";
59  // Identifier for a level load error - data: { url : faulty URL, response : { code: error code, text: error text }}
60  ErrorDetails["LEVEL_LOAD_ERROR"] = "levelLoadError";
61  // Identifier for a level load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
62  ErrorDetails["LEVEL_LOAD_TIMEOUT"] = "levelLoadTimeOut";
63  // Identifier for a level parse error - data: { url : faulty URL, error: Error, reason: error message }
64  ErrorDetails["LEVEL_PARSING_ERROR"] = "levelParsingError";
65  // Identifier for a level switch error - data: { level : faulty level Id, event : error description}
66  ErrorDetails["LEVEL_SWITCH_ERROR"] = "levelSwitchError";
67  // Identifier for an audio track load error - data: { url : faulty URL, response : { code: error code, text: error text }}
68  ErrorDetails["AUDIO_TRACK_LOAD_ERROR"] = "audioTrackLoadError";
69  // Identifier for an audio track load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
70  ErrorDetails["AUDIO_TRACK_LOAD_TIMEOUT"] = "audioTrackLoadTimeOut";
71  // Identifier for a subtitle track load error - data: { url : faulty URL, response : { code: error code, text: error text }}
72  ErrorDetails["SUBTITLE_LOAD_ERROR"] = "subtitleTrackLoadError";
73  // Identifier for a subtitle track load timeout - data: { url : faulty URL, response : { code: error code, text: error text }}
74  ErrorDetails["SUBTITLE_TRACK_LOAD_TIMEOUT"] = "subtitleTrackLoadTimeOut";
75  // Identifier for fragment load error - data: { frag : fragment object, response : { code: error code, text: error text }}
76  ErrorDetails["FRAG_LOAD_ERROR"] = "fragLoadError";
77  // Identifier for fragment load timeout error - data: { frag : fragment object}
78  ErrorDetails["FRAG_LOAD_TIMEOUT"] = "fragLoadTimeOut";
79  // Identifier for a fragment decryption error event - data: {id : demuxer Id,frag: fragment object, reason : parsing error description }
80  ErrorDetails["FRAG_DECRYPT_ERROR"] = "fragDecryptError";
81  // Identifier for a fragment parsing error event - data: { id : demuxer Id, reason : parsing error description }
82  // will be renamed DEMUX_PARSING_ERROR and switched to MUX_ERROR in the next major release
83  ErrorDetails["FRAG_PARSING_ERROR"] = "fragParsingError";
84  // Identifier for a fragment or part load skipped because of a GAP tag or attribute
85  ErrorDetails["FRAG_GAP"] = "fragGap";
86  // 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 }
87  ErrorDetails["REMUX_ALLOC_ERROR"] = "remuxAllocError";
88  // Identifier for decrypt key load error - data: { frag : fragment object, response : { code: error code, text: error text }}
89  ErrorDetails["KEY_LOAD_ERROR"] = "keyLoadError";
90  // Identifier for decrypt key load timeout error - data: { frag : fragment object}
91  ErrorDetails["KEY_LOAD_TIMEOUT"] = "keyLoadTimeOut";
92  // Triggered when an exception occurs while adding a sourceBuffer to MediaSource - data : { error : exception , mimeType : mimeType }
93  ErrorDetails["BUFFER_ADD_CODEC_ERROR"] = "bufferAddCodecError";
94  // 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 }
95  ErrorDetails["BUFFER_INCOMPATIBLE_CODECS_ERROR"] = "bufferIncompatibleCodecsError";
96  // Identifier for a buffer append error - data: append error description
97  ErrorDetails["BUFFER_APPEND_ERROR"] = "bufferAppendError";
98  // Identifier for a buffer appending error event - data: appending error description
99  ErrorDetails["BUFFER_APPENDING_ERROR"] = "bufferAppendingError";
100  // Identifier for a buffer stalled error event
101  ErrorDetails["BUFFER_STALLED_ERROR"] = "bufferStalledError";
102  // Identifier for a buffer full event
103  ErrorDetails["BUFFER_FULL_ERROR"] = "bufferFullError";
104  // Identifier for a buffer seek over hole event
105  ErrorDetails["BUFFER_SEEK_OVER_HOLE"] = "bufferSeekOverHole";
106  // Identifier for a buffer nudge on stall (playback is stuck although currentTime is in a buffered area)
107  ErrorDetails["BUFFER_NUDGE_ON_STALL"] = "bufferNudgeOnStall";
108  // Identifier for a Interstitial Asset List load error - data: { url: faulty URL, response: { code: error code, text: error text } }
109  ErrorDetails["ASSET_LIST_LOAD_ERROR"] = "assetListLoadError";
110  // Identifier for a Interstitial Asset List load timeout - data: { url: faulty URL, response: { code: error code, text: error text } }
111  ErrorDetails["ASSET_LIST_LOAD_TIMEOUT"] = "assetListLoadTimeout";
112  // Identifier for a Interstitial Asset List parsing error - data: { url : faulty URL, reason : error reason, response : { code: error code, text: error text }}
113  ErrorDetails["ASSET_LIST_PARSING_ERROR"] = "assetListParsingError";
114  // Identifier for a Interstitial Asset List parsing error - data: { url : faulty URL, reason : error reason, response : { code: error code, text: error text }}
115  ErrorDetails["INTERSTITIAL_ASSET_ITEM_ERROR"] = "interstitialAssetItemError";
116  // Identifier for an internal exception happening inside hls.js while handling an event
117  ErrorDetails["INTERNAL_EXCEPTION"] = "internalException";
118  // Identifier for an internal call to abort a loader
119  ErrorDetails["INTERNAL_ABORTED"] = "aborted";
120  // Triggered when attachMedia fails
121  ErrorDetails["ATTACH_MEDIA_ERROR"] = "attachMediaError";
122  // Uncategorized error
123  ErrorDetails["UNKNOWN"] = "unknown";
124  return ErrorDetails;
125}({});
126
127let Events = /*#__PURE__*/function (Events) {
128  // Fired before MediaSource is attaching to media element
129  Events["MEDIA_ATTACHING"] = "hlsMediaAttaching";
130  // Fired when MediaSource has been successfully attached to media element
131  Events["MEDIA_ATTACHED"] = "hlsMediaAttached";
132  // Fired before detaching MediaSource from media element
133  Events["MEDIA_DETACHING"] = "hlsMediaDetaching";
134  // Fired when MediaSource has been detached from media element
135  Events["MEDIA_DETACHED"] = "hlsMediaDetached";
136  // Fired when HTMLMediaElement dispatches "ended" event, or stalls at end of VOD program
137  Events["MEDIA_ENDED"] = "hlsMediaEnded";
138  // Fired after playback stall is resolved with playing, seeked, or ended event following BUFFER_STALLED_ERROR
139  Events["STALL_RESOLVED"] = "hlsStallResolved";
140  // Fired when the buffer is going to be reset
141  Events["BUFFER_RESET"] = "hlsBufferReset";
142  // Fired when we know about the codecs that we need buffers for to push into - data: {tracks : { container, codec, levelCodec, initSegment, metadata }}
143  Events["BUFFER_CODECS"] = "hlsBufferCodecs";
144  // fired when sourcebuffers have been created - data: { tracks : tracks }
145  Events["BUFFER_CREATED"] = "hlsBufferCreated";
146  // fired when we append a segment to the buffer - data: { segment: segment object }
147  Events["BUFFER_APPENDING"] = "hlsBufferAppending";
148  // 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}
149  Events["BUFFER_APPENDED"] = "hlsBufferAppended";
150  // fired when the stream is finished and we want to notify the media buffer that there will be no more data - data: { }
151  Events["BUFFER_EOS"] = "hlsBufferEos";
152  // fired when all buffers are full to the end of the program, after calling MediaSource.endOfStream() (unless restricted)
153  Events["BUFFERED_TO_END"] = "hlsBufferedToEnd";
154  // fired when the media buffer should be flushed - data { startOffset, endOffset }
155  Events["BUFFER_FLUSHING"] = "hlsBufferFlushing";
156  // fired when the media buffer has been flushed - data: { }
157  Events["BUFFER_FLUSHED"] = "hlsBufferFlushed";
158  // fired to signal that a manifest loading starts - data: { url : manifestURL}
159  Events["MANIFEST_LOADING"] = "hlsManifestLoading";
160  // fired after manifest has been loaded - data: { levels : [available quality levels], audioTracks : [ available audio tracks ], url : manifestURL, stats : LoaderStats }
161  Events["MANIFEST_LOADED"] = "hlsManifestLoaded";
162  // fired after manifest has been parsed - data: { levels : [available quality levels], firstLevel : index of first quality level appearing in Manifest}
163  Events["MANIFEST_PARSED"] = "hlsManifestParsed";
164  // fired when a level switch is requested - data: { level : id of new level }
165  Events["LEVEL_SWITCHING"] = "hlsLevelSwitching";
166  // fired when a level switch is effective - data: { level : id of new level }
167  Events["LEVEL_SWITCHED"] = "hlsLevelSwitched";
168  // fired when a level playlist loading starts - data: { url : level URL, level : id of level being loaded}
169  Events["LEVEL_LOADING"] = "hlsLevelLoading";
170  // fired when a level playlist loading finishes - data: { details : levelDetails object, level : id of loaded level, stats : LoaderStats }
171  Events["LEVEL_LOADED"] = "hlsLevelLoaded";
172  // 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 }
173  Events["LEVEL_UPDATED"] = "hlsLevelUpdated";
174  // 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 }
175  Events["LEVEL_PTS_UPDATED"] = "hlsLevelPtsUpdated";
176  // fired to notify that levels have changed after removing a level - data: { levels : [available quality levels] }
177  Events["LEVELS_UPDATED"] = "hlsLevelsUpdated";
178  // fired to notify that audio track lists has been updated - data: { audioTracks : audioTracks }
179  Events["AUDIO_TRACKS_UPDATED"] = "hlsAudioTracksUpdated";
180  // fired when an audio track switching is requested - data: { id : audio track id }
181  Events["AUDIO_TRACK_SWITCHING"] = "hlsAudioTrackSwitching";
182  // fired when an audio track switch actually occurs - data: { id : audio track id }
183  Events["AUDIO_TRACK_SWITCHED"] = "hlsAudioTrackSwitched";
184  // fired when an audio track loading starts - data: { url : audio track URL, id : audio track id }
185  Events["AUDIO_TRACK_LOADING"] = "hlsAudioTrackLoading";
186  // fired when an audio track loading finishes - data: { details : levelDetails object, id : audio track id, stats : LoaderStats }
187  Events["AUDIO_TRACK_LOADED"] = "hlsAudioTrackLoaded";
188  // 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 }
189  Events["AUDIO_TRACK_UPDATED"] = "hlsAudioTrackUpdated";
190  // fired to notify that subtitle track lists has been updated - data: { subtitleTracks : subtitleTracks }
191  Events["SUBTITLE_TRACKS_UPDATED"] = "hlsSubtitleTracksUpdated";
192  // fired to notify that subtitle tracks were cleared as a result of stopping the media
193  Events["SUBTITLE_TRACKS_CLEARED"] = "hlsSubtitleTracksCleared";
194  // fired when an subtitle track switch occurs - data: { id : subtitle track id }
195  Events["SUBTITLE_TRACK_SWITCH"] = "hlsSubtitleTrackSwitch";
196  // fired when a subtitle track loading starts - data: { url : subtitle track URL, id : subtitle track id }
197  Events["SUBTITLE_TRACK_LOADING"] = "hlsSubtitleTrackLoading";
198  // fired when a subtitle track loading finishes - data: { details : levelDetails object, id : subtitle track id, stats : LoaderStats }
199  Events["SUBTITLE_TRACK_LOADED"] = "hlsSubtitleTrackLoaded";
200  // 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 }
201  Events["SUBTITLE_TRACK_UPDATED"] = "hlsSubtitleTrackUpdated";
202  // fired when a subtitle fragment has been processed - data: { success : boolean, frag : the processed frag }
203  Events["SUBTITLE_FRAG_PROCESSED"] = "hlsSubtitleFragProcessed";
204  // fired when a set of VTTCues to be managed externally has been parsed - data: { type: string, track: string, cues: [ VTTCue ] }
205  Events["CUES_PARSED"] = "hlsCuesParsed";
206  // fired when a text track to be managed externally is found - data: { tracks: [ { label: string, kind: string, default: boolean } ] }
207  Events["NON_NATIVE_TEXT_TRACKS_FOUND"] = "hlsNonNativeTextTracksFound";

208  // fired when the first timestamp is found - data: { id : demuxer id, initPTS: initPTS, timescale: timescale, frag : fragment object }
209  Events["INIT_PTS_FOUND"] = "hlsInitPtsFound";
210  // fired when a fragment loading starts - data: { frag : fragment object }
211  Events["FRAG_LOADING"] = "hlsFragLoading";
212  // fired when a fragment loading is progressing - data: { frag : fragment object, { trequest, tfirst, loaded } }
213  // FRAG_LOAD_PROGRESS = 'hlsFragLoadProgress',
214  // Identifier for fragment load aborting for emergency switch down - data: { frag : fragment object }
215  Events["FRAG_LOAD_EMERGENCY_ABORTED"] = "hlsFragLoadEmergencyAborted";
216  // fired when a fragment loading is completed - data: { frag : fragment object, payload : fragment payload, stats : LoaderStats }
217  Events["FRAG_LOADED"] = "hlsFragLoaded";
218  // fired when a fragment has finished decrypting - data: { id : demuxer id, frag: fragment object, payload : fragment payload, stats : { tstart, tdecrypt } }
219  Events["FRAG_DECRYPTED"] = "hlsFragDecrypted";
220  // 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 }
221  Events["FRAG_PARSING_INIT_SEGMENT"] = "hlsFragParsingInitSegment";
222  // fired when parsing sei text is completed - data: { id : demuxer id, frag: fragment object, samples : [ sei samples pes ] }
223  Events["FRAG_PARSING_USERDATA"] = "hlsFragParsingUserdata";
224  // fired when parsing id3 is completed - data: { id : demuxer id, frag: fragment object, samples : [ id3 samples pes ] }
225  Events["FRAG_PARSING_METADATA"] = "hlsFragParsingMetadata";
226  // 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}
227  // FRAG_PARSING_DATA = 'hlsFragParsingData',
228  // fired when fragment parsing is completed - data: { id : demuxer id, frag: fragment object }
229  Events["FRAG_PARSED"] = "hlsFragParsed";
230  // fired when fragment remuxed MP4 boxes have all been appended into SourceBuffer - data: { id : demuxer id, frag : fragment object, stats : LoaderStats }
231  Events["FRAG_BUFFERED"] = "hlsFragBuffered";
232  // fired when fragment matching with current media position is changing - data : { id : demuxer id, frag : fragment object }
233  Events["FRAG_CHANGED"] = "hlsFragChanged";
234  // Identifier for a FPS drop event - data: { currentDropped, currentDecoded, totalDroppedFrames }
235  Events["FPS_DROP"] = "hlsFpsDrop";
236  // triggered when FPS drop triggers auto level capping - data: { level, droppedLevel }
237  Events["FPS_DROP_LEVEL_CAPPING"] = "hlsFpsDropLevelCapping";
238  // triggered when maxAutoLevel changes - data { autoLevelCapping, levels, maxAutoLevel, minAutoLevel, maxHdcpLevel }
239  Events["MAX_AUTO_LEVEL_UPDATED"] = "hlsMaxAutoLevelUpdated";
240  // 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 }
241  Events["ERROR"] = "hlsError";
242  // 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: { }
243  Events["DESTROYING"] = "hlsDestroying";
244  // fired when a decrypt key loading starts - data: { frag : fragment object }
245  Events["KEY_LOADING"] = "hlsKeyLoading";
246  // fired when a decrypt key loading is completed - data: { frag : fragment object, keyInfo : KeyLoaderInfo }
247  Events["KEY_LOADED"] = "hlsKeyLoaded";
248  // deprecated; please use BACK_BUFFER_REACHED - data : { bufferEnd: number }
249  Events["LIVE_BACK_BUFFER_REACHED"] = "hlsLiveBackBufferReached";
250  // fired when the back buffer is reached as defined by the backBufferLength config option - data : { bufferEnd: number }
251  Events["BACK_BUFFER_REACHED"] = "hlsBackBufferReached";
252  // fired after steering manifest has been loaded - data: { steeringManifest: SteeringManifest object, url: steering manifest URL }
253  Events["STEERING_MANIFEST_LOADED"] = "hlsSteeringManifestLoaded";
254  // fired when asset list has begun loading
255  Events["ASSET_LIST_LOADING"] = "hlsAssetListLoading";
256  // fired when a valid asset list is loaded
257  Events["ASSET_LIST_LOADED"] = "hlsAssetListLoaded";
258  // fired when the list of Interstitial Events and Interstitial Schedule is updated
259  Events["INTERSTITIALS_UPDATED"] = "hlsInterstitialsUpdated";
260  // fired when the buffer reaches an Interstitial Schedule boundary (both Primary segments and Interstitial Assets)
261  Events["INTERSTITIALS_BUFFERED_TO_BOUNDARY"] = "hlsInterstitialsBufferedToBoundary";
262  // fired when a player instance for an Interstitial Asset has been created
263  Events["INTERSTITIAL_ASSET_PLAYER_CREATED"] = "hlsInterstitialAssetPlayerCreated";
264  // Interstitial playback started
265  Events["INTERSTITIAL_STARTED"] = "hlsInterstitialStarted";
266  // InterstitialAsset playback started
267  Events["INTERSTITIAL_ASSET_STARTED"] = "hlsInterstitialAssetStarted";
268  // InterstitialAsset playback ended
269  Events["INTERSTITIAL_ASSET_ENDED"] = "hlsInterstitialAssetEnded";
270  // InterstitialAsset playback errored
271  Events["INTERSTITIAL_ASSET_ERROR"] = "hlsInterstitialAssetError";
272  // Interstitial playback ended
273  Events["INTERSTITIAL_ENDED"] = "hlsInterstitialEnded";
274  // Interstitial schedule resumed primary playback
275  Events["INTERSTITIALS_PRIMARY_RESUMED"] = "hlsInterstitialsPrimaryResumed";
276  // Interstitial players dispatch this event when playout limit is reached
277  Events["PLAYOUT_LIMIT_REACHED"] = "hlsPlayoutLimitReached";
278  // Event DateRange cue "enter" event dispatched
279  Events["EVENT_CUE_ENTER"] = "hlsEventCueEnter";
280  return Events;
281}({});
282
283/**
284 * Defines each Event type and payload by Event name. Used in {@link hls.js#HlsEventEmitter} to strongly type the event listener API.
285 */
286
287var PlaylistContextType = {
288  MANIFEST: "manifest",
289  LEVEL: "level",
290  AUDIO_TRACK: "audioTrack",
291  SUBTITLE_TRACK: "subtitleTrack"
292};
293var PlaylistLevelType = {
294  MAIN: "main",
295  AUDIO: "audio",
296  SUBTITLE: "subtitle"
297};
298
299/*
300 * compute an Exponential Weighted moving average
301 * - https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
302 *  - heavily inspired from shaka-player
303 */
304
305class EWMA {
306  //  About half of the estimated value will be from the last |halfLife| samples by weight.
307  constructor(halfLife, estimate = 0, weight = 0) {
308    this.halfLife = void 0;
309    this.alpha_ = void 0;
310    this.estimate_ = void 0;
311    this.totalWeight_ = void 0;
312    this.halfLife = halfLife;
313    // Larger values of alpha expire historical data more slowly.
314    this.alpha_ = halfLife ? Math.exp(Math.log(0.5) / halfLife) : 0;
315    this.estimate_ = estimate;
316    this.totalWeight_ = weight;
317  }
318  sample(weight, value) {
319    const adjAlpha = Math.pow(this.alpha_, weight);
320    this.estimate_ = value * (1 - adjAlpha) + adjAlpha * this.estimate_;
321    this.totalWeight_ += weight;
322  }
323  getTotalWeight() {
324    return this.totalWeight_;
325  }
326  getEstimate() {
327    if (this.alpha_) {
328      const zeroFactor = 1 - Math.pow(this.alpha_, this.totalWeight_);
329      if (zeroFactor) {
330        return this.estimate_ / zeroFactor;
331      }
332    }
333    return this.estimate_;
334  }
335}
336
337/*
338 * EWMA Bandwidth Estimator
339 *  - heavily inspired from shaka-player
340 * Tracks bandwidth samples and estimates available bandwidth.
341 * Based on the minimum of two exponentially-weighted moving averages with
342 * different half-lives.
343 */
344
345class EwmaBandWidthEstimator {
346  constructor(slow, fast, defaultEstimate, defaultTTFB = 100) {
347    this.defaultEstimate_ = void 0;
348    this.minWeight_ = void 0;
349    this.minDelayMs_ = void 0;
350    this.slow_ = void 0;
351    this.fast_ = void 0;
352    this.defaultTTFB_ = void 0;
353    this.ttfb_ = void 0;
354    this.defaultEstimate_ = defaultEstimate;
355    this.minWeight_ = 0.001;
356    this.minDelayMs_ = 50;
357    this.slow_ = new EWMA(slow);
358    this.fast_ = new EWMA(fast);
359    this.defaultTTFB_ = defaultTTFB;
360    this.ttfb_ = new EWMA(slow);
361  }
362  update(slow, fast) {
363    const {
364      slow_,
365      fast_,
366      ttfb_
367    } = this;
368    if (slow_.halfLife !== slow) {
369      this.slow_ = new EWMA(slow, slow_.getEstimate(), slow_.getTotalWeight());
370    }
371    if (fast_.halfLife !== fast) {
372      this.fast_ = new EWMA(fast, fast_.getEstimate(), fast_.getTotalWeight());
373    }
374    if (ttfb_.halfLife !== slow) {
375      this.ttfb_ = new EWMA(slow, ttfb_.getEstimate(), ttfb_.getTotalWeight());
376    }
377  }
378  sample(durationMs, numBytes) {
379    durationMs = Math.max(durationMs, this.minDelayMs_);
380    const numBits = 8 * numBytes;
381    // weight is duration in seconds
382    const durationS = durationMs / 1000;
383    // value is bandwidth in bits/s
384    const bandwidthInBps = numBits / durationS;
385    this.fast_.sample(durationS, bandwidthInBps);
386    this.slow_.sample(durationS, bandwidthInBps);
387  }
388  sampleTTFB(ttfb) {
389    // weight is frequency curve applied to TTFB in seconds
390    // (longer times have less weight with expected input under 1 second)
391    const seconds = ttfb / 1000;
392    const weight = Math.sqrt(2) * Math.exp(-Math.pow(seconds, 2) / 2);
393    this.ttfb_.sample(weight, Math.max(ttfb, 5));
394  }
395  canEstimate() {
396    return this.fast_.getTotalWeight() >= this.minWeight_;
397  }
398  getEstimate() {
399    if (this.canEstimate()) {
400      // console.log('slow estimate:'+ Math.round(this.slow_.getEstimate()));
401      // console.log('fast estimate:'+ Math.round(this.fast_.getEstimate()));
402      // Take the minimum of these two estimates.  This should have the effect of
403      // adapting down quickly, but up more slowly.
404      return Math.min(this.fast_.getEstimate(), this.slow_.getEstimate());
405    } else {
406      return this.defaultEstimate_;
407    }
408  }
409  getEstimateTTFB() {
410    if (this.ttfb_.getTotalWeight() >= this.minWeight_) {
411      return this.ttfb_.getEstimate();
412    } else {
413      return this.defaultTTFB_;
414    }
415  }
416  get defaultEstimate() {
417    return this.defaultEstimate_;
418  }
419  destroy() {}
420}
421
422function _defineProperty(e, r, t) {
423  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
424    value: t,
425    enumerable: true,
426    configurable: true,
427    writable: true
428  }) : e[r] = t, e;
429}
430function _extends() {
431  return _extends = Object.assign ? Object.assign.bind() : function (n) {
432    for (var e = 1; e < arguments.length; e++) {
433      var t = arguments[e];
434      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
435    }
436    return n;
437  }, _extends.apply(null, arguments);
438}
439function ownKeys(e, r) {
440  var t = Object.keys(e);
441  if (Object.getOwnPropertySymbols) {
442    var o = Object.getOwnPropertySymbols(e);
443    r && (o = o.filter(function (r) {
444      return Object.getOwnPropertyDescriptor(e, r).enumerable;
445    })), t.push.apply(t, o);
446  }
447  return t;
448}
449function _objectSpread2(e) {
450  for (var r = 1; r < arguments.length; r++) {
451    var t = null != arguments[r] ? arguments[r] : {};
452    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
453      _defineProperty(e, r, t[r]);
454    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
455      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
456    });
457  }
458  return e;
459}
460function _toPrimitive(t, r) {
461  if ("object" != typeof t || !t) return t;
462  var e = t[Symbol.toPrimitive];
463  if (void 0 !== e) {
464    var i = e.call(t, r);
465    if ("object" != typeof i) return i;
466    throw new TypeError("@@toPrimitive must return a primitive value.");
467  }
468  return ("string" === r ? String : Number)(t);
469}
470function _toPropertyKey(t) {
471  var i = _toPrimitive(t, "string");
472  return "symbol" == typeof i ? i : i + "";
473}
474
475class Logger {
476  constructor(label, logger) {
477    this.trace = void 0;
478    this.debug = void 0;
479    this.log = void 0;
480    this.warn = void 0;
481    this.info = void 0;
482    this.error = void 0;
483    const lb = `[${label}]:`;
484    this.trace = noop;
485    this.debug = logger.debug.bind(null, lb);
486    this.log = logger.log.bind(null, lb);
487    this.warn = logger.warn.bind(null, lb);
488    this.info = logger.info.bind(null, lb);
489    this.error = logger.error.bind(null, lb);
490  }
491}
492const noop = function noop() {};
493const fakeLogger = {
494  trace: noop,
495  debug: noop,
496  log: noop,
497  warn: noop,
498  info: noop,
499  error: noop
500};
501function createLogger() {
502  return _extends({}, fakeLogger);
503}
504
505// let lastCallTime;
506// function formatMsgWithTimeInfo(type, msg) {
507//   const now = Date.now();
508//   const diff = lastCallTime ? '+' + (now - lastCallTime) : '0';

509//   lastCallTime = now;
510//   msg = (new Date(now)).toISOString() + ' | [' +  type + '] > ' + msg + ' ( ' + diff + ' ms )';
511//   return msg;
512// }
513
514function consolePrintFn(type, id) {
515  const func = self.console[type];
516  return func ? func.bind(self.console, `${id ? '[' + id + '] ' : ''}[${type}] >`) : noop;
517}
518function getLoggerFn(key, debugConfig, id) {
519  return debugConfig[key] ? debugConfig[key].bind(debugConfig) : consolePrintFn(key, id);
520}
521const exportedLogger = createLogger();
522function enableLogs(debugConfig, context, id) {
523  // check that console is available
524  const newLogger = createLogger();
525  if (typeof console === 'object' && debugConfig === true || typeof debugConfig === 'object') {
526    const keys = [
527    // Remove out from list here to hard-disable a log-level
528    // 'trace',
529    'debug', 'log', 'info', 'warn', 'error'];
530    keys.forEach(key => {
531      newLogger[key] = getLoggerFn(key, debugConfig, id);
532    });
533    // Some browsers don't allow to use bind on console object anyway
534    // fallback to default if needed
535    try {
536      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.16"}`);
537    } catch (e) {
538      /* log fn threw an exception. All logger methods are no-ops. */
539      return createLogger();
540    }
541    // global exported logger uses the same functions as new logger without `id`
542    keys.forEach(key => {
543      exportedLogger[key] = getLoggerFn(key, debugConfig);
544    });
545  } else {
546    // Reset global exported logger
547    _extends(exportedLogger, newLogger);
548  }
549  return newLogger;
550}
551const logger = exportedLogger;
552
553function getMediaSource(preferManagedMediaSource = true) {
554  if (typeof self === 'undefined') return undefined;
555  const mms = (preferManagedMediaSource || !self.MediaSource) && self.ManagedMediaSource;
556  return mms || self.MediaSource || self.WebKitMediaSource;
557}
558function isManagedMediaSource(source) {
559  return typeof self !== 'undefined' && source === self.ManagedMediaSource;
560}
561function isCompatibleTrackChange(currentTracks, requiredTracks) {
562  const trackNames = Object.keys(currentTracks);
563  const requiredTrackNames = Object.keys(requiredTracks);
564  const trackCount = trackNames.length;
565  const requiredTrackCount = requiredTrackNames.length;
566  return !trackCount || !requiredTrackCount || trackCount === requiredTrackCount && !trackNames.some(name => requiredTrackNames.indexOf(name) === -1);
567}
568
569// http://stackoverflow.com/questions/8936984/uint8array-to-string-in-javascript/22373197
570// http://www.onicos.com/staff/iz/amuse/javascript/expert/utf.txt
571/* utf.js - UTF-8 <=> UTF-16 convertion
572 *
573 * Copyright (C) 1999 Masanao Izumo <[email protected]>
574 * Version: 1.0
575 * LastModified: Dec 25 1999
576 * This library is free.  You can redistribute it and/or modify it.
577 */
578/**
579 * Converts a UTF-8 array to a string.
580 *
581 * @param array - The UTF-8 array to convert
582 *
583 * @returns The string
584 *
585 * @group Utils
586 *
587 * @beta
588 */
589function utf8ArrayToStr(array, exitOnNull = false) {
590  if (typeof TextDecoder !== 'undefined') {
591    const decoder = new TextDecoder('utf-8');
592    const decoded = decoder.decode(array);
593    if (exitOnNull) {
594      // grab up to the first null
595      const idx = decoded.indexOf('\0');
596      return idx !== -1 ? decoded.substring(0, idx) : decoded;
597    }
598    // remove any null characters
599    return decoded.replace(/\0/g, '');
600  }
601  const len = array.length;
602  let c;
603  let char2;
604  let char3;
605  let out = '';
606  let i = 0;
607  while (i < len) {
608    c = array[i++];
609    if (c === 0x00 && exitOnNull) {
610      return out;
611    } else if (c === 0x00 || c === 0x03) {
612      // If the character is 3 (END_OF_TEXT) or 0 (NULL) then skip it
613      continue;
614    }
615    switch (c >> 4) {
616      case 0:
617      case 1:
618      case 2:
619      case 3:
620      case 4:
621      case 5:
622      case 6:
623      case 7:
624        // 0xxxxxxx
625        out += String.fromCharCode(c);
626        break;
627      case 12:
628      case 13:
629        // 110x xxxx   10xx xxxx
630        char2 = array[i++];
631        out += String.fromCharCode((c & 0x1f) << 6 | char2 & 0x3f);
632        break;
633      case 14:
634        // 1110 xxxx  10xx xxxx  10xx xxxx
635        char2 = array[i++];
636        char3 = array[i++];
637        out += String.fromCharCode((c & 0x0f) << 12 | (char2 & 0x3f) << 6 | (char3 & 0x3f) << 0);
638        break;
639    }
640  }
641  return out;
642}
643
644/**
645 *  hex dump helper class
646 */
647
648function arrayToHex(array) {
649  let str = '';
650  for (let i = 0; i < array.length; i++) {
651    let h = array[i].toString(16);
652    if (h.length < 2) {
653      h = '0' + h;
654    }
655    str += h;
656  }
657  return str;
658}
659function hexToArrayBuffer(str) {
660  return Uint8Array.from(str.replace(/^0x/, '').replace(/([\da-fA-F]{2}) ?/g, '0x$1 ').replace(/ +$/, '').split(' ')).buffer;
661}
662
663function getDefaultExportFromCjs (x) {
664	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
665}
666
667var urlToolkit = {exports: {}};
668
669var hasRequiredUrlToolkit;
670
671function requireUrlToolkit () {
672	if (hasRequiredUrlToolkit) return urlToolkit.exports;
673	hasRequiredUrlToolkit = 1;

674	(function (module, exports) {
675		// see https://tools.ietf.org/html/rfc1808
676
677		(function (root) {
678		  var URL_REGEX =
679		    /^(?=((?:[a-zA-Z0-9+\-.]+:)?))\1(?=((?:\/\/[^\/?#]*)?))\2(?=((?:(?:[^?#\/]*\/)*[^;?#\/]*)?))\3((?:;[^?#]*)?)(\?[^#]*)?(#[^]*)?$/;
680		  var FIRST_SEGMENT_REGEX = /^(?=([^\/?#]*))\1([^]*)$/;
681		  var SLASH_DOT_REGEX = /(?:\/|^)\.(?=\/)/g;
682		  var SLASH_DOT_DOT_REGEX = /(?:\/|^)\.\.\/(?!\.\.\/)[^\/]*(?=\/)/g;
683
684		  var URLToolkit = {
685		    // If opts.alwaysNormalize is true then the path will always be normalized even when it starts with / or //
686		    // E.g
687		    // With opts.alwaysNormalize = false (default, spec compliant)
688		    // http://a.com/b/cd + /e/f/../g => http://a.com/e/f/../g
689		    // With opts.alwaysNormalize = true (not spec compliant)
690		    // http://a.com/b/cd + /e/f/../g => http://a.com/e/g
691		    buildAbsoluteURL: function (baseURL, relativeURL, opts) {
692		      opts = opts || {};
693		      // remove any remaining space and CRLF
694		      baseURL = baseURL.trim();
695		      relativeURL = relativeURL.trim();
696		      if (!relativeURL) {
697		        // 2a) If the embedded URL is entirely empty, it inherits the
698		        // entire base URL (i.e., is set equal to the base URL)
699		        // and we are done.
700		        if (!opts.alwaysNormalize) {
701		          return baseURL;
702		        }
703		        var basePartsForNormalise = URLToolkit.parseURL(baseURL);
704		        if (!basePartsForNormalise) {
705		          throw new Error('Error trying to parse base URL.');
706		        }
707		        basePartsForNormalise.path = URLToolkit.normalizePath(
708		          basePartsForNormalise.path
709		        );
710		        return URLToolkit.buildURLFromParts(basePartsForNormalise);
711		      }
712		      var relativeParts = URLToolkit.parseURL(relativeURL);
713		      if (!relativeParts) {
714		        throw new Error('Error trying to parse relative URL.');
715		      }
716		      if (relativeParts.scheme) {
717		        // 2b) If the embedded URL starts with a scheme name, it is
718		        // interpreted as an absolute URL and we are done.
719		        if (!opts.alwaysNormalize) {
720		          return relativeURL;
721		        }
722		        relativeParts.path = URLToolkit.normalizePath(relativeParts.path);
723		        return URLToolkit.buildURLFromParts(relativeParts);
724		      }
725		      var baseParts = URLToolkit.parseURL(baseURL);
726		      if (!baseParts) {
727		        throw new Error('Error trying to parse base URL.');
728		      }
729		      if (!baseParts.netLoc && baseParts.path && baseParts.path[0] !== '/') {
730		        // If netLoc missing and path doesn't start with '/', assume everthing before the first '/' is the netLoc
731		        // This causes 'example.com/a' to be handled as '//example.com/a' instead of '/example.com/a'
732		        var pathParts = FIRST_SEGMENT_REGEX.exec(baseParts.path);
733		        baseParts.netLoc = pathParts[1];
734		        baseParts.path = pathParts[2];
735		      }
736		      if (baseParts.netLoc && !baseParts.path) {
737		        baseParts.path = '/';
738		      }
739		      var builtParts = {
740		        // 2c) Otherwise, the embedded URL inherits the scheme of
741		        // the base URL.
742		        scheme: baseParts.scheme,
743		        netLoc: relativeParts.netLoc,
744		        path: null,
745		        params: relativeParts.params,
746		        query: relativeParts.query,
747		        fragment: relativeParts.fragment,
748		      };
749		      if (!relativeParts.netLoc) {
750		        // 3) If the embedded URL's <net_loc> is non-empty, we skip to
751		        // Step 7.  Otherwise, the embedded URL inherits the <net_loc>
752		        // (if any) of the base URL.
753		        builtParts.netLoc = baseParts.netLoc;
754		        // 4) If the embedded URL path is preceded by a slash "/", the
755		        // path is not relative and we skip to Step 7.
756		        if (relativeParts.path[0] !== '/') {
757		          if (!relativeParts.path) {
758		            // 5) If the embedded URL path is empty (and not preceded by a
759		            // slash), then the embedded URL inherits the base URL path
760		            builtParts.path = baseParts.path;
761		            // 5a) if the embedded URL's <params> is non-empty, we skip to
762		            // step 7; otherwise, it inherits the <params> of the base
763		            // URL (if any) and
764		            if (!relativeParts.params) {
765		              builtParts.params = baseParts.params;
766		              // 5b) if the embedded URL's <query> is non-empty, we skip to
767		              // step 7; otherwise, it inherits the <query> of the base
768		              // URL (if any) and we skip to step 7.
769		              if (!relativeParts.query) {
770		                builtParts.query = baseParts.query;
771		              }
772		            }
773		          } else {
774		            // 6) The last segment of the base URL's path (anything
775		            // following the rightmost slash "/", or the entire path if no
776		            // slash is present) is removed and the embedded URL's path is
777		            // appended in its place.
778		            var baseURLPath = baseParts.path;
779		            var newPath =
780		              baseURLPath.substring(0, baseURLPath.lastIndexOf('/') + 1) +
781		              relativeParts.path;
782		            builtParts.path = URLToolkit.normalizePath(newPath);
783		          }
784		        }
785		      }
786		      if (builtParts.path === null) {
787		        builtParts.path = opts.alwaysNormalize
788		          ? URLToolkit.normalizePath(relativeParts.path)
789		          : relativeParts.path;
790		      }
791		      return URLToolkit.buildURLFromParts(builtParts);
792		    },
793		    parseURL: function (url) {
794		      var parts = URL_REGEX.exec(url);
795		      if (!parts) {
796		        return null;
797		      }
798		      return {
799		        scheme: parts[1] || '',
800		        netLoc: parts[2] || '',
801		        path: parts[3] || '',
802		        params: parts[4] || '',
803		        query: parts[5] || '',
804		        fragment: parts[6] || '',
805		      };
806		    },
807		    normalizePath: function (path) {
808		      // The following operations are
809		      // then applied, in order, to the new path:
810		      // 6a) All occurrences of "./", where "." is a complete path
811		      // segment, are removed.
812		      // 6b) If the path ends with "." as a complete path segment,
813		      // that "." is removed.
814		      path = path.split('').reverse().join('').replace(SLASH_DOT_REGEX, '');
815		      // 6c) All occurrences of "<segment>/../", where <segment> is a
816		      // complete path segment not equal to "..", are removed.
817		      // Removal of these path segments is performed iteratively,
818		      // removing the leftmost matching pattern on each iteration,
819		      // until no matching pattern remains.
820		      // 6d) If the path ends with "<segment>/..", where <segment> is a
821		      // complete path segment not equal to "..", that
822		      // "<segment>/.." is removed.
823		      while (
824		        path.length !== (path = path.replace(SLASH_DOT_DOT_REGEX, '')).length
825		      ) {}
826		      return path.split('').reverse().join('');
827		    },
828		    buildURLFromParts: function (parts) {
829		      return (
830		        parts.scheme +
831		        parts.netLoc +
832		        parts.path +
833		        parts.params +
834		        parts.query +
835		        parts.fragment
836		      );
837		    },
838		  };
839
840		  module.exports = URLToolkit;
841		})(); 
842	} (urlToolkit));
843	return urlToolkit.exports;
844}
845
846var urlToolkitExports = requireUrlToolkit();
847
848class LoadStats {
849  constructor() {
850    this.aborted = false;
851    this.loaded = 0;
852    this.retry = 0;
853    this.total = 0;
854    this.chunkCount = 0;
855    this.bwEstimate = 0;
856    this.loading = {
857      start: 0,
858      first: 0,
859      end: 0
860    };
861    this.parsing = {
862      start: 0,
863      end: 0
864    };
865    this.buffering = {
866      start: 0,
867      first: 0,
868      end: 0
869    };
870  }
871}
872
873var ElementaryStreamTypes = {
874  AUDIO: "audio",
875  VIDEO: "video",
876  AUDIOVIDEO: "audiovideo"
877};
878class BaseSegment {
879  constructor(base) {
880    this._byteRange = null;
881    this._url = null;
882    this._stats = null;
883    this._streams = null;
884    // baseurl is the URL to the playlist
885    this.base = void 0;
886    // relurl is the portion of the URL that comes from inside the playlist.
887    this.relurl = void 0;
888    if (typeof base === 'string') {
889      base = {
890        url: base
891      };
892    }
893    this.base = base;
894    makeEnumerable(this, 'stats');
895  }
896
897  // setByteRange converts a EXT-X-BYTERANGE attribute into a two element array
898  setByteRange(value, previous) {
899    const params = value.split('@', 2);
900    let start;
901    if (params.length === 1) {
902      start = (previous == null ? void 0 : previous.byteRangeEndOffset) || 0;
903    } else {
904      start = parseInt(params[1]);
905    }
906    this._byteRange = [start, parseInt(params[0]) + start];
907  }
908  get baseurl() {
909    return this.base.url;
910  }
911  get byteRange() {
912    if (this._byteRange === null) {
913      return [];
914    }
915    return this._byteRange;
916  }
917  get byteRangeStartOffset() {
918    return this.byteRange[0];
919  }
920  get byteRangeEndOffset() {
921    return this.byteRange[1];
922  }
923  get elementaryStreams() {
924    if (this._streams === null) {
925      this._streams = {
926        [ElementaryStreamTypes.AUDIO]: null,
927        [ElementaryStreamTypes.VIDEO]: null,
928        [ElementaryStreamTypes.AUDIOVIDEO]: null
929      };
930    }
931    return this._streams;
932  }
933  set elementaryStreams(value) {
934    this._streams = value;
935  }
936  get hasStats() {
937    return this._stats !== null;
938  }
939  get hasStreams() {
940    return this._streams !== null;
941  }
942  get stats() {
943    if (this._stats === null) {
944      this._stats = new LoadStats();
945    }
946    return this._stats;
947  }
948  set stats(value) {
949    this._stats = value;
950  }
951  get url() {
952    if (!this._url && this.baseurl && this.relurl) {
953      this._url = urlToolkitExports.buildAbsoluteURL(this.baseurl, this.relurl, {
954        alwaysNormalize: true
955      });
956    }
957    return this._url || '';
958  }
959  set url(value) {
960    this._url = value;
961  }
962  clearElementaryStreamInfo() {
963    const {
964      elementaryStreams
965    } = this;
966    elementaryStreams[ElementaryStreamTypes.AUDIO] = null;
967    elementaryStreams[ElementaryStreamTypes.VIDEO] = null;
968    elementaryStreams[ElementaryStreamTypes.AUDIOVIDEO] = null;
969  }
970}
971function isMediaFragment(frag) {
972  return frag.sn !== 'initSegment';
973}
974
975/**
976 * Object representing parsed data from an HLS Segment. Found in {@link hls.js#LevelDetails.fragments}.
977 */
978class Fragment extends BaseSegment {
979  constructor(type, base) {
980    super(base);
981    this._decryptdata = null;
982    this._programDateTime = null;
983    this._ref = null;
984    // Approximate bit rate of the fragment expressed in bits per second (bps) as indicated by the last EXT-X-BITRATE (kbps) tag
985    this._bitrate = void 0;
986    this.rawProgramDateTime = null;
987    this.tagList = [];
988    // EXTINF has to be present for a m3u8 to be considered valid
989    this.duration = 0;
990    // sn notates the sequence number for a segment, and if set to a string can be 'initSegment'
991    this.sn = 0;
992    // levelkeys are the EXT-X-KEY tags that apply to this segment for decryption
993    // core difference from the private field _decryptdata is the lack of the initialized IV
994    // _decryptdata will set the IV for this segment based on the segment number in the fragment
995    this.levelkeys = void 0;
996    // A string representing the fragment type
997    this.type = void 0;
998    // A reference to the loader. Set while the fragment is loading, and removed afterwards. Used to abort fragment loading
999    this.loader = null;
1000    // A reference to the key loader. Set while the key is loading, and removed afterwards. Used to abort key loading
1001    this.keyLoader = null;
1002    // The level/track index to which the fragment belongs
1003    this.level = -1;
1004    // The continuity counter of the fragment
1005    this.cc = 0;
1006    // The starting Presentation Time Stamp (PTS) of the fragment. Set after transmux complete.
1007    this.startPTS = void 0;
1008    // The ending Presentation Time Stamp (PTS) of the fragment. Set after transmux complete.
1009    this.endPTS = void 0;
1010    // The starting Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
1011    this.startDTS = void 0;
1012    // The ending Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
1013    this.endDTS = void 0;
1014    // The start time of the fragment, as listed in the manifest. Updated after transmux complete.
1015    this.start = 0;
1016    // The offset time (seconds) of the fragment from the start of the Playlist
1017    this.playlistOffset = 0;
1018    // Set by `updateFragPTSDTS` in level-helper
1019    this.deltaPTS = void 0;
1020    // The maximum starting Presentation Time Stamp (audio/video PTS) of the fragment. Set after transmux complete.
1021    this.maxStartPTS = void 0;
1022    // The minimum ending Presentation Time Stamp (audio/video PTS) of the fragment. Set after transmux complete.
1023    this.minEndPTS = void 0;
1024    // Init Segment bytes (unset for media segments)
1025    this.data = void 0;
1026    // A flag indicating whether the segment was downloaded in order to test bitrate, and was not buffered
1027    this.bitrateTest = false;
1028    // #EXTINF  segment title
1029    this.title = null;
1030    // The Media Initialization Section for this segment
1031    this.initSegment = null;
1032    // Fragment is the last fragment in the media playlist
1033    this.endList = void 0;
1034    // Fragment is marked by an EXT-X-GAP tag indicating that it does not contain media data and should not be loaded
1035    this.gap = void 0;
1036    // Deprecated
1037    this.urlId = 0;
1038    this.type = type;
1039  }
1040  get byteLength() {
1041    if (this.hasStats) {
1042      const total = this.stats.total;
1043      if (total) {
1044        return total;
1045      }
1046    }
1047    if (this.byteRange.length) {
1048      const start = this.byteRange[0];
1049      const end = this.byteRange[1];
1050      if (isFiniteNumber(start) && isFiniteNumber(end)) {
1051        return end - start;
1052      }
1053    }
1054    return null;
1055  }
1056  get bitrate() {
1057    if (this.byteLength) {
1058      return this.byteLength * 8 / this.duration;
1059    }
1060    if (this._bitrate) {
1061      return this._bitrate;
1062    }
1063    return null;
1064  }
1065  set bitrate(value) {
1066    this._bitrate = value;
1067  }
1068  get decryptdata() {
1069    var _this$_decryptdata;
1070    const {
1071      levelkeys
1072    } = this;
1073    if (!levelkeys || levelkeys.NONE) {
1074      return null;
1075    }
1076    if (levelkeys.identity) {
1077      if (!this._decryptdata) {
1078        this._decryptdata = levelkeys.identity.getDecryptData(this.sn);
1079      }
1080    } else if (!((_this$_decryptdata = this._decryptdata) != null && _this$_decryptdata.keyId)) {
1081      const keyFormats = Object.keys(levelkeys);
1082      if (keyFormats.length === 1) {
1083        const levelKey = this._decryptdata = levelkeys[keyFormats[0]] || null;
1084        if (levelKey) {
1085          this._decryptdata = levelKey.getDecryptData(this.sn, levelkeys);
1086        }
1087      }
1088    }
1089    return this._decryptdata;
1090  }
1091  get end() {
1092    return this.start + this.duration;
1093  }
1094  get endProgramDateTime() {
1095    if (this.programDateTime === null) {
1096      return null;
1097    }
1098    const duration = !isFiniteNumber(this.duration) ? 0 : this.duration;
1099    return this.programDateTime + duration * 1000;
1100  }
1101  get encrypted() {
1102    var _this$_decryptdata2;
1103    // At the m3u8-parser level we need to add support for manifest signalled keyformats
1104    // when we want the fragment to start reporting that it is encrypted.
1105    // Currently, keyFormat will only be set for identity keys
1106    if ((_this$_decryptdata2 = this._decryptdata) != null && _this$_decryptdata2.encrypted) {
1107      return true;
1108    } else if (this.levelkeys) {
1109      var _this$levelkeys$keyFo;
1110      const keyFormats = Object.keys(this.levelkeys);
1111      const len = keyFormats.length;
1112      if (len > 1 || len === 1 && (_this$levelkeys$keyFo = this.levelkeys[keyFormats[0]]) != null && _this$levelkeys$keyFo.encrypted) {
1113        return true;
1114      }
1115    }
1116    return false;
1117  }
1118  get programDateTime() {
1119    if (this._programDateTime === null && this.rawProgramDateTime) {
1120      this.programDateTime = Date.parse(this.rawProgramDateTime);
1121    }
1122    return this._programDateTime;
1123  }
1124  set programDateTime(value) {
1125    if (!isFiniteNumber(value)) {
1126      this._programDateTime = this.rawProgramDateTime = null;
1127      return;
1128    }
1129    this._programDateTime = value;
1130  }
1131  get ref() {
1132    if (!isMediaFragment(this)) {
1133      return null;
1134    }
1135    if (!this._ref) {
1136      this._ref = {
1137        base: this.base,
1138        start: this.start,
1139        duration: this.duration,
1140        sn: this.sn,
1141        programDateTime: this.programDateTime
1142      };
1143    }
1144    return this._ref;
1145  }
1146  addStart(value) {
1147    this.setStart(this.start + value);
1148  }
1149  setStart(value) {
1150    this.start = value;
1151    if (this._ref) {
1152      this._ref.start = value;
1153    }
1154  }
1155  setDuration(value) {
1156    this.duration = value;
1157    if (this._ref) {
1158      this._ref.duration = value;
1159    }
1160  }
1161  setKeyFormat(keyFormat) {
1162    const levelkeys = this.levelkeys;
1163    if (levelkeys) {
1164      var _this$_decryptdata3;
1165      const key = levelkeys[keyFormat];
1166      if (key && !((_this$_decryptdata3 = this._decryptdata) != null && _this$_decryptdata3.keyId)) {
1167        this._decryptdata = key.getDecryptData(this.sn, levelkeys);
1168      }
1169    }
1170  }
1171  abortRequests() {
1172    var _this$loader, _this$keyLoader;
1173    (_this$loader = this.loader) == null || _this$loader.abort();
1174    (_this$keyLoader = this.keyLoader) == null || _this$keyLoader.abort();
1175  }
1176  setElementaryStreamInfo(type, startPTS, endPTS, startDTS, endDTS, partial = false) {
1177    const {
1178      elementaryStreams
1179    } = this;
1180    const info = elementaryStreams[type];
1181    if (!info) {
1182      elementaryStreams[type] = {
1183        startPTS,
1184        endPTS,
1185        startDTS,
1186        endDTS,
1187        partial
1188      };
1189      return;
1190    }
1191    info.startPTS = Math.min(info.startPTS, startPTS);
1192    info.endPTS = Math.max(info.endPTS, endPTS);
1193    info.startDTS = Math.min(info.startDTS, startDTS);
1194    info.endDTS = Math.max(info.endDTS, endDTS);
1195  }
1196}
1197
1198/**
1199 * Object representing parsed data from an HLS Partial Segment. Found in {@link hls.js#LevelDetails.partList}.
1200 */
1201class Part extends BaseSegment {
1202  constructor(partAttrs, frag, base, index, previous) {
1203    super(base);
1204    this.fragOffset = 0;
1205    this.duration = 0;
1206    this.gap = false;
1207    this.independent = false;
1208    this.relurl = void 0;
1209    this.fragment = void 0;
1210    this.index = void 0;
1211    this.duration = partAttrs.decimalFloatingPoint('DURATION');
1212    this.gap = partAttrs.bool('GAP');
1213    this.independent = partAttrs.bool('INDEPENDENT');
1214    this.relurl = partAttrs.enumeratedString('URI');
1215    this.fragment = frag;
1216    this.index = index;
1217    const byteRange = partAttrs.enumeratedString('BYTERANGE');
1218    if (byteRange) {
1219      this.setByteRange(byteRange, previous);
1220    }
1221    if (previous) {
1222      this.fragOffset = previous.fragOffset + previous.duration;
1223    }
1224  }
1225  get start() {
1226    return this.fragment.start + this.fragOffset;
1227  }
1228  get end() {
1229    return this.start + this.duration;
1230  }
1231  get loaded() {
1232    const {
1233      elementaryStreams
1234    } = this;
1235    return !!(elementaryStreams.audio || elementaryStreams.video || elementaryStreams.audiovideo);
1236  }
1237}
1238function getOwnPropertyDescriptorFromPrototypeChain(object, property) {
1239  const prototype = Object.getPrototypeOf(object);
1240  if (prototype) {
1241    const propertyDescriptor = Object.getOwnPropertyDescriptor(prototype, property);
1242    if (propertyDescriptor) {
1243      return propertyDescriptor;
1244    }
1245    return getOwnPropertyDescriptorFromPrototypeChain(prototype, property);
1246  }
1247}
1248function makeEnumerable(object, property) {
1249  const d = getOwnPropertyDescriptorFromPrototypeChain(object, property);
1250  if (d) {
1251    d.enumerable = true;
1252    Object.defineProperty(object, property, d);
1253  }
1254}
1255
1256const UINT32_MAX$1 = Math.pow(2, 32) - 1;
1257const push = [].push;
1258
1259// We are using fixed track IDs for driving the MP4 remuxer
1260// instead of following the TS PIDs.
1261// There is no reason not to do this and some browsers/SourceBuffer-demuxers
1262// may not like if there are TrackID "switches"
1263// See https://github.com/video-dev/hls.js/issues/1331
1264// Here we are mapping our internal track types to constant MP4 track IDs
1265// With MSE currently one can only have one track of each, and we are muxing
1266// whatever video/audio rendition in them.
1267const RemuxerTrackIdConfig = {
1268  video: 1,
1269  audio: 2,
1270  id3: 3,
1271  text: 4
1272};
1273function bin2str(data) {
1274  return String.fromCharCode.apply(null, data);
1275}
1276function readUint16(buffer, offset) {
1277  const val = buffer[offset] << 8 | buffer[offset + 1];
1278  return val < 0 ? 65536 + val : val;
1279}
1280function readUint32(buffer, offset) {
1281  const val = readSint32(buffer, offset);
1282  return val < 0 ? 4294967296 + val : val;
1283}
1284function readUint64(buffer, offset) {
1285  let result = readUint32(buffer, offset);
1286  result *= Math.pow(2, 32);
1287  result += readUint32(buffer, offset + 4);
1288  return result;
1289}
1290function readSint32(buffer, offset) {
1291  return buffer[offset] << 24 | buffer[offset + 1] << 16 | buffer[offset + 2] << 8 | buffer[offset + 3];
1292}
1293
1294// Find "moof" box
1295function hasMoofData(data) {
1296  const end = data.byteLength;
1297  for (let i = 0; i < end;) {
1298    const size = readUint32(data, i);
1299    if (size > 8 && data[i + 4] === 0x6d && data[i + 5] === 0x6f && data[i + 6] === 0x6f && data[i + 7] === 0x66) {
1300      return true;
1301    }
1302    i = size > 1 ? i + size : end;
1303  }
1304  return false;
1305}
1306
1307// Find the data for a box specified by its path
1308function findBox(data, path) {
1309  const results = [];
1310  if (!path.length) {
1311    // short-circuit the search for empty paths
1312    return results;
1313  }
1314  const end = data.byteLength;
1315  for (let i = 0; i < end;) {
1316    const size = readUint32(data, i);
1317    const type = bin2str(data.subarray(i + 4, i + 8));
1318    const endbox = size > 1 ? i + size : end;
1319    if (type === path[0]) {
1320      if (path.length === 1) {
1321        // this is the end of the path and we've found the box we were
1322        // looking for
1323        results.push(data.subarray(i + 8, endbox));
1324      } else {
1325        // recursively search for the next box along the path
1326        const subresults = findBox(data.subarray(i + 8, endbox), path.slice(1));
1327        if (subresults.length) {
1328          push.apply(results, subresults);
1329        }
1330      }
1331    }
1332    i = endbox;
1333  }
1334
1335  // we've finished searching all of data
1336  return results;
1337}
1338function parseSegmentIndex(sidx) {
1339  const references = [];
1340  const version = sidx[0];
1341
1342  // set initial offset, we skip the reference ID (not needed)
1343  let index = 8;
1344  const timescale = readUint32(sidx, index);
1345  index += 4;
1346  let earliestPresentationTime = 0;
1347  let firstOffset = 0;
1348  if (version === 0) {
1349    earliestPresentationTime = readUint32(sidx, index);
1350    firstOffset = readUint32(sidx, index + 4);
1351    index += 8;
1352  } else {
1353    earliestPresentationTime = readUint64(sidx, index);
1354    firstOffset = readUint64(sidx, index + 8);
1355    index += 16;
1356  }
1357
1358  // skip reserved
1359  index += 2;
1360  let startByte = sidx.length + firstOffset;
1361  const referencesCount = readUint16(sidx, index);
1362  index += 2;
1363  for (let i = 0; i < referencesCount; i++) {
1364    let referenceIndex = index;
1365    const referenceInfo = readUint32(sidx, referenceIndex);
1366    referenceIndex += 4;
1367    const referenceSize = referenceInfo & 0x7fffffff;
1368    const referenceType = (referenceInfo & 0x80000000) >>> 31;
1369    if (referenceType === 1) {
1370      logger.warn('SIDX has hierarchical references (not supported)');
1371      return null;
1372    }
1373    const subsegmentDuration = readUint32(sidx, referenceIndex);
1374    referenceIndex += 4;
1375    references.push({
1376      referenceSize,
1377      subsegmentDuration,
1378      // unscaled
1379      info: {
1380        duration: subsegmentDuration / timescale,
1381        start: startByte,
1382        end: startByte + referenceSize - 1
1383      }
1384    });
1385    startByte += referenceSize;
1386
1387    // Skipping 1 bit for |startsWithSap|, 3 bits for |sapType|, and 28 bits
1388    // for |sapDelta|.
1389    referenceIndex += 4;
1390
1391    // skip to next ref
1392    index = referenceIndex;
1393  }
1394  return {
1395    earliestPresentationTime,
1396    timescale,
1397    version,
1398    referencesCount,
1399    references
1400  };
1401}
1402
1403/**
1404 * Parses an MP4 initialization segment and extracts stream type and
1405 * timescale values for any declared tracks. Timescale values indicate the
1406 * number of clock ticks per second to assume for time-based values
1407 * elsewhere in the MP4.
1408 *
1409 * To determine the start time of an MP4, you need two pieces of
1410 * information: the timescale unit and the earliest base media decode
1411 * time. Multiple timescales can be specified within an MP4 but the
1412 * base media decode time is always expressed in the timescale from
1413 * the media header box for the track:
1414 * ```
1415 * moov > trak > mdia > mdhd.timescale
1416 * moov > trak > mdia > hdlr
1417 * ```
1418 * @param initSegment the bytes of the init segment
1419 * @returns a hash of track type to timescale values or null if
1420 * the init segment is malformed.
1421 */
1422
1423function parseInitSegment(initSegment) {
1424  const result = [];
1425  const traks = findBox(initSegment, ['moov', 'trak']);
1426  for (let i = 0; i < traks.length; i++) {
1427    const trak = traks[i];
1428    const tkhd = findBox(trak, ['tkhd'])[0];
1429    if (tkhd) {
1430      let version = tkhd[0];
1431      const trackId = readUint32(tkhd, version === 0 ? 12 : 20);
1432      const mdhd = findBox(trak, ['mdia', 'mdhd'])[0];
1433      if (mdhd) {
1434        version = mdhd[0];
1435        const timescale = readUint32(mdhd, version === 0 ? 12 : 20);
1436        const hdlr = findBox(trak, ['mdia', 'hdlr'])[0];
1437        if (hdlr) {
1438          const hdlrType = bin2str(hdlr.subarray(8, 12));
1439          const type = {
1440            soun: ElementaryStreamTypes.AUDIO,
1441            vide: ElementaryStreamTypes.VIDEO
1442          }[hdlrType];
1443          // Parse codec details
1444          const stsdBox = findBox(trak, ['mdia', 'minf', 'stbl', 'stsd'])[0];
1445          const stsd = parseStsd(stsdBox);
1446          if (type) {
1447            // Add 'audio', 'video', and 'audiovideo' track records that will map to SourceBuffers
1448            result[trackId] = {
1449              timescale,
1450              type,
1451              stsd
1452            };
1453            result[type] = _objectSpread2({
1454              timescale,
1455              id: trackId
1456            }, stsd);
1457          } else {
1458            // Add 'meta' and other track records
1459            result[trackId] = {
1460              timescale,
1461              type: hdlrType,
1462              stsd
1463            };
1464          }
1465        }
1466      }
1467    }
1468  }
1469  const trex = findBox(initSegment, ['moov', 'mvex', 'trex']);
1470  trex.forEach(trex => {
1471    const trackId = readUint32(trex, 4);
1472    const track = result[trackId];
1473    if (track) {
1474      track.default = {
1475        duration: readUint32(trex, 12),
1476        flags: readUint32(trex, 20)
1477      };
1478    }
1479  });
1480  return result;
1481}
1482function parseStsd(stsd) {
1483  const sampleEntries = stsd.subarray(8);
1484  const sampleEntriesEnd = sampleEntries.subarray(8 + 78);
1485  const fourCC = bin2str(sampleEntries.subarray(4, 8));
1486  let codec = fourCC;
1487  let supplemental;
1488  const encrypted = fourCC === 'enca' || fourCC === 'encv';
1489  if (encrypted) {
1490    const encBox = findBox(sampleEntries, [fourCC])[0];
1491    const encBoxChildren = encBox.subarray(fourCC === 'enca' ? 28 : 78);
1492    const sinfs = findBox(encBoxChildren, ['sinf']);
1493    sinfs.forEach(sinf => {
1494      const schm = findBox(sinf, ['schm'])[0];
1495      if (schm) {
1496        const scheme = bin2str(schm.subarray(4, 8));
1497        if (scheme === 'cbcs' || scheme === 'cenc') {
1498          const frma = findBox(sinf, ['frma'])[0];
1499          if (frma) {
1500            // for encrypted content codec fourCC will be in frma
1501            codec = bin2str(frma);
1502          }
1503        }
1504      }
1505    });
1506  }
1507  const codecFourCC = codec;
1508  switch (codec) {
1509    case 'avc1':
1510    case 'avc2':
1511    case 'avc3':
1512    case 'avc4':
1513      {
1514        // extract profile + compatibility + level out of avcC box
1515        const avcCBox = findBox(sampleEntriesEnd, ['avcC'])[0];
1516        if (avcCBox && avcCBox.length > 3) {
1517          codec += '.' + toHex(avcCBox[1]) + toHex(avcCBox[2]) + toHex(avcCBox[3]);
1518          supplemental = parseSupplementalDoViCodec(codecFourCC === 'avc1' ? 'dva1' : 'dvav', sampleEntriesEnd);
1519        }
1520        break;
1521      }
1522    case 'mp4a':
1523      {
1524        const codecBox = findBox(sampleEntries, [fourCC])[0];
1525        const esdsBox = findBox(codecBox.subarray(28), ['esds'])[0];
1526        if (esdsBox && esdsBox.length > 7) {
1527          let i = 4;
1528          // ES Descriptor tag
1529          if (esdsBox[i++] !== 0x03) {
1530            break;
1531          }
1532          i = skipBERInteger(esdsBox, i);
1533          i += 2; // skip es_id;
1534          const flags = esdsBox[i++];
1535          if (flags & 0x80) {
1536            i += 2; // skip dependency es_id
1537          }
1538          if (flags & 0x40) {
1539            i += esdsBox[i++]; // skip URL
1540          }
1541          // Decoder config descriptor
1542          if (esdsBox[i++] !== 0x04) {
1543            break;
1544          }
1545          i = skipBERInteger(esdsBox, i);
1546          const objectType = esdsBox[i++];
1547          if (objectType === 0x40) {
1548            codec += '.' + toHex(objectType);
1549          } else {
1550            break;
1551          }
1552          i += 12;
1553          // Decoder specific info
1554          if (esdsBox[i++] !== 0x05) {
1555            break;
1556          }
1557          i = skipBERInteger(esdsBox, i);
1558          const firstByte = esdsBox[i++];
1559          let audioObjectType = (firstByte & 0xf8) >> 3;
1560          if (audioObjectType === 31) {
1561            audioObjectType += 1 + ((firstByte & 0x7) << 3) + ((esdsBox[i] & 0xe0) >> 5);
1562          }
1563          codec += '.' + audioObjectType;
1564        }
1565        break;
1566      }
1567    case 'hvc1':
1568    case 'hev1':
1569      {
1570        const hvcCBox = findBox(sampleEntriesEnd, ['hvcC'])[0];
1571        if (hvcCBox && hvcCBox.length > 12) {
1572          const profileByte = hvcCBox[1];
1573          const profileSpace = ['', 'A', 'B', 'C'][profileByte >> 6];
1574          const generalProfileIdc = profileByte & 0x1f;
1575          const profileCompat = readUint32(hvcCBox, 2);
1576          const tierFlag = (profileByte & 0x20) >> 5 ? 'H' : 'L';
1577          const levelIDC = hvcCBox[12];
1578          const constraintIndicator = hvcCBox.subarray(6, 12);
1579          codec += '.' + profileSpace + generalProfileIdc;
1580          codec += '.' + reverse32BitInt(profileCompat).toString(16).toUpperCase();
1581          codec += '.' + tierFlag + levelIDC;
1582          let constraintString = '';
1583          for (let i = constraintIndicator.length; i--;) {
1584            const byte = constraintIndicator[i];
1585            if (byte || constraintString) {
1586              const encodedByte = byte.toString(16).toUpperCase();
1587              constraintString = '.' + encodedByte + constraintString;
1588            }
1589          }
1590          codec += constraintString;
1591        }
1592        supplemental = parseSupplementalDoViCodec(codecFourCC == 'hev1' ? 'dvhe' : 'dvh1', sampleEntriesEnd);
1593        break;
1594      }
1595    case 'dvh1':
1596    case 'dvhe':
1597    case 'dvav':
1598    case 'dva1':
1599    case 'dav1':
1600      {
1601        codec = parseSupplementalDoViCodec(codec, sampleEntriesEnd) || codec;
1602        break;
1603      }
1604    case 'vp09':
1605      {
1606        const vpcCBox = findBox(sampleEntriesEnd, ['vpcC'])[0];
1607        if (vpcCBox && vpcCBox.length > 6) {
1608          const profile = vpcCBox[4];
1609          const level = vpcCBox[5];
1610          const bitDepth = vpcCBox[6] >> 4 & 0x0f;
1611          codec += '.' + addLeadingZero(profile) + '.' + addLeadingZero(level) + '.' + addLeadingZero(bitDepth);
1612        }
1613        break;
1614      }
1615    case 'av01':
1616      {
1617        const av1CBox = findBox(sampleEntriesEnd, ['av1C'])[0];
1618        if (av1CBox && av1CBox.length > 2) {
1619          const profile = av1CBox[1] >>> 5;
1620          const level = av1CBox[1] & 0x1f;
1621          const tierFlag = av1CBox[2] >>> 7 ? 'H' : 'M';
1622          const highBitDepth = (av1CBox[2] & 0x40) >> 6;
1623          const twelveBit = (av1CBox[2] & 0x20) >> 5;
1624          const bitDepth = profile === 2 && highBitDepth ? twelveBit ? 12 : 10 : highBitDepth ? 10 : 8;
1625          const monochrome = (av1CBox[2] & 0x10) >> 4;
1626          const chromaSubsamplingX = (av1CBox[2] & 0x08) >> 3;
1627          const chromaSubsamplingY = (av1CBox[2] & 0x04) >> 2;
1628          const chromaSamplePosition = av1CBox[2] & 0x03;
1629          // TODO: parse color_description_present_flag
1630          // default it to BT.709/limited range for now
1631          // more info https://aomediacodec.github.io/av1-isobmff/#av1codecconfigurationbox-syntax
1632          const colorPrimaries = 1;
1633          const transferCharacteristics = 1;
1634          const matrixCoefficients = 1;
1635          const videoFullRangeFlag = 0;
1636          codec += '.' + profile + '.' + addLeadingZero(level) + tierFlag + '.' + addLeadingZero(bitDepth) + '.' + monochrome + '.' + chromaSubsamplingX + chromaSubsamplingY + chromaSamplePosition + '.' + addLeadingZero(colorPrimaries) + '.' + addLeadingZero(transferCharacteristics) + '.' + addLeadingZero(matrixCoefficients) + '.' + videoFullRangeFlag;
1637          supplemental = parseSupplementalDoViCodec('dav1', sampleEntriesEnd);
1638        }
1639        break;
1640      }
1641  }
1642  return {
1643    codec,
1644    encrypted,
1645    supplemental
1646  };
1647}
1648function parseSupplementalDoViCodec(fourCC, sampleEntriesEnd) {
1649  const dvvCResult = findBox(sampleEntriesEnd, ['dvvC']); // used by DoVi Profile 8 to 10
1650  const dvXCBox = dvvCResult.length ? dvvCResult[0] : findBox(sampleEntriesEnd, ['dvcC'])[0]; // used by DoVi Profiles up to 7 and 20
1651  if (dvXCBox) {
1652    const doViProfile = dvXCBox[2] >> 1 & 0x7f;
1653    const doViLevel = dvXCBox[2] << 5 & 0x20 | dvXCBox[3] >> 3 & 0x1f;
1654    return fourCC + '.' + addLeadingZero(doViProfile) + '.' + addLeadingZero(doViLevel);
1655  }
1656}
1657function reverse32BitInt(val) {
1658  let result = 0;
1659  for (let i = 0; i < 32; i++) {
1660    result |= (val >> i & 1) << 32 - 1 - i;
1661  }
1662  return result >>> 0;
1663}
1664function skipBERInteger(bytes, i) {
1665  const limit = i + 5;
1666  while (bytes[i++] & 0x80 && i < limit) {
1667    /* do nothing */
1668  }
1669  return i;
1670}
1671function toHex(x) {
1672  return ('0' + x.toString(16).toUpperCase()).slice(-2);
1673}
1674function addLeadingZero(num) {
1675  return (num < 10 ? '0' : '') + num;
1676}
1677function patchEncyptionData(initSegment, decryptdata) {
1678  if (!initSegment || !decryptdata) {
1679    return;
1680  }
1681  const keyId = decryptdata.keyId;
1682  if (keyId && decryptdata.isCommonEncryption) {
1683    applyToTencBoxes(initSegment, (tenc, isAudio) => {
1684      // Look for default key id (keyID offset is always 8 within the tenc box):
1685      const tencKeyId = tenc.subarray(8, 24);
1686      if (!tencKeyId.some(b => b !== 0)) {
1687        logger.log(`[eme] Patching keyId in 'enc${isAudio ? 'a' : 'v'}>sinf>>tenc' box: ${arrayToHex(tencKeyId)} -> ${arrayToHex(keyId)}`);
1688        tenc.set(keyId, 8);
1689      }
1690    });
1691  }
1692}
1693function parseKeyIdsFromTenc(initSegment) {
1694  const keyIds = [];
1695  applyToTencBoxes(initSegment, tenc => keyIds.push(tenc.subarray(8, 24)));
1696  return keyIds;
1697}
1698function applyToTencBoxes(initSegment, predicate) {
1699  const traks = findBox(initSegment, ['moov', 'trak']);
1700  traks.forEach(trak => {
1701    const stsd = findBox(trak, ['mdia', 'minf', 'stbl', 'stsd'])[0];
1702    if (!stsd) return;
1703    const sampleEntries = stsd.subarray(8);
1704    let encBoxes = findBox(sampleEntries, ['enca']);
1705    const isAudio = encBoxes.length > 0;
1706    if (!isAudio) {
1707      encBoxes = findBox(sampleEntries, ['encv']);
1708    }
1709    encBoxes.forEach(enc => {
1710      const encBoxChildren = isAudio ? enc.subarray(28) : enc.subarray(78);
1711      const sinfBoxes = findBox(encBoxChildren, ['sinf']);
1712      sinfBoxes.forEach(sinf => {
1713        const tenc = parseSinf(sinf);
1714        if (tenc) {
1715          predicate(tenc, isAudio);
1716        }
1717      });
1718    });
1719  });
1720}
1721function parseSinf(sinf) {
1722  const schm = findBox(sinf, ['schm'])[0];
1723  if (schm) {
1724    const scheme = bin2str(schm.subarray(4, 8));
1725    if (scheme === 'cbcs' || scheme === 'cenc') {
1726      const tenc = findBox(sinf, ['schi', 'tenc'])[0];
1727      if (tenc) {
1728        return tenc;
1729      }
1730    }
1731  }
1732}
1733
1734/*
1735  For Reference:
1736  aligned(8) class TrackFragmentHeaderBox
1737           extends FullBox(‘tfhd’, 0, tf_flags){
1738     unsigned int(32)  track_ID;
1739     // all the following are optional fields
1740     unsigned int(64)  base_data_offset;
1741     unsigned int(32)  sample_description_index;
1742     unsigned int(32)  default_sample_duration;
1743     unsigned int(32)  default_sample_size;
1744     unsigned int(32)  default_sample_flags
1745  }
1746 */
1747
1748function getSampleData(data, initData, logger) {
1749  const tracks = {};
1750  const trafs = findBox(data, ['moof', 'traf']);
1751  for (let i = 0; i < trafs.length; i++) {
1752    const traf = trafs[i];
1753    // There is only one tfhd & trun per traf
1754    // This is true for CMAF style content, and we should perhaps check the ftyp
1755    // and only look for a single trun then, but for ISOBMFF we should check
1756    // for multiple track runs.
1757    const tfhd = findBox(traf, ['tfhd'])[0];
1758    // get the track id from the tfhd
1759    const id = readUint32(tfhd, 4);
1760    const track = initData[id];
1761    if (!track) {
1762      continue;
1763    }
1764    tracks[id] || (tracks[id] = {
1765      start: NaN,
1766      duration: 0,
1767      sampleCount: 0,
1768      timescale: track.timescale,
1769      type: track.type
1770    });
1771    const trackTimes = tracks[id];
1772    // get start DTS
1773    const tfdt = findBox(traf, ['tfdt'])[0];
1774    if (tfdt) {
1775      const version = tfdt[0];
1776      let baseTime = readUint32(tfdt, 4);
1777      if (version === 1) {
1778        // If value is too large, assume signed 64-bit. Negative track fragment decode times are invalid, but they exist in the wild.
1779        // This prevents large values from being used for initPTS, which can cause playlist sync issues.
1780        // https://github.com/video-dev/hls.js/issues/5303
1781        if (baseTime === UINT32_MAX$1) {
1782          logger.warn(`[mp4-demuxer]: Ignoring assumed invalid signed 64-bit track fragment decode time`);
1783        } else {
1784          baseTime *= UINT32_MAX$1 + 1;
1785          baseTime += readUint32(tfdt, 8);
1786        }
1787      }
1788      if (isFiniteNumber(baseTime) && (!isFiniteNumber(trackTimes.start) || baseTime < trackTimes.start)) {
1789        trackTimes.start = baseTime;
1790      }
1791    }
1792    const trackDefault = track.default;
1793    const tfhdFlags = readUint32(tfhd, 0) | (trackDefault == null ? void 0 : trackDefault.flags);
1794    let defaultSampleDuration = (trackDefault == null ? void 0 : trackDefault.duration) || 0;
1795    if (tfhdFlags & 0x000008) {
1796      // 0x000008 indicates the presence of the default_sample_duration field
1797      if (tfhdFlags & 0x000002) {
1798        // 0x000002 indicates the presence of the sample_description_index field, which precedes default_sample_duration
1799        // If present, the default_sample_duration exists at byte offset 12
1800        defaultSampleDuration = readUint32(tfhd, 12);
1801      } else {
1802        // Otherwise, the duration is at byte offset 8
1803        defaultSampleDuration = readUint32(tfhd, 8);
1804      }
1805    }
1806    const truns = findBox(traf, ['trun']);
1807    let sampleDTS = trackTimes.start || 0;
1808    let rawDuration = 0;
1809    let sampleDuration = defaultSampleDuration;
1810    for (let j = 0; j < truns.length; j++) {
1811      const trun = truns[j];
1812      const sampleCount = readUint32(trun, 4);
1813      const sampleIndex = trackTimes.sampleCount;

1814      trackTimes.sampleCount += sampleCount;
1815      // Get duration from samples
1816      const dataOffsetPresent = trun[3] & 0x01;
1817      const firstSampleFlagsPresent = trun[3] & 0x04;
1818      const sampleDurationPresent = trun[2] & 0x01;
1819      const sampleSizePresent = trun[2] & 0x02;
1820      const sampleFlagsPresent = trun[2] & 0x04;
1821      const sampleCompositionTimeOffsetPresent = trun[2] & 0x08;
1822      let offset = 8;
1823      let remaining = sampleCount;
1824      if (dataOffsetPresent) {
1825        offset += 4;
1826      }
1827      if (firstSampleFlagsPresent && sampleCount) {
1828        const isNonSyncSample = trun[offset + 1] & 0x01;
1829        if (!isNonSyncSample && trackTimes.keyFrameIndex === undefined) {
1830          trackTimes.keyFrameIndex = sampleIndex;
1831        }
1832        offset += 4;
1833        if (sampleDurationPresent) {
1834          sampleDuration = readUint32(trun, offset);
1835          offset += 4;
1836        } else {
1837          sampleDuration = defaultSampleDuration;
1838        }
1839        if (sampleSizePresent) {
1840          offset += 4;
1841        }
1842        if (sampleCompositionTimeOffsetPresent) {
1843          offset += 4;
1844        }
1845        sampleDTS += sampleDuration;
1846        rawDuration += sampleDuration;
1847        remaining--;
1848      }
1849      while (remaining--) {
1850        if (sampleDurationPresent) {
1851          sampleDuration = readUint32(trun, offset);
1852          offset += 4;
1853        } else {
1854          sampleDuration = defaultSampleDuration;
1855        }
1856        if (sampleSizePresent) {
1857          offset += 4;
1858        }
1859        if (sampleFlagsPresent) {
1860          const isNonSyncSample = trun[offset + 1] & 0x01;
1861          if (!isNonSyncSample) {
1862            if (trackTimes.keyFrameIndex === undefined) {
1863              trackTimes.keyFrameIndex = trackTimes.sampleCount - (remaining + 1);
1864              trackTimes.keyFrameStart = sampleDTS;
1865            }
1866          }
1867          offset += 4;
1868        }
1869        if (sampleCompositionTimeOffsetPresent) {
1870          offset += 4;
1871        }
1872        sampleDTS += sampleDuration;
1873        rawDuration += sampleDuration;
1874      }
1875      if (!rawDuration && defaultSampleDuration) {
1876        rawDuration += defaultSampleDuration * sampleCount;
1877      }
1878    }
1879    trackTimes.duration += rawDuration;
1880  }
1881  if (!Object.keys(tracks).some(trackId => tracks[trackId].duration)) {
1882    // If duration samples are not available in the traf use sidx subsegment_duration
1883    let sidxMinStart = Infinity;
1884    let sidxMaxEnd = 0;
1885    const sidxs = findBox(data, ['sidx']);
1886    for (let i = 0; i < sidxs.length; i++) {
1887      const sidx = parseSegmentIndex(sidxs[i]);
1888      if (sidx != null && sidx.references) {
1889        sidxMinStart = Math.min(sidxMinStart, sidx.earliestPresentationTime / sidx.timescale);
1890        const subSegmentDuration = sidx.references.reduce((dur, ref) => dur + ref.info.duration || 0, 0);
1891        sidxMaxEnd = Math.max(sidxMaxEnd, subSegmentDuration + sidx.earliestPresentationTime / sidx.timescale);
1892      }
1893    }
1894    if (sidxMaxEnd && isFiniteNumber(sidxMaxEnd)) {

1895      Object.keys(tracks).forEach(trackId => {
1896        if (!tracks[trackId].duration) {
1897          tracks[trackId].duration = sidxMaxEnd * tracks[trackId].timescale - tracks[trackId].start;
1898        }
1899      });
1900    }
1901  }
1902  return tracks;
1903}
1904
1905// TODO: Check if the last moof+mdat pair is part of the valid range
1906function segmentValidRange(data) {
1907  const segmentedRange = {
1908    valid: null,
1909    remainder: null
1910  };
1911  const moofs = findBox(data, ['moof']);
1912  if (moofs.length < 2) {
1913    segmentedRange.remainder = data;
1914    return segmentedRange;
1915  }
1916  const last = moofs[moofs.length - 1];
1917  // Offset by 8 bytes; findBox offsets the start by as much
1918  segmentedRange.valid = data.slice(0, last.byteOffset - 8);
1919  segmentedRange.remainder = data.slice(last.byteOffset - 8);
1920  return segmentedRange;
1921}
1922function appendUint8Array(data1, data2) {
1923  const temp = new Uint8Array(data1.length + data2.length);
1924  temp.set(data1);
1925  temp.set(data2, data1.length);
1926  return temp;
1927}
1928function parseSamples(timeOffset, track) {
1929  const seiSamples = [];
1930  const videoData = track.samples;
1931  const timescale = track.timescale;
1932  const trackId = track.id;
1933  let isHEVCFlavor = false;
1934  const moofs = findBox(videoData, ['moof']);
1935  moofs.map(moof => {
1936    const moofOffset = moof.byteOffset - 8;
1937    const trafs = findBox(moof, ['traf']);
1938    trafs.map(traf => {
1939      // get the base media decode time from the tfdt
1940      const baseTime = findBox(traf, ['tfdt']).map(tfdt => {
1941        const version = tfdt[0];
1942        let result = readUint32(tfdt, 4);
1943        if (version === 1) {
1944          result *= Math.pow(2, 32);
1945          result += readUint32(tfdt, 8);
1946        }
1947        return result / timescale;
1948      })[0];
1949      if (baseTime !== undefined) {
1950        timeOffset = baseTime;
1951      }
1952      return findBox(traf, ['tfhd']).map(tfhd => {
1953        const id = readUint32(tfhd, 4);
1954        const tfhdFlags = readUint32(tfhd, 0) & 0xffffff;
1955        const baseDataOffsetPresent = (tfhdFlags & 0x000001) !== 0;
1956        const sampleDescriptionIndexPresent = (tfhdFlags & 0x000002) !== 0;
1957        const defaultSampleDurationPresent = (tfhdFlags & 0x000008) !== 0;
1958        let defaultSampleDuration = 0;
1959        const defaultSampleSizePresent = (tfhdFlags & 0x000010) !== 0;
1960        let defaultSampleSize = 0;
1961        const defaultSampleFlagsPresent = (tfhdFlags & 0x000020) !== 0;
1962        let tfhdOffset = 8;
1963        if (id === trackId) {
1964          if (baseDataOffsetPresent) {
1965            tfhdOffset += 8;
1966          }
1967          if (sampleDescriptionIndexPresent) {
1968            tfhdOffset += 4;
1969          }
1970          if (defaultSampleDurationPresent) {
1971            defaultSampleDuration = readUint32(tfhd, tfhdOffset);
1972            tfhdOffset += 4;
1973          }
1974          if (defaultSampleSizePresent) {
1975            defaultSampleSize = readUint32(tfhd, tfhdOffset);
1976            tfhdOffset += 4;
1977          }
1978          if (defaultSampleFlagsPresent) {
1979            tfhdOffset += 4;
1980          }
1981          if (track.type === 'video') {
1982            isHEVCFlavor = isHEVC(track.codec);
1983          }
1984          findBox(traf, ['trun']).map(trun => {
1985            const version = trun[0];
1986            const flags = readUint32(trun, 0) & 0xffffff;
1987            const dataOffsetPresent = (flags & 0x000001) !== 0;
1988            let dataOffset = 0;
1989            const firstSampleFlagsPresent = (flags & 0x000004) !== 0;
1990            const sampleDurationPresent = (flags & 0x000100) !== 0;
1991            let sampleDuration = 0;
1992            const sampleSizePresent = (flags & 0x000200) !== 0;
1993            let sampleSize = 0;
1994            const sampleFlagsPresent = (flags & 0x000400) !== 0;
1995            const sampleCompositionOffsetsPresent = (flags & 0x000800) !== 0;
1996            let compositionOffset = 0;
1997            const sampleCount = readUint32(trun, 4);
1998            let trunOffset = 8; // past version, flags, and sample count
1999
2000            if (dataOffsetPresent) {
2001              dataOffset = readUint32(trun, trunOffset);
2002              trunOffset += 4;
2003            }
2004            if (firstSampleFlagsPresent) {
2005              trunOffset += 4;
2006            }
2007            let sampleOffset = dataOffset + moofOffset;
2008            for (let ix = 0; ix < sampleCount; ix++) {
2009              if (sampleDurationPresent) {
2010                sampleDuration = readUint32(trun, trunOffset);
2011                trunOffset += 4;
2012              } else {
2013                sampleDuration = defaultSampleDuration;
2014              }
2015              if (sampleSizePresent) {
2016                sampleSize = readUint32(trun, trunOffset);
2017                trunOffset += 4;
2018              } else {
2019                sampleSize = defaultSampleSize;
2020              }
2021              if (sampleFlagsPresent) {
2022                trunOffset += 4;
2023              }
2024              if (sampleCompositionOffsetsPresent) {
2025                if (version === 0) {
2026                  compositionOffset = readUint32(trun, trunOffset);
2027                } else {
2028                  compositionOffset = readSint32(trun, trunOffset);
2029                }
2030                trunOffset += 4;
2031              }
2032              if (track.type === ElementaryStreamTypes.VIDEO) {
2033                let naluTotalSize = 0;
2034                while (naluTotalSize < sampleSize) {
2035                  const naluSize = readUint32(videoData, sampleOffset);
2036                  sampleOffset += 4;
2037                  if (isSEIMessage(isHEVCFlavor, videoData[sampleOffset])) {
2038                    const data = videoData.subarray(sampleOffset, sampleOffset + naluSize);
2039                    parseSEIMessageFromNALu(data, isHEVCFlavor ? 2 : 1, timeOffset + compositionOffset / timescale, seiSamples);
2040                  }
2041                  sampleOffset += naluSize;
2042                  naluTotalSize += naluSize + 4;
2043                }
2044              }
2045              timeOffset += sampleDuration / timescale;
2046            }
2047          });
2048        }
2049      });
2050    });
2051  });
2052  return seiSamples;
2053}
2054function isHEVC(codec) {
2055  if (!codec) {
2056    return false;
2057  }
2058  const baseCodec = codec.substring(0, 4);
2059  return baseCodec === 'hvc1' || baseCodec === 'hev1' ||
2060  // Dolby Vision
2061  baseCodec === 'dvh1' || baseCodec === 'dvhe';
2062}
2063function isSEIMessage(isHEVCFlavor, naluHeader) {
2064  if (isHEVCFlavor) {
2065    const naluType = naluHeader >> 1 & 0x3f;
2066    return naluType === 39 || naluType === 40;
2067  } else {
2068    const naluType = naluHeader & 0x1f;
2069    return naluType === 6;
2070  }
2071}
2072function parseSEIMessageFromNALu(unescapedData, headerSize, pts, samples) {
2073  const data = discardEPB(unescapedData);
2074  let seiPtr = 0;
2075  // skip nal header
2076  seiPtr += headerSize;
2077  let payloadType = 0;
2078  let payloadSize = 0;
2079  let b = 0;
2080  while (seiPtr < data.length) {
2081    payloadType = 0;
2082    do {
2083      if (seiPtr >= data.length) {
2084        break;
2085      }
2086      b = data[seiPtr++];
2087      payloadType += b;
2088    } while (b === 0xff);
2089
2090    // Parse payload size.
2091    payloadSize = 0;
2092    do {
2093      if (seiPtr >= data.length) {
2094        break;
2095      }
2096      b = data[seiPtr++];
2097      payloadSize += b;
2098    } while (b === 0xff);
2099    const leftOver = data.length - seiPtr;
2100    // Create a variable to process the payload
2101    let payPtr = seiPtr;
2102
2103    // Increment the seiPtr to the end of the payload
2104    if (payloadSize < leftOver) {
2105      seiPtr += payloadSize;
2106    } else if (payloadSize > leftOver) {
2107      // Some type of corruption has happened?
2108      logger.error(`Malformed SEI payload. ${payloadSize} is too small, only ${leftOver} bytes left to parse.`);
2109      // We might be able to parse some data, but let's be safe and ignore it.
2110      break;
2111    }
2112    if (payloadType === 4) {
2113      const countryCode = data[payPtr++];
2114      if (countryCode === 181) {
2115        const providerCode = readUint16(data, payPtr);
2116        payPtr += 2;
2117        if (providerCode === 49) {
2118          const userStructure = readUint32(data, payPtr);
2119          payPtr += 4;
2120          if (userStructure === 0x47413934) {
2121            const userDataType = data[payPtr++];
2122
2123            // Raw CEA-608 bytes wrapped in CEA-708 packet
2124            if (userDataType === 3) {
2125              const firstByte = data[payPtr++];
2126              const totalCCs = 0x1f & firstByte;
2127              const enabled = 0x40 & firstByte;
2128              const totalBytes = enabled ? 2 + totalCCs * 3 : 0;
2129              const byteArray = new Uint8Array(totalBytes);
2130              if (enabled) {
2131                byteArray[0] = firstByte;
2132                for (let i = 1; i < totalBytes; i++) {
2133                  byteArray[i] = data[payPtr++];
2134                }
2135              }
2136              samples.push({
2137                type: userDataType,
2138                payloadType,
2139                pts,
2140                bytes: byteArray
2141              });
2142            }
2143          }
2144        }
2145      }
2146    } else if (payloadType === 5) {
2147      if (payloadSize > 16) {
2148        const uuidStrArray = [];
2149        for (let i = 0; i < 16; i++) {
2150          const _b = data[payPtr++].toString(16);
2151          uuidStrArray.push(_b.length == 1 ? '0' + _b : _b);
2152          if (i === 3 || i === 5 || i === 7 || i === 9) {
2153            uuidStrArray.push('-');
2154          }
2155        }
2156        const length = payloadSize - 16;
2157        const userDataBytes = new Uint8Array(length);
2158        for (let i = 0; i < length; i++) {
2159          userDataBytes[i] = data[payPtr++];
2160        }
2161        samples.push({
2162          payloadType,
2163          pts,
2164          uuid: uuidStrArray.join(''),
2165          userData: utf8ArrayToStr(userDataBytes),
2166          userDataBytes
2167        });
2168      }
2169    }
2170  }
2171}
2172
2173/**
2174 * remove Emulation Prevention bytes from a RBSP
2175 */
2176function discardEPB(data) {
2177  const length = data.byteLength;
2178  const EPBPositions = [];
2179  let i = 1;
2180
2181  // Find all `Emulation Prevention Bytes`
2182  while (i < length - 2) {
2183    if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
2184      EPBPositions.push(i + 2);
2185      i += 2;
2186    } else {
2187      i++;
2188    }
2189  }
2190
2191  // If no Emulation Prevention Bytes were found just return the original
2192  // array
2193  if (EPBPositions.length === 0) {
2194    return data;
2195  }
2196
2197  // Create a new array to hold the NAL unit data
2198  const newLength = length - EPBPositions.length;
2199  const newData = new Uint8Array(newLength);
2200  let sourceIndex = 0;
2201  for (i = 0; i < newLength; sourceIndex++, i++) {
2202    if (sourceIndex === EPBPositions[0]) {
2203      // Skip this byte
2204      sourceIndex++;
2205      // Remove this position index
2206      EPBPositions.shift();
2207    }
2208    newData[i] = data[sourceIndex];
2209  }
2210  return newData;
2211}
2212function parseEmsg(data) {
2213  const version = data[0];
2214  let schemeIdUri = '';
2215  let value = '';
2216  let timeScale = 0;
2217  let presentationTimeDelta = 0;
2218  let presentationTime = 0;
2219  let eventDuration = 0;
2220  let id = 0;
2221  let offset = 0;
2222  if (version === 0) {
2223    while (bin2str(data.subarray(offset, offset + 1)) !== '\0') {
2224      schemeIdUri += bin2str(data.subarray(offset, offset + 1));
2225      offset += 1;
2226    }
2227    schemeIdUri += bin2str(data.subarray(offset, offset + 1));
2228    offset += 1;
2229    while (bin2str(data.subarray(offset, offset + 1)) !== '\0') {
2230      value += bin2str(data.subarray(offset, offset + 1));
2231      offset += 1;
2232    }
2233    value += bin2str(data.subarray(offset, offset + 1));
2234    offset += 1;
2235    timeScale = readUint32(data, 12);
2236    presentationTimeDelta = readUint32(data, 16);
2237    eventDuration = readUint32(data, 20);
2238    id = readUint32(data, 24);
2239    offset = 28;
2240  } else if (version === 1) {
2241    offset += 4;
2242    timeScale = readUint32(data, offset);
2243    offset += 4;
2244    const leftPresentationTime = readUint32(data, offset);
2245    offset += 4;
2246    const rightPresentationTime = readUint32(data, offset);
2247    offset += 4;
2248    presentationTime = 2 ** 32 * leftPresentationTime + rightPresentationTime;
2249    if (!isSafeInteger(presentationTime)) {
2250      presentationTime = Number.MAX_SAFE_INTEGER;
2251      logger.warn('Presentation time exceeds safe integer limit and wrapped to max safe integer in parsing emsg box');
2252    }
2253    eventDuration = readUint32(data, offset);
2254    offset += 4;
2255    id = readUint32(data, offset);
2256    offset += 4;
2257    while (bin2str(data.subarray(offset, offset + 1)) !== '\0') {
2258      schemeIdUri += bin2str(data.subarray(offset, offset + 1));
2259      offset += 1;
2260    }
2261    schemeIdUri += bin2str(data.subarray(offset, offset + 1));
2262    offset += 1;
2263    while (bin2str(data.subarray(offset, offset + 1)) !== '\0') {
2264      value += bin2str(data.subarray(offset, offset + 1));
2265      offset += 1;
2266    }
2267    value += bin2str(data.subarray(offset, offset + 1));
2268    offset += 1;
2269  }
2270  const payload = data.subarray(offset, data.byteLength);
2271  return {
2272    schemeIdUri,
2273    value,
2274    timeScale,
2275    presentationTime,
2276    presentationTimeDelta,
2277    eventDuration,
2278    id,
2279    payload
2280  };
2281}
2282function mp4Box(type, ...payload) {
2283  const len = payload.length;
2284  let size = 8;
2285  let i = len;
2286  while (i--) {
2287    size += payload[i].byteLength;
2288  }
2289  const result = new Uint8Array(size);
2290  result[0] = size >> 24 & 0xff;
2291  result[1] = size >> 16 & 0xff;
2292  result[2] = size >> 8 & 0xff;
2293  result[3] = size & 0xff;
2294  result.set(type, 4);
2295  for (i = 0, size = 8; i < len; i++) {
2296    result.set(payload[i], size);
2297    size += payload[i].byteLength;
2298  }
2299  return result;
2300}
2301function mp4pssh(systemId, keyids, data) {
2302  if (systemId.byteLength !== 16) {
2303    throw new RangeError('Invalid system id');
2304  }
2305  let version;
2306  let kids;
2307  {
2308    version = 0;
2309    kids = new Uint8Array();
2310  }
2311  let kidCount;
2312  if (version > 0) {
2313    kidCount = new Uint8Array(4);
2314    if (keyids.length > 0) {
2315      new DataView(kidCount.buffer).setUint32(0, keyids.length, false);
2316    }
2317  } else {
2318    kidCount = new Uint8Array();
2319  }
2320  const dataSize = new Uint8Array(4);
2321  if (data.byteLength > 0) {
2322    new DataView(dataSize.buffer).setUint32(0, data.byteLength, false);
2323  }
2324  return mp4Box([112, 115, 115, 104], new Uint8Array([version, 0x00, 0x00, 0x00 // Flags
2325  ]), systemId,
2326  // 16 bytes
2327  kidCount, kids, dataSize, data);
2328}
2329function parseMultiPssh(initData) {
2330  const results = [];
2331  if (initData instanceof ArrayBuffer) {
2332    const length = initData.byteLength;
2333    let offset = 0;
2334    while (offset + 32 < length) {
2335      const view = new DataView(initData, offset);
2336      const pssh = parsePssh(view);
2337      results.push(pssh);
2338      offset += pssh.size;
2339    }
2340  }
2341  return results;
2342}
2343function parsePssh(view) {
2344  const size = view.getUint32(0);
2345  const offset = view.byteOffset;
2346  const length = view.byteLength;
2347  if (length < size) {
2348    return {
2349      offset,
2350      size: length
2351    };
2352  }
2353  const type = view.getUint32(4);
2354  if (type !== 0x70737368) {
2355    return {
2356      offset,
2357      size
2358    };
2359  }
2360  const version = view.getUint32(8) >>> 24;
2361  if (version !== 0 && version !== 1) {
2362    return {
2363      offset,
2364      size
2365    };
2366  }
2367  const buffer = view.buffer;
2368  const systemId = arrayToHex(new Uint8Array(buffer, offset + 12, 16));
2369  let kids = null;
2370  let data = null;
2371  let dataSizeOffset = 0;
2372  if (version === 0) {
2373    dataSizeOffset = 28;
2374  } else {
2375    const kidCounts = view.getUint32(28);
2376    if (!kidCounts || length < 32 + kidCounts * 16) {
2377      return {
2378        offset,
2379        size
2380      };
2381    }
2382    kids = [];
2383    for (let i = 0; i < kidCounts; i++) {
2384      kids.push(new Uint8Array(buffer, offset + 32 + i * 16, 16));
2385    }
2386    dataSizeOffset = 32 + kidCounts * 16;
2387  }
2388  if (!dataSizeOffset) {
2389    return {
2390      offset,
2391      size
2392    };
2393  }
2394  const dataSizeOrKidCount = view.getUint32(dataSizeOffset);
2395  if (size - 32 < dataSizeOrKidCount) {
2396    return {
2397      offset,
2398      size
2399    };
2400  }
2401  data = new Uint8Array(buffer, offset + dataSizeOffset + 4, dataSizeOrKidCount);
2402  return {
2403    version,
2404    systemId,
2405    kids,
2406    data,
2407    offset,
2408    size
2409  };
2410}
2411
2412const userAgentHevcSupportIsInaccurate = () => {
2413  return /\(Windows.+Firefox\//i.test(navigator.userAgent);
2414};
2415
2416// from http://mp4ra.org/codecs.html
2417// values indicate codec selection preference (lower is higher priority)
2418const sampleEntryCodesISO = {
2419  audio: {
2420    a3ds: 1,
2421    'ac-3': 0.95,
2422    'ac-4': 1,
2423    alac: 0.9,
2424    alaw: 1,
2425    dra1: 1,
2426    'dts+': 1,
2427    'dts-': 1,
2428    dtsc: 1,
2429    dtse: 1,
2430    dtsh: 1,
2431    'ec-3': 0.9,
2432    enca: 1,
2433    fLaC: 0.9,
2434    // MP4-RA listed codec entry for FLAC
2435    flac: 0.9,
2436    // legacy browser codec name for FLAC
2437    FLAC: 0.9,
2438    // some manifests may list "FLAC" with Apple's tools
2439    g719: 1,
2440    g726: 1,
2441    m4ae: 1,
2442    mha1: 1,
2443    mha2: 1,
2444    mhm1: 1,
2445    mhm2: 1,
2446    mlpa: 1,
2447    mp4a: 1,
2448    'raw ': 1,
2449    Opus: 1,
2450    opus: 1,
2451    // browsers expect this to be lowercase despite MP4RA says 'Opus'
2452    samr: 1,
2453    sawb: 1,
2454    sawp: 1,
2455    sevc: 1,
2456    sqcp: 1,
2457    ssmv: 1,
2458    twos: 1,
2459    ulaw: 1
2460  },
2461  video: {
2462    avc1: 1,
2463    avc2: 1,
2464    avc3: 1,
2465    avc4: 1,
2466    avcp: 1,
2467    av01: 0.8,
2468    dav1: 0.8,
2469    drac: 1,
2470    dva1: 1,
2471    dvav: 1,
2472    dvh1: 0.7,
2473    dvhe: 0.7,
2474    encv: 1,
2475    hev1: 0.75,
2476    hvc1: 0.75,
2477    mjp2: 1,
2478    mp4v: 1,
2479    mvc1: 1,
2480    mvc2: 1,
2481    mvc3: 1,
2482    mvc4: 1,
2483    resv: 1,
2484    rv60: 1,
2485    s263: 1,
2486    svc1: 1,
2487    svc2: 1,
2488    'vc-1': 1,
2489    vp08: 1,
2490    vp09: 0.9
2491  },
2492  text: {
2493    stpp: 1,
2494    wvtt: 1
2495  }
2496};
2497function isCodecType(codec, type) {
2498  const typeCodes = sampleEntryCodesISO[type];
2499  return !!typeCodes && !!typeCodes[codec.slice(0, 4)];
2500}
2501function areCodecsMediaSourceSupported(codecs, type, preferManagedMediaSource = true) {
2502  return !codecs.split(',').some(codec => !isCodecMediaSourceSupported(codec, type, preferManagedMediaSource));
2503}
2504function isCodecMediaSourceSupported(codec, type, preferManagedMediaSource = true) {
2505  var _MediaSource$isTypeSu;
2506  const MediaSource = getMediaSource(preferManagedMediaSource);
2507  return (_MediaSource$isTypeSu = MediaSource == null ? void 0 : MediaSource.isTypeSupported(mimeTypeForCodec(codec, type))) != null ? _MediaSource$isTypeSu : false;
2508}
2509function mimeTypeForCodec(codec, type) {
2510  return `${type}/mp4;codecs=${codec}`;
2511}
2512function videoCodecPreferenceValue(videoCodec) {
2513  if (videoCodec) {
2514    const fourCC = videoCodec.substring(0, 4);
2515    return sampleEntryCodesISO.video[fourCC];
2516  }
2517  return 2;
2518}
2519function codecsSetSelectionPreferenceValue(codecSet) {
2520  const limitedHevcSupport = userAgentHevcSupportIsInaccurate();
2521  return codecSet.split(',').reduce((num, fourCC) => {
2522    const lowerPriority = limitedHevcSupport && isHEVC(fourCC);
2523    const preferenceValue = lowerPriority ? 9 : sampleEntryCodesISO.video[fourCC];
2524    if (preferenceValue) {
2525      return (preferenceValue * 2 + num) / (num ? 3 : 2);
2526    }
2527    return (sampleEntryCodesISO.audio[fourCC] + num) / (num ? 2 : 1);
2528  }, 0);
2529}
2530const CODEC_COMPATIBLE_NAMES = {};
2531function getCodecCompatibleNameLower(lowerCaseCodec, preferManagedMediaSource = true) {
2532  if (CODEC_COMPATIBLE_NAMES[lowerCaseCodec]) {
2533    return CODEC_COMPATIBLE_NAMES[lowerCaseCodec];
2534  }
2535  const codecsToCheck = {
2536    // Idealy fLaC and Opus would be first (spec-compliant) but
2537    // some browsers will report that fLaC is supported then fail.
2538    // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
2539    flac: ['flac', 'fLaC', 'FLAC'],
2540    opus: ['opus', 'Opus'],
2541    // Replace audio codec info if browser does not support mp4a.40.34,
2542    // and demuxer can fallback to 'audio/mpeg' or 'audio/mp4;codecs="mp3"'
2543    'mp4a.40.34': ['mp3']
2544  }[lowerCaseCodec];
2545  for (let i = 0; i < codecsToCheck.length; i++) {
2546    var _getMediaSource;
2547    if (isCodecMediaSourceSupported(codecsToCheck[i], 'audio', preferManagedMediaSource)) {
2548      CODEC_COMPATIBLE_NAMES[lowerCaseCodec] = codecsToCheck[i];
2549      return codecsToCheck[i];
2550    } else if (codecsToCheck[i] === 'mp3' && (_getMediaSource = getMediaSource(preferManagedMediaSource)) != null && _getMediaSource.isTypeSupported('audio/mpeg')) {
2551      return '';
2552    }
2553  }
2554  return lowerCaseCodec;
2555}
2556const AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
2557function getCodecCompatibleName(codec, preferManagedMediaSource = true) {
2558  return codec.replace(AUDIO_CODEC_REGEXP, m => getCodecCompatibleNameLower(m.toLowerCase(), preferManagedMediaSource));
2559}
2560function replaceVideoCodec(originalCodecs, newVideoCodec) {
2561  const codecs = [];
2562  if (originalCodecs) {
2563    const allCodecs = originalCodecs.split(',');
2564    for (let i = 0; i < allCodecs.length; i++) {
2565      if (!isCodecType(allCodecs[i], 'video')) {
2566        codecs.push(allCodecs[i]);
2567      }
2568    }
2569  }
2570  if (newVideoCodec) {
2571    codecs.push(newVideoCodec);
2572  }
2573  return codecs.join(',');
2574}
2575function pickMostCompleteCodecName(parsedCodec, levelCodec) {
2576  // Parsing of mp4a codecs strings in mp4-tools from media is incomplete as of d8c6c7a
2577  // so use level codec is parsed codec is unavailable or incomplete
2578  if (parsedCodec && (parsedCodec.length > 4 || ['ac-3', 'ec-3', 'alac', 'fLaC', 'Opus'].indexOf(parsedCodec) !== -1)) {
2579    if (isCodecSupportedAsType(parsedCodec, 'audio') || isCodecSupportedAsType(parsedCodec, 'video')) {
2580      return parsedCodec;
2581    }
2582  }
2583  if (levelCodec) {
2584    const levelCodecs = levelCodec.split(',');
2585    if (levelCodecs.length > 1) {
2586      if (parsedCodec) {
2587        for (let i = levelCodecs.length; i--;) {
2588          if (levelCodecs[i].substring(0, 4) === parsedCodec.substring(0, 4)) {
2589            return levelCodecs[i];
2590          }
2591        }
2592      }
2593      return levelCodecs[0];
2594    }
2595  }
2596  return levelCodec || parsedCodec;
2597}
2598function isCodecSupportedAsType(codec, type) {
2599  return isCodecType(codec, type) && isCodecMediaSourceSupported(codec, type);
2600}
2601function convertAVC1ToAVCOTI(videoCodecs) {
2602  // Convert avc1 codec string from RFC-4281 to RFC-6381 for MediaSource.isTypeSupported
2603  // Examples: avc1.66.30 to avc1.42001e and avc1.77.30,avc1.66.30 to avc1.4d001e,avc1.42001e.
2604  const codecs = videoCodecs.split(',');
2605  for (let i = 0; i < codecs.length; i++) {
2606    const avcdata = codecs[i].split('.');
2607    // only convert codec strings starting with avc1 (Examples: avc1.64001f,dvh1.05.07)
2608    if (avcdata.length > 2 && avcdata[0] === 'avc1') {
2609      codecs[i] = `avc1.${parseInt(avcdata[1]).toString(16)}${('000' + parseInt(avcdata[2]).toString(16)).slice(-4)}`;
2610    }
2611  }
2612  return codecs.join(',');
2613}
2614function fillInMissingAV01Params(videoCodec) {
2615  // Used to fill in incomplete AV1 playlist CODECS strings for mediaCapabilities.decodingInfo queries
2616  if (videoCodec.startsWith('av01.')) {
2617    const av1params = videoCodec.split('.');
2618    const placeholders = ['0', '111', '01', '01', '01', '0'];
2619    for (let i = av1params.length; i > 4 && i < 10; i++) {
2620      av1params[i] = placeholders[i - 4];
2621    }
2622    return av1params.join('.');
2623  }
2624  return videoCodec;
2625}
2626function getM2TSSupportedAudioTypes(preferManagedMediaSource) {
2627  const MediaSource = getMediaSource(preferManagedMediaSource) || {
2628    isTypeSupported: () => false
2629  };
2630  return {
2631    mpeg: MediaSource.isTypeSupported('audio/mpeg'),
2632    mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
2633    ac3: MediaSource.isTypeSupported('audio/mp4; codecs="ac-3"') 
2634  };
2635}
2636function getCodecsForMimeType(mimeType) {
2637  return mimeType.replace(/^.+codecs=["']?([^"']+).*$/, '$1');
2638}
2639
2640// @ts-ignore
2641const supportedResult = {
2642  supported: true,
2643  powerEfficient: true,
2644  smooth: true
2645  // keySystemAccess: null,
2646};
2647
2648// @ts-ignore
2649const unsupportedResult = {
2650  supported: false,
2651  smooth: false,
2652  powerEfficient: false
2653  // keySystemAccess: null,
2654};
2655const SUPPORTED_INFO_DEFAULT = {
2656  supported: true,
2657  configurations: [],
2658  decodingInfoResults: [supportedResult]
2659};
2660function getUnsupportedResult(error, configurations) {
2661  return {
2662    supported: false,
2663    configurations,
2664    decodingInfoResults: [unsupportedResult],
2665    error
2666  };
2667}
2668function requiresMediaCapabilitiesDecodingInfo(level, audioTracksByGroup, currentVideoRange, currentFrameRate, currentBw, audioPreference) {
2669  // Only test support when configuration is exceeds minimum options
2670  const videoCodecs = level.videoCodec;
2671  const audioGroups = level.audioCodec ? level.audioGroups : null;
2672  const audioCodecPreference = audioPreference == null ? void 0 : audioPreference.audioCodec;
2673  const channelsPreference = audioPreference == null ? void 0 : audioPreference.channels;
2674  const maxChannels = channelsPreference ? parseInt(channelsPreference) : audioCodecPreference ? Infinity : 2;
2675  let audioChannels = null;
2676  if (audioGroups != null && audioGroups.length) {
2677    try {
2678      if (audioGroups.length === 1 && audioGroups[0]) {
2679        audioChannels = audioTracksByGroup.groups[audioGroups[0]].channels;
2680      } else {
2681        audioChannels = audioGroups.reduce((acc, groupId) => {
2682          if (groupId) {
2683            const audioTrackGroup = audioTracksByGroup.groups[groupId];
2684            if (!audioTrackGroup) {
2685              throw new Error(`Audio track group ${groupId} not found`);
2686            }
2687            // Sum all channel key values
2688            Object.keys(audioTrackGroup.channels).forEach(key => {
2689              acc[key] = (acc[key] || 0) + audioTrackGroup.channels[key];
2690            });
2691          }
2692          return acc;
2693        }, {
2694          2: 0
2695        });
2696      }
2697    } catch (error) {
2698      return true;
2699    }
2700  }
2701  return videoCodecs !== undefined && (
2702  // Force media capabilities check for HEVC to avoid failure on Windows
2703  videoCodecs.split(',').some(videoCodec => isHEVC(videoCodec)) || level.width > 1920 && level.height > 1088 || level.height > 1920 && level.width > 1088 || level.frameRate > Math.max(currentFrameRate, 30) || level.videoRange !== 'SDR' && level.videoRange !== currentVideoRange || level.bitrate > Math.max(currentBw, 8e6)) || !!audioChannels && isFiniteNumber(maxChannels) && Object.keys(audioChannels).some(channels => parseInt(channels) > maxChannels);
2704}
2705function getMediaDecodingInfoPromise(level, audioTracksByGroup, mediaCapabilities, cache = {}) {
2706  const videoCodecs = level.videoCodec;
2707  if (!videoCodecs && !level.audioCodec || !mediaCapabilities) {
2708    return Promise.resolve(SUPPORTED_INFO_DEFAULT);
2709  }
2710  const configurations = [];
2711  const videoDecodeList = makeVideoConfigurations(level);
2712  const videoCount = videoDecodeList.length;
2713  const audioDecodeList = makeAudioConfigurations(level, audioTracksByGroup, videoCount > 0);
2714  const audioCount = audioDecodeList.length;
2715  for (let i = videoCount || 1 * audioCount || 1; i--;) {
2716    const configuration = {
2717      type: 'media-source'
2718    };
2719    if (videoCount) {
2720      configuration.video = videoDecodeList[i % videoCount];
2721    }
2722    if (audioCount) {
2723      configuration.audio = audioDecodeList[i % audioCount];
2724      const audioBitrate = configuration.audio.bitrate;
2725      if (configuration.video && audioBitrate) {
2726        configuration.video.bitrate -= audioBitrate;
2727      }
2728    }
2729    configurations.push(configuration);
2730  }
2731  if (videoCodecs) {
2732    // Override Windows Firefox HEVC MediaCapabilities result (https://github.com/video-dev/hls.js/issues/7046)
2733    const ua = navigator.userAgent;
2734    if (videoCodecs.split(',').some(videoCodec => isHEVC(videoCodec)) && userAgentHevcSupportIsInaccurate()) {
2735      return Promise.resolve(getUnsupportedResult(new Error(`Overriding Windows Firefox HEVC MediaCapabilities result based on user-agent string: (${ua})`), configurations));
2736    }
2737  }
2738  return Promise.all(configurations.map(configuration => {
2739    // Cache MediaCapabilities promises
2740    const decodingInfoKey = getMediaDecodingInfoKey(configuration);
2741    return cache[decodingInfoKey] || (cache[decodingInfoKey] = mediaCapabilities.decodingInfo(configuration));
2742  })).then(decodingInfoResults => ({
2743    supported: !decodingInfoResults.some(info => !info.supported),
2744    configurations,
2745    decodingInfoResults
2746  })).catch(error => ({
2747    supported: false,
2748    configurations,
2749    decodingInfoResults: [],
2750    error
2751  }));
2752}
2753function makeVideoConfigurations(level) {
2754  var _level$videoCodec;
2755  const videoCodecs = (_level$videoCodec = level.videoCodec) == null ? void 0 : _level$videoCodec.split(',');
2756  const bitrate = getVariantDecodingBitrate(level);
2757  const width = level.width || 640;
2758  const height = level.height || 480;
2759  // Assume a framerate of 30fps since MediaCapabilities will not accept Level default of 0.
2760  const framerate = level.frameRate || 30;
2761  const videoRange = level.videoRange.toLowerCase();
2762  return videoCodecs ? videoCodecs.map(videoCodec => {
2763    const videoConfiguration = {
2764      contentType: mimeTypeForCodec(fillInMissingAV01Params(videoCodec), 'video'),
2765      width,
2766      height,
2767      bitrate,
2768      framerate
2769    };
2770    if (videoRange !== 'sdr') {
2771      videoConfiguration.transferFunction = videoRange;
2772    }
2773    return videoConfiguration;
2774  }) : [];
2775}
2776function makeAudioConfigurations(level, audioTracksByGroup, hasVideo) {
2777  var _level$audioCodec;
2778  const audioCodecs = (_level$audioCodec = level.audioCodec) == null ? void 0 : _level$audioCodec.split(',');
2779  const combinedBitrate = getVariantDecodingBitrate(level);
2780  if (audioCodecs && level.audioGroups) {
2781    return level.audioGroups.reduce((configurations, audioGroupId) => {
2782      var _audioTracksByGroup$g;
2783      const tracks = audioGroupId ? (_audioTracksByGroup$g = audioTracksByGroup.groups[audioGroupId]) == null ? void 0 : _audioTracksByGroup$g.tracks : null;
2784      if (tracks) {
2785        return tracks.reduce((configs, audioTrack) => {
2786          if (audioTrack.groupId === audioGroupId) {
2787            const channelsNumber = parseFloat(audioTrack.channels || '');
2788            audioCodecs.forEach(audioCodec => {
2789              const audioConfiguration = {
2790                contentType: mimeTypeForCodec(audioCodec, 'audio'),
2791                bitrate: hasVideo ? estimatedAudioBitrate(audioCodec, combinedBitrate) : combinedBitrate
2792              };
2793              if (channelsNumber) {
2794                audioConfiguration.channels = '' + channelsNumber;
2795              }
2796              configs.push(audioConfiguration);
2797            });
2798          }
2799          return configs;
2800        }, configurations);
2801      }
2802      return configurations;
2803    }, []);
2804  }
2805  return [];
2806}
2807function estimatedAudioBitrate(audioCodec, levelBitrate) {
2808  if (levelBitrate <= 1) {
2809    return 1;
2810  }
2811  let audioBitrate = 128000;
2812  if (audioCodec === 'ec-3') {
2813    audioBitrate = 768000;
2814  } else if (audioCodec === 'ac-3') {
2815    audioBitrate = 640000;
2816  }
2817  return Math.min(levelBitrate / 2, audioBitrate); // Don't exceed some % of level bitrate
2818}
2819function getVariantDecodingBitrate(level) {
2820  return Math.ceil(Math.max(level.bitrate * 0.9, level.averageBitrate) / 1000) * 1000 || 1;
2821}
2822function getMediaDecodingInfoKey(config) {
2823  let key = '';
2824  const {
2825    audio,
2826    video
2827  } = config;
2828  if (video) {
2829    const codec = getCodecsForMimeType(video.contentType);
2830    key += `${codec}_r${video.height}x${video.width}f${Math.ceil(video.framerate)}${video.transferFunction || 'sd'}_${Math.ceil(video.bitrate / 1e5)}`;
2831  }
2832  if (audio) {
2833    const codec = getCodecsForMimeType(audio.contentType);
2834    key += `${video ? '_' : ''}${codec}_c${audio.channels}`;
2835  }
2836  return key;
2837}
2838
2839const HdcpLevels = ['NONE', 'TYPE-0', 'TYPE-1', null];
2840function isHdcpLevel(value) {
2841  return HdcpLevels.indexOf(value) > -1;
2842}
2843const VideoRangeValues = ['SDR', 'PQ', 'HLG'];
2844function isVideoRange(value) {
2845  return !!value && VideoRangeValues.indexOf(value) > -1;
2846}
2847var HlsSkip = {
2848  No: "",
2849  Yes: "YES",
2850  v2: "v2"
2851};
2852function getSkipValue(details) {
2853  const {
2854    canSkipUntil,
2855    canSkipDateRanges,
2856    age
2857  } = details;
2858  // A Client SHOULD NOT request a Playlist Delta Update unless it already
2859  // has a version of the Playlist that is no older than one-half of the Skip Boundary.
2860  // @see: https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis#section-6.3.7
2861  const playlistRecentEnough = age < canSkipUntil / 2;
2862  if (canSkipUntil && playlistRecentEnough) {
2863    if (canSkipDateRanges) {
2864      return HlsSkip.v2;
2865    }
2866    return HlsSkip.Yes;
2867  }
2868  return HlsSkip.No;
2869}
2870class HlsUrlParameters {
2871  constructor(msn, part, skip) {
2872    this.msn = void 0;
2873    this.part = void 0;
2874    this.skip = void 0;
2875    this.msn = msn;
2876    this.part = part;
2877    this.skip = skip;
2878  }
2879  addDirectives(uri) {
2880    const url = new self.URL(uri);
2881    if (this.msn !== undefined) {
2882      url.searchParams.set('_HLS_msn', this.msn.toString());
2883    }
2884    if (this.part !== undefined) {
2885      url.searchParams.set('_HLS_part', this.part.toString());
2886    }
2887    if (this.skip) {
2888      url.searchParams.set('_HLS_skip', this.skip);
2889    }
2890    return url.href;
2891  }
2892}
2893class Level {
2894  constructor(data) {
2895    this._attrs = void 0;
2896    this.audioCodec = void 0;
2897    this.bitrate = void 0;
2898    this.codecSet = void 0;
2899    this.url = void 0;
2900    this.frameRate = void 0;
2901    this.height = void 0;
2902    this.id = void 0;
2903    this.name = void 0;
2904    this.supplemental = void 0;
2905    this.videoCodec = void 0;
2906    this.width = void 0;
2907    this.details = void 0;
2908    this.fragmentError = 0;
2909    this.loadError = 0;
2910    this.loaded = void 0;
2911    this.realBitrate = 0;
2912    this.supportedPromise = void 0;
2913    this.supportedResult = void 0;
2914    this._avgBitrate = 0;
2915    this._audioGroups = void 0;
2916    this._subtitleGroups = void 0;
2917    // Deprecated (retained for backwards compatibility)
2918    this._urlId = 0;
2919    this.url = [data.url];
2920    this._attrs = [data.attrs];
2921    this.bitrate = data.bitrate;
2922    if (data.details) {
2923      this.details = data.details;
2924    }
2925    this.id = data.id || 0;
2926    this.name = data.name;
2927    this.width = data.width || 0;
2928    this.height = data.height || 0;
2929    this.frameRate = data.attrs.optionalFloat('FRAME-RATE', 0);
2930    this._avgBitrate = data.attrs.decimalInteger('AVERAGE-BANDWIDTH');
2931    this.audioCodec = data.audioCodec;
2932    this.videoCodec = data.videoCodec;
2933    this.codecSet = [data.videoCodec, data.audioCodec].filter(c => !!c).map(s => s.substring(0, 4)).join(',');
2934    if ('supplemental' in data) {
2935      var _data$supplemental;
2936      this.supplemental = data.supplemental;
2937      const supplementalVideo = (_data$supplemental = data.supplemental) == null ? void 0 : _data$supplemental.videoCodec;
2938      if (supplementalVideo && supplementalVideo !== data.videoCodec) {
2939        this.codecSet += `,${supplementalVideo.substring(0, 4)}`;
2940      }
2941    }
2942    this.addGroupId('audio', data.attrs.AUDIO);
2943    this.addGroupId('text', data.attrs.SUBTITLES);
2944  }
2945  get maxBitrate() {
2946    return Math.max(this.realBitrate, this.bitrate);
2947  }
2948  get averageBitrate() {
2949    return this._avgBitrate || this.realBitrate || this.bitrate;
2950  }
2951  get attrs() {
2952    return this._attrs[0];
2953  }
2954  get codecs() {
2955    return this.attrs.CODECS || '';
2956  }
2957  get pathwayId() {
2958    return this.attrs['PATHWAY-ID'] || '.';
2959  }
2960  get videoRange() {
2961    return this.attrs['VIDEO-RANGE'] || 'SDR';
2962  }
2963  get score() {
2964    return this.attrs.optionalFloat('SCORE', 0);
2965  }
2966  get uri() {
2967    return this.url[0] || '';
2968  }
2969  hasAudioGroup(groupId) {
2970    return hasGroup(this._audioGroups, groupId);
2971  }
2972  hasSubtitleGroup(groupId) {
2973    return hasGroup(this._subtitleGroups, groupId);
2974  }
2975  get audioGroups() {
2976    return this._audioGroups;
2977  }
2978  get subtitleGroups() {
2979    return this._subtitleGroups;
2980  }
2981  addGroupId(type, groupId) {
2982    if (!groupId) {
2983      return;
2984    }
2985    if (type === 'audio') {
2986      let audioGroups = this._audioGroups;
2987      if (!audioGroups) {
2988        audioGroups = this._audioGroups = [];
2989      }
2990      if (audioGroups.indexOf(groupId) === -1) {
2991        audioGroups.push(groupId);
2992      }
2993    } else if (type === 'text') {
2994      let subtitleGroups = this._subtitleGroups;
2995      if (!subtitleGroups) {
2996        subtitleGroups = this._subtitleGroups = [];
2997      }
2998      if (subtitleGroups.indexOf(groupId) === -1) {
2999        subtitleGroups.push(groupId);
3000      }
3001    }
3002  }
3003
3004  // Deprecated methods (retained for backwards compatibility)
3005  get urlId() {
3006    return 0;
3007  }
3008  set urlId(value) {}
3009  get audioGroupIds() {
3010    return this.audioGroups ? [this.audioGroupId] : undefined;
3011  }
3012  get textGroupIds() {
3013    return this.subtitleGroups ? [this.textGroupId] : undefined;
3014  }
3015  get audioGroupId() {
3016    var _this$audioGroups;
3017    return (_this$audioGroups = this.audioGroups) == null ? void 0 : _this$audioGroups[0];
3018  }
3019  get textGroupId() {
3020    var _this$subtitleGroups;
3021    return (_this$subtitleGroups = this.subtitleGroups) == null ? void 0 : _this$subtitleGroups[0];
3022  }
3023  addFallback() {}
3024}
3025function hasGroup(groups, groupId) {
3026  if (!groupId || !groups) {
3027    return false;
3028  }
3029  return groups.indexOf(groupId) !== -1;
3030}
3031
3032/**
3033 * @returns Whether we can detect and validate HDR capability within the window context
3034 */
3035function isHdrSupported() {
3036  if (typeof matchMedia === 'function') {
3037    const mediaQueryList = matchMedia('(dynamic-range: high)');
3038    const badQuery = matchMedia('bad query');
3039    if (mediaQueryList.media !== badQuery.media) {
3040      return mediaQueryList.matches === true;
3041    }
3042  }
3043  return false;
3044}
3045
3046/**
3047 * Sanitizes inputs to return the active video selection options for HDR/SDR.
3048 * When both inputs are null:
3049 *
3050 *    `{ preferHDR: false, allowedVideoRanges: [] }`
3051 *
3052 * When `currentVideoRange` non-null, maintain the active range:
3053 *
3054 *    `{ preferHDR: currentVideoRange !== 'SDR', allowedVideoRanges: [currentVideoRange] }`
3055 *
3056 * When VideoSelectionOption non-null:
3057 *
3058 *  - Allow all video ranges if `allowedVideoRanges` unspecified.
3059 *  - If `preferHDR` is non-null use the value to filter `allowedVideoRanges`.
3060 *  - Else check window for HDR support and set `preferHDR` to the result.
3061 *
3062 * @param currentVideoRange
3063 * @param videoPreference
3064 */
3065function getVideoSelectionOptions(currentVideoRange, videoPreference) {
3066  let preferHDR = false;
3067  let allowedVideoRanges = [];
3068  if (currentVideoRange) {
3069    preferHDR = currentVideoRange !== 'SDR';
3070    allowedVideoRanges = [currentVideoRange];
3071  }
3072  if (videoPreference) {
3073    allowedVideoRanges = videoPreference.allowedVideoRanges || VideoRangeValues.slice(0);
3074    const allowAutoPreferHDR = allowedVideoRanges.join('') !== 'SDR' && !videoPreference.videoCodec;
3075    preferHDR = videoPreference.preferHDR !== undefined ? videoPreference.preferHDR : allowAutoPreferHDR && isHdrSupported();
3076    if (!preferHDR) {
3077      allowedVideoRanges = ['SDR'];
3078    }
3079  }
3080  return {
3081    preferHDR,
3082    allowedVideoRanges
3083  };
3084}
3085
3086const omitCircularRefsReplacer = replacer => {
3087  const known = new WeakSet();
3088  return (_, value) => {
3089    if (replacer) {
3090      value = replacer(_, value);
3091    }
3092    if (typeof value === 'object' && value !== null) {
3093      if (known.has(value)) {
3094        return;
3095      }
3096      known.add(value);
3097    }
3098    return value;
3099  };
3100};
3101const stringify = (object, replacer) => JSON.stringify(object, omitCircularRefsReplacer(replacer));
3102
3103function getStartCodecTier(codecTiers, currentVideoRange, currentBw, audioPreference, videoPreference) {
3104  const codecSets = Object.keys(codecTiers);
3105  const channelsPreference = audioPreference == null ? void 0 : audioPreference.channels;
3106  const audioCodecPreference = audioPreference == null ? void 0 : audioPreference.audioCodec;
3107  const videoCodecPreference = videoPreference == null ? void 0 : videoPreference.videoCodec;
3108  const preferStereo = channelsPreference && parseInt(channelsPreference) === 2;
3109  // Use first level set to determine stereo, and minimum resolution and framerate
3110  let hasStereo = false;
3111  let hasCurrentVideoRange = false;
3112  let minHeight = Infinity;
3113  let minFramerate = Infinity;
3114  let minBitrate = Infinity;
3115  let minIndex = Infinity;
3116  let selectedScore = 0;
3117  let videoRanges = [];
3118  const {
3119    preferHDR,
3120    allowedVideoRanges
3121  } = getVideoSelectionOptions(currentVideoRange, videoPreference);
3122  for (let i = codecSets.length; i--;) {
3123    const tier = codecTiers[codecSets[i]];
3124    hasStereo || (hasStereo = tier.channels[2] > 0);
3125    minHeight = Math.min(minHeight, tier.minHeight);
3126    minFramerate = Math.min(minFramerate, tier.minFramerate);
3127    minBitrate = Math.min(minBitrate, tier.minBitrate);
3128    const matchingVideoRanges = allowedVideoRanges.filter(range => tier.videoRanges[range] > 0);
3129    if (matchingVideoRanges.length > 0) {
3130      hasCurrentVideoRange = true;
3131    }
3132  }
3133  minHeight = isFiniteNumber(minHeight) ? minHeight : 0;
3134  minFramerate = isFiniteNumber(minFramerate) ? minFramerate : 0;
3135  const maxHeight = Math.max(1080, minHeight);
3136  const maxFramerate = Math.max(30, minFramerate);
3137  minBitrate = isFiniteNumber(minBitrate) ? minBitrate : currentBw;
3138  currentBw = Math.max(minBitrate, currentBw);
3139  // If there are no variants with matching preference, set currentVideoRange to undefined
3140  if (!hasCurrentVideoRange) {
3141    currentVideoRange = undefined;
3142  }
3143  const hasMultipleSets = codecSets.length > 1;
3144  const codecSet = codecSets.reduce((selected, candidate) => {
3145    // Remove candiates which do not meet bitrate, default audio, stereo or channels preference, 1080p or lower, 30fps or lower, or SDR/HDR selection if present
3146    const candidateTier = codecTiers[candidate];
3147    if (candidate === selected) {
3148      return selected;
3149    }
3150    videoRanges = hasCurrentVideoRange ? allowedVideoRanges.filter(range => candidateTier.videoRanges[range] > 0) : [];
3151    if (hasMultipleSets) {
3152      if (candidateTier.minBitrate > currentBw) {
3153        logStartCodecCandidateIgnored(candidate, `min bitrate of ${candidateTier.minBitrate} > current estimate of ${currentBw}`);
3154        return selected;
3155      }
3156      if (!candidateTier.hasDefaultAudio) {
3157        logStartCodecCandidateIgnored(candidate, `no renditions with default or auto-select sound found`);
3158        return selected;
3159      }
3160      if (audioCodecPreference && candidate.indexOf(audioCodecPreference.substring(0, 4)) % 5 !== 0) {
3161        logStartCodecCandidateIgnored(candidate, `audio codec preference "${audioCodecPreference}" not found`);
3162        return selected;
3163      }
3164      if (channelsPreference && !preferStereo) {
3165        if (!candidateTier.channels[channelsPreference]) {
3166          logStartCodecCandidateIgnored(candidate, `no renditions with ${channelsPreference} channel sound found (channels options: ${Object.keys(candidateTier.channels)})`);
3167          return selected;
3168        }
3169      } else if ((!audioCodecPreference || preferStereo) && hasStereo && candidateTier.channels['2'] === 0) {
3170        logStartCodecCandidateIgnored(candidate, `no renditions with stereo sound found`);
3171        return selected;
3172      }
3173      if (candidateTier.minHeight > maxHeight) {
3174        logStartCodecCandidateIgnored(candidate, `min resolution of ${candidateTier.minHeight} > maximum of ${maxHeight}`);
3175        return selected;
3176      }
3177      if (candidateTier.minFramerate > maxFramerate) {
3178        logStartCodecCandidateIgnored(candidate, `min framerate of ${candidateTier.minFramerate} > maximum of ${maxFramerate}`);
3179        return selected;
3180      }
3181      if (!videoRanges.some(range => candidateTier.videoRanges[range] > 0)) {
3182        logStartCodecCandidateIgnored(candidate, `no variants with VIDEO-RANGE of ${stringify(videoRanges)} found`);
3183        return selected;
3184      }
3185      if (videoCodecPreference && candidate.indexOf(videoCodecPreference.substring(0, 4)) % 5 !== 0) {
3186        logStartCodecCandidateIgnored(candidate, `video codec preference "${videoCodecPreference}" not found`);
3187        return selected;
3188      }
3189      if (candidateTier.maxScore < selectedScore) {
3190        logStartCodecCandidateIgnored(candidate, `max score of ${candidateTier.maxScore} < selected max of ${selectedScore}`);
3191        return selected;
3192      }
3193    }
3194    // Remove candiates with less preferred codecs or more errors
3195    if (selected && (codecsSetSelectionPreferenceValue(candidate) >= codecsSetSelectionPreferenceValue(selected) || candidateTier.fragmentError > codecTiers[selected].fragmentError)) {
3196      return selected;
3197    }
3198    minIndex = candidateTier.minIndex;
3199    selectedScore = candidateTier.maxScore;
3200    return candidate;
3201  }, undefined);
3202  return {
3203    codecSet,
3204    videoRanges,
3205    preferHDR,
3206    minFramerate,
3207    minBitrate,
3208    minIndex
3209  };
3210}
3211function logStartCodecCandidateIgnored(codeSet, reason) {
3212  logger.log(`[abr] start candidates with "${codeSet}" ignored because ${reason}`);
3213}
3214function getAudioTracksByGroup(allAudioTracks) {
3215  return allAudioTracks.reduce((audioTracksByGroup, track) => {
3216    let trackGroup = audioTracksByGroup.groups[track.groupId];
3217    if (!trackGroup) {
3218      trackGroup = audioTracksByGroup.groups[track.groupId] = {
3219        tracks: [],
3220        channels: {
3221          2: 0
3222        },
3223        hasDefault: false,
3224        hasAutoSelect: false
3225      };
3226    }
3227    trackGroup.tracks.push(track);
3228    const channelsKey = track.channels || '2';
3229    trackGroup.channels[channelsKey] = (trackGroup.channels[channelsKey] || 0) + 1;
3230    trackGroup.hasDefault = trackGroup.hasDefault || track.default;
3231    trackGroup.hasAutoSelect = trackGroup.hasAutoSelect || track.autoselect;
3232    if (trackGroup.hasDefault) {
3233      audioTracksByGroup.hasDefaultAudio = true;
3234    }
3235    if (trackGroup.hasAutoSelect) {
3236      audioTracksByGroup.hasAutoSelectAudio = true;
3237    }
3238    return audioTracksByGroup;
3239  }, {
3240    hasDefaultAudio: false,
3241    hasAutoSelectAudio: false,
3242    groups: {}
3243  });
3244}
3245function getCodecTiers(levels, audioTracksByGroup, minAutoLevel, maxAutoLevel) {
3246  return levels.slice(minAutoLevel, maxAutoLevel + 1).reduce((tiers, level, index) => {
3247    if (!level.codecSet) {
3248      return tiers;
3249    }
3250    const audioGroups = level.audioGroups;
3251    let tier = tiers[level.codecSet];
3252    if (!tier) {
3253      tiers[level.codecSet] = tier = {
3254        minBitrate: Infinity,
3255        minHeight: Infinity,
3256        minFramerate: Infinity,
3257        minIndex: index,
3258        maxScore: 0,
3259        videoRanges: {
3260          SDR: 0
3261        },
3262        channels: {
3263          '2': 0
3264        },
3265        hasDefaultAudio: !audioGroups,
3266        fragmentError: 0
3267      };
3268    }
3269    tier.minBitrate = Math.min(tier.minBitrate, level.bitrate);
3270    const lesserWidthOrHeight = Math.min(level.height, level.width);
3271    tier.minHeight = Math.min(tier.minHeight, lesserWidthOrHeight);
3272    tier.minFramerate = Math.min(tier.minFramerate, level.frameRate);
3273    tier.minIndex = Math.min(tier.minIndex, index);
3274    tier.maxScore = Math.max(tier.maxScore, level.score);
3275    tier.fragmentError += level.fragmentError;
3276    tier.videoRanges[level.videoRange] = (tier.videoRanges[level.videoRange] || 0) + 1;
3277    if (audioGroups) {
3278      audioGroups.forEach(audioGroupId => {
3279        if (!audioGroupId) {
3280          return;
3281        }
3282        const audioGroup = audioTracksByGroup.groups[audioGroupId];
3283        if (!audioGroup) {
3284          return;
3285        }
3286        // Default audio is any group with DEFAULT=YES, or if missing then any group with AUTOSELECT=YES, or all variants
3287        tier.hasDefaultAudio = tier.hasDefaultAudio || audioTracksByGroup.hasDefaultAudio ? audioGroup.hasDefault : audioGroup.hasAutoSelect || !audioTracksByGroup.hasDefaultAudio && !audioTracksByGroup.hasAutoSelectAudio;
3288        Object.keys(audioGroup.channels).forEach(channels => {
3289          tier.channels[channels] = (tier.channels[channels] || 0) + audioGroup.channels[channels];
3290        });
3291      });
3292    }
3293    return tiers;
3294  }, {});
3295}
3296function getBasicSelectionOption(option) {
3297  if (!option) {
3298    return option;
3299  }
3300  const {
3301    lang,
3302    assocLang,
3303    characteristics,
3304    channels,
3305    audioCodec
3306  } = option;
3307  return {
3308    lang,
3309    assocLang,
3310    characteristics,
3311    channels,
3312    audioCodec
3313  };
3314}
3315function findMatchingOption(option, tracks, matchPredicate) {
3316  if ('attrs' in option) {
3317    const index = tracks.indexOf(option);
3318    if (index !== -1) {
3319      return index;
3320    }
3321  }
3322  for (let i = 0; i < tracks.length; i++) {
3323    const track = tracks[i];
3324    if (matchesOption(option, track, matchPredicate)) {
3325      return i;
3326    }
3327  }
3328  return -1;
3329}
3330function matchesOption(option, track, matchPredicate) {
3331  const {
3332    groupId,
3333    name,
3334    lang,
3335    assocLang,
3336    default: isDefault
3337  } = option;
3338  const forced = option.forced;
3339  return (groupId === undefined || track.groupId === groupId) && (name === undefined || track.name === name) && (lang === undefined || languagesMatch(lang, track.lang)) && (lang === undefined || track.assocLang === assocLang) && (isDefault === undefined || track.default === isDefault) && (forced === undefined || track.forced === forced) && (!('characteristics' in option) || characteristicsMatch(option.characteristics || '', track.characteristics)) && (matchPredicate === undefined || matchPredicate(option, track));
3340}
3341function languagesMatch(languageA, languageB = '--') {
3342  if (languageA.length === languageB.length) {
3343    return languageA === languageB;
3344  }
3345  return languageA.startsWith(languageB) || languageB.startsWith(languageA);
3346}
3347function characteristicsMatch(characteristicsA, characteristicsB = '') {
3348  const arrA = characteristicsA.split(',');
3349  const arrB = characteristicsB.split(',');
3350  // Expects each item to be unique:
3351  return arrA.length === arrB.length && !arrA.some(el => arrB.indexOf(el) === -1);
3352}
3353function audioMatchPredicate(option, track) {
3354  const {
3355    audioCodec,
3356    channels
3357  } = option;
3358  return (audioCodec === undefined || (track.audioCodec || '').substring(0, 4) === audioCodec.substring(0, 4)) && (channels === undefined || channels === (track.channels || '2'));
3359}
3360function findClosestLevelWithAudioGroup(option, levels, allAudioTracks, searchIndex, matchPredicate) {
3361  const currentLevel = levels[searchIndex];
3362  // Are there variants with same URI as current level?
3363  // If so, find a match that does not require any level URI change
3364  const variants = levels.reduce((variantMap, level, index) => {
3365    const uri = level.uri;
3366    const renditions = variantMap[uri] || (variantMap[uri] = []);
3367    renditions.push(index);
3368    return variantMap;
3369  }, {});
3370  const renditions = variants[currentLevel.uri];
3371  if (renditions.length > 1) {
3372    searchIndex = Math.max.apply(Math, renditions);
3373  }
3374  // Find best match
3375  const currentVideoRange = currentLevel.videoRange;
3376  const currentFrameRate = currentLevel.frameRate;
3377  const currentVideoCodec = currentLevel.codecSet.substring(0, 4);
3378  const matchingVideo = searchDownAndUpList(levels, searchIndex, level => {
3379    if (level.videoRange !== currentVideoRange || level.frameRate !== currentFrameRate || level.codecSet.substring(0, 4) !== currentVideoCodec) {
3380      return false;
3381    }
3382    const audioGroups = level.audioGroups;
3383    const tracks = allAudioTracks.filter(track => !audioGroups || audioGroups.indexOf(track.groupId) !== -1);
3384    return findMatchingOption(option, tracks, matchPredicate) > -1;
3385  });
3386  if (matchingVideo > -1) {
3387    return matchingVideo;
3388  }
3389  return searchDownAndUpList(levels, searchIndex, level => {
3390    const audioGroups = level.audioGroups;
3391    const tracks = allAudioTracks.filter(track => !audioGroups || audioGroups.indexOf(track.groupId) !== -1);
3392    return findMatchingOption(option, tracks, matchPredicate) > -1;
3393  });
3394}
3395function searchDownAndUpList(arr, searchIndex, predicate) {
3396  for (let i = searchIndex; i > -1; i--) {
3397    if (predicate(arr[i])) {
3398      return i;
3399    }
3400  }
3401  for (let i = searchIndex + 1; i < arr.length; i++) {
3402    if (predicate(arr[i])) {
3403      return i;
3404    }
3405  }
3406  return -1;
3407}
3408function useAlternateAudio(audioTrackUrl, hls) {
3409  var _hls$loadLevelObj;
3410  return !!audioTrackUrl && audioTrackUrl !== ((_hls$loadLevelObj = hls.loadLevelObj) == null ? void 0 : _hls$loadLevelObj.uri);
3411}
3412
3413class AbrController extends Logger {
3414  constructor(_hls) {
3415    super('abr', _hls.logger);
3416    this.hls = void 0;
3417    this.lastLevelLoadSec = 0;
3418    this.lastLoadedFragLevel = -1;
3419    this.firstSelection = -1;
3420    this._nextAutoLevel = -1;
3421    this.nextAutoLevelKey = '';
3422    this.audioTracksByGroup = null;
3423    this.codecTiers = null;
3424    this.timer = -1;
3425    this.fragCurrent = null;
3426    this.partCurrent = null;
3427    this.bitrateTestDelay = 0;
3428    this.rebufferNotice = -1;
3429    this.supportedCache = {};
3430    this.bwEstimator = void 0;
3431    /*
3432        This method monitors the download rate of the current fragment, and will downswitch if that fragment will not load
3433        quickly enough to prevent underbuffering
3434      */
3435    this._abandonRulesCheck = levelLoaded => {
3436      var _ref;
3437      const {
3438        fragCurrent: frag,
3439        partCurrent: part,
3440        hls
3441      } = this;
3442      const {
3443        autoLevelEnabled,
3444        media
3445      } = hls;
3446      if (!frag || !media) {
3447        return;
3448      }
3449      const now = performance.now();
3450      const stats = part ? part.stats : frag.stats;
3451      const duration = part ? part.duration : frag.duration;
3452      const timeLoading = now - stats.loading.start;
3453      const minAutoLevel = hls.minAutoLevel;
3454      const loadingFragForLevel = frag.level;
3455      const currentAutoLevel = this._nextAutoLevel;
3456      // If frag loading is aborted, complete, or from lowest level, stop timer and return
3457      if (stats.aborted || stats.loaded && stats.loaded === stats.total || loadingFragForLevel <= minAutoLevel) {
3458        this.clearTimer();
3459        // reset forced auto level value so that next level will be selected
3460        this._nextAutoLevel = -1;
3461        return;
3462      }
3463
3464      // This check only runs if we're in ABR mode
3465      if (!autoLevelEnabled) {
3466        return;
3467      }
3468
3469      // Must be loading/loaded a new level or be in a playing state
3470      const fragBlockingSwitch = currentAutoLevel > -1 && currentAutoLevel !== loadingFragForLevel;
3471      const levelChange = !!levelLoaded || fragBlockingSwitch;
3472      if (!levelChange && (media.paused || !media.playbackRate || !media.readyState)) {
3473        return;
3474      }
3475      const bufferInfo = hls.mainForwardBufferInfo;
3476      if (!levelChange && bufferInfo === null) {
3477        return;
3478      }
3479      const ttfbEstimate = this.bwEstimator.getEstimateTTFB();
3480      const playbackRate = Math.abs(media.playbackRate);
3481      // To maintain stable adaptive playback, only begin monitoring frag loading after half or more of its playback duration has passed
3482      if (timeLoading <= Math.max(ttfbEstimate, 1000 * (duration / (playbackRate * 2)))) {
3483        return;
3484      }
3485
3486      // bufferStarvationDelay is an estimate of the amount time (in seconds) it will take to exhaust the buffer
3487      const bufferStarvationDelay = bufferInfo ? bufferInfo.len / playbackRate : 0;
3488      const ttfb = stats.loading.first ? stats.loading.first - stats.loading.start : -1;
3489      const loadedFirstByte = stats.loaded && ttfb > -1;
3490      const bwEstimate = this.getBwEstimate();
3491      const levels = hls.levels;
3492      const level = levels[loadingFragForLevel];
3493      const expectedLen = Math.max(stats.loaded, Math.round(duration * (frag.bitrate || level.averageBitrate) / 8));
3494      let timeStreaming = loadedFirstByte ? timeLoading - ttfb : timeLoading;
3495      if (timeStreaming < 1 && loadedFirstByte) {
3496        timeStreaming = Math.min(timeLoading, stats.loaded * 8 / bwEstimate);
3497      }
3498      const loadRate = loadedFirstByte ? stats.loaded * 1000 / timeStreaming : 0;
3499      // fragLoadDelay is an estimate of the time (in seconds) it will take to buffer the remainder of the fragment
3500      const ttfbSeconds = ttfbEstimate / 1000;
3501      const fragLoadedDelay = loadRate ? (expectedLen - stats.loaded) / loadRate : expectedLen * 8 / bwEstimate + ttfbSeconds;
3502      // Only downswitch if the time to finish loading the current fragment is greater than the amount of buffer left
3503      if (fragLoadedDelay <= bufferStarvationDelay) {
3504        return;
3505      }
3506      const bwe = loadRate ? loadRate * 8 : bwEstimate;
3507      const live = ((_ref = (levelLoaded == null ? void 0 : levelLoaded.details) || this.hls.latestLevelDetails) == null ? void 0 : _ref.live) === true;
3508      const abrBandWidthUpFactor = this.hls.config.abrBandWidthUpFactor;
3509      let fragLevelNextLoadedDelay = Number.POSITIVE_INFINITY;
3510      let nextLoadLevel;
3511      // Iterate through lower level and try to find the largest one that avoids rebuffering
3512      for (nextLoadLevel = loadingFragForLevel - 1; nextLoadLevel > minAutoLevel; nextLoadLevel--) {
3513        // compute time to load next fragment at lower level
3514        // 8 = bits per byte (bps/Bps)
3515        const levelNextBitrate = levels[nextLoadLevel].maxBitrate;
3516        const requiresLevelLoad = !levels[nextLoadLevel].details || live;
3517        fragLevelNextLoadedDelay = this.getTimeToLoadFrag(ttfbSeconds, bwe, duration * levelNextBitrate, requiresLevelLoad);
3518        if (fragLevelNextLoadedDelay < Math.min(bufferStarvationDelay, duration + ttfbSeconds)) {
3519          break;
3520        }
3521      }
3522      // Only emergency switch down if it takes less time to load a new fragment at lowest level instead of continuing
3523      // to load the current one
3524      if (fragLevelNextLoadedDelay >= fragLoadedDelay) {
3525        return;
3526      }
3527
3528      // if estimated load time of new segment is completely unreasonable, ignore and do not emergency switch down
3529      if (fragLevelNextLoadedDelay > duration * 10) {
3530        return;
3531      }
3532      if (loadedFirstByte) {
3533        // If there has been loading progress, sample bandwidth using loading time offset by minimum TTFB time
3534        this.bwEstimator.sample(timeLoading - Math.min(ttfbEstimate, ttfb), stats.loaded);
3535      } else {
3536        // If there has been no loading progress, sample TTFB
3537        this.bwEstimator.sampleTTFB(timeLoading);
3538      }
3539      const nextLoadLevelBitrate = levels[nextLoadLevel].maxBitrate;
3540      if (this.getBwEstimate() * abrBandWidthUpFactor > nextLoadLevelBitrate) {
3541        this.resetEstimator(nextLoadLevelBitrate);
3542      }
3543      const bestSwitchLevel = this.findBestLevel(nextLoadLevelBitrate, minAutoLevel, nextLoadLevel, 0, bufferStarvationDelay, 1, 1);
3544      if (bestSwitchLevel > -1) {
3545        nextLoadLevel = bestSwitchLevel;
3546      }
3547      this.warn(`Fragment ${frag.sn}${part ? ' part ' + part.index : ''} of level ${loadingFragForLevel} is loading too slowly;
3548      Fragment duration: ${frag.duration.toFixed(3)}
3549      Time to underbuffer: ${bufferStarvationDelay.toFixed(3)} s
3550      Estimated load time for current fragment: ${fragLoadedDelay.toFixed(3)} s
3551      Estimated load time for down switch fragment: ${fragLevelNextLoadedDelay.toFixed(3)} s
3552      TTFB estimate: ${ttfb | 0} ms
3553      Current BW estimate: ${isFiniteNumber(bwEstimate) ? bwEstimate | 0 : 'Unknown'} bps
3554      New BW estimate: ${this.getBwEstimate() | 0} bps
3555      Switching to level ${nextLoadLevel} @ ${nextLoadLevelBitrate | 0} bps`);
3556      hls.nextLoadLevel = hls.nextAutoLevel = nextLoadLevel;
3557      this.clearTimer();
3558      const abortAndSwitch = () => {
3559        // Are nextLoadLevel details available or is stream-controller still in "WAITING_LEVEL" state?
3560        this.clearTimer();
3561        if (this.fragCurrent === frag && this.hls.loadLevel === nextLoadLevel && nextLoadLevel > 0) {
3562          const bufferStarvationDelay = this.getStarvationDelay();
3563          this.warn(`Aborting inflight request ${nextLoadLevel > 0 ? 'and switching down' : ''}
3564      Fragment duration: ${frag.duration.toFixed(3)} s
3565      Time to underbuffer: ${bufferStarvationDelay.toFixed(3)} s`);
3566          frag.abortRequests();
3567          this.fragCurrent = this.partCurrent = null;
3568          if (nextLoadLevel > minAutoLevel) {
3569            let lowestSwitchLevel = this.findBestLevel(this.hls.levels[minAutoLevel].bitrate, minAutoLevel, nextLoadLevel, 0, bufferStarvationDelay, 1, 1);
3570            if (lowestSwitchLevel === -1) {
3571              lowestSwitchLevel = minAutoLevel;
3572            }
3573            this.hls.nextLoadLevel = this.hls.nextAutoLevel = lowestSwitchLevel;
3574            this.resetEstimator(this.hls.levels[lowestSwitchLevel].bitrate);
3575          }
3576        }
3577      };
3578      if (fragBlockingSwitch || fragLoadedDelay > fragLevelNextLoadedDelay * 2) {
3579        abortAndSwitch();
3580      } else {
3581        this.timer = self.setInterval(abortAndSwitch, fragLevelNextLoadedDelay * 1000);
3582      }
3583      hls.trigger(Events.FRAG_LOAD_EMERGENCY_ABORTED, {
3584        frag,
3585        part,
3586        stats
3587      });
3588    };
3589    this.hls = _hls;
3590    this.bwEstimator = this.initEstimator();
3591    this.registerListeners();
3592  }
3593  resetEstimator(abrEwmaDefaultEstimate) {
3594    if (abrEwmaDefaultEstimate) {
3595      this.log(`setting initial bwe to ${abrEwmaDefaultEstimate}`);
3596      this.hls.config.abrEwmaDefaultEstimate = abrEwmaDefaultEstimate;
3597    }
3598    this.firstSelection = -1;
3599    this.bwEstimator = this.initEstimator();
3600  }
3601  initEstimator() {
3602    const config = this.hls.config;
3603    return new EwmaBandWidthEstimator(config.abrEwmaSlowVoD, config.abrEwmaFastVoD, config.abrEwmaDefaultEstimate);
3604  }
3605  registerListeners() {
3606    const {
3607      hls
3608    } = this;
3609    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
3610    hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
3611    hls.on(Events.FRAG_LOADED, this.onFragLoaded, this);
3612    hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
3613    hls.on(Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
3614    hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
3615    hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
3616    hls.on(Events.MAX_AUTO_LEVEL_UPDATED, this.onMaxAutoLevelUpdated, this);
3617    hls.on(Events.ERROR, this.onError, this);
3618  }
3619  unregisterListeners() {
3620    const {
3621      hls
3622    } = this;
3623    if (!hls) {
3624      return;
3625    }
3626    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
3627    hls.off(Events.FRAG_LOADING, this.onFragLoading, this);
3628    hls.off(Events.FRAG_LOADED, this.onFragLoaded, this);
3629    hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
3630    hls.off(Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
3631    hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
3632    hls.off(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
3633    hls.off(Events.MAX_AUTO_LEVEL_UPDATED, this.onMaxAutoLevelUpdated, this);
3634    hls.off(Events.ERROR, this.onError, this);
3635  }
3636  destroy() {
3637    this.unregisterListeners();
3638    this.clearTimer();
3639    // @ts-ignore
3640    this.hls = this._abandonRulesCheck = this.supportedCache = null;
3641    this.fragCurrent = this.partCurrent = null;
3642  }
3643  onManifestLoading(event, data) {
3644    this.lastLoadedFragLevel = -1;
3645    this.firstSelection = -1;
3646    this.lastLevelLoadSec = 0;
3647    this.supportedCache = {};
3648    this.fragCurrent = this.partCurrent = null;
3649    this.onLevelsUpdated();
3650    this.clearTimer();
3651  }
3652  onLevelsUpdated() {
3653    if (this.lastLoadedFragLevel > -1 && this.fragCurrent) {
3654      this.lastLoadedFragLevel = this.fragCurrent.level;
3655    }
3656    this._nextAutoLevel = -1;
3657    this.onMaxAutoLevelUpdated();
3658    this.codecTiers = null;
3659    this.audioTracksByGroup = null;
3660  }
3661  onMaxAutoLevelUpdated() {
3662    this.firstSelection = -1;
3663    this.nextAutoLevelKey = '';
3664  }
3665  onFragLoading(event, data) {
3666    const frag = data.frag;
3667    if (this.ignoreFragment(frag)) {
3668      return;
3669    }
3670    if (!frag.bitrateTest) {
3671      var _data$part;
3672      this.fragCurrent = frag;
3673      this.partCurrent = (_data$part = data.part) != null ? _data$part : null;
3674    }
3675    this.clearTimer();
3676    this.timer = self.setInterval(this._abandonRulesCheck, 100);
3677  }
3678  onLevelSwitching(event, data) {
3679    this.clearTimer();
3680  }
3681  onError(event, data) {
3682    if (data.fatal) {
3683      return;
3684    }
3685    switch (data.details) {
3686      case ErrorDetails.BUFFER_ADD_CODEC_ERROR:
3687      case ErrorDetails.BUFFER_APPEND_ERROR:
3688        // Reset last loaded level so that a new selection can be made after calling recoverMediaError
3689        this.lastLoadedFragLevel = -1;
3690        this.firstSelection = -1;
3691        break;
3692      case ErrorDetails.FRAG_LOAD_TIMEOUT:
3693        {
3694          const frag = data.frag;
3695          const {
3696            fragCurrent,
3697            partCurrent: part
3698          } = this;
3699          if (frag && fragCurrent && frag.sn === fragCurrent.sn && frag.level === fragCurrent.level) {
3700            const now = performance.now();
3701            const stats = part ? part.stats : frag.stats;
3702            const timeLoading = now - stats.loading.start;
3703            const ttfb = stats.loading.first ? stats.loading.first - stats.loading.start : -1;
3704            const loadedFirstByte = stats.loaded && ttfb > -1;
3705            if (loadedFirstByte) {
3706              const ttfbEstimate = this.bwEstimator.getEstimateTTFB();
3707              this.bwEstimator.sample(timeLoading - Math.min(ttfbEstimate, ttfb), stats.loaded);
3708            } else {
3709              this.bwEstimator.sampleTTFB(timeLoading);
3710            }
3711          }
3712          break;
3713        }
3714    }
3715  }
3716  getTimeToLoadFrag(timeToFirstByteSec, bandwidth, fragSizeBits, isSwitch) {
3717    const fragLoadSec = timeToFirstByteSec + fragSizeBits / bandwidth;
3718    const playlistLoadSec = isSwitch ? timeToFirstByteSec + this.lastLevelLoadSec : 0;
3719    return fragLoadSec + playlistLoadSec;
3720  }
3721  onLevelLoaded(event, data) {
3722    const config = this.hls.config;
3723    const {
3724      loading
3725    } = data.stats;
3726    const timeLoadingMs = loading.end - loading.first;
3727    if (isFiniteNumber(timeLoadingMs)) {
3728      this.lastLevelLoadSec = timeLoadingMs / 1000;
3729    }
3730    if (data.details.live) {
3731      this.bwEstimator.update(config.abrEwmaSlowLive, config.abrEwmaFastLive);
3732    } else {
3733      this.bwEstimator.update(config.abrEwmaSlowVoD, config.abrEwmaFastVoD);
3734    }
3735    if (this.timer > -1) {
3736      this._abandonRulesCheck(data.levelInfo);
3737    }
3738  }
3739  onFragLoaded(event, {
3740    frag,
3741    part
3742  }) {
3743    const stats = part ? part.stats : frag.stats;
3744    if (frag.type === PlaylistLevelType.MAIN) {
3745      this.bwEstimator.sampleTTFB(stats.loading.first - stats.loading.start);
3746    }
3747    if (this.ignoreFragment(frag)) {
3748      return;
3749    }
3750    // stop monitoring bw once frag loaded
3751    this.clearTimer();
3752    // reset forced auto level value so that next level will be selected
3753    if (frag.level === this._nextAutoLevel) {
3754      this._nextAutoLevel = -1;
3755    }
3756    this.firstSelection = -1;
3757
3758    // compute level average bitrate
3759    if (this.hls.config.abrMaxWithRealBitrate) {
3760      const duration = part ? part.duration : frag.duration;
3761      const level = this.hls.levels[frag.level];
3762      const loadedBytes = (level.loaded ? level.loaded.bytes : 0) + stats.loaded;
3763      const loadedDuration = (level.loaded ? level.loaded.duration : 0) + duration;
3764      level.loaded = {
3765        bytes: loadedBytes,
3766        duration: loadedDuration
3767      };
3768      level.realBitrate = Math.round(8 * loadedBytes / loadedDuration);
3769    }
3770    if (frag.bitrateTest) {
3771      const fragBufferedData = {
3772        stats,
3773        frag,
3774        part,
3775        id: frag.type
3776      };
3777      this.onFragBuffered(Events.FRAG_BUFFERED, fragBufferedData);
3778      frag.bitrateTest = false;
3779    } else {
3780      // store level id after successful fragment load for playback
3781      this.lastLoadedFragLevel = frag.level;
3782    }
3783  }
3784  onFragBuffered(event, data) {
3785    const {
3786      frag,
3787      part
3788    } = data;
3789    const stats = part != null && part.stats.loaded ? part.stats : frag.stats;
3790    if (stats.aborted) {
3791      return;
3792    }
3793    if (this.ignoreFragment(frag)) {
3794      return;
3795    }
3796    // Use the difference between parsing and request instead of buffering and request to compute fragLoadingProcessing;
3797    // rationale is that buffer appending only happens once media is attached. This can happen when config.startFragPrefetch
3798    // is used. If we used buffering in that case, our BW estimate sample will be very large.
3799    const processingMs = stats.parsing.end - stats.loading.start - Math.min(stats.loading.first - stats.loading.start, this.bwEstimator.getEstimateTTFB());
3800    this.bwEstimator.sample(processingMs, stats.loaded);
3801    stats.bwEstimate = this.getBwEstimate();
3802    if (frag.bitrateTest) {
3803      this.bitrateTestDelay = processingMs / 1000;
3804    } else {
3805      this.bitrateTestDelay = 0;
3806    }
3807  }
3808  ignoreFragment(frag) {
3809    // Only count non-alt-audio frags which were actually buffered in our BW calculations
3810    return frag.type !== PlaylistLevelType.MAIN || frag.sn === 'initSegment';
3811  }
3812  clearTimer() {
3813    if (this.timer > -1) {
3814      self.clearInterval(this.timer);
3815      this.timer = -1;
3816    }
3817  }
3818  get firstAutoLevel() {
3819    const {
3820      maxAutoLevel,
3821      minAutoLevel
3822    } = this.hls;
3823    const bwEstimate = this.getBwEstimate();
3824    const maxStartDelay = this.hls.config.maxStarvationDelay;
3825    const abrAutoLevel = this.findBestLevel(bwEstimate, minAutoLevel, maxAutoLevel, 0, maxStartDelay, 1, 1);
3826    if (abrAutoLevel > -1) {
3827      return abrAutoLevel;
3828    }
3829    const firstLevel = this.hls.firstLevel;
3830    const clamped = Math.min(Math.max(firstLevel, minAutoLevel), maxAutoLevel);
3831    this.warn(`Could not find best starting auto level. Defaulting to first in playlist ${firstLevel} clamped to ${clamped}`);
3832    return clamped;
3833  }
3834  get forcedAutoLevel() {
3835    if (this.nextAutoLevelKey) {
3836      return -1;
3837    }
3838    return this._nextAutoLevel;
3839  }
3840
3841  // return next auto level
3842  get nextAutoLevel() {
3843    const forcedAutoLevel = this.forcedAutoLevel;
3844    const bwEstimator = this.bwEstimator;
3845    const useEstimate = bwEstimator.canEstimate();
3846    const loadedFirstFrag = this.lastLoadedFragLevel > -1;
3847    // in case next auto level has been forced, and bw not available or not reliable, return forced value
3848    if (forcedAutoLevel !== -1 && (!useEstimate || !loadedFirstFrag || this.nextAutoLevelKey === this.getAutoLevelKey())) {
3849      return forcedAutoLevel;
3850    }
3851
3852    // compute next level using ABR logic
3853    const nextABRAutoLevel = useEstimate && loadedFirstFrag ? this.getNextABRAutoLevel() : this.firstAutoLevel;
3854
3855    // use forced auto level while it hasn't errored more than ABR selection
3856    if (forcedAutoLevel !== -1) {
3857      const levels = this.hls.levels;
3858      if (levels.length > Math.max(forcedAutoLevel, nextABRAutoLevel) && levels[forcedAutoLevel].loadError <= levels[nextABRAutoLevel].loadError) {
3859        return forcedAutoLevel;
3860      }
3861    }
3862
3863    // save result until state has changed
3864    this._nextAutoLevel = nextABRAutoLevel;
3865    this.nextAutoLevelKey = this.getAutoLevelKey();
3866    return nextABRAutoLevel;
3867  }
3868  getAutoLevelKey() {
3869    return `${this.getBwEstimate()}_${this.getStarvationDelay().toFixed(2)}`;
3870  }
3871  getNextABRAutoLevel() {
3872    const {
3873      fragCurrent,
3874      partCurrent,
3875      hls
3876    } = this;
3877    if (hls.levels.length <= 1) {
3878      return hls.loadLevel;
3879    }
3880    const {
3881      maxAutoLevel,
3882      config,
3883      minAutoLevel
3884    } = hls;
3885    const currentFragDuration = partCurrent ? partCurrent.duration : fragCurrent ? fragCurrent.duration : 0;
3886    const avgbw = this.getBwEstimate();
3887    // bufferStarvationDelay is the wall-clock time left until the playback buffer is exhausted.
3888    const bufferStarvationDelay = this.getStarvationDelay();
3889    let bwFactor = config.abrBandWidthFactor;
3890    let bwUpFactor = config.abrBandWidthUpFactor;
3891
3892    // First, look to see if we can find a level matching with our avg bandwidth AND that could also guarantee no rebuffering at all
3893    if (bufferStarvationDelay) {
3894      const _bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, 0, bwFactor, bwUpFactor);
3895      if (_bestLevel >= 0) {
3896        this.rebufferNotice = -1;
3897        return _bestLevel;
3898      }
3899    }
3900    // not possible to get rid of rebuffering... try to find level that will guarantee less than maxStarvationDelay of rebuffering
3901    let maxStarvationDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxStarvationDelay) : config.maxStarvationDelay;
3902    if (!bufferStarvationDelay) {
3903      // in case buffer is empty, let's check if previous fragment was loaded to perform a bitrate test
3904      const bitrateTestDelay = this.bitrateTestDelay;
3905      if (bitrateTestDelay) {
3906        // if it is the case, then we need to adjust our max starvation delay using maxLoadingDelay config value
3907        // max video loading delay used in  automatic start level selection :
3908        // in that mode ABR controller will ensure that video loading time (ie the time to fetch the first fragment at lowest quality level +
3909        // the time to fetch the fragment at the appropriate quality level is less than ```maxLoadingDelay``` )
3910        // cap maxLoadingDelay and ensure it is not bigger 'than bitrate test' frag duration
3911        const maxLoadingDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxLoadingDelay) : config.maxLoadingDelay;
3912        maxStarvationDelay = maxLoadingDelay - bitrateTestDelay;
3913        this.info(`bitrate test took ${Math.round(1000 * bitrateTestDelay)}ms, set first fragment max fetchDuration to ${Math.round(1000 * maxStarvationDelay)} ms`);
3914        // don't use conservative factor on bitrate test
3915        bwFactor = bwUpFactor = 1;
3916      }
3917    }
3918    const bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, maxStarvationDelay, bwFactor, bwUpFactor);
3919    if (this.rebufferNotice !== bestLevel) {
3920      this.rebufferNotice = bestLevel;
3921      this.info(`${bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty'}, optimal quality level ${bestLevel}`);
3922    }
3923    if (bestLevel > -1) {
3924      return bestLevel;
3925    }
3926    // If no matching level found, see if min auto level would be a better option
3927    const minLevel = hls.levels[minAutoLevel];
3928    const autoLevel = hls.loadLevelObj;
3929    if (autoLevel && (minLevel == null ? void 0 : minLevel.bitrate) < autoLevel.bitrate) {
3930      return minAutoLevel;
3931    }
3932    // or if bitrate is not lower, continue to use loadLevel
3933    return hls.loadLevel;
3934  }
3935  getStarvationDelay() {
3936    const hls = this.hls;
3937    const media = hls.media;
3938    if (!media) {
3939      return Infinity;
3940    }
3941    // playbackRate is the absolute value of the playback rate; if media.playbackRate is 0, we use 1 to load as
3942    // if we're playing back at the normal rate.
3943    const playbackRate = media && media.playbackRate !== 0 ? Math.abs(media.playbackRate) : 1.0;
3944    const bufferInfo = hls.mainForwardBufferInfo;
3945    return (bufferInfo ? bufferInfo.len : 0) / playbackRate;
3946  }
3947  getBwEstimate() {
3948    return this.bwEstimator.canEstimate() ? this.bwEstimator.getEstimate() : this.hls.config.abrEwmaDefaultEstimate;
3949  }
3950  findBestLevel(currentBw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, maxStarvationDelay, bwFactor, bwUpFactor) {
3951    var _this$hls$latestLevel;
3952    const maxFetchDuration = bufferStarvationDelay + maxStarvationDelay;
3953    const lastLoadedFragLevel = this.lastLoadedFragLevel;
3954    const selectionBaseLevel = lastLoadedFragLevel === -1 ? this.hls.firstLevel : lastLoadedFragLevel;
3955    const {
3956      fragCurrent,
3957      partCurrent
3958    } = this;
3959    const {
3960      levels,
3961      allAudioTracks,
3962      loadLevel,
3963      config
3964    } = this.hls;
3965    if (levels.length === 1) {
3966      return 0;
3967    }
3968    const level = levels[selectionBaseLevel];
3969    const live = !!((_this$hls$latestLevel = this.hls.latestLevelDetails) != null && _this$hls$latestLevel.live);
3970    const firstSelection = loadLevel === -1 || lastLoadedFragLevel === -1;
3971    let currentCodecSet;
3972    let currentVideoRange = 'SDR';
3973    let currentFrameRate = (level == null ? void 0 : level.frameRate) || 0;
3974    const {
3975      audioPreference,
3976      videoPreference
3977    } = config;
3978    const audioTracksByGroup = this.audioTracksByGroup || (this.audioTracksByGroup = getAudioTracksByGroup(allAudioTracks));
3979    let minStartIndex = -1;
3980    if (firstSelection) {
3981      if (this.firstSelection !== -1) {
3982        return this.firstSelection;
3983      }
3984      const codecTiers = this.codecTiers || (this.codecTiers = getCodecTiers(levels, audioTracksByGroup, minAutoLevel, maxAutoLevel));
3985      const startTier = getStartCodecTier(codecTiers, currentVideoRange, currentBw, audioPreference, videoPreference);
3986      const {
3987        codecSet,
3988        videoRanges,
3989        minFramerate,
3990        minBitrate,
3991        minIndex,
3992        preferHDR
3993      } = startTier;
3994      minStartIndex = minIndex;
3995      currentCodecSet = codecSet;
3996      currentVideoRange = preferHDR ? videoRanges[videoRanges.length - 1] : videoRanges[0];
3997      currentFrameRate = minFramerate;
3998      currentBw = Math.max(currentBw, minBitrate);
3999      this.log(`picked start tier ${stringify(startTier)}`);
4000    } else {
4001      currentCodecSet = level == null ? void 0 : level.codecSet;
4002      currentVideoRange = level == null ? void 0 : level.videoRange;
4003    }
4004    const currentFragDuration = partCurrent ? partCurrent.duration : fragCurrent ? fragCurrent.duration : 0;
4005    const ttfbEstimateSec = this.bwEstimator.getEstimateTTFB() / 1000;
4006    const levelsSkipped = [];
4007    for (let i = maxAutoLevel; i >= minAutoLevel; i--) {
4008      var _levelInfo$supportedR;
4009      const levelInfo = levels[i];
4010      const upSwitch = i > selectionBaseLevel;
4011      if (!levelInfo) {
4012        continue;
4013      }
4014      if (config.useMediaCapabilities && !levelInfo.supportedResult && !levelInfo.supportedPromise) {
4015        const mediaCapabilities = navigator.mediaCapabilities;
4016        if (typeof (mediaCapabilities == null ? void 0 : mediaCapabilities.decodingInfo) === 'function' && requiresMediaCapabilitiesDecodingInfo(levelInfo, audioTracksByGroup, currentVideoRange, currentFrameRate, currentBw, audioPreference)) {
4017          levelInfo.supportedPromise = getMediaDecodingInfoPromise(levelInfo, audioTracksByGroup, mediaCapabilities, this.supportedCache);
4018          levelInfo.supportedPromise.then(decodingInfo => {
4019            if (!this.hls) {
4020              return;
4021            }
4022            levelInfo.supportedResult = decodingInfo;
4023            const levels = this.hls.levels;
4024            const index = levels.indexOf(levelInfo);
4025            if (decodingInfo.error) {
4026              this.warn(`MediaCapabilities decodingInfo error: "${decodingInfo.error}" for level ${index} ${stringify(decodingInfo)}`);
4027            } else if (!decodingInfo.supported) {
4028              this.warn(`Unsupported MediaCapabilities decodingInfo result for level ${index} ${stringify(decodingInfo)}`);
4029              if (index > -1 && levels.length > 1) {
4030                this.log(`Removing unsupported level ${index}`);
4031                this.hls.removeLevel(index);
4032                if (this.hls.loadLevel === -1) {
4033                  this.hls.nextLoadLevel = 0;
4034                }
4035              }
4036            } else if (decodingInfo.decodingInfoResults.some(info => info.smooth === false || info.powerEfficient === false)) {
4037              this.log(`MediaCapabilities decodingInfo for level ${index} not smooth or powerEfficient: ${stringify(decodingInfo)}`);
4038            }
4039          }).catch(error => {
4040            this.warn(`Error handling MediaCapabilities decodingInfo: ${error}`);
4041          });
4042        } else {
4043          levelInfo.supportedResult = SUPPORTED_INFO_DEFAULT;
4044        }
4045      }
4046
4047      // skip candidates which change codec-family or video-range,
4048      // and which decrease or increase frame-rate for up and down-switch respectfully
4049      if (currentCodecSet && levelInfo.codecSet !== currentCodecSet || currentVideoRange && levelInfo.videoRange !== currentVideoRange || upSwitch && currentFrameRate > levelInfo.frameRate || !upSwitch && currentFrameRate > 0 && currentFrameRate < levelInfo.frameRate || (_levelInfo$supportedR = levelInfo.supportedResult) != null && (_levelInfo$supportedR = _levelInfo$supportedR.decodingInfoResults) != null && _levelInfo$supportedR.some(info => info.smooth === false)) {
4050        if (!firstSelection || i !== minStartIndex) {
4051          levelsSkipped.push(i);
4052          continue;
4053        }
4054      }
4055      const levelDetails = levelInfo.details;
4056      const avgDuration = (partCurrent ? levelDetails == null ? void 0 : levelDetails.partTarget : levelDetails == null ? void 0 : levelDetails.averagetargetduration) || currentFragDuration;
4057      let adjustedbw;
4058      // follow algorithm captured from stagefright :
4059      // https://android.googlesource.com/platform/frameworks/av/+/master/media/libstagefright/httplive/LiveSession.cpp
4060      // Pick the highest bandwidth stream below or equal to estimated bandwidth.
4061      // consider only 80% of the available bandwidth, but if we are switching up,
4062      // be even more conservative (70%) to avoid overestimating and immediately
4063      // switching back.
4064      if (!upSwitch) {
4065        adjustedbw = bwFactor * currentBw;
4066      } else {
4067        adjustedbw = bwUpFactor * currentBw;
4068      }
4069
4070      // Use average bitrate when starvation delay (buffer length) is gt or eq two segment durations and rebuffering is not expected (maxStarvationDelay > 0)
4071      const bitrate = currentFragDuration && bufferStarvationDelay >= currentFragDuration * 2 && maxStarvationDelay === 0 ? levelInfo.averageBitrate : levelInfo.maxBitrate;
4072      const fetchDuration = this.getTimeToLoadFrag(ttfbEstimateSec, adjustedbw, bitrate * avgDuration, levelDetails === undefined);
4073      const canSwitchWithinTolerance =
4074      // if adjusted bw is greater than level bitrate AND
4075      adjustedbw >= bitrate && (
4076      // no level change, or new level has no error history
4077      i === lastLoadedFragLevel || levelInfo.loadError === 0 && levelInfo.fragmentError === 0) && (
4078      // fragment fetchDuration unknown OR live stream OR fragment fetchDuration less than max allowed fetch duration, then this level matches
4079      // we don't account for max Fetch Duration for live streams, this is to avoid switching down when near the edge of live sliding window ...
4080      // special case to support startLevel = -1 (bitrateTest) on live streams : in that case we should not exit loop so that findBestLevel will return -1
4081      fetchDuration <= ttfbEstimateSec || !isFiniteNumber(fetchDuration) || live && !this.bitrateTestDelay || fetchDuration < maxFetchDuration);
4082      if (canSwitchWithinTolerance) {
4083        const forcedAutoLevel = this.forcedAutoLevel;
4084        if (i !== loadLevel && (forcedAutoLevel === -1 || forcedAutoLevel !== loadLevel)) {
4085          if (levelsSkipped.length) {
4086            this.trace(`Skipped level(s) ${levelsSkipped.join(',')} of ${maxAutoLevel} max with CODECS and VIDEO-RANGE:"${levels[levelsSkipped[0]].codecs}" ${levels[levelsSkipped[0]].videoRange}; not compatible with "${currentCodecSet}" ${currentVideoRange}`);
4087          }
4088          this.info(`switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${levelInfo.codecSet} videoRange:${levelInfo.videoRange} hls.loadLevel:${loadLevel}`);
4089        }
4090        if (firstSelection) {
4091          this.firstSelection = i;
4092        }
4093        // as we are looping from highest to lowest, this will return the best achievable quality level
4094        return i;
4095      }
4096    }
4097    // not enough time budget even with quality level 0 ... rebuffering might happen
4098    return -1;
4099  }
4100  set nextAutoLevel(nextLevel) {
4101    const value = this.deriveNextAutoLevel(nextLevel);
4102    if (this._nextAutoLevel !== value) {
4103      this.nextAutoLevelKey = '';
4104      this._nextAutoLevel = value;
4105    }
4106  }
4107  deriveNextAutoLevel(nextLevel) {
4108    const {
4109      maxAutoLevel,
4110      minAutoLevel
4111    } = this.hls;
4112    return Math.min(Math.max(nextLevel, minAutoLevel), maxAutoLevel);
4113  }
4114}
4115
4116const BinarySearch = {
4117  /**
4118   * Searches for an item in an array which matches a certain condition.
4119   * This requires the condition to only match one item in the array,
4120   * and for the array to be ordered.
4121   *
4122   * @param list The array to search.
4123   * @param comparisonFn
4124   *      Called and provided a candidate item as the first argument.
4125   *      Should return:
4126   *          > -1 if the item should be located at a lower index than the provided item.
4127   *          > 1 if the item should be located at a higher index than the provided item.
4128   *          > 0 if the item is the item you're looking for.
4129   *
4130   * @returns the object if found, otherwise returns null
4131   */
4132  search: function (list, comparisonFn) {
4133    let minIndex = 0;
4134    let maxIndex = list.length - 1;
4135    let currentIndex = null;
4136    let currentElement = null;
4137    while (minIndex <= maxIndex) {
4138      currentIndex = (minIndex + maxIndex) / 2 | 0;
4139      currentElement = list[currentIndex];
4140      const comparisonResult = comparisonFn(currentElement);
4141      if (comparisonResult > 0) {
4142        minIndex = currentIndex + 1;
4143      } else if (comparisonResult < 0) {
4144        maxIndex = currentIndex - 1;
4145      } else {
4146        return currentElement;
4147      }
4148    }
4149    return null;
4150  }
4151};
4152
4153/**
4154 * Returns first fragment whose endPdt value exceeds the given PDT, or null.
4155 * @param fragments - The array of candidate fragments
4156 * @param PDTValue - The PDT value which must be exceeded
4157 * @param maxFragLookUpTolerance - The amount of time that a fragment's start/end can be within in order to be considered contiguous
4158 */
4159function findFragmentByPDT(fragments, PDTValue, maxFragLookUpTolerance) {
4160  if (PDTValue === null || !Array.isArray(fragments) || !fragments.length || !isFiniteNumber(PDTValue)) {
4161    return null;
4162  }
4163
4164  // if less than start
4165  const startPDT = fragments[0].programDateTime;
4166  if (PDTValue < (startPDT || 0)) {
4167    return null;
4168  }
4169  const endPDT = fragments[fragments.length - 1].endProgramDateTime;
4170  if (PDTValue >= (endPDT || 0)) {
4171    return null;
4172  }
4173  for (let seg = 0; seg < fragments.length; ++seg) {
4174    const frag = fragments[seg];
4175    if (pdtWithinToleranceTest(PDTValue, maxFragLookUpTolerance, frag)) {
4176      return frag;
4177    }
4178  }
4179  return null;
4180}
4181
4182/**
4183 * Finds a fragment based on the SN of the previous fragment; or based on the needs of the current buffer.
4184 * This method compensates for small buffer gaps by applying a tolerance to the start of any candidate fragment, thus
4185 * breaking any traps which would cause the same fragment to be continuously selected within a small range.
4186 * @param fragPrevious - The last frag successfully appended
4187 * @param fragments - The array of candidate fragments
4188 * @param bufferEnd - The end of the contiguous buffered range the playhead is currently within
4189 * @param maxFragLookUpTolerance - The amount of time that a fragment's start/end can be within in order to be considered contiguous
4190 * @returns a matching fragment or null
4191 */
4192function findFragmentByPTS(fragPrevious, fragments, bufferEnd = 0, maxFragLookUpTolerance = 0, nextFragLookupTolerance = 0.005) {
4193  let fragNext = null;
4194  if (fragPrevious) {
4195    fragNext = fragments[1 + fragPrevious.sn - fragments[0].sn] || null;
4196    // check for buffer-end rounding error
4197    const bufferEdgeError = fragPrevious.endDTS - bufferEnd;
4198    if (bufferEdgeError > 0 && bufferEdgeError < 0.0000015) {
4199      bufferEnd += 0.0000015;
4200    }
4201    if (fragNext && fragPrevious.level !== fragNext.level && fragNext.end <= fragPrevious.end) {
4202      fragNext = fragments[2 + fragPrevious.sn - fragments[0].sn] || null;
4203    }
4204  } else if (bufferEnd === 0 && fragments[0].start === 0) {
4205    fragNext = fragments[0];
4206  }
4207  // Prefer the next fragment if it's within tolerance
4208  if (fragNext && ((!fragPrevious || fragPrevious.level === fragNext.level) && fragmentWithinToleranceTest(bufferEnd, maxFragLookUpTolerance, fragNext) === 0 || fragmentWithinFastStartSwitch(fragNext, fragPrevious, Math.min(nextFragLookupTolerance, maxFragLookUpTolerance)))) {
4209    return fragNext;
4210  }
4211  // We might be seeking past the tolerance so find the best match
4212  const foundFragment = BinarySearch.search(fragments, fragmentWithinToleranceTest.bind(null, bufferEnd, maxFragLookUpTolerance));
4213  if (foundFragment && (foundFragment !== fragPrevious || !fragNext)) {
4214    return foundFragment;
4215  }
4216  // If no match was found return the next fragment after fragPrevious, or null
4217  return fragNext;
4218}
4219function fragmentWithinFastStartSwitch(fragNext, fragPrevious, nextFragLookupTolerance) {
4220  if (fragPrevious && fragPrevious.start === 0 && fragPrevious.level < fragNext.level && (fragPrevious.endPTS || 0) > 0) {
4221    const firstDuration = fragPrevious.tagList.reduce((duration, tag) => {
4222      if (tag[0] === 'INF') {
4223        duration += parseFloat(tag[1]);
4224      }
4225      return duration;
4226    }, nextFragLookupTolerance);
4227    return fragNext.start <= firstDuration;
4228  }
4229  return false;
4230}
4231
4232/**
4233 * The test function used by the findFragmentBySn's BinarySearch to look for the best match to the current buffer conditions.
4234 * @param candidate - The fragment to test
4235 * @param bufferEnd - The end of the current buffered range the playhead is currently within
4236 * @param maxFragLookUpTolerance - The amount of time that a fragment's start can be within in order to be considered contiguous
4237 * @returns 0 if it matches, 1 if too low, -1 if too high
4238 */
4239function fragmentWithinToleranceTest(bufferEnd = 0, maxFragLookUpTolerance = 0, candidate) {
4240  // eagerly accept an accurate match (no tolerance)
4241  if (candidate.start <= bufferEnd && candidate.start + candidate.duration > bufferEnd) {
4242    return 0;
4243  }
4244  // offset should be within fragment boundary - config.maxFragLookUpTolerance
4245  // this is to cope with situations like
4246  // bufferEnd = 9.991
4247  // frag[Ø] : [0,10]
4248  // frag[1] : [10,20]
4249  // bufferEnd is within frag[0] range ... although what we are expecting is to return frag[1] here
4250  //              frag start               frag start+duration
4251  //                  |-----------------------------|
4252  //              <--->                         <--->
4253  //  ...--------><-----------------------------><---------....
4254  // previous frag         matching fragment         next frag
4255  //  return -1             return 0                 return 1
4256  // logger.log(`level/sn/start/end/bufEnd:${level}/${candidate.sn}/${candidate.start}/${(candidate.start+candidate.duration)}/${bufferEnd}`);
4257  // Set the lookup tolerance to be small enough to detect the current segment - ensures we don't skip over very small segments
4258  const candidateLookupTolerance = Math.min(maxFragLookUpTolerance, candidate.duration + (candidate.deltaPTS ? candidate.deltaPTS : 0));
4259  if (candidate.start + candidate.duration - candidateLookupTolerance <= bufferEnd) {
4260    return 1;
4261  } else if (candidate.start - candidateLookupTolerance > bufferEnd && candidate.start) {
4262    // if maxFragLookUpTolerance will have negative value then don't return -1 for first element
4263    return -1;
4264  }
4265  return 0;
4266}
4267
4268/**
4269 * The test function used by the findFragmentByPdt's BinarySearch to look for the best match to the current buffer conditions.
4270 * This function tests the candidate's program date time values, as represented in Unix time
4271 * @param candidate - The fragment to test
4272 * @param pdtBufferEnd - The Unix time representing the end of the current buffered range
4273 * @param maxFragLookUpTolerance - The amount of time that a fragment's start can be within in order to be considered contiguous
4274 * @returns true if contiguous, false otherwise
4275 */
4276function pdtWithinToleranceTest(pdtBufferEnd, maxFragLookUpTolerance, candidate) {
4277  const candidateLookupTolerance = Math.min(maxFragLookUpTolerance, candidate.duration + (candidate.deltaPTS ? candidate.deltaPTS : 0)) * 1000;
4278
4279  // endProgramDateTime can be null, default to zero
4280  const endProgramDateTime = candidate.endProgramDateTime || 0;
4281  return endProgramDateTime - candidateLookupTolerance > pdtBufferEnd;
4282}
4283function findNearestWithCC(details, cc, pos) {
4284  if (details) {
4285    if (details.startCC <= cc && details.endCC >= cc) {
4286      let fragments = details.fragments;
4287      const {
4288        fragmentHint
4289      } = details;
4290      if (fragmentHint) {
4291        fragments = fragments.concat(fragmentHint);
4292      }
4293      let closest;
4294      BinarySearch.search(fragments, candidate => {
4295        if (candidate.cc < cc) {
4296          return 1;
4297        }
4298        if (candidate.cc > cc) {
4299          return -1;
4300        }
4301        closest = candidate;
4302        if (candidate.end <= pos) {
4303          return 1;
4304        }
4305        if (candidate.start > pos) {
4306          return -1;
4307        }
4308        return 0;
4309      });
4310      return closest || null;
4311    }
4312  }
4313  return null;
4314}
4315
4316function isTimeoutError(error) {
4317  switch (error.details) {
4318    case ErrorDetails.FRAG_LOAD_TIMEOUT:
4319    case ErrorDetails.KEY_LOAD_TIMEOUT:
4320    case ErrorDetails.LEVEL_LOAD_TIMEOUT:
4321    case ErrorDetails.MANIFEST_LOAD_TIMEOUT:
4322      return true;
4323  }
4324  return false;