https://www.ananey.com/wp-content/themes/whitewebworx/js/hls.js?ver=1790361172

46 i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
47function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
48function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
49function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66// If possible, keep hlsDefaultConfig shallow
67// It is cloned whenever a new Hls instance is created, by keeping the config
68// shallow the properties are cloned, and we don't end up manipulating the default
69var hlsDefaultConfig = _objectSpread(_objectSpread({
70  autoStartLoad: true,
71  // used by stream-controller
72  startPosition: -1,
73  // used by stream-controller
74  defaultAudioCodec: undefined,
75  // used by stream-controller
76  debug: false,
77  // used by logger
78  capLevelOnFPSDrop: false,
79  // used by fps-controller
80  capLevelToPlayerSize: false,
81  // used by cap-level-controller
82  ignoreDevicePixelRatio: false,
83  // used by cap-level-controller
84  initialLiveManifestSize: 1,
85  // used by stream-controller
86  maxBufferLength: 30,
87  // used by stream-controller
88  backBufferLength: Infinity,
89  // used by buffer-controller
90  maxBufferSize: 60 * 1000 * 1000,
91  // used by stream-controller
92  maxBufferHole: 0.1,
93  // used by stream-controller
94  highBufferWatchdogPeriod: 2,
95  // used by stream-controller
96  nudgeOffset: 0.1,
97  // used by stream-controller
98  nudgeMaxRetry: 3,
99  // used by stream-controller
100  maxFragLookUpTolerance: 0.25,
101  // used by stream-controller
102  liveSyncDurationCount: 3,
103  // used by latency-controller
104  liveMaxLatencyDurationCount: Infinity,
105  // used by latency-controller
106  liveSyncDuration: undefined,
107  // used by latency-controller
108  liveMaxLatencyDuration: undefined,
109  // used by latency-controller
110  maxLiveSyncPlaybackRate: 1,
111  // used by latency-controller
112  liveDurationInfinity: false,
113  // used by buffer-controller
114  liveBackBufferLength: null,
115  // used by buffer-controller
116  maxMaxBufferLength: 600,
117  // used by stream-controller
118  enableWorker: true,
119  // used by demuxer
120  enableSoftwareAES: true,
121  // used by decrypter
122  manifestLoadingTimeOut: 10000,
123  // used by playlist-loader
124  manifestLoadingMaxRetry: 1,
125  // used by playlist-loader
126  manifestLoadingRetryDelay: 1000,
127  // used by playlist-loader
128  manifestLoadingMaxRetryTimeout: 64000,
129  // used by playlist-loader
130  startLevel: undefined,
131  // used by level-controller
132  levelLoadingTimeOut: 10000,
133  // used by playlist-loader
134  levelLoadingMaxRetry: 4,
135  // used by playlist-loader
136  levelLoadingRetryDelay: 1000,
137  // used by playlist-loader
138  levelLoadingMaxRetryTimeout: 64000,
139  // used by playlist-loader
140  fragLoadingTimeOut: 20000,
141  // used by fragment-loader
142  fragLoadingMaxRetry: 6,
143  // used by fragment-loader
144  fragLoadingRetryDelay: 1000,
145  // used by fragment-loader
146  fragLoadingMaxRetryTimeout: 64000,
147  // used by fragment-loader
148  startFragPrefetch: false,
149  // used by stream-controller
150  fpsDroppedMonitoringPeriod: 5000,
151  // used by fps-controller
152  fpsDroppedMonitoringThreshold: 0.2,
153  // used by fps-controller
154  appendErrorMaxRetry: 3,
155  // used by buffer-controller
156  loader: _utils_xhr_loader__WEBPACK_IMPORTED_MODULE_11__["default"],
157  // loader: FetchLoader,
158  fLoader: undefined,
159  // used by fragment-loader
160  pLoader: undefined,
161  // used by playlist-loader
162  xhrSetup: undefined,
163  // used by xhr-loader
164  licenseXhrSetup: undefined,
165  // used by eme-controller
166  licenseResponseCallback: undefined,
167  // used by eme-controller
168  abrController: _controller_abr_controller__WEBPACK_IMPORTED_MODULE_0__["default"],
169  bufferController: _controller_buffer_controller__WEBPACK_IMPORTED_MODULE_5__["default"],
170  capLevelController: _controller_cap_level_controller__WEBPACK_IMPORTED_MODULE_7__["default"],
171  fpsController: _controller_fps_controller__WEBPACK_IMPORTED_MODULE_8__["default"],
172  stretchShortVideoTrack: false,
173  // used by mp4-remuxer
174  maxAudioFramesDrift: 1,
175  // used by mp4-remuxer
176  forceKeyFrameOnDiscontinuity: true,
177  // used by ts-demuxer
178  abrEwmaFastLive: 3,
179  // used by abr-controller
180  abrEwmaSlowLive: 9,
181  // used by abr-controller
182  abrEwmaFastVoD: 3,
183  // used by abr-controller
184  abrEwmaSlowVoD: 9,
185  // used by abr-controller
186  abrEwmaDefaultEstimate: 5e5,
187  // 500 kbps  // used by abr-controller
188  abrBandWidthFactor: 0.95,
189  // used by abr-controller
190  abrBandWidthUpFactor: 0.7,
191  // used by abr-controller

279__.logger.log('[config]: Progressive streaming enabled, using FetchLoader');
280    }
281  }
282}
283
284/***/ }),
285
286/***/ "./src/controller/abr-controller.ts":
287/*!******************************************!*\
288  !*** ./src/controller/abr-controller.ts ***!
289  \******************************************/
290/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
291
292"use strict";
293__webpack_require__.r(__webpack_exports__);
294/* harmony export */ __webpack_require__.d(__webpack_exports__, {
295/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
296/* harmony export */ });
297/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
298/* harmony import */ var _utils_ewma_bandwidth_estimator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils/ewma-bandwidth-estimator */ "./src/utils/ewma-bandwidth-estimator.ts");
299/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../events */ "./src/events.ts");
300/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
301/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
302/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
303
304
305
306function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
307function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
308function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
309function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
310
311
312
313
314
315var AbrController = /*#__PURE__*/function () {
316  function AbrController(hls) {
317    this.hls = void 0;
318    this.lastLoadedFragLevel = 0;
319    this._nextAutoLevel = -1;
320    this.timer = void 0;
321    this.onCheck = this._abandonRulesCheck.bind(this);
322    this.fragCurrent = null;
323    this.partCurrent = null;
324    this.bitrateTestDelay = 0;
325    this.bwEstimator = void 0;
326    this.hls = hls;
327    var config = hls.config;
328    this.bwEstimator = new _utils_ewma_bandwidth_estimator__WEBPACK_IMPORTED_MODULE_1__["default"](config.abrEwmaSlowVoD, config.abrEwmaFastVoD, config.abrEwmaDefaultEstimate);
329    this.registerListeners();
330  }
331  var _proto = AbrController.prototype;
332  _proto.registerListeners = function registerListeners() {
333    var hls = this.hls;
334    hls.on(_events__WEBPACK_IMPORTED_MODULE_2__.Events.FRAG_LOADING, this.onFragLoading, this);
335    hls.on(_events__WEBPACK_IMPORTED_MODULE_2__.Events.FRAG_LOADED, this.onFragLoaded, this);
336    hls.on(_events__WEBPACK_IMPORTED_MODULE_2__.Events.FRAG_BUFFERED, this.onFragBuffered, this);
337    hls.on(_events__WEBPACK_IMPORTED_MODULE_2__.Events.LEVEL_LOADED, this.onLevelLoaded, this);
338    hls.on(_events__WEBPACK_IMPORTED_MODULE_2__.Events.ERROR, this.onError, this);
339  };
340  _proto.unregisterListeners = function unregisterListeners() {
341    var hls = this.hls;
342    hls.off(_events__WEBPACK_IMPORTED_MODULE_2__.Events.FRAG_LOADING, this.onFragLoading, this);
343    hls.off(_events__WEBPACK_IMPORTED_MODULE_2__.Events.FRAG_LOADED, this.onFragLoaded, this);
344    hls.off(_events__WEBPACK_IMPORTED_MODULE_2__.Events.FRAG_BUFFERED, this.onFragBuffered, this);
345    hls.off(_events__WEBPACK_IMPORTED_MODULE_2__.Events.LEVEL_LOADED, this.onLevelLoaded, this);
346    hls.off(_events__WEBPACK_IMPORTED_MODULE_2__.Events.ERROR, this.onError, this);
347  };
348  _proto.destroy = function destroy() {
349    this.unregisterListeners();
350    this.clearTimer();
351    // @ts-ignore
352    this.hls = this.onCheck = null;
353    this.fragCurrent = this.partCurrent = null;
354  };
355  _proto.onFragLoading = function onFragLoading(event, data) {
356    var frag = data.frag;
357    if (frag.type === _types_loader__WEBPACK_IMPORTED_MODULE_4__.PlaylistLevelType.MAIN) {
358      if (!this.timer) {
359        var _data$part;
360        this.fragCurrent = frag;
361        this.partCurrent = (_data$part = data.part) != null ? _data$part : null;
362        this.timer = self.setInterval(this.onCheck, 100);
363      }
364    }
365  };
366  _proto.onLevelLoaded = function onLevelLoaded(event, data) {
367    var config = this.hls.config;
368    if (data.details.live) {
369      this.bwEstimator.update(config.abrEwmaSlowLive, config.abrEwmaFastLive);
370    } else {
371      this.bwEstimator.update(config.abrEwmaSlowVoD, config.abrEwmaFastVoD);
372    }
373  }
374
375  /*
376      This method monitors the download rate of the current fragment, and will downswitch if that fragment will not load
377      quickly enough to prevent underbuffering
378    */;
379  _proto._abandonRulesCheck = function _abandonRulesCheck() {
380    var frag = this.fragCurrent,
381      part = this.partCurrent,
382      hls = this.hls;
383    var autoLevelEnabled = hls.autoLevelEnabled,
384      media = hls.media;
385    if (!frag || !media) {
386      return;
387    }
388    var stats = part ? part.stats : frag.stats;
389    var duration = part ? part.duration : frag.duration;
390    // If frag loading is aborted, complete, or from lowest level, stop timer and return
391    if (stats.aborted || stats.loaded && stats.loaded === stats.total || frag.level === 0) {
392      this.clearTimer();
393      // reset forced auto level value so that next level will be selected
394      this._nextAutoLevel = -1;
395      return;
396    }
397
398    // This check only runs if we're in ABR mode and actually playing
399    if (!autoLevelEnabled || media.paused || !media.playbackRate || !media.readyState) {
400      return;
401    }
402    var bufferInfo = hls.mainForwardBufferInfo;
403    if (bufferInfo === null) {
404      return;
405    }
406    var requestDelay = performance.now() - stats.loading.start;
407    var playbackRate = Math.abs(media.playbackRate);
408    // In order to work with a stable bandwidth, only begin monitoring bandwidth after half of the fragment has been loaded
409    if (requestDelay <= 500 * duration / playbackRate) {
410      return;
411    }
412    var loadedFirstByte = stats.loaded && stats.loading.first;
413    var bwEstimate = this.bwEstimator.getEstimate();
414    var levels = hls.levels,
415      minAutoLevel = hls.minAutoLevel;
416    var level = levels[frag.level];
417    var expectedLen = stats.total || Math.max(stats.loaded, Math.round(duration * level.maxBitrate / 8));
418    var loadRate = loadedFirstByte ? stats.loaded * 1000 / requestDelay : 0;
419
420    // fragLoadDelay is an estimate of the time (in seconds) it will take to buffer the remainder of the fragment
421    var fragLoadedDelay = loadRate ? (expectedLen - stats.loaded) / loadRate : expectedLen * 8 / bwEstimate;
422
423    // bufferStarvationDelay is an estimate of the amount time (in seconds) it will take to exhaust the buffer
424    var bufferStarvationDelay = bufferInfo.len / playbackRate;
425
426    // Only downswitch if the time to finish loading the current fragment is greater than the amount of buffer left
427    if (fragLoadedDelay <= bufferStarvationDelay) {
428      return;
429    }
430    var fragLevelNextLoadedDelay = Number.POSITIVE_INFINITY;
431    var nextLoadLevel;
432    // Iterate through lower level and try to find the largest one that avoids rebuffering
433    for (nextLoadLevel = frag.level - 1; nextLoadLevel > minAutoLevel; nextLoadLevel--) {
434      // compute time to load next fragment at lower level
435      // 0.8 : consider only 80% of current bw to be conservative
436      // 8 = bits per byte (bps/Bps)
437      var levelNextBitrate = levels[nextLoadLevel].maxBitrate;
438      fragLevelNextLoadedDelay = loadRate ? duration * levelNextBitrate / (8 * 0.8 * loadRate) : duration * levelNextBitrate / bwEstimate;
439      if (fragLevelNextLoadedDelay < bufferStarvationDelay) {
440        break;
441      }
442    }
443    // Only emergency switch down if it takes less time to load a new fragment at lowest level instead of continuing
444    // to load the current one
445    if (fragLevelNextLoadedDelay >= fragLoadedDelay) {
446      return;
447    }
448    _utils_logger__WEBPACK_IMPORTED_MODULE_5__.logger.warn("Fragment " + frag.sn + (part ? ' part ' + part.index : '') + " of level " + frag.level + " is loading too slowly and will cause an underbuffer; aborting and switching to level " + nextLoadLevel + "\n      Current BW estimate: " + ((0,_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__.isFiniteNumber)(bwEstimate) ? (bwEstimate / 1024).toFixed(3) : 'Unknown') + " Kb/s\n      Estimated load time for current fragment: " + fragLoadedDelay.toFixed(3) + " s\n      Estimated load time for the next fragment: " + fragLevelNextLoadedDelay.toFixed(3) + " s\n      Time to underbuffer: " + bufferStarvationDelay.toFixed(3) + " s");
449    hls.nextLoadLevel = nextLoadLevel;
450    if (loadedFirstByte) {
451      // If there has been loading progress, sample bandwidth
452      this.bwEstimator.sample(requestDelay, stats.loaded);
453    }
454    this.clearTimer();
455    if (frag.loader || frag.keyLoader) {
456      this.fragCurrent = this.partCurrent = null;
457      frag.abortRequests();
458    }
459    hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__.Events.FRAG_LOAD_EMERGENCY_ABORTED, {
460      frag: frag,
461      part: part,
462      stats: stats
463    });
464  };
465  _proto.onFragLoaded = function onFragLoaded(event, _ref) {
466    var frag = _ref.frag,
467      part = _ref.part;
468    if (frag.type === _types_loader__WEBPACK_IMPORTED_MODULE_4__.PlaylistLevelType.MAIN && (0,_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__.isFiniteNumber)(frag.sn)) {
469      var stats = part ? part.stats : frag.stats;
470      var duration = part ? part.duration : frag.duration;
471      // stop monitoring bw once frag loaded
472      this.clearTimer();
473      // store level id after successful fragment load
474      this.lastLoadedFragLevel = frag.level;
475      // reset forced auto level value so that next level will be selected
476      this._nextAutoLevel = -1;
477
478      // compute level average bitrate
479      if (this.hls.config.abrMaxWithRealBitrate) {
480        var level = this.hls.levels[frag.level];
481        var loadedBytes = (level.loaded ? level.loaded.bytes : 0) + stats.loaded;
482        var loadedDuration = (level.loaded ? level.loaded.duration : 0) + duration;
483        level.loaded = {
484          bytes: loadedBytes,
485          duration: loadedDuration
486        };
487        level.realBitrate = Math.round(8 * loadedBytes / loadedDuration);
488      }
489      if (frag.bitrateTest) {
490        var fragBufferedData = {
491          stats: stats,
492          frag: frag,
493          part: part,
494          id: frag.type
495        };
496        this.onFragBuffered(_events__WEBPACK_IMPORTED_MODULE_2__.Events.FRAG_BUFFERED, fragBufferedData);
497      }
498    }
499  };
500  _proto.onFragBuffered = function onFragBuffered(event, data) {
501    var frag = data.frag,
502      part = data.part;
503    var stats = part ? part.stats : frag.stats;
504    if (stats.aborted) {
505      return;
506    }
507    // Only count non-alt-audio frags which were actually buffered in our BW calculations
508    if (frag.type !== _types_loader__WEBPACK_IMPORTED_MODULE_4__.PlaylistLevelType.MAIN || frag.sn === 'initSegment') {
509      return;
510    }
511    // Use the difference between parsing and request instead of buffering and request to compute fragLoadingProcessing;
512    // rationale is that buffer appending only happens once media is attached. This can happen when config.startFragPrefetch
513    // is used. If we used buffering in that case, our BW estimate sample will be very large.
514    var processingMs = stats.parsing.end - stats.loading.start;
515    this.bwEstimator.sample(processingMs, stats.loaded);
516    stats.bwEstimate = this.bwEstimator.getEstimate();
517    if (frag.bitrateTest) {
518      this.bitrateTestDelay = processingMs / 1000;
519    } else {
520      this.bitrateTestDelay = 0;
521    }
522  };
523  _proto.onError = function onError(event, data) {
524    var _data$frag;
525    // stop timer in case of frag loading error
526    if (((_data$frag = data.frag) === null || _data$frag === void 0 ? void 0 : _data$frag.type) === _types_loader__WEBPACK_IMPORTED_MODULE_4__.PlaylistLevelType.MAIN) {
527      if (data.type === _errors__WEBPACK_IMPORTED_MODULE_3__.ErrorTypes.KEY_SYSTEM_ERROR) {
528        this.clearTimer();
529        return;
530      }
531      switch (data.details) {
532        case _errors__WEBPACK_IMPORTED_MODULE_3__.ErrorDetails.FRAG_LOAD_ERROR:
533        case _errors__WEBPACK_IMPORTED_MODULE_3__.ErrorDetails.FRAG_LOAD_TIMEOUT:
534        case _errors__WEBPACK_IMPORTED_MODULE_3__.ErrorDetails.KEY_LOAD_ERROR:
535        case _errors__WEBPACK_IMPORTED_MODULE_3__.ErrorDetails.KEY_LOAD_TIMEOUT:
536          this.clearTimer();
537          break;
538        default:
539          break;
540      }
541    }
542  };
543  _proto.clearTimer = function clearTimer() {
544    self.clearInterval(this.timer);
545    this.timer = undefined;
546  }
547
548  // return next auto level
549  ;
550  _proto.getNextABRAutoLevel = function getNextABRAutoLevel() {
551    var fragCurrent = this.fragCurrent,
552      partCurrent = this.partCurrent,
553      hls = this.hls;
554    var maxAutoLevel = hls.maxAutoLevel,
555      config = hls.config,
556      minAutoLevel = hls.minAutoLevel,
557      media = hls.media;
558    var currentFragDuration = partCurrent ? partCurrent.duration : fragCurrent ? fragCurrent.duration : 0;
559
560    // playbackRate is the absolute value of the playback rate; if media.playbackRate is 0, we use 1 to load as
561    // if we're playing back at the normal rate.
562    var playbackRate = media && media.playbackRate !== 0 ? Math.abs(media.playbackRate) : 1.0;
563    var avgbw = this.bwEstimator ? this.bwEstimator.getEstimate() : config.abrEwmaDefaultEstimate;
564    // bufferStarvationDelay is the wall-clock time left until the playback buffer is exhausted.
565    var bufferInfo = hls.mainForwardBufferInfo;
566    var bufferStarvationDelay = (bufferInfo ? bufferInfo.len : 0) / playbackRate;
567
568    // First, look to see if we can find a level matching with our avg bandwidth AND that could also guarantee no rebuffering at all
569    var bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, config.abrBandWidthFactor, config.abrBandWidthUpFactor);
570    if (bestLevel >= 0) {
571      return bestLevel;
572    }
573    _utils_logger__WEBPACK_IMPORTED_MODULE_5__.logger.trace((bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty') + ", finding optimal quality level");
574    // not possible to get rid of rebuffering ... let's try to find level that will guarantee less than maxStarvationDelay of rebuffering
575    // if no matching level found, logic will return 0
576    var maxStarvationDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxStarvationDelay) : config.maxStarvationDelay;
577    var bwFactor = config.abrBandWidthFactor;
578    var bwUpFactor = config.abrBandWidthUpFactor;
579    if (!bufferStarvationDelay) {
580      // in case buffer is empty, let's check if previous fragment was loaded to perform a bitrate test
581      var bitrateTestDelay = this.bitrateTestDelay;
582      if (bitrateTestDelay) {
583        // if it is the case, then we need to adjust our max starvation delay using maxLoadingDelay config value
584        // max video loading delay used in  automatic start level selection :
585        // in that mode ABR controller will ensure that video loading time (ie the time to fetch the first fragment at lowest quality level +
586        // the time to fetch the fragment at the appropriate quality level is less than ```maxLoadingDelay``` )
587        // cap maxLoadingDelay and ensure it is not bigger 'than bitrate test' frag duration
588        var maxLoadingDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxLoadingDelay) : config.maxLoadingDelay;
589        maxStarvationDelay = maxLoadingDelay - bitrateTestDelay;
590        _utils_logger__WEBPACK_IMPORTED_MODULE_5__.logger.trace("bitrate test took " + Math.round(1000 * bitrateTestDelay) + "ms, set first fragment max fetchDuration to " + Math.round(1000 * maxStarvationDelay) + " ms");
591        // don't use conservative factor on bitrate test
592        bwFactor = bwUpFactor = 1;
593      }
594    }
595    bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay + maxStarvationDelay, bwFactor, bwUpFactor);
596    return Math.max(bestLevel, 0);
597  };
598  _proto.findBestLevel = function findBestLevel(currentBw, minAutoLevel, maxAutoLevel, maxFetchDuration, bwFactor, bwUpFactor) {
599    var _level$details;
600    var fragCurrent = this.fragCurrent,
601      partCurrent = this.partCurrent,
602      currentLevel = this.lastLoadedFragLevel;
603    var levels = this.hls.levels;
604    var level = levels[currentLevel];
605    var live = !!(level !== null && level !== void 0 && (_level$details = level.details) !== null && _level$details !== void 0 && _level$details.live);
606    var currentCodecSet = level === null || level === void 0 ? void 0 : level.codecSet;
607    var currentFragDuration = partCurrent ? partCurrent.duration : fragCurrent ? fragCurrent.duration : 0;
608    for (var i = maxAutoLevel; i >= minAutoLevel; i--) {
609      var levelInfo = levels[i];
610      if (!levelInfo || currentCodecSet && levelInfo.codecSet !== currentCodecSet) {
611        continue;
612      }
613      var levelDetails = levelInfo.details;
614      var avgDuration = (partCurrent ? levelDetails === null || levelDetails === void 0 ? void 0 : levelDetails.partTarget : levelDetails === null || levelDetails === void 0 ? void 0 : levelDetails.averagetargetduration) || currentFragDuration;
615      var adjustedbw = void 0;
616      // follow algorithm captured from stagefright :
617      // https://android.googlesource.com/platform/frameworks/av/+/master/media/libstagefright/httplive/LiveSession.cpp
618      // Pick the highest bandwidth stream below or equal to estimated bandwidth.
619      // consider only 80% of the available bandwidth, but if we are switching up,
620      // be even more conservative (70%) to avoid overestimating and immediately
621      // switching back.
622      if (i <= currentLevel) {
623        adjustedbw = bwFactor * currentBw;
624      } else {
625        adjustedbw = bwUpFactor * currentBw;
626      }
627      var bitrate = levels[i].maxBitrate;
628      var fetchDuration = bitrate * avgDuration / adjustedbw;
629      _utils_logger__WEBPACK_IMPORTED_MODULE_5__.logger.trace("level/adjustedbw/bitrate/avgDuration/maxFetchDuration/fetchDuration: " + i + "/" + Math.round(adjustedbw) + "/" + bitrate + "/" + avgDuration + "/" + maxFetchDuration + "/" + fetchDuration);
630      // if adjusted bw is greater than level bitrate AND
631      if (adjustedbw > bitrate && (
632      // fragment fetchDuration unknown OR live stream OR fragment fetchDuration less than max allowed fetch duration, then this level matches
633      // 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 ...
634      // special case to support startLevel = -1 (bitrateTest) on live streams : in that case we should not exit loop so that findBestLevel will return -1
635      fetchDuration === 0 || !(0,_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__.isFiniteNumber)(fetchDuration) || live && !this.bitrateTestDelay || fetchDuration < maxFetchDuration)) {
636        // as we are looping from highest to lowest, this will return the best achievable quality level
637        return i;
638      }
639    }
640    // not enough time budget even with quality level 0 ... rebuffering might happen
641    return -1;
642  };
643  _createClass(AbrController, [{
644    key: "nextAutoLevel",
645    get: function get() {
646      var forcedAutoLevel = this._nextAutoLevel;
647      var bwEstimator = this.bwEstimator;
648      // in case next auto level has been forced, and bw not available or not reliable, return forced value
649      if (forcedAutoLevel !== -1 && !bwEstimator.canEstimate()) {
650        return forcedAutoLevel;
651      }
652
653      // compute next level using ABR logic
654      var nextABRAutoLevel = this.getNextABRAutoLevel();
655      // use forced auto level when ABR selected level has errored
656      if (forcedAutoLevel !== -1 && this.hls.levels[nextABRAutoLevel].loadError) {
657        return forcedAutoLevel;
658      }
659      // if forced auto level has been defined, use it to cap ABR computed quality level
660      if (forcedAutoLevel !== -1) {
661        nextABRAutoLevel = Math.min(forcedAutoLevel, nextABRAutoLevel);
662      }
663      return nextABRAutoLevel;
664    },
665    set: function set(nextLevel) {
666      this._nextAutoLevel = nextLevel;
667    }
668  }]);
669  return AbrController;
670}();
671/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (AbrController);
672
673/***/ }),
674
675/***/ "./src/controller/

675audio-stream-controller.ts":
676/*!***************************************************!*\
677  !*** ./src/controller/audio-stream-controller.ts ***!
678  \***************************************************/
679/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
680
681"use strict";
682__webpack_require__.r(__webpack_exports__);
683/* harmony export */ __webpack_require__.d(__webpack_exports__, {
684/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
685/* harmony export */ });
686/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
687/* harmony import */ var _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./base-stream-controller */ "./src/controller/base-stream-controller.ts");
688/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../events */ "./src/events.ts");
689/* harmony import */ var _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.ts");
690/* harmony import */ var _fragment_tracker__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./fragment-tracker */ "./src/controller/fragment-tracker.ts");
691/* harmony import */ var _types_level__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../types/level */ "./src/types/level.ts");
692/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
693/* harmony import */ var _loader_fragment__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../loader/fragment */ "./src/loader/fragment.ts");
694/* harmony import */ var _demux_chunk_cache__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../demux/chunk-cache */ "./src/demux/chunk-cache.ts");
695/* harmony import */ var _demux_transmuxer_interface__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../demux/transmuxer-interface */ "./src/demux/transmuxer-interface.ts");
696/* harmony import */ var _types_transmuxer__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../types/transmuxer */ "./src/types/transmuxer.ts");
697/* harmony import */ var _fragment_finders__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./fragment-finders */ "./src/controller/fragment-finders.ts");
698/* harmony import */ var _utils_discontinuities__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../utils/discontinuities */ "./src/utils/discontinuities.ts");
699/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
700
701function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
702function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
703function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
704
705
706
707
708
709
710
711
712
713
714
715
716
717var TICK_INTERVAL = 100; // how often to tick in ms
718var AudioStreamController = /*#__PURE__*/function (_BaseStreamController) {
719  _inheritsLoose(AudioStreamController, _BaseStreamController);
720  function AudioStreamController(hls, fragmentTracker, keyLoader) {
721    var _this;
722    _this = _BaseStreamController.call(this, hls, fragmentTracker, keyLoader, '[audio-stream-controller]') || this;
723    _this.videoBuffer = null;
724    _this.videoTrackCC = -1;
725    _this.waitingVideoCC = -1;
726    _this.audioSwitch = false;
727    _this.trackId = -1;
728    _this.waitingData = null;
729    _this.mainDetails = null;
730    _this.bufferFlushed = false;
731    _this.cachedTrackLoadedData = null;
732    _this._registerListeners();
733    return _this;
734  }
735  var _proto = AudioStreamController.prototype;
736  _proto.onHandlerDestroying = function onHandlerDestroying() {
737    this._unregisterListeners();
738    this.mainDetails = null;
739  };
740  _proto._registerListeners = function _registerListeners() {
741    var hls = this.hls;
742    hls.on(_events__WEBPACK_IMPORTED_MODULE_2__.Events.MEDIA_ATTA

1395/***/ "./src/controller/audio-track-controller.ts":
1396/*!**************************************************!*\
1397  !*** ./src/controller/audio-track-controller.ts ***!
1398  \**************************************************/
1399/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1400
1401"use strict";
1402__webpack_require__.r(__webpack_exports__);
1403/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1404/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
1405/* harmony export */ });
1406/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
1407/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
1408/* harmony import */ var _base_playlist_controller__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./base-playlist-controller */ "./src/controller/base-playlist-controller.ts");
1409/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
1410function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
1411function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
1412function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
1413function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
1414function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
1415function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
1416
1417
1418
1419
1420var AudioTrackController = /*#__PURE__*/function (_BasePlaylistControll) {
1421  _inheritsLoose(AudioTrackController, _BasePlaylistControll);
1422  function AudioTrackController(hls) {
1423    var _this;
1424    _this = _BasePlaylistControll.call(this, hls, '[audio-track-controller]') || this;
1425    _this.tracks = [];
1426    _this.groupId = null;
1427    _this.tracksInGroup = [];
1428    _this.trackId = -1;
1429    _this.trackName = '';
1430    _this.selectDefaultTrack = true;
1431    _this.registerListeners();
1432    return _this;
1433  }
1434  var _proto = AudioTrackController.prototype;
1435  _proto.registerListeners = function registerListeners() {
1436    var hls = this.hls;
1437    hls.on(_events__WEBPACK_IMPORTED_MODULE_0__.Events.MANIFEST_LOADING, this.onManifestLoading, this);
1438    hls.on(_events__WEBPACK_IMPORTED_MODULE_0__.Events.MANIFEST_PARSED, this.onManifestParsed, this);
1439    hls.on(_events__WEBPACK_IMPORTED_MODULE_0__.Events.LEVEL_LOADING, this.onLevelLoading, this);
1440    hls.on(_events__WEBPACK_IMPORTED_MODULE_0__.Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
1441    hls.on(_events__WEBPACK_IMPORTED_MODULE_0__.Events.AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
1442    hls.on(_events__WEBPACK_IMPORTED_MODULE_0__.Events.ERROR, this.onError, this);
1443  };
1444  _proto.unregisterListeners = function unregisterListeners() {
1445    var hls = this.hls;
1446    hls.off(_events__WEBPACK_IMPORTED_MODULE_0__.Events.MANIFEST_LOADING, this.onManifestLoading, this);
1447    hls.off(_events__WEBPACK_IMPORTED_MODULE_0__.Events.MANIFEST_PARSED, this.onManifestParsed, this);
1448    hls.off(_events__WEBPACK_IMPORTED_MODULE_0__.Events.LEVEL_LOADING, this.onLevelLoading, this);
1449    hls.off(_events__WEBPACK_IMPORTED_MODULE_0__.Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
1450    hls.off(_events__WEBPACK_IMPORTED_MODULE_0__.Events.AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
1451    hls.off(_events__WEBPACK_IMPORTED_MODULE_0__.Events.ERROR, this.onError, this);
1452  };
1453  _proto.destroy = function destroy() {
1454    this.unregisterListeners();
1455    this.tracks.length = 0;
1456    this.tracksInGroup.length = 0;
1457    _BasePlaylistControll.prototype.destroy.call(this);
1458  };
1459  _proto.onManifestLoading = function onManifestLoading() {
1460    this.tracks = [];
1461    this.groupId = null;
1462    this.tracksInGroup = [];
1463    this.trackId = -1;
1464    this.trackName = '';
1465    this.selectDefaultTrack = true;
1466  };
1467  _proto.onManifestParsed = function onManifestParsed(event, data) {
1468    this.tracks = data.audioTracks || [];
1469  };
1470  _proto.onAudioTrackLoaded = function onAudioTrackLoaded(event, data) {
1471    var id = data.id,
1472      details = data.details;
1473    var currentTrack = this.tracksInGroup[id];
1474    if (!currentTrack) {
1475      this.warn("Invalid audio track id " + id);
1476      return;
1477    }
1478    var curDetails = currentTrack.details;
1479    currentTrack.details = data.details;
1480    this.log("audioTrack " + id + " loaded [" + details.startSN + "-" + details.endSN + "]");
1481    if (id === this.trackId) {
1482      this.retryCount = 0;
1483      this.playlistLoaded(id, data, curDetails);
1484    }
1485  };
1486  _proto.onLevelLoading = function onLevelLoading(event, data) {
1487    this.switchLevel(data.level);
1488  };
1489  _proto.onLevelSwitching = function onLevelSwitching(event, data) {
1490    this.switchLevel(data.level);
1491  };
1492  _proto.switchLevel = function switchLevel(levelIndex) {
1493    var levelInfo = this.hls.levels[levelIndex];
1494    if (!(levelInfo !== null && levelInfo !== void 0 && levelInfo.audioGroupIds)) {
1495      return;
1496    }
1497    var audioGroupId = levelInfo.audioGroupIds[levelInfo.urlId];
1498    if (this.groupId !== audioGroupId) {
1499      this.groupId = audioGroupId;
1500      var audioTracks = this.tracks.filter(function (track) {
1501        return !audioGroupId || track.groupId === audioGroupId;
1502      });
1503
1504      // Disable selectDefaultTrack if there are no default tracks
1505      if (this.selectDefaultTrack && !audioTracks.some(function (track) {
1506        return track.default;
1507      })) {
1508        this.selectDefaultTrack = false;

1636Controller);
1637
1638/***/ }),
1639
1640/***/ "./src/controller/base-playlist-controller.ts":
1641/*!****************************************************!*\
1642  !*** ./src/controller/base-playlist-controller.ts ***!
1643  \****************************************************/
1644/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1645
1646"use strict";
1647__webpack_require__.r(__webpack_exports__);
1648/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1649/* harmony export */   "default": () => (/* binding */ BasePlaylistController)
1650/* harmony export */ });
1651/* harmony import */ var _types_level__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../types/level */ "./src/types/level.ts");
1652/* harmony import */ var _level_helper__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./level-helper */ "./src/controller/level-helper.ts");
1653/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
1654/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
1655
1656
1657
1658
1659var BasePlaylistController = /*#__PURE__*/function () {
1660  function BasePlaylistController(hls, logPrefix) {
1661    this.hls = void 0;
1662    this.timer = -1;
1663    this.requestScheduled = -1;
1664    this.canLoad = false;
1665    this.retryCount = 0;
1666    this.log = void 0;
1667    this.warn = void 0;
1668    this.log = _utils_logger__WEBPACK_IMPORTED_MODULE_2__.logger.log.bind(_utils_logger__WEBPACK_IMPORTED_MODULE_2__.logger, logPrefix + ":");
1669    this.warn = _utils_logger__WEBPACK_IMPORTED_MODULE_2__.logger.warn.bind(_utils_logger__WEBPACK_IMPORTED_MODULE_2__.logger, logPrefix + ":");
1670    this.hls = hls;
1671  }
1672  var _proto = BasePlaylistController.prototype;
1673  _proto.destroy = function destroy() {
1674    this.clearTimer();
1675    // @ts-ignore
1676    this.hls = this.log = this.warn = null;
1677  };
1678  _proto.onError = function onError(event, data) {
1679    if (data.fatal && (data.type === _errors__WEBPACK_IMPORTED_MODULE_3__.ErrorTypes.NETWORK_ERROR || data.type === _errors__WEBPACK_IMPORTED_MODULE_3__.ErrorTypes.KEY_SYSTEM_ERROR)) {
1680      this.stopLoad();
1681    }
1682  };
1683  _proto.clearTimer = function clearTimer() {
1684    clearTimeout(this.timer);
1685    this.timer = -1;
1686  };
1687  _proto.startLoad = function startLoad() {
1688    this.canLoad = true;
1689    this.retryCount = 0;
1690    this.requestScheduled = -1;
1691    this.loadPlaylist();
1692  };
1693  _proto.stopLoad = function stopLoad() {
1694    this.canLoad = false;
1695    this.clearTimer();
1696  };
1697  _proto.switchParams = function switchParams(playlistUri, previous) {
1698    var renditionReports = previous === null || previous === void 0 ? void 0 : previous.renditionReports;
1699    if (renditionReports) {
1700      for (var i = 0; i < renditionReports.length; i++) {
1701        var attr = renditionReports[i];
1702        var uri = void 0;
1703        try {
1704          uri = new self.URL(attr.URI, previous.url).href;
1705        } catch (error) {
1706          _utils_logger__WEBPACK_IMPORTED_MODULE_2__.logger.warn("Could not construct new URL for Rendition Report: " + error);
1707          uri = attr.URI || '';
1708        }
1709        if (uri === playlistUri.slice(-uri.length)) {
1710          var msn = parseInt(attr['LAST-MSN']) || (previous === null || previous === void 0 ? void 0 : previous.lastPartSn);
1711          var part = parseInt(attr['LAST-PART']) || (previous === null || previous === void 0 ? void 0 : previous.lastPartIndex);
1712          if (this.hls.config.lowLatencyMode) {
1713            var currentGoal = Math.min(previous.age - previous.partTarget, previous.targetduration);
1714            if (part >= 0 && currentGoal > previous.partTarget) {
1715              part += 1;
1716            }
1717          }
1718          return new _types_level__WEBPACK_IMPORTED_MODULE_0__.HlsUrlParameters(msn, part >= 0 ? part : undefined, _types_level__WEBPACK_IMPORTED_MODULE_0__.HlsSkip.No);
1719        }
1720      }
1721    }
1722  };
1723  _proto.loadPlaylist = function loadPlaylist(hlsUrlParameters) {
1724    if (this.requestScheduled === -1) {
1725      this.requestScheduled = self.performance.now();
1726    }
1727  };
1728  _proto.shouldLoadTrack = function shouldLoadTrack(track) {
1729    return this.canLoad && track && !!track.url && (!track.details || track.details.live);
1730  };
1731  _proto.playlistLoaded = function playlistLoaded(index, data, previousDetails) {
1732    var _this = this;
1733    var details = data.details,
1734      stats = data.stats;
1735
1736    // Set last updated date-time
1737    var now = self.performance.now();
1738    var elapsed = stats.loading.first ? Math.max(0, now - stats.loading.first) : 0;
1739    details.advancedDateTime = Date.now() - elapsed;
1740
1741    // if current playlist is a live playlist, arm a timer to reload it
1742    if (details.live || previousDetails !== null && previousDetails !== void 0 && previousDetails.live) {
1743      details.reloaded(previousDetails);
1744      if (previousDetails) {
1745        this.log("live playlist " + index + " " + (details.advanced ? 'REFRESHED ' + details.lastPartSn + '-' + details.lastPartIndex : 'MISSED'));
1746      }
1747      // Merge live playlists to adjust fragment starts and fill in delta playlist skipped segments
1748      if (previousDetails && details.fragments.length > 0) {
1749        (0,_level_helper__WEBPACK_IMPORTED_MODULE_1__.mergeDetails)(previousDetails, details);
1750      }
1751      if (!this.canLoad || !details.live) {
1752        return;
1753      }
1754      var deliveryDirectives;
1755      var msn = undefined;
1756      var part = undefined;
1757      if (details.canBlockReload && details.endSN && details.advanced) {
1758        // Load level with LL-HLS delivery directives
1759        var lowLatencyMode = this.hls.config.lowLatencyMode;
1760        var lastPartSn = details.lastPartSn;
1761        var endSn = details.endSN;
1762        var lastPartIndex = details.lastPartIndex;
1763        var hasParts = lastPartIndex !== -1;
1764        var lastPart = lastPartSn === endSn;
1765        // When low latency mode is disabled, we'll skip part requests once the last part index is found
1766        var nextSnStartIndex = lowLatencyMode ? 0 : lastPartIndex;
1767        if (hasParts) {
1768          msn = lastPart ? endSn + 1 : lastPartSn;
1769          part = lastPart ? nextSnStartIndex : lastPartIndex + 1;
1770        } else {
1771          msn = endSn + 1;
1772        }
1773        // Low-Latency CDN Tune-in: "age" header and time since load indicates we're behind by more than one part
1774        // Update directives to obtain the Playlist that has the estimated additional duration of media
1775        var lastAdvanced = details.age;
1776        var cdnAge = lastAdvanced + details.ageHeader;
1777        var currentGoal = Math.min(cdnAge - details.partTarget, details.targetduration * 1.5);
1778        if (currentGoal > 0) {
1779          if (previousDetails && currentGoal > previousDetails.tuneInGoal) {
1780            // If we attempted to get the next or latest playlist update, but currentGoal increased,
1781            // then we either can't catchup, or the "age" header cannot be trusted.
1782            this.warn("CDN Tune-in goal increased from: " + previousDetails.tuneInGoal + " to: " + currentGoal + " with playlist age: " + details.age);
1783            currentGoal = 0;
1784          } else {
1785            var segments = Math.floor(currentGoal / details.targetduration);
1786            msn += segments;
1787            if (part !== undefined) {
1788              var parts = Math.round(currentGoal % details.targetduration / details.partTarget);
1789              part += parts;
1790            }
1791            this.log("CDN Tune-in age: " + details.ageHeader + "s last advanced " + lastAdvanced.toFixed(2) + "s goal: " + currentGoal + " skip sn " + segments + " to part " + part);
1792          }
1793          details.tuneInGoal = currentGoal;
1794        }
1795        deliveryDirectives = this.getDeliveryDirectives(details, data.deliveryDirectives, msn, part);
1796        if (lowLatencyMode || !lastPart) {
1797          this.loadPlaylist(deliveryDirectives);
1798          return;
1799        }
1800      } else {
1801        deliveryDirectives = this.getDeliveryDirectives(details, data.deliveryDirectives, msn, part);
1802      }
1803      var bufferInfo = this.hls.mainForwardBufferInfo;
1804      var position = bufferInfo ? bufferInfo.end - bufferInfo.len : 0;
1805      var distanceToLiveEdgeMs = (details.edge - position) * 1000;
1806      var reloadInterval = (0,_level_helper__WEBPACK_IMPORTED_MODULE_1__.computeReloadInterval)(details, distanceToLiveEdgeMs);
1807      if (!details.updated) {
1808        this.requestScheduled = -1;
1809      } else if (now > this.requestScheduled + reloadInterval) {
1810        this.requestScheduled = stats.loading.start;
1811      }
1812      if (msn !== undefined && details.canBlockReload) {
1813        this.requestScheduled = stats.loading.first + reloadInterval - (details.partTarget * 1000 || 1000);
1814      } else {
1815        this.requestScheduled = (this.requestScheduled === -1 ? now : this.requestScheduled) + reloadInterval;
1816      }
1817      var estimatedTimeUntilUpdate = this.requestScheduled - now;
1818      estimatedTimeUntilUpdate = Math.max(0, estimatedTimeUntilUpdate);
1819      this.log("reload live playlist " + index + " in " + Math.round(estimatedTimeUntilUpdate) + " ms");
1820      //     this.log(
1821      //       `live reload ${details.updated ? 'REFRESHED' : 'MISSED'}
1822      // reload in ${estimatedTimeUntilUpdate / 1000}
1823      // round trip ${(stats.loading.end - stats.loading.start) / 1000}
1824      // diff ${
1825      //   (reloadInterval -
1826      //     (estimatedTimeUntilUpdate + stats.loading.end - stats.loading.start)) /
1827      //   1000
1828      // }
1829      // reload interval ${reloadInterval / 1000}
1830      // target duration ${details.targetduration}
1831      // distance to edge ${distanceToLiveEdgeMs / 1000}`
1832      //     );
1833
1834      this.timer = self.setTimeout(function () {
1835        return _this.loadPlaylist(deliveryDirectives);
1836      }, estimatedTimeUntilUpdate);
1837    } else {
1838      this.clearTimer();
1839    }
1840  };
1841  _proto.getDeliveryDirectives = function getDeliveryDirectives(details, previousDeliveryDirectives, msn, part) {
1842    var skip = (0,_types_level__WEBPACK_IMPORTED_MODULE_0__.getSkipValue)(details, msn);
1843    if (previousDeliveryDirectives !== null && previousDeliveryDirectives !== void 0 && previousDeliveryDirectives.skip && details.deltaUpdateFailed) {
1844      msn = previousDeliveryDirectives.msn;
1845      part = previousDeliveryDirectives.part;
1846      skip = _types_level__WEBPACK_IMPORTED_MODULE_0__.HlsSkip.No;
1847    }
1848    return new _types_level__WEBPACK_IMPORTED_MODULE_0__.HlsUrlParameters(msn, part, skip);
1849  };
1850  _proto.retryLoadingOrFail = function retryLoadingOrFail(errorEvent) {
1851    var _this2 = this;
1852    var config = this.hls.config;
1853    var retry = this.retryCount < config.levelLoadingMaxRetry;
1854    if (retry) {
1855      var _errorEvent$context;
1856      this.requestScheduled = -1;
1857      this.retryCount++;
1858      if (errorEvent.details.indexOf('LoadTimeOut') > -1 && (_errorEvent$context = errorEvent.context) !== null && _errorEvent$context !== void 0 && _errorEvent$context.deliveryDirectives) {
1859        // The LL-HLS request already timed out so retry immediately
1860        this.warn("retry playlist loading #" + this.retryCount + " after \"" + errorEvent.details + "\"");
1861        this.loadPlaylist();
1862      } else {
1863        // exponential backoff capped to max retry timeout
1864        var delay = Math.min(Math.pow(2, this.retryCount) * config.levelLoadingRetryDelay, config.levelLoadingMaxRetryTimeout);
1865        // Schedule level/track reload
1866        this.timer = self.setTimeout(function () {
1867          return _this2.loadPlaylist();
1868        }, delay);
1869        this.warn("retry playlist loading #" + this.retryCount + " in " + delay + " ms after \"" + errorEvent.details + "\"");
1870      }
1871    } else {
1872      this.warn("cannot recover from error \"" + errorEvent.details + "\"");
1873      // stopping live reloading timer if any
1874      this.clearTimer();
1875      // switch error to fatal
1876      errorEvent.fatal = true;
1877    }
1878    return retry;
1879  };
1880  return BasePlaylistController;
1881}();
1882
1883
1884/***/ }),
1885
1886/***/ "./src/controller/base-stream-controller.ts":
1887/*!**************************************************!*\
1888  !*** ./src/controller/base-stream-controller.ts ***!
1889  \**************************************************/
1890/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1891
1892"use strict";
1893__webpack_require__.r(__webpack_exports__);
1894/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1895/* harmony export */   "State": () => (/* binding */ State),
1896/* harmony export */   "default": () => (/* binding */ BaseStreamController)
1897/* harmony export */ });
1898/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
1899/* harmony import */ var _task_loop__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../task-loop */ "./src/task-loop.ts");
1900/* harmony import */ var _fragment_tracker__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./fragment-tracker */ "./src/controller/fragment-tracker.ts");
1901/* harmony import */ var _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.ts");
1902/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
1903/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../events */ "./src/events.ts");
1904/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
1905/* harmony import */ var _types_transmuxer__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../types/transmuxer */ "./src/types/transmuxer.ts");
1906/* harmony import */ var _utils_mp4_tools__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../utils/mp4-tools */ "./src/utils/mp4-tools.ts");
1907/* harmony import */ var _utils_discontinuities__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../utils/discontinuities */ "./src/utils/discontinuities.ts");
1908/* harmony import */ var _fragment_finders__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./fragment-finders */ "./src/controller/fragment-finders.ts");
1909/* harmony import */ var _level_helper__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./level-helper */ "./src/controller/level-helper.ts");
1910/* harmony import */ var _loader_fragment_loader__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../loader/fragment-loader */ "./src/loader/fragment-loader.ts");
1911/* harmony import */ var _crypt_decrypter__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../crypt/decrypter */ "./src/crypt/decrypter.ts");
1912/* harmony import */ var _utils_time_ranges__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../utils/time-ranges */ "./src/utils/time-ranges.ts");
1913/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
1914
1915
1916
1917
1918
1919function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
1920function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
1921function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
1922function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
1923function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
1924function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
1925function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941var State = {
1942  STOPPED: 'STOPPED',
1943  IDLE: 'IDLE',
1944  KEY_LOADING: 'KEY_LOADING',
1945  FRAG_LOADING: 'FRAG_LOADING',
1946  FRAG_LOADING_WAITING_RETRY: 'FRAG_LOADING_WAITING_RETRY',
1947  WAITING_TRACK: 'WAITING_TRACK',
1948  PARSING: 'PARSING',
1949  PARSED: 'PARSED',
1950  ENDED: 'ENDED',
1951  ERROR: 'ERROR',
1952  WAITING_INIT_PTS: 'WAITING_INIT_PTS',
1953  WAITING_LEVEL: 'WAITING_LEVEL'
1954};
1955var BaseStreamController = /*#__PURE__*/function (_TaskLoop) {
1956  _inheritsLoose(BaseStreamController, _TaskLoop);
1957  function BaseStreamController(hls, fragmentTracker, keyLoader, logPrefix) {
1958    var _this;
1959    _this = _TaskLoop.call(this) || this;
1960    _this.hls = void 0;
1961    _this.fragPrevious = null;
1962    _this.fragCurrent = null;
1963    _this.fragmentTracker = void 0;
1964    _this.transmuxer = null;
1965    _this._state = State.STOPPED;
1966    _this.media = null;
1967    _this.mediaBuffer = null;
1968    _this.config = void 0;
1969    _this.bitrateTest = false;
1970    _this.lastCurrentTime = 0;
1971    _this.nextLoadPosition = 0;
1972    _this.startPosition = 0;
1973    _this.loadedmetadata = false;
1974    _this.fragLoadError = 0;
1975    _this.retryDate = 0;
1976    _this.levels = null;
1977    _this.fragmentLoader = void 0;
1978    _this.keyLoader = void 0;
1979    _this.levelLastLoaded = null;
1980    _this.startFragRequested = false;
1981    _this.decrypter = void 0;
1982    _this.initPTS = [];
1983    _this.onvseeking = null;
1984    _this.onvended = null;
1985    _this.logPrefix = '';
1986    _this.log = void 0;
1987    _this.warn = void 0;
1988    _this.logPrefix = logPrefix;
1989    _this.log = _utils_logger__WEBPACK_IMPORTED_MODULE_4__.logger.log.bind(_utils_logger__WEBPACK_IMPORTED_MODULE_4__.logger, logPrefix + ":");
1990    _this.warn = _utils_logger__WEBPACK_IMPORTED_MODULE_4__.logger.warn.bind(_utils_logger__WEBPACK_IMPORTED_MODULE_4__.logger, logPrefix + ":");
1991    _this.hls = hls;
1992    _this.fragmentLoader = new _loader_fragment_loader__WEBPACK_IMPORTED_MODULE_12__["default"](hls.config);
1993    _this.keyLoader = keyLoader;
1994    _this.fragmentTracker = fragmentTracker;
1995    _this.config = hls.config;
1996    _this.decrypter = new _crypt_decrypter__WEBPACK_IMPORTED_MODULE_13__["default"](hls.config);
1997    hls.on(_events__WEBPACK_IMPORTED_MODULE_5__.Events.LEVEL_SWITCHING, _this.onLevelSwitching, _assertThisInitialized(_this));
1998    return _this;
1999  }
2000  var _proto = BaseStreamController.prototype;
2001  _proto.doTick = function doTick() {
2002    this.onTickEnd();
2003  };
2004  _proto.onTickEnd = function onTickEnd() {}
2005
2006  // eslint-disable-next-line @typescript-eslint/no-unused-vars
2007  ;
2008  _proto.startLoad = function startLoad(startPosition) {};
2009  _proto.stopLoad = function stopLoad() {
2010    this.fragmentLoader.abort();
2011    this.keyLoader.abort();
2012    var frag = this.fragCurrent;
2013    if (frag) {
2014      frag.abortRequests();
2015      this.fragmentTracker.removeFragment(frag);
2016    }
2017    this.resetTransmuxer();
2018    this.fragCurrent = null;
2019    this.fragPrevious = null;
2020    this.clearInterval();
2021    this.clearNextTick();
2022    this.state = State.STOPPED;
2023  };
2024  _proto._streamEnded = function _streamEnded(bufferInfo, levelDetails) {
2025    // If playlist is live, there is another buffered range after the current range, nothing buffered, media is detached,
2026    // of nothing loading/loaded return false
2027    if (levelDetails.live || bufferInfo.nextStart || !bufferInfo.end || !this.media) {
2028      return false;
2029    }
2030    var partList = levelDetails.partList;
2031    // Since the last part isn't guaranteed to correspond to the last playlist segment for Low-Latency HLS,
2032    // check instead if the last part is buffered.
2033    if (partList !== null && partList !== void 0 && partList.length) {
2034      var lastPart = partList[partList.length - 1];
2035
2036      // Checking the midpoint of the part for potential margin of error and related issues.
2037      // NOTE: Technically I believe parts could yield content that is < the computed duration (including potential a duration of 0)
2038      // and still be spec-compliant, so there may still be edge cases here. Likewise, there could be issues in end of stream
2039      // part mismatches for independent audio and video playlists/segments.
2040      var lastPartBuffered = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__.BufferHelper.isBuffered(this.media, lastPart.start + lastPart.duration / 2);
2041      return lastPartBuffered;
2042    }
2043    var playlistType = levelDetails.fragments[levelDetails.fragments.length - 1].type;
2044    return this.fragmentTracker.isEndListAppended(playlistType);
2045  };
2046  _proto.getLevelDetails = function getLevelDetails() {
2047    if (this.levels && this.levelLastLoaded !== null) {
2048      var _this$levels$this$lev;
2049      return (_this$levels$this$lev = this.levels[this.levelLastLoaded]) === null || _this$levels$this$lev === void 0 ? void 0 : _this$levels$this$lev.details;
2050    }
2051  };
2052  _proto.onMediaAttached = function onMediaAttached(event, data) {
2053    var media = this.media = this.mediaBuffer = data.media;
2054    this.onvseeking = this.onMediaSeeking.bind(this);
2055    this.onvended = this.onMediaEnded.bind(this);
2056    media.addEventListener('seeking', this.onvseeking);
2057    media.addEventListener('ended', this.onvended);
2058    var config = this.config;
2059    if (this.levels && config.autoStartLoad && this.state === State.STOPPED) {
2060      this.startLoad(config.startPosition);
2061    }
2062  };
2063  _proto.onMediaDetaching = function onMediaDetaching() {
2064    var media = this.media;
2065    if (media !== null && media !== void 0 && media.ended) {
2066      this.log('MSE detaching and video ended, reset startPosition');
2067      this.startPosition = this.lastCurrentTime = 0;
2068    }
2069
2070    // remove video listeners
2071    if (media && this.onvseeking && this.onvended) {
2072      media.removeEventListener('seeking', this.onvseeking);
2073      media.removeEventListener('ended', this.onvended);
2074      this.onvseeking = this.onvended = null;
2075    }
2076    if (this.keyLoader) {
2077      this.keyLoader.detach();
2078    }
2079    this.media = this.mediaBuffer = null;
2080    this.loadedmetadata = false;
2081    this.fragmentTracker.removeAllFragments();
2082    this.stopLoad();
2083  };
2084  _proto.onMediaSeeking = function onMediaSeeking() {
2085    var config = this.config,
2086      fragCurrent = this.fragCurrent,
2087      media = this.media,
2088      mediaBuffer = this.mediaBuffer,
2089      state = this.state;
2090    var currentTime = media ? media.currentTime : 0;
2091    var bufferInfo = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__.BufferHelper.bufferInfo(mediaBuffer ? mediaBuffer : media, currentTime, config.maxBufferHole);
2092    this.log("media seeking to " + ((0,_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__.isFiniteNumber)(currentTime) ? currentTime.toFixed(3) : currentTime) + ", state: " + state);
2093    if (this.state === State.ENDED) {
2094      this.resetLoadingState();
2095    } else if (fragCurrent) {
2096      // Seeking while frag load is in progress
2097      var tolerance = config.maxFragLookUpTolerance;
2098      var fragStartOffset = fragCurrent.start - tolerance;
2099      var fragEndOffset = fragCurrent.start + fragCurrent.duration + tolerance;
2100      // if seeking out of buffered range or into new one
2101      if (!bufferInfo.len || fragEndOffset < bufferInfo.start || fragStartOffset > bufferInfo.end) {
2102        var pastFragment = currentTime > fragEndOffset;
2103        // if the seek position is outside the current fragment range
2104        if (currentTime < fragStartOffset || pastFragment) {
2105          if (pastFragment && fragCurrent.loader) {
2106            this.log('seeking outside of buffer while fragment load in progress, cancel fragment load');
2107            fragCurrent.abortRequests();
2108          }
2109          this.resetLoadingState();
2110        }
2111      }
2112    }
2113    if (media) {
2114      this.lastCurrentTime = currentTime;
2115    }
2116
2117    // in case seeking occurs although no media buffered, adjust startPosition and nextLoadPosition to seek target
2118    if (!this.loadedmetadata && !bufferInfo.len) {
2119      this.nextLoadPosition = this.startPosition = currentTime;
2120    }
2121
2122    // Async tick to speed up processing
2123    this.tickImmediate();
2124  };
2125  _proto.onMediaEnded = function onMediaEnded() {
2126    // reset startPosition and lastCurrentTime to restart playback @ stream beginning
2127    this.startPosition = this.lastCurrentTime = 0;
2128  };
2129  _proto.onLevelSwitching = function onLevelSwitching(event, data) {
2130    this.fragLoadError = 0;
2131  };
2132  _proto.onHandlerDestroying = function onHandlerDestroying() {
2133    this.stopLoad();
2134    _TaskLoop.prototype.onHandlerDestroying.call(this);
2135  };
2136  _proto.onHandlerDestroyed = function onHandlerDestroyed() {
2137    this.state = State.STOPPED;
2138    this.hls.off(_events__WEBPACK_IMPORTED_MODULE_5__.Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
2139    if (this.fragmentLoader) {
2140      this.fragmentLoader.destroy();
2141    }
2142    if (this.keyLoader) {
2143      this.keyLoader.destroy();
2144    }
2145    if (this.decrypter) {
2146      this.decrypter.destroy();
2147    }
2148    this.hls = this.log = this.warn = this.decrypter = this.keyLoader = this.fragmentLoader = this.fragmentTracker = null;
2149    _TaskLoop.prototype.onHandlerDestroyed.call(this);
2150  };
2151  _proto.loadFragment = function loadFragment(frag, levelDetails, targetBufferTime) {
2152    this._loadFragForPlayback(frag, levelDetails, targetBufferTime);
2153  };
2154  _proto._loadFragForPlayback = function _loadFragForPlayback(frag, levelDetails, targetBufferTime) {
2155    var _this2 = this;
2156    var progressCallback = function progressCallback(data) {
2157      if (_this2.fragContextChanged(frag)) {
2158        _this2.warn("Fragment " + frag.sn + (data.part ? ' p: ' + data.part.index : '') + " of level " + frag.level + " was dropped during download.");
2159        _this2.fragmentTracker.removeFragment(frag);
2160        return;
2161      }
2162      frag.stats.chunkCount++;
2163      _this2._handleFragmentLoadProgress(data);
2164    };
2165    this._doFragLoad(frag, levelDetails, targetBufferTime, progressCallback).then(function (data) {
2166      if (!data) {
2167        // if we're here we probably needed to backtrack or are waiting for more parts
2168        return;
2169      }
2170      _this2.fragLoadError = 0;
2171      var state = _this2.state;
2172      if (_this2.fragContextChanged(frag)) {
2173        if (state === State.FRAG_LOADING || !_this2.fragCurrent && state === State.PARSING) {
2174          _this2.fragmentTracker.removeFragment(frag);
2175          _this2.state = State.IDLE;
2176        }
2177        return;
2178      }
2179      if ('payload' in data) {
2180        _this2.log("Loaded fragment " + frag.sn + " of level " + frag.level);
2181        _this2.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.FRAG_LOADED, data);
2182      }
2183
2184      // Pass through the whole payload; controllers not implementing progressive loading receive data from this callback
2185      _this2._handleFragmentLoadComplete(data);
2186    }).catch(function (reason) {
2187      if (_this2.state === State.STOPPED || _this2.state === State.ERROR) {
2188        return;
2189      }
2190      _this2.warn(reason);
2191      _this2.resetFragmentLoading(frag);
2192    });
2193  };
2194  _proto.flushMainBuffer = function flushMainBuffer(startOffset, endOffset, type) {
2195    if (type === void 0) {
2196      type = null;
2197    }
2198    if (!(startOffset - endOffset)) {
2199      return;
2200    }
2201    // When alternate audio is playing, the audio-stream-controller is responsible for the audio buffer. Otherwise,
2202    // passing a null type flushes both buffers
2203    var flushScope = {
2204      startOffset: startOffset,
2205      endOffset: endOffset,
2206      type: type
2207    };
2208    // Reset load errors on flush
2209    this.fragLoadError = 0;
2210    this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.BUFFER_FLUSHING, flushScope);
2211  };
2212  _proto._loadInitSegment = function _loadInitSegment(frag, details) {
2213    var _this3 = this;
2214    this._doFragLoad(frag, details).then(function (data) {
2215      if (!data || _this3.fragContextChanged(frag) || !_this3.levels) {
2216        throw new Error('init load aborted');
2217      }
2218      return data;
2219    }).then(function (data) {
2220      var hls = _this3.hls;
2221      var payload = data.payload;
2222      var decryptData = frag.decryptdata;
2223
2224      // check to see if the payload needs to be decrypted
2225      if (payload && payload.byteLength > 0 && decryptData && decryptData.key && decryptData.iv && decryptData.method === 'AES-128') {
2226        var startTime = self.performance.now();
2227        // decrypt the subtitles
2228        return _this3.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer).then(function (decryptedData) {
2229          var endTime = self.performance.now();
2230          hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.FRAG_DECRYPTED, {
2231            frag: frag,
2232            payload: decryptedData,
2233            stats: {
2234              tstart: startTime,
2235              tdecrypt: endTime
2236            }
2237          });
2238          data.payload = decryptedData;
2239          return data;
2240        });
2241      }
2242      return data;
2243    }).then(function (data) {
2244      var fragCurrent = _this3.fragCurrent,
2245        hls = _this3.hls,
2246        levels = _this3.levels;
2247      if (!levels) {
2248        throw new Error('init load aborted, missing levels');
2249      }
2250      var details = levels[frag.level].details;
2251      console.assert(details, 'Level details are defined when init segment is loaded');
2252      var stats = frag.stats;
2253      _this3.state = State.IDLE;
2254      _this3.fragLoadError = 0;
2255      frag.data = new Uint8Array(data.payload);
2256      stats.parsing.start = stats.buffering.start = self.performance.now();
2257      stats.parsing.end = stats.buffering.end = self.performance.now();
2258
2259      // Silence FRAG_BUFFERED event if fragCurrent is null
2260      if (data.frag === fragCurrent) {
2261        hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.FRAG_BUFFERED, {
2262          stats: stats,
2263          frag: fragCurrent,
2264          part: null,
2265          id: frag.type
2266        });
2267      }
2268      _this3.tick();
2269    }).catch(function (reason) {
2270      if (_this3.state === State.STOPPED || _this3.state === State.ERROR) {
2271        return;
2272      }
2273      _this3.warn(reason);
2274      _this3.resetFragmentLoading(frag);
2275    });
2276  };
2277  _proto.fragContextChanged = function fragContextChanged(frag) {
2278    var fragCurrent = this.fragCurrent;
2279    return !frag || !fragCurrent || frag.level !== fragCurrent.level || frag.sn !== fragCurrent.sn || frag.urlId !== fragCurrent.urlId;
2280  };
2281  _proto.fragBufferedComplete = function fragBufferedComplete(frag, part) {
2282    var _

2282this$fragCurrent, _this$fragPrevious;
2283    var media = this.mediaBuffer ? this.mediaBuffer : this.media;
2284    this.log("Buffered " + frag.type + " sn: " + frag.sn + (part ? ' part: ' + part.index : '') + " of " + (this.logPrefix === '[stream-controller]' ? 'level' : 'track') + " " + frag.level + " (frag:[" + (frag.startPTS || NaN).toFixed(3) + "-" + (frag.endPTS || NaN).toFixed(3) + "] > buffer:" + (media ? _utils_time_ranges__WEBPACK_IMPORTED_MODULE_14__["default"].toString(_utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__.BufferHelper.getBuffered(media)) : '(detached)') + ")");
2285    this.state = State.IDLE;
2286    if (!media) {
2287      return;
2288    }
2289    if (!this.loadedmetadata && frag.type == _types_loader__WEBPACK_IMPORTED_MODULE_15__.PlaylistLevelType.MAIN && media.buffered.length && ((_this$fragCurrent = this.fragCurrent) === null || _this$fragCurrent === void 0 ? void 0 : _this$fragCurrent.sn) === ((_this$fragPrevious = this.fragPrevious) === null || _this$fragPrevious === void 0 ? void 0 : _this$fragPrevious.sn)) {
2290      this.loadedmetadata = true;
2291      this.seekToStartPos();
2292    }
2293    this.tick();
2294  };
2295  _proto.seekToStartPos = function seekToStartPos() {};
2296  _proto._handleFragmentLoadComplete = function _handleFragmentLoadComplete(fragLoadedEndData) {
2297    var transmuxer = this.transmuxer;
2298    if (!transmuxer) {
2299      return;
2300    }
2301    var frag = fragLoadedEndData.frag,
2302      part = fragLoadedEndData.part,
2303      partsLoaded = fragLoadedEndData.partsLoaded;
2304    // If we did not load parts, or loaded all parts, we have complete (not partial) fragment data
2305    var complete = !partsLoaded || partsLoaded.length === 0 || partsLoaded.some(function (fragLoaded) {
2306      return !fragLoaded;
2307    });
2308    var chunkMeta = new _types_transmuxer__WEBPACK_IMPORTED_MODULE_7__.ChunkMetadata(frag.level, frag.sn, frag.stats.chunkCount + 1, 0, part ? part.index : -1, !complete);
2309    transmuxer.flush(chunkMeta);
2310  }
2311
2312  // eslint-disable-next-line @typescript-eslint/no-unused-vars
2313  ;
2314  _proto._handleFragmentLoadProgress = function _handleFragmentLoadProgress(frag) {};
2315  _proto._doFragLoad = function _doFragLoad(frag, details, targetBufferTime, progressCallback) {
2316    var _frag$decryptdata,
2317      _this4 = this;
2318    if (targetBufferTime === void 0) {
2319      targetBufferTime = null;
2320    }
2321    if (!this.levels) {
2322      throw new Error('frag load aborted, missing levels');
2323    }
2324    var keyLoadingPromise = null;
2325    if (frag.encrypted && !((_frag$decryptdata = frag.decryptdata) !== null && _frag$decryptdata !== void 0 && _frag$decryptdata.key)) {
2326      this.log("Loading key for " + frag.sn + " of [" + details.startSN + "-" + details.endSN + "], " + (this.logPrefix === '[stream-controller]' ? 'level' : 'track') + " " + frag.level);
2327      this.state = State.KEY_LOADING;
2328      this.fragCurrent = frag;
2329      keyLoadingPromise = this.keyLoader.load(frag).then(function (keyLoadedData) {
2330        if (!_this4.fragContextChanged(keyLoadedData.frag)) {
2331          _this4.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.KEY_LOADED, keyLoadedData);

2331
2332          return keyLoadedData;
2333        }
2334      });
2335      this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.KEY_LOADING, {
2336        frag: frag
2337      });
2338      this.throwIfFragContextChanged('KEY_LOADING');
2339    } else if (!frag.encrypted && details.encryptedFragments.length) {
2340      this.keyLoader.loadClear(frag, details.encryptedFragments);
2341    }
2342    targetBufferTime = Math.max(frag.start, targetBufferTime || 0);
2343    if (this.config.lowLatencyMode && details) {
2344      var partList = details.partList;
2345      if (partList && progressCallback) {
2346        if (targetBufferTime > frag.end && details.fragmentHint) {
2347          frag = details.fragmentHint;
2348        }
2349        var partIndex = this.getNextPart(partList, frag, targetBufferTime);
2350        if (partIndex > -1) {
2351          var part = partList[partIndex];
2352          this.log("Loading part sn: " + frag.sn + " p: " + part.index + " cc: " + frag.cc + " of playlist [" + details.startSN + "-" + details.endSN + "] parts [0-" + partIndex + "-" + (partList.length - 1) + "] " + (this.logPrefix === '[stream-controller]' ? 'level' : 'track') + ": " + frag.level + ", target: " + parseFloat(targetBufferTime.toFixed(3)));
2353          this.nextLoadPosition = part.start + part.duration;
2354          this.state = State.FRAG_LOADING;
2355          this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.FRAG_LOADING, {
2356            frag: frag,
2357            part: partList[partIndex],
2358            targetBufferTime: targetBufferTime
2359          });
2360          this.throwIfFragContextChanged('FRAG_LOADING parts');
2361          if (keyLoadingPromise) {
2362            return keyLoadingPromise.then(function (keyLoadedData) {
2363              if (!keyLoadedData || _this4.fragContextChanged(keyLoadedData.frag)) {
2364                return null;
2365              }
2366              return _this4.doFragPartsLoad(frag, partList, partIndex, progressCallback);
2367            }).catch(function (error) {
2368              return _this4.handleFragLoadError(error);
2369            });
2370          }
2371          return this.doFragPartsLoad(frag, partList, partIndex, progressCallback).catch(function (error) {
2372            return _this4.handleFragLoadError(error);
2373          });
2374        } else if (!frag.url || this.loadedEndOfParts(partList, targetBufferTime)) {
2375          // Fragment hint has no parts
2376          return Promise.resolve(null);
2377        }
2378      }
2379    }
2380    this.log("Loading fragment " + frag.sn + " cc: " + frag.cc + " " + (details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : '') + (this.logPrefix === '[stream-controller]' ? 'level' : 'track') + ": " + frag.level + ", target: " + parseFloat(targetBufferTime.toFixed(3)));
2381    // Don't update nextLoadPosition for fragments which are not buffered
2382    if ((0,_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__.isFiniteNumber)(frag.sn) && !this.bitrateTest) {
2383      this.nextLoadPosition = frag.start + frag.duration;
2384    }
2385    this.state = State.FRAG_LOADING;
2386    this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.FRAG_LOADING, {
2387      frag: frag,
2388      targetBufferTime: targetBufferTime
2389    });
2390    this.throwIfFragContextChanged('FRAG_LOADING');
2391
2392    // Load key before streaming fragment data
2393    var dataOnProgress = this.config.progressive;
2394    if (dataOnProgress && keyLoadingPromise) {
2395      return keyLoadingPromise.then(function (keyLoadedData) {
2396        if (!keyLoadedData || _this4.fragContextChanged(keyLoadedData === null || keyLoadedData === void 0 ? void 0 : keyLoadedData.frag)) {
2397          return null;
2398        }
2399        return _this4.fragmentLoader.load(frag, progressCallback);
2400      }).catch(function (error) {
2401        return _this4.handleFragLoadError(error);
2402      });
2403    }
2404
2405    // load unencrypted fragment data with progress event,
2406    // or handle fragment result after key and fragment are finished loading
2407    return Promise.all([this.fragmentLoader.load(frag, dataOnProgress ? progressCallback : undefined), keyLoadingPromise]).then(function (_ref) {
2408      var fragLoadedData = _ref[0];
2409      if (!dataOnProgress && fragLoadedData && progressCallback) {
2410        progressCallback(fragLoadedData);
2411      }
2412      return fragLoadedData;
2413    }).catch(function (error) {
2414      return _this4.handleFragLoadError(error);
2415    });
2416  };
2417  _proto.throwIfFragContextChanged = function throwIfFragContextChanged(context) {
2418    // exit if context changed during event loop
2419    if (this.fragCurrent === null) {
2420      throw new Error("frag load aborted, context changed in " + context);
2421    }
2422  };
2423  _proto.doFragPartsLoad = function doFragPartsLoad(frag, partList, partIndex, progressCallback) {
2424    var _this5 = this;
2425    return new Promise(function (resolve, reject) {
2426      var partsLoaded = [];
2427      var loadPartIndex = function loadPartIndex(index) {
2428        var part = partList[index];
2429        _this5.fragmentLoader.loadPart(frag, part, progressCallback).then(function (partLoadedData) {
2430          partsLoaded[part.index] = partLoadedData;
2431          var loadedPart = partLoadedData.part;
2432          _this5.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.FRAG_LOADED, partLoadedData);
2433          var nextPart = partList[index + 1];
2434          if (nextPart && nextPart.fragment === frag) {
2435            loadPartIndex(index + 1);
2436          } else {
2437            return resolve({
2438              frag: frag,
2439              part: loadedPart,
2440              partsLoaded: partsLoaded
2441            });
2442          }
2443        }).catch(reject);
2444      };
2445      loadPartIndex(partIndex);
2446    });
2447  };
2448  _proto.handleFragLoadError = function handleFragLoadError(error) {
2449    if ('data' in error) {
2450      var data = error.data;
2451      if (error.data && data.details === _errors__WEBPACK_IMPORTED_MODULE_6__.ErrorDetails.INTERNAL_ABORTED) {
2452        this.handleFragLoadAborted(data.frag, data.part);
2453      } else {
2454        this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.ERROR, data);
2455      }
2456    } else {
2457      this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.ERROR, {
2458        type: _errors__WEBPACK_IMPORTED_MODULE_6__.ErrorTypes.OTHER_ERROR,
2459        details: _errors__WEBPACK_IMPORTED_MODULE_6__.ErrorDetails.INTERNAL_EXCEPTION,
2460        err: error,
2461        fatal: true
2462      });
2463    }
2464    return null;
2465  };
2466  _proto._handleTransmuxerFlush = function _handleTransmuxerFlush(chunkMeta) {
2467    var context = this.getCurrentContext(chunkMeta);
2468    if (!context || this.state !== State.PARSING) {
2469      if (!this.fragCurrent && this.state !== State.STOPPED && this.state !== State.ERROR) {
2470        this.state = State.IDLE;
2471      }
2472      return;
2473    }
2474    var frag = context.frag,
2475      part = context.part,
2476      level = context.level;
2477    var now = self.performance.now();
2478    frag.stats.parsing.end = now;
2479    if (part) {
2480      part.stats.parsing.end = now;
2481    }
2482    this.updateLevelTiming(frag, part, level, chunkMeta.partial);
2483  };
2484  _proto.getCurrentContext = function getCurrentContext(chunkMeta) {
2485    var levels = this.levels;
2486    var levelIndex = chunkMeta.level,
2487      sn = chunkMeta.sn,
2488      partIndex = chunkMeta.part;
2489    if (!levels || !levels[levelIndex]) {
2490      this.warn("Levels object was unset while buffering fragment " + sn + " of level " + levelIndex + ". The current chunk will not be buffered.");
2491      return null;
2492    }
2493    var level = levels[levelIndex];
2494    var part = partIndex > -1 ? (0,_level_helper__WEBPACK_IMPORTED_MODULE_11__.getPartWith)(level, sn, partIndex) : null;
2495    var frag = part ? part.fragment : (0,_level_helper__WEBPACK_IMPORTED_MODULE_11__.getFragmentWithSN)(level, sn, this.fragCurrent);
2496    if (!frag) {
2497      return null;
2498    }
2499    return {
2500      frag: frag,
2501      part: part,
2502      level: level
2503    };
2504  };
2505  _proto.bufferFragmentData = function bufferFragmentData(data, frag, part, chunkMeta) {
2506    if (!data || this.state !== State.PARSING) {
2507      return;
2508    }
2509    var data1 = data.data1,
2510      data2 = data.data2;
2511    var buffer = data1;
2512    if (data1 && data2) {
2513      // Combine the moof + mdat so that we buffer with a single append
2514      buffer = (0,_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_8__.appendUint8Array)(data1, data2);
2515    }
2516    if (!buffer || !buffer.length) {
2517      return;
2518    }
2519    var segment = {
2520      type: data.type,
2521      frag: frag,
2522      part: part,
2523      chunkMeta: chunkMeta,
2524      parent: frag.type,
2525      data: buffer
2526    };
2527    this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.BUFFER_APPENDING, segment);
2528    if (data.dropped && data.independent && !part) {
2529      // Clear buffer so that we reload previous segments sequentially if required
2530      this.flushBufferGap(frag);
2531    }
2532  };
2533  _proto.flushBufferGap = function flushBufferGap(frag) {
2534    var media = this.media;
2535    if (!media) {
2536      return;
2537    }
2538    // If currentTime is not buffered, clear the back buffer so that we can backtrack as much as needed
2539    if (!_utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__.BufferHelper.isBuffered(media, media.currentTime)) {
2540      this.flushMainBuffer(0, frag.start);
2541      return;
2542    }
2543    // Remove back-buffer without interrupting playback to allow back tracking
2544    var currentTime = media.currentTime;
2545    var bufferInfo = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__.BufferHelper.bufferInfo(media, currentTime, 0);
2546    var fragDuration = frag.duration;
2547    var segmentFraction = Math.min(this.config.maxFragLookUpTolerance * 2, fragDuration * 0.25);
2548    var start = Math.max(Math.min(frag.start - segmentFraction, bufferInfo.end - segmentFraction), currentTime + segmentFraction);
2549    if (frag.start - start > segmentFraction) {
2550      this.flushMainBuffer(start, frag.start);
2551    }
2552  };
2553  _proto.getFwdBufferInfo = function getFwdBufferInfo(bufferable, type) {
2554    var config = this.config;
2555    var pos = this.getLoadPosition();
2556    if (!(0,_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__.isFiniteNumber)(pos)) {
2557      return null;
2558    }
2559    var bufferInfo = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__.BufferHelper.bufferInfo(bufferable, pos, config.maxBufferHole);
2560    // Workaround flaw in getting forward buffer when maxBufferHole is smaller than gap at current pos
2561    if (bufferInfo.len === 0 && bufferInfo.nextStart !== undefined) {
2562      var bufferedFragAtPos = this.fragmentTracker.getBufferedFrag(pos, type);
2563      if (bufferedFragAtPos && bufferInfo.nextStart < bufferedFragAtPos.end) {
2564        return _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__.BufferHelper.bufferInfo(bufferable, pos, Math.max(bufferInfo.nextStart, config.maxBufferHole));
2565      }
2566    }
2567    return bufferInfo;
2568  };
2569  _proto.getMaxBufferLength = function getMaxBufferLength(levelBitrate) {
2570    var config = this.config;
2571    var maxBufLen;
2572    if (levelBitrate) {
2573      maxBufLen = Math.max(8 * config.maxBufferSize / levelBitrate, config.maxBufferLength);
2574    } else {
2575      maxBufLen = config.maxBufferLength;
2576    }
2577    return Math.min(maxBufLen, config.maxMaxBufferLength);
2578  };
2579  _proto.reduceMaxBufferLength = function reduceMaxBufferLength(threshold) {
2580    var config = this.config;
2581    var minLength = threshold || config.maxBufferLength;
2582    if (config.maxMaxBufferLength >= minLength) {
2583      // reduce max buffer length as it might be too high. we do this to avoid loop flushing ...
2584      config.maxMaxBufferLength /= 2;
2585      this.warn("Reduce max buffer length to " + config.maxMaxBufferLength + "s");
2586      return true;
2587    }
2588    return false;
2589  };
2590  _proto.getNextFragment = function getNextFragment(pos, levelDetails) {
2591    var fragments = levelDetails.fragments;
2592    var fragLen = fragments.length;
2593    if (!fragLen) {
2594      return null;
2595    }
2596
2597    // find fragment index, contiguous with end of buffer position
2598    var config = this.config;
2599    var start = fragments[0].start;
2600    var frag;
2601    if (levelDetails.live) {
2602      var initialLiveManifestSize = config.initialLiveManifestSize;
2603      if (fragLen < initialLiveManifestSize) {
2604        this.warn("Not enough fragments to start playback (have: " + fragLen + ", need: " + initialLiveManifestSize + ")");
2605        return null;
2606      }
2607      // The real fragment start times for a live stream are only known after the PTS range for that level is known.
2608      // In order to discover the range, we load the best matching fragment for that level and demux it.
2609      // Do not load using live logic if the starting frag is requested - we want to use getFragmentAtPosition() so that
2610      // we get the fragment matching that start time
2611      if (!levelDetails.PTSKnown && !this.startFragRequested && this.startPosition === -1) {
2612        frag = this.getInitialLiveFragment(levelDetails, fragments);
2613        this.startPosition = frag ? this.hls.liveSyncPosition || frag.start : pos;
2614      }
2615    } else if (pos <= start) {
2616      // VoD playlist: if loadPosition before start of playlist, load first fragment
2617      frag = fragments[0];
2618    }
2619
2620    // If we haven't run into any special cases already, just load the fragment most closely matching the requested position
2621    if (!frag) {
2622      var end = config.lowLatencyMode ? levelDetails.partEnd : levelDetails.fragmentEnd;
2623      frag = this.getFragmentAtPosition(pos, end, levelDetails);
2624    }
2625    return this.mapToInitFragWhenRequired(frag);
2626  };
2627  _proto.mapToInitFragWhenRequired = function mapToInitFragWhenRequired(frag) {
2628    // If an initSegment is present, it must be buffered first
2629    if (frag !== null && frag !== void 0 && frag.initSegment && !(frag !== null && frag !== void 0 && frag.initSegment.data) && !this.bitrateTest) {
2630      return frag.initSegment;
2631    }
2632    return frag;
2633  };
2634  _proto.getNextPart = function getNextPart(partList, frag, targetBufferTime) {
2635    var nextPart = -1;
2636    var contiguous = false;
2637    var independentAttrOmitted = true;
2638    for (var i = 0, len = partList.length; i < len; i++) {
2639      var part = partList[i];
2640      independentAttrOmitted = independentAttrOmitted && !part.independent;
2641      if (nextPart > -1 && targetBufferTime < part.start) {
2642        break;
2643      }
2644      var loaded = part.loaded;
2645      if (loaded) {
2646        nextPart = -1;
2647      } else if ((contiguous || part.independent || independentAttrOmitted) && part.fragment === frag) {
2648        nextPart = i;
2649      }
2650      contiguous = loaded;
2651    }
2652    return nextPart;
2653  };
2654  _proto.loadedEndOfParts = function loadedEndOfParts(partList, targetBufferTime) {
2655    var lastPart = partList[partList.length - 1];
2656    return lastPart && targetBufferTime > lastPart.start && lastPart.loaded;
2657  }
2658
2659  /*
2660   This method is used find the best matching first fragment for a live playlist. This fragment is used to calculate the
2661   "sliding" of the playlist, which is its offset from the start of playback. After sliding we can compute the real
2662   start and end times for each fragment in the playlist (after which this method will not need to be called).
2663  */;
2664  _proto.getInitialLiveFragment = function getInitialLiveFragment(levelDetails, fragments) {
2665    var fragPrevious = this.fragPrevious;
2666    var frag = null;
2667    if (fragPrevious) {
2668      if (levelDetails.hasProgramDateTime) {
2669        // Prefer using PDT, because it can be accurate enough to choose the correct fragment without knowing the level sliding
2670        this.log("Live playlist, switching playlist, load frag with same PDT: " + fragPrevious.programDateTime);
2671        frag = (0,_fragment_finders__WEBPACK_IMPORTED_MODULE_10__.findFragmentByPDT)(fragments, fragPrevious.endProgramDateTime, this.config.maxFragLookUpTolerance);
2672      }
2673      if (!frag) {
2674        // SN does not need to be accurate between renditions, but depending on the packaging it may be so.
2675        var targetSN = fragPrevious.sn + 1;
2676        if (targetSN >= levelDetails.startSN && targetSN <= levelDetails.endSN) {
2677          var fragNext = fragments[targetSN - levelDetails.startSN];
2678          // Ensure that we're staying within the continuity range, since PTS resets upon a new range
2679          if (fragPrevious.cc === fragNext.cc) {
2680            frag = fragNext;
2681            this.log("Live playlist, switching playlist, load frag with next SN: " + frag.sn);
2682          }
2683        }
2684        // It's important to stay within the continuity range if available; otherwise the fragments in the playlist
2685        // will have the wrong start times
2686        if (!frag) {
2687          frag = (0,_fragment_finders__WEBPACK_IMPORTED_MODULE_10__.findFragWithCC)(fragments, fragPrevious.cc);
2688          if (frag) {
2689            this.log("Live playlist, switching playlist, load frag with same CC: " + frag.sn);
2690          }
2691        }
2692      }
2693    } else {
2694      // Find a new start fragment when fragPrevious is null
2695      var liveStart = this.hls.liveSyncPosition;
2696      if (liveStart !== null) {
2697        frag = this.getFragmentAtPosition(liveStart, this.bitrateTest ? levelDetails.fragmentEnd : levelDetails.edge, levelDetails);
2698      }
2699    }
2700    return frag;
2701  }
2702
2703  /*
2704  This method finds the best matching fragment given the provided position.
2705   */;
2706  _proto.getFragmentAtPosition = function getFragmentAtPosition(bufferEnd, end, levelDetails) {
2707    var config = this.config;
2708    var fragPrevious = this.fragPrevious;
2709    var fragments = levelDetails.fragments,
2710      endSN = levelDetails.endSN;
2711    var fragmentHint = levelDetails.fragmentHint;
2712    var tolerance = config.maxFragLookUpTolerance;
2713    var loadingParts = !!(config.lowLatencyMode && levelDetails.partList && fragmentHint);
2714    if (loadingParts && fragmentHint && !this.bitrateTest) {
2715      // Include incomplete fragment with parts at end
2716      fragments = fragments.concat(fragmentHint);
2717      endSN = fragmentHint.sn;
2718    }
2719    var frag;
2720    if (bufferEnd < end) {
2721      var lookupTolerance = bufferEnd > end - tolerance ? 0 : tolerance;
2722      // Remove the tolerance if it would put the bufferEnd past the actual end of stream
2723      // Uses buffer and sequence number to calculate switch segment (required if using EXT-X-DISCONTINUITY-SEQUENCE)
2724      frag = (0,_fragment_finders__WEBPACK_IMPORTED_MODULE_10__.findFragmentByPTS)(fragPrevious, fragments, bufferEnd, lookupTolerance);
2725    } else {
2726      // reach end of playlist
2727      frag = fragments[fragments.length - 1];
2728    }
2729    if (frag) {
2730      var curSNIdx = frag.sn - levelDetails.startSN;
2731      // Move fragPrevious forward to support forcing the next fragment to load
2732      // when the buffer catches up to a previously buffered range.
2733      if (this.fragmentTracker.getState(frag) === _fragment_tracker__WEBPACK_IMPORTED_MODULE_2__.FragmentState.OK) {
2734        fragPrevious = frag;
2735      }
2736      if (fragPrevious && frag.sn === fragPrevious.sn && !loadingParts) {
2737        // Force the next fragment to load if the previous one was already selected. This can occasionally happen with
2738        // non-uniform fragment durations
2739        var sameLevel = fragPrevious && frag.level === fragPrevious.level;
2740        if (sameLevel) {
2741          var nextFrag = fragments[curSNIdx + 1];
2742          if (frag.sn < endSN && this.fragmentTracker.getState(nextFrag) !== _fragment_tracker__WEBPACK_IMPORTED_MODULE_2__.FragmentState.OK) {
2743            this.log("SN " + frag.sn + " just loaded, load next one: " + nextFrag.sn);
2744            frag = nextFrag;
2745          } else {
2746            frag = null;
2747          }
2748        }
2749      }
2750    }
2751    return frag;
2752  };
2753  _proto.synchronizeToLiveEdge = function synchronizeToLiveEdge(levelDetails) {
2754    var config = this.config,
2755      media = this.media;
2756    if (!media) {
2757      return;
2758    }
2759    var liveSyncPosition = this.hls.liveSyncPosition;
2760    var currentTime = media.currentTime;
2761    var start = levelDetails.fragments[0].start;
2762    var end = levelDetails.edge;
2763    var withinSlidingWindow = currentTime >= start - config.maxFragLookUpTolerance && currentTime <= end;
2764    // Continue if we can seek forward to sync position or if current time is outside of sliding window
2765    if (liveSyncPosition !== null && media.duration > liveSyncPosition && (currentTime < liveSyncPosition || !withinSlidingWindow)) {
2766      // Continue if buffer is starving or if current time is behind max latency
2767      var maxLatency = config.liveMaxLatencyDuration !== undefined ? config.liveMaxLatencyDuration : config.liveMaxLatencyDurationCount * levelDetails.targetduration;
2768      if (!withinSlidingWindow && media.readyState < 4 || currentTime < end - maxLatency) {
2769        if (!this.loadedmetadata) {
2770          this.nextLoadPosition = liveSyncPosition;
2771        }
2772        // Only seek if ready and there is not a significant forward buffer available for playback
2773        if (media.readyState) {
2774          this.warn("Playback: " + currentTime.toFixed(3) + " is located too far from the end of live sliding playlist: " + end + ", reset currentTime to : " + liveSyncPosition.toFixed(3));
2775          media.currentTime = liveSyncPosition;
2776        }
2777      }
2778    }
2779  };
2780  _proto.alignPlaylists = function alignPlaylists(details, previousDetails) {
2781    var levels = this.levels,
2782      levelLastLoaded = this.levelLastLoaded,
2783      fragPrevious = this.fragPrevious;
2784    var lastLevel = levelLastLoaded !== null ? levels[levelLastLoaded] : null;
2785
2786    // FIXME: If not for `shouldAlignOnDiscontinuities` requiring fragPrevious.cc,
2787    //  this could all go in level-helper mergeDetails()
2788    var length = details.fragments.length;
2789    if (!length) {
2790      this.warn("No fragments in live playlist");
2791      return 0;
2792    }
2793    var slidingStart = details.fragments[0].start;
2794    var firstLevelLoad = !previousDetails;
2795    var aligned = details.alignedSliding && (0,_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__.isFiniteNumber)(slidingStart);
2796    if (firstLevelLoad || !aligned && !slidingStart) {
2797      (0,_utils_discontinuities__WEBPACK_IMPORTED_MODULE_9__.alignStream)(fragPrevious, lastLevel, details);
2798      var alignedSlidingStart = details.fragments[0].start;
2799      this.log("Live playlist sliding: " + alignedSlidingStart.toFixed(2) + " start-sn: " + (previousDetails ? previousDetails.startSN : 'na') + "->" + details.startSN + " prev-sn: " + (fragPrevious ? fragPrevious.sn : 'na') + " fragments: " + length);
2800      return alignedSlidingStart;
2801    }
2802    return slidingStart;
2803  };
2804  _proto.waitForCdnTuneIn = function waitForCdnTuneIn(details) {
2805    // Wait for Low-Latency CDN Tune-in to get an updated playlist
2806    var advancePartLimit = 3;
2807    return details.live && details.canBlockReload && details.partTarget && details.tuneInGoal > Math.max(details.partHoldBack, details.partTarget * advancePartLimit);
2808  };
2809  _proto.setStartPosition = function setStartPosition(details, sliding) {
2810    // compute start position if set to -1. use it straight away if value is defined
2811    var startPosition = this.startPosition;
2812    if (startPosition < sliding) {
2813      startPosition = -1;
2814    }
2815    if (startPosition === -1 || this.lastCurrentTime === -1) {
2816      // first, check if start time offset has been set in playlist, if yes, use this value
2817      var startTimeOffset = details.startTimeOffset;
2818      if ((0,_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__.isFiniteNumber)(startTimeOffset)) {
2819        startPosition = sliding + startTimeOffset;
2820        if (startTimeOffset < 0) {
2821          startPosition += details.totalduration;
2822        }
2823        startPosition = Math.min(Math.max(sliding, startPosition), sliding + details.totalduration);
2824        this.log("Start time offset " + startTimeOffset + " found in playlist, adjust startPosition to " + startPosition);
2825        this.startPosition = startPosition;
2826      } else if (details.live) {
2827        // Leave this.startPosition at -1, so that we can use `getInitialLiveFragment` logic when startPosition has
2828        // not been specified via the config or an as an argument to startLoad (#3736).
2829        startPosition = this.hls.liveSyncPosition || sliding;
2830      } else {
2831        this.startPosition = startPosition = 0;
2832      }
2833      this.lastCurrentTime = startPosition;
2834    }
2835    this.nextLoadPosition = startPosition;
2836  };
2837  _proto.getLoadPosition = function getLoadPosition() {
2838    var media = this.media;
2839    // if we have not yet loaded any fragment, start loading from start position
2840    var pos = 0;
2841    if (this.loadedmetadata && media) {
2842      pos = media.currentTime;
2843    } else if (this.nextLoadPosition) {
2844      pos = this.nextLoadPosition;
2845    }
2846    return pos;
2847  };
2848  _proto.handleFragLoadAborted = function handleFragLoadAborted(frag, part) {
2849    if (this.transmuxer && frag.sn !== 'initSegment' && frag.stats.aborted) {
2850      this.warn("Fragment " + frag.sn + (part ? ' part' + part.index : '') + " of level " + frag.level + " was aborted");
2851      this.resetFragmentLoading(frag);
2852    }
2853  };
2854  _proto.resetFragmentLoading = function resetFragmentLoading(frag) {
2855    if (!this.fragCurrent || !this.fragContextChanged(frag) && this.state !== State.FRAG_LOADING_WAITING_RETRY) {
2856      this.state = State.IDLE;
2857    }
2858  };
2859  _proto.onFragmentOrKeyLoadError = function onFragmentOrKeyLoadError(filterType, data) {
2860    if (data.fatal) {
2861      this.stopLoad();
2862      this.state = State.ERROR;
2863      return;
2864    }
2865    var config = this.config;
2866    if (data.chunkMeta) {
2867      // Parsing Error: no retries
2868      var context = this.getCurrentContext(data.chunkMeta);
2869      if (context) {
2870        data.frag = context.frag;
2871        data.levelRetry = true;
2872        this.fragLoadError = config.fragLoadingMaxRetry;
2873      }
2874    }
2875    var frag = data.frag;
2876    // Handle frag error related to caller's filterType
2877    if (!frag || frag.type !== filterType) {
2878      return;
2879    }
2880    var fragCurrent = this.fragCurrent;
2881    console.assert(fragCurrent && frag.sn === fragCurrent.sn && frag.level === fragCurrent.level && frag.urlId === fragCurrent.urlId, 'Frag load error must match current frag to retry');
2882    // keep retrying until the limit will be reached
2883    if (this.fragLoadError + 1 <= config.fragLoadingMaxRetry) {
2884      if (!this.loadedmetadata) {
2885        this.startFragRequested = false;
2886        this.nextLoadPosition = this.startPosition;
2887      }
2888      // exponential backoff capped to config.fragLoadingMaxRetryTimeout
2889      var delay = Math.min(Math.pow(2, this.fragLoadError) * config.fragLoadingRetryDelay, config.fragLoadingMaxRetryTimeout);
2890      this.warn("Fragment " + frag.sn + " of " + filterType + " " + frag.level + " failed to load, retrying in " + delay + "ms");
2891      this.retryDate = self.performance.now() + delay;
2892      this.fragLoadError++;
2893      this.state = State.FRAG_LOADING_WAITING_RETRY;
2894    } else if (data.levelRetry) {
2895      if (filterType === _types_loader__WEBPACK_IMPORTED_MODULE_15__.PlaylistLevelType.AUDIO) {
2896        // Reset current fragment since audio track audio is essential and may not have a fail-over track
2897        this.fragCurrent = null;
2898      }
2899      // Fragment errors that result in a level switch or redundant fail-over
2900      // should reset the stream controller state to idle
2901      this.fragLoadError = 0;
2902      this.state = State.IDLE;
2903    } else {
2904      _utils_logger__WEBPACK_IMPORTED_MODULE_4__.logger.error(data.details + " reaches max retry, redispatch as fatal ...");
2905      // switch error to fatal
2906      data.fatal = true;
2907      this.hls.stopLoad();
2908      this.state = State.ERROR;
2909    }
2910  };
2911  _proto.afterBufferFlushed = function afterBufferFlushed(media, bufferType, playlistType) {
2912    if (!media) {
2913      return;
2914    }
2915    // After successful buffer flushing, filter flushed fragments from bufferedFrags use mediaBuffered instead of media
2916    // (so that we will check against video.buffered ranges in case of alt audio track)
2917    var bufferedTimeRanges = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__.BufferHelper.getBuffered(media);
2918    this.fragmentTracker.detectEvictedFragments(bufferType, bufferedTimeRanges, playlistType);
2919    if (this.state === State.ENDED) {
2920      this.resetLoadingState();
2921    }
2922  };
2923  _proto.resetLoadingState = function resetLoadingState() {
2924    this.log('Reset loading state');
2925    this.fragCurrent = null;
2926    this.fragPrevious = null;
2927    this.state = State.IDLE;
2928  };
2929  _proto.resetStartWhenNotLoaded = function resetStartWhenNotLoaded(level) {
2930    // if loadedmetadata is not set, it means that first frag request failed
2931    // in that case, reset startFragRequested flag
2932    if (!this.loadedmetadata) {
2933      this.startFragRequested = false;
2934      var details = this.levels ? this.levels[level].details : null;
2935      if (details !== null && details !== void 0 && details.live) {
2936        // Update the start position and return to IDLE to recover live start
2937        this.startPosition = -1;
2938        this.setStartPosition(details, 0);
2939        this.resetLoadingState();
2940      } else {
2941        this.nextLoadPosition = this.startPosition;
2942      }
2943    }
2944  };
2945  _proto.updateLevelTiming = function updateLevelTiming(frag, part, level, partial) {
2946    var _this6 = this;
2947    var details = level.details;
2948    console.assert(!!details, 'level.details must be defined');
2949    var parsed = Object.keys(frag.elementaryStreams).reduce(function (result, type) {
2950      var info = frag.elementaryStreams[type];
2951      if (info) {
2952        var parsedDuration = info.endPTS - info.startPTS;
2953        if (parsedDuration <= 0) {
2954          // Destroy the transmuxer after it's next time offset failed to advance because duration was <= 0.
2955          // The new transmuxer will be configured with a time offset matching the next fragment start,
2956          // preventing the timeline from shifting.
2957          _this6.warn("Could not parse fragment " + frag.sn + " " + type + " duration reliably (" + parsedDuration + ")");
2958          return result || false;
2959        }
2960        var drift = partial ? 0 : (0,_level_helper__WEBPACK_IMPORTED_MODULE_11__.updateFragPTSDTS)(details, frag, info.startPTS, info.endPTS, info.startDTS, info.endDTS);
2961        _this6.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.LEVEL_PTS_UPDATED, {
2962          details: details,
2963          level: level,
2964          drift: drift,
2965          type: type,
2966          frag: frag,
2967          start: info.startPTS,
2968          end: info.endPTS
2969        });
2970        return true;
2971      }
2972      return result;
2973    }, false);
2974    if (!parsed) {
2975      this.warn("Found no media in fragment " + frag.sn + " of level " + level.id + " resetting transmuxer to fallback to playlist timing");
2976      this.resetTransmuxer();
2977    }
2978    this.state = State.PARSED;
2979    this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__.Events.FRAG_PARSED, {
2980      frag: frag,
2981      part: part
2982    });
2983  };
2984  _proto.resetTransmuxer = function resetTransmuxer() {
2985    if (this.transmuxer) {
2986      this.transmuxer.destroy();
2987      this.transmuxer = null;
2988    }
2989  };
2990  _createClass(BaseStreamController, [{
2991    key: "state",
2992    get: function get() {
2993      return this._state;
2994    },
2995    set: function set(nextState) {
2996      var previousState = this._state;
2997      if (previousState !== nextState) {
2998        this._state = nextState;
2999        this.log(previousState + "->" + nextState);
3000      }
3001    }
3002  }]);
3003  return BaseStreamController;
3004}(_task_loop__WEBPACK_IMPORTED_MODULE_1__["default"]);
3005
3006
3007/***/ }),
3008
3009/***/ "./src/controller/buffer-controller.ts":
3010/*!*********************************************!*\
3011  !*** ./src/controller/buffer-controller.ts ***!
3012  \*********************************************/
3013/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
3014
3015"use strict";
3016__webpack_require__.r(__webpack_exports__);
3017/* harmony export */ __webpack_require__.d(__webpack_exports__, {
3018/* harmony export */   "default": () => (/* binding */ BufferController)
3019/* harmony export */ });
3020/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
3021/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../events */ "./src/events.ts");
3022/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
3023/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
3024/* harmony import */ var _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.ts");
3025/* harmony import */ var _utils_mediasource_helper__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../utils/mediasource-helper */ "./src/utils/mediasource-helper.ts");
3026/* harmony import */ var _loader_fragment__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../loader/fragment */ "./src/loader/fragment.ts");
3027/* harmony import */ var _buffer_operation_queue__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./buffer-operation-queue */ "./src/controller/buffer-operation-queue.ts");
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040var MediaSource = (0,_utils_mediasource_helper__WEBPACK_IMPORTED_MODULE_5__.getMediaSource)();
3041var VIDEO_CODEC_PROFILE_REPACE = /([ha]vc.)(?:\.[^.,]+)+/;
3042var BufferController = /*#__PURE__*/function () {
3043  // The level details used to determine duration, target-duration and live
3044
3045  // cache the self generated object url to detect hijack of video tag
3046
3047  // A queue of buffer operations which require the SourceBuffer to not be updating upon execution
3048
3049  // References to event listeners for each SourceBuffer, so that they can be referenced for event removal
3050
3051  // The number of BUFFER_CODEC events received before any sourceBuffers are created
3052
3053  // The total number of BUFFER_CODEC events received
3054
3055  // A reference to the attached media element
3056
3057  // A reference to the active media source
3058
3059  // Last MP3 audio chunk appended
3060
3061  // counters
3062
3063  function BufferController(