hls.js 1.5.7-0.canary.10040 → 1.5.7

package/dist/hls.light.mjs

@@ -256,7 +256,6 @@ let Events = /*#__PURE__*/function (Events) {
   Events["MEDIA_ATTACHED"] = "hlsMediaAttached";
   Events["MEDIA_DETACHING"] = "hlsMediaDetaching";
   Events["MEDIA_DETACHED"] = "hlsMediaDetached";
-  Events["MEDIA_ENDED"] = "hlsMediaEnded";
   Events["BUFFER_RESET"] = "hlsBufferReset";
   Events["BUFFER_CODECS"] = "hlsBufferCodecs";
   Events["BUFFER_CREATED"] = "hlsBufferCreated";
@@ -370,6 +369,58 @@ let ErrorDetails = /*#__PURE__*/function (ErrorDetails) {
   return ErrorDetails;
 }({});
 
+const noop = function noop() {};
+const fakeLogger = {
+  trace: noop,
+  debug: noop,
+  log: noop,
+  warn: noop,
+  info: noop,
+  error: noop
+};
+let exportedLogger = fakeLogger;
+
+// let lastCallTime;
+// function formatMsgWithTimeInfo(type, msg) {
+//   const now = Date.now();
+//   const diff = lastCallTime ? '+' + (now - lastCallTime) : '0';
+//   lastCallTime = now;
+//   msg = (new Date(now)).toISOString() + ' | [' +  type + '] > ' + msg + ' ( ' + diff + ' ms )';
+//   return msg;
+// }
+
+function consolePrintFn(type) {
+  const func = self.console[type];
+  if (func) {
+    return func.bind(self.console, `[${type}] >`);
+  }
+  return noop;
+}
+function exportLoggerFunctions(debugConfig, ...functions) {
+  functions.forEach(function (type) {
+    exportedLogger[type] = debugConfig[type] ? debugConfig[type].bind(debugConfig) : consolePrintFn(type);
+  });
+}
+function enableLogs(debugConfig, id) {
+  // check that console is available
+  if (typeof console === 'object' && debugConfig === true || typeof debugConfig === 'object') {
+    exportLoggerFunctions(debugConfig,
+    // Remove out from list here to hard-disable a log-level
+    // 'trace',
+    'debug', 'log', 'info', 'warn', 'error');
+    // Some browsers don't allow to use bind on console object anyway
+    // fallback to default if needed
+    try {
+      exportedLogger.log(`Debug logs enabled for "${id}" in hls.js version ${"1.5.7"}`);
+    } catch (e) {
+      exportedLogger = fakeLogger;
+    }
+  } else {
+    exportedLogger = fakeLogger;
+  }
+}
+const logger = exportedLogger;
+
 const DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/;
 const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
 
@@ -451,79 +502,6 @@ class AttrList {
   }
 }
 
-class Logger {
-  constructor(label, logger) {
-    this.trace = void 0;
-    this.debug = void 0;
-    this.log = void 0;
-    this.warn = void 0;
-    this.info = void 0;
-    this.error = void 0;
-    const lb = `[${label}]:`;
-    this.trace = noop;
-    this.debug = logger.debug.bind(null, lb);
-    this.log = logger.log.bind(null, lb);
-    this.warn = logger.warn.bind(null, lb);
-    this.info = logger.info.bind(null, lb);
-    this.error = logger.error.bind(null, lb);
-  }
-}
-const noop = function noop() {};
-const fakeLogger = {
-  trace: noop,
-  debug: noop,
-  log: noop,
-  warn: noop,
-  info: noop,
-  error: noop
-};
-function createLogger() {
-  return _extends({}, fakeLogger);
-}
-
-// let lastCallTime;
-// function formatMsgWithTimeInfo(type, msg) {
-//   const now = Date.now();
-//   const diff = lastCallTime ? '+' + (now - lastCallTime) : '0';
-//   lastCallTime = now;
-//   msg = (new Date(now)).toISOString() + ' | [' +  type + '] > ' + msg + ' ( ' + diff + ' ms )';
-//   return msg;
-// }
-
-function consolePrintFn(type, id) {
-  const func = self.console[type];
-  return func ? func.bind(self.console, `${id ? '[' + id + '] ' : ''}[${type}] >`) : noop;
-}
-function getLoggerFn(key, debugConfig, id) {
-  return debugConfig[key] ? debugConfig[key].bind(debugConfig) : consolePrintFn(key, id);
-}
-const exportedLogger = createLogger();
-function enableLogs(debugConfig, context, id) {
-  // check that console is available
-  const newLogger = createLogger();
-  if (typeof console === 'object' && debugConfig === true || typeof debugConfig === 'object') {
-    const keys = [
-    // Remove out from list here to hard-disable a log-level
-    // 'trace',
-    'debug', 'log', 'info', 'warn', 'error'];
-    keys.forEach(key => {
-      newLogger[key] = getLoggerFn(key, debugConfig, id);
-    });
-    // Some browsers don't allow to use bind on console object anyway
-    // fallback to default if needed
-    try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.7-0.canary.10040"}`);
-    } catch (e) {
-      /* log fn threw an exception. All logger methods are no-ops. */
-      return createLogger();
-    }
-  }
-  // global exported logger uses the log methods from last call to `enableLogs`
-  _extends(exportedLogger, newLogger);
-  return newLogger;
-}
-const logger = exportedLogger;
-
 // Avoid exporting const enum so that these values can be inlined
 
 function isDateRangeCueAttribute(attrName) {
@@ -1013,30 +991,10 @@ class LevelDetails {
   }
 }
 
-var DecrypterAesMode = {
-  cbc: 0,
-  ctr: 1
-};
-
-function isFullSegmentEncryption(method) {
-  return method === 'AES-128' || method === 'AES-256' || method === 'AES-256-CTR';
-}
-function getAesModeFromFullSegmentMethod(method) {
-  switch (method) {
-    case 'AES-128':
-    case 'AES-256':
-      return DecrypterAesMode.cbc;
-    case 'AES-256-CTR':
-      return DecrypterAesMode.ctr;
-    default:
-      throw new Error(`invalid full segment method ${method}`);
-  }
-}
-
 // This file is inserted as a shim for modules which we do not want to include into the distro.
 // This replacement is done in the "alias" plugin of the rollup config.
 var empty = undefined;
-var HevcVideoParser = /*@__PURE__*/getDefaultExportFromCjs(empty);
+var Cues = /*@__PURE__*/getDefaultExportFromCjs(empty);
 
 function sliceUint8(array, start, end) {
   // @ts-expect-error This polyfills IE11 usage of Uint8Array slice.
@@ -1668,7 +1626,7 @@ function parseStsd(stsd) {
       {
         const codecBox = findBox(sampleEntries, [fourCC])[0];
         const esdsBox = findBox(codecBox.subarray(28), ['esds'])[0];
-        if (esdsBox && esdsBox.length > 7) {
+        if (esdsBox && esdsBox.length > 12) {
           let i = 4;
           // ES Descriptor tag
           if (esdsBox[i++] !== 0x03) {
@@ -1783,9 +1741,7 @@ function parseStsd(stsd) {
 }
 function skipBERInteger(bytes, i) {
   const limit = i + 5;
-  while (bytes[i++] & 0x80 && i < limit) {
-    /* do nothing */
-  }
+  while (bytes[i++] & 0x80 && i < limit) {}
   return i;
 }
 function toHex(x) {
@@ -2477,12 +2433,12 @@ class LevelKey {
     this.keyFormatVersions = formatversions;
     this.iv = iv;
     this.encrypted = method ? method !== 'NONE' : false;
-    this.isCommonEncryption = this.encrypted && !isFullSegmentEncryption(method);
+    this.isCommonEncryption = this.encrypted && method !== 'AES-128';
   }
   isSupported() {
     // If it's Segment encryption or No encryption, just select that key system
     if (this.method) {
-      if (isFullSegmentEncryption(this.method) || this.method === 'NONE') {
+      if (this.method === 'AES-128' || this.method === 'NONE') {
         return true;
       }
       if (this.keyFormat === 'identity') {
@@ -2496,13 +2452,14 @@ class LevelKey {
     if (!this.encrypted || !this.uri) {
       return null;
     }
-    if (isFullSegmentEncryption(this.method) && this.uri && !this.iv) {
+    if (this.method === 'AES-128' && this.uri && !this.iv) {
       if (typeof sn !== 'number') {
         // We are fetching decryption data for a initialization segment
-        // If the segment was encrypted with AES-128/256
+        // If the segment was encrypted with AES-128
         // It must have an IV defined. We cannot substitute the Segment Number in.
-        logger.warn(`missing IV for initialization segment with method="${this.method}" - compliance issue`);
-
+        if (this.method === 'AES-128' && !this.iv) {
+          logger.warn(`missing IV for initialization segment with method="${this.method}" - compliance issue`);
+        }
         // Explicitly set sn to resulting value from implicit conversions 'initSegment' values for IV generation.
         sn = 0;
       }
@@ -2649,28 +2606,23 @@ function getCodecCompatibleNameLower(lowerCaseCodec, preferManagedMediaSource =
   if (CODEC_COMPATIBLE_NAMES[lowerCaseCodec]) {
     return CODEC_COMPATIBLE_NAMES[lowerCaseCodec];
   }
+
+  // Idealy fLaC and Opus would be first (spec-compliant) but
+  // some browsers will report that fLaC is supported then fail.
+  // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
   const codecsToCheck = {
-    // Idealy fLaC and Opus would be first (spec-compliant) but
-    // some browsers will report that fLaC is supported then fail.
-    // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
     flac: ['flac', 'fLaC', 'FLAC'],
-    opus: ['opus', 'Opus'],
-    // Replace audio codec info if browser does not support mp4a.40.34,
-    // and demuxer can fallback to 'audio/mpeg' or 'audio/mp4;codecs="mp3"'
-    'mp4a.40.34': ['mp3']
+    opus: ['opus', 'Opus']
   }[lowerCaseCodec];
   for (let i = 0; i < codecsToCheck.length; i++) {
-    var _getMediaSource;
     if (isCodecMediaSourceSupported(codecsToCheck[i], 'audio', preferManagedMediaSource)) {
       CODEC_COMPATIBLE_NAMES[lowerCaseCodec] = codecsToCheck[i];
       return codecsToCheck[i];
-    } else if (codecsToCheck[i] === 'mp3' && (_getMediaSource = getMediaSource(preferManagedMediaSource)) != null && _getMediaSource.isTypeSupported('audio/mpeg')) {
-      return '';
     }
   }
   return lowerCaseCodec;
 }
-const AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
+const AUDIO_CODEC_REGEXP = /flac|opus/i;
 function getCodecCompatibleName(codec, preferManagedMediaSource = true) {
   return codec.replace(AUDIO_CODEC_REGEXP, m => getCodecCompatibleNameLower(m.toLowerCase(), preferManagedMediaSource));
 }
@@ -2693,16 +2645,6 @@ function convertAVC1ToAVCOTI(codec) {
   }
   return codec;
 }
-function getM2TSSupportedAudioTypes(preferManagedMediaSource) {
-  const MediaSource = getMediaSource(preferManagedMediaSource) || {
-    isTypeSupported: () => false
-  };
-  return {
-    mpeg: MediaSource.isTypeSupported('audio/mpeg'),
-    mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
-    ac3: false
-  };
-}
 
 const MASTER_PLAYLIST_REGEX = /#EXT-X-STREAM-INF:([^\r\n]*)(?:[\r\n](?:#[^\r\n]*)?)*([^\r\n]+)|#EXT-X-(SESSION-DATA|SESSION-KEY|DEFINE|CONTENT-STEERING|START):([^\r\n]*)[\r\n]+/g;
 const MASTER_PLAYLIST_MEDIA_REGEX = /#EXT-X-MEDIA:(.*)/g;
@@ -3503,10 +3445,10 @@ class PlaylistLoader {
       const loaderContext = loader.context;
       if (loaderContext && loaderContext.url === context.url && loaderContext.level === context.level) {
         // same URL can't overlap
-        this.hls.logger.trace('[playlist-loader]: playlist request ongoing');
+        logger.trace('[playlist-loader]: playlist request ongoing');
         return;
       }
-      this.hls.logger.log(`[playlist-loader]: aborting previous loader for type: ${context.type}`);
+      logger.log(`[playlist-loader]: aborting previous loader for type: ${context.type}`);
       loader.abort();
     }
 
@@ -3616,7 +3558,7 @@ class PlaylistLoader {
       // alt audio rendition in which quality levels (main)
       // contains both audio+video. but with mixed audio track not signaled
       if (!embeddedAudioFound && levels[0].audioCodec && !levels[0].attrs.AUDIO) {
-        this.hls.logger.log('[playlist-loader]: audio codec signaled in quality level, but no embedded audio track signaled, create one');
+        logger.log('[playlist-loader]: audio codec signaled in quality level, but no embedded audio track signaled, create one');
         audioTracks.unshift({
           type: 'main',
           name: 'main',
@@ -3715,7 +3657,7 @@ class PlaylistLoader {
       message += ` id: ${context.id} group-id: "${context.groupId}"`;
     }
     const error = new Error(message);
-    this.hls.logger.warn(`[playlist-loader]: ${message}`);
+    logger.warn(`[playlist-loader]: ${message}`);
     let details = ErrorDetails.UNKNOWN;
     let fatal = false;
     const loader = this.getInternalLoader(context);
@@ -4280,47 +4222,7 @@ class LatencyController {
     this.currentTime = 0;
     this.stallCount = 0;
     this._latency = null;
-    this.onTimeupdate = () => {
-      const {
-        media,
-        levelDetails
-      } = this;
-      if (!media || !levelDetails) {
-        return;
-      }
-      this.currentTime = media.currentTime;
-      const latency = this.computeLatency();
-      if (latency === null) {
-        return;
-      }
-      this._latency = latency;
-
-      // Adapt playbackRate to meet target latency in low-latency mode
-      const {
-        lowLatencyMode,
-        maxLiveSyncPlaybackRate
-      } = this.config;
-      if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
-        return;
-      }
-      const targetLatency = this.targetLatency;
-      if (targetLatency === null) {
-        return;
-      }
-      const distanceFromTarget = latency - targetLatency;
-      // Only adjust playbackRate when within one target duration of targetLatency
-      // and more than one second from under-buffering.
-      // Playback further than one target duration from target can be considered DVR playback.
-      const liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
-      const inLiveRange = distanceFromTarget < liveMinLatencyDuration;
-      if (inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
-        const max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
-        const rate = Math.round(2 / (1 + Math.exp(-0.75 * distanceFromTarget - this.edgeStalled)) * 20) / 20;
-        media.playbackRate = Math.min(max, Math.max(1, rate));
-      } else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
-        media.playbackRate = 1;
-      }
-    };
+    this.timeupdateHandler = () => this.timeupdate();
     this.hls = hls;
     this.config = hls.config;
     this.registerListeners();
@@ -4412,7 +4314,7 @@ class LatencyController {
     this.onMediaDetaching();
     this.levelDetails = null;
     // @ts-ignore
-    this.hls = null;
+    this.hls = this.timeupdateHandler = null;
   }
   registerListeners() {
     this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
@@ -4430,11 +4332,11 @@ class LatencyController {
   }
   onMediaAttached(event, data) {
     this.media = data.media;
-    this.media.addEventListener('timeupdate', this.onTimeupdate);
+    this.media.addEventListener('timeupdate', this.timeupdateHandler);
   }
   onMediaDetaching() {
     if (this.media) {
-      this.media.removeEventListener('timeupdate', this.onTimeupdate);
+      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
       this.media = null;
     }
   }
@@ -4448,10 +4350,10 @@ class LatencyController {
   }) {
     this.levelDetails = details;
     if (details.advanced) {
-      this.onTimeupdate();
+      this.timeupdate();
     }
     if (!details.live && this.media) {
-      this.media.removeEventListener('timeupdate', this.onTimeupdate);
+      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
     }
   }
   onError(event, data) {
@@ -4461,7 +4363,48 @@ class LatencyController {
     }
     this.stallCount++;
     if ((_this$levelDetails = this.levelDetails) != null && _this$levelDetails.live) {
-      this.hls.logger.warn('[latency-controller]: Stall detected, adjusting target latency');
+      logger.warn('[playback-rate-controller]: Stall detected, adjusting target latency');
+    }
+  }
+  timeupdate() {
+    const {
+      media,
+      levelDetails
+    } = this;
+    if (!media || !levelDetails) {
+      return;
+    }
+    this.currentTime = media.currentTime;
+    const latency = this.computeLatency();
+    if (latency === null) {
+      return;
+    }
+    this._latency = latency;
+
+    // Adapt playbackRate to meet target latency in low-latency mode
+    const {
+      lowLatencyMode,
+      maxLiveSyncPlaybackRate
+    } = this.config;
+    if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
+      return;
+    }
+    const targetLatency = this.targetLatency;
+    if (targetLatency === null) {
+      return;
+    }
+    const distanceFromTarget = latency - targetLatency;
+    // Only adjust playbackRate when within one target duration of targetLatency
+    // and more than one second from under-buffering.
+    // Playback further than one target duration from target can be considered DVR playback.
+    const liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
+    const inLiveRange = distanceFromTarget < liveMinLatencyDuration;
+    if (inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
+      const max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
+      const rate = Math.round(2 / (1 + Math.exp(-0.75 * distanceFromTarget - this.edgeStalled)) * 20) / 20;
+      media.playbackRate = Math.min(max, Math.max(1, rate));
+    } else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
+      media.playbackRate = 1;
     }
   }
   estimateLiveEdge() {
@@ -5233,13 +5176,18 @@ var ErrorActionFlags = {
   MoveAllAlternatesMatchingHDCP: 2,
   SwitchToSDR: 4
 }; // Reserved for future use
-class ErrorController extends Logger {
+class ErrorController {
   constructor(hls) {
-    super('error-controller', hls.logger);
     this.hls = void 0;
     this.playlistError = 0;
     this.penalizedRenditions = {};
+    this.log = void 0;
+    this.warn = void 0;
+    this.error = void 0;
     this.hls = hls;
+    this.log = logger.log.bind(logger, `[info]:`);
+    this.warn = logger.warn.bind(logger, `[warning]:`);
+    this.error = logger.error.bind(logger, `[error]:`);
     this.registerListeners();
   }
   registerListeners() {
@@ -5591,13 +5539,16 @@ class ErrorController extends Logger {
   }
 }
 
-class BasePlaylistController extends Logger {
+class BasePlaylistController {
   constructor(hls, logPrefix) {
-    super(logPrefix, hls.logger);
     this.hls = void 0;
     this.timer = -1;
     this.requestScheduled = -1;
     this.canLoad = false;
+    this.log = void 0;
+    this.warn = void 0;
+    this.log = logger.log.bind(logger, `${logPrefix}:`);
+    this.warn = logger.warn.bind(logger, `${logPrefix}:`);
     this.hls = hls;
   }
   destroy() {
@@ -5630,7 +5581,7 @@ class BasePlaylistController extends Logger {
         try {
           uri = new self.URL(attr.URI, previous.url).href;
         } catch (error) {
-          this.warn(`Could not construct new URL for Rendition Report: ${error}`);
+          logger.warn(`Could not construct new URL for Rendition Report: ${error}`);
           uri = attr.URI || '';
         }
         // Use exact match. Otherwise, the last partial match, if any, will be used
@@ -5717,12 +5668,7 @@ class BasePlaylistController extends Logger {
         const cdnAge = lastAdvanced + details.ageHeader;
         let currentGoal = Math.min(cdnAge - details.partTarget, details.targetduration * 1.5);
         if (currentGoal > 0) {
-          if (cdnAge > details.targetduration * 3) {
-            // Omit segment and part directives when the last response was more than 3 target durations ago,
-            this.log(`Playlist last advanced ${lastAdvanced.toFixed(2)}s ago. Omitting segment and part directives.`);
-            msn = undefined;
-            part = undefined;
-          } else if (previousDetails != null && previousDetails.tuneInGoal && cdnAge - details.partTarget > previousDetails.tuneInGoal) {
+          if (previousDetails && currentGoal > previousDetails.tuneInGoal) {
             // If we attempted to get the next or latest playlist update, but currentGoal increased,
             // then we either can't catchup, or the "age" header cannot be trusted.
             this.warn(`CDN Tune-in goal increased from: ${previousDetails.tuneInGoal} to: ${currentGoal} with playlist age: ${details.age}`);
@@ -6181,9 +6127,8 @@ function getCodecTiers(levels, audioTracksByGroup, minAutoLevel, maxAutoLevel) {
   }, {});
 }
 
-class AbrController extends Logger {
+class AbrController {
   constructor(_hls) {
-    super('abr', _hls.logger);
     this.hls = void 0;
     this.lastLevelLoadSec = 0;
     this.lastLoadedFragLevel = -1;
@@ -6297,7 +6242,7 @@ class AbrController extends Logger {
         this.resetEstimator(nextLoadLevelBitrate);
       }
       this.clearTimer();
-      this.warn(`Fragment ${frag.sn}${part ? ' part ' + part.index : ''} of level ${frag.level} is loading too slowly;
+      logger.warn(`[abr] Fragment ${frag.sn}${part ? ' part ' + part.index : ''} of level ${frag.level} is loading too slowly;
       Time to underbuffer: ${bufferStarvationDelay.toFixed(3)} s
       Estimated load time for current fragment: ${fragLoadedDelay.toFixed(3)} s
       Estimated load time for down switch fragment: ${fragLevelNextLoadedDelay.toFixed(3)} s
@@ -6317,7 +6262,7 @@ class AbrController extends Logger {
   }
   resetEstimator(abrEwmaDefaultEstimate) {
     if (abrEwmaDefaultEstimate) {
-      this.log(`setting initial bwe to ${abrEwmaDefaultEstimate}`);
+      logger.log(`setting initial bwe to ${abrEwmaDefaultEstimate}`);
       this.hls.config.abrEwmaDefaultEstimate = abrEwmaDefaultEstimate;
     }
     this.firstSelection = -1;
@@ -6549,7 +6494,7 @@ class AbrController extends Logger {
     }
     const firstLevel = this.hls.firstLevel;
     const clamped = Math.min(Math.max(firstLevel, minAutoLevel), maxAutoLevel);
-    this.warn(`Could not find best starting auto level. Defaulting to first in playlist ${firstLevel} clamped to ${clamped}`);
+    logger.warn(`[abr] Could not find best starting auto level. Defaulting to first in playlist ${firstLevel} clamped to ${clamped}`);
     return clamped;
   }
   get forcedAutoLevel() {
@@ -6595,9 +6540,6 @@ class AbrController extends Logger {
       partCurrent,
       hls
     } = this;
-    if (hls.levels.length <= 1) {
-      return hls.loadLevel;
-    }
     const {
       maxAutoLevel,
       config,
@@ -6630,13 +6572,13 @@ class AbrController extends Logger {
         // cap maxLoadingDelay and ensure it is not bigger 'than bitrate test' frag duration
         const maxLoadingDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxLoadingDelay) : config.maxLoadingDelay;
         maxStarvationDelay = maxLoadingDelay - bitrateTestDelay;
-        this.info(`bitrate test took ${Math.round(1000 * bitrateTestDelay)}ms, set first fragment max fetchDuration to ${Math.round(1000 * maxStarvationDelay)} ms`);
+        logger.info(`[abr] bitrate test took ${Math.round(1000 * bitrateTestDelay)}ms, set first fragment max fetchDuration to ${Math.round(1000 * maxStarvationDelay)} ms`);
         // don't use conservative factor on bitrate test
         bwFactor = bwUpFactor = 1;
       }
     }
     const bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, maxStarvationDelay, bwFactor, bwUpFactor);
-    this.info(`${bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty'}, optimal quality level ${bestLevel}`);
+    logger.info(`[abr] ${bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty'}, optimal quality level ${bestLevel}`);
     if (bestLevel > -1) {
       return bestLevel;
     }
@@ -6710,7 +6652,7 @@ class AbrController extends Logger {
       currentVideoRange = preferHDR ? videoRanges[videoRanges.length - 1] : videoRanges[0];
       currentFrameRate = minFramerate;
       currentBw = Math.max(currentBw, minBitrate);
-      this.log(`picked start tier ${JSON.stringify(startTier)}`);
+      logger.log(`[abr] picked start tier ${JSON.stringify(startTier)}`);
     } else {
       currentCodecSet = level == null ? void 0 : level.codecSet;
       currentVideoRange = level == null ? void 0 : level.videoRange;
@@ -6763,9 +6705,9 @@ class AbrController extends Logger {
         const forcedAutoLevel = this.forcedAutoLevel;
         if (i !== loadLevel && (forcedAutoLevel === -1 || forcedAutoLevel !== loadLevel)) {
           if (levelsSkipped.length) {
-            this.trace(`Skipped level(s) ${levelsSkipped.join(',')} of ${maxAutoLevel} max with CODECS and VIDEO-RANGE:"${levels[levelsSkipped[0]].codecs}" ${levels[levelsSkipped[0]].videoRange}; not compatible with "${level.codecs}" ${currentVideoRange}`);
+            logger.trace(`[abr] Skipped level(s) ${levelsSkipped.join(',')} of ${maxAutoLevel} max with CODECS and VIDEO-RANGE:"${levels[levelsSkipped[0]].codecs}" ${levels[levelsSkipped[0]].videoRange}; not compatible with "${level.codecs}" ${currentVideoRange}`);
           }
-          this.info(`switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${currentCodecSet} videoRange:${currentVideoRange} hls.loadLevel:${loadLevel}`);
+          logger.info(`[abr] switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${currentCodecSet} videoRange:${currentVideoRange} hls.loadLevel:${loadLevel}`);
         }
         if (firstSelection) {
           this.firstSelection = i;
@@ -6808,29 +6750,40 @@ class BufferHelper {
    * Return true if `media`'s buffered include `position`
    */
   static isBuffered(media, position) {
-    if (media) {
-      const buffered = BufferHelper.getBuffered(media);
-      for (let i = buffered.length; i--;) {
-        if (position >= buffered.start(i) && position <= buffered.end(i)) {
-          return true;
+    try {
+      if (media) {
+        const buffered = BufferHelper.getBuffered(media);
+        for (let i = 0; i < buffered.length; i++) {
+          if (position >= buffered.start(i) && position <= buffered.end(i)) {
+            return true;
+          }
         }
       }
+    } catch (error) {
+      // this is to catch
+      // InvalidStateError: Failed to read the 'buffered' property from 'SourceBuffer':
+      // This SourceBuffer has been removed from the parent media source
     }
     return false;
   }
   static bufferInfo(media, pos, maxHoleDuration) {
-    if (media) {
-      const vbuffered = BufferHelper.getBuffered(media);
-      if (vbuffered.length) {
+    try {
+      if (media) {
+        const vbuffered = BufferHelper.getBuffered(media);
         const buffered = [];
-        for (let i = 0; i < vbuffered.length; i++) {
+        let i;
+        for (i = 0; i < vbuffered.length; i++) {
           buffered.push({
             start: vbuffered.start(i),
             end: vbuffered.end(i)
           });
         }
-        return BufferHelper.bufferedInfo(buffered, pos, maxHoleDuration);
+        return this.bufferedInfo(buffered, pos, maxHoleDuration);
       }
+    } catch (error) {
+      // this is to catch
+      // InvalidStateError: Failed to read the 'buffered' property from 'SourceBuffer':
+      // This SourceBuffer has been removed from the parent media source
     }
     return {
       len: 0,
@@ -6842,7 +6795,14 @@ class BufferHelper {
   static bufferedInfo(buffered, pos, maxHoleDuration) {
     pos = Math.max(0, pos);
     // sort on buffer.start/smaller end (IE does not always return sorted buffered range)
-    buffered.sort((a, b) => a.start - b.start || b.end - a.end);
+    buffered.sort(function (a, b) {
+      const diff = a.start - b.start;
+      if (diff) {
+        return diff;
+      } else {
+        return b.end - a.end;
+      }
+    });
     let buffered2 = [];
     if (maxHoleDuration) {
       // there might be some small holes between buffer time range
@@ -6909,7 +6869,7 @@ class BufferHelper {
    */
   static getBuffered(media) {
     try {
-      return media.buffered || noopBuffered;
+      return media.buffered;
     } catch (e) {
       logger.log('failed to get media.buffered', e);
       return noopBuffered;
@@ -6934,22 +6894,24 @@ class BufferOperationQueue {
       this.executeNext(type);
     }
   }
+  insertAbort(operation, type) {
+    const queue = this.queues[type];
+    queue.unshift(operation);
+    this.executeNext(type);
+  }
   appendBlocker(type) {
-    return new Promise(resolve => {
-      const operation = {
-        execute: resolve,
-        onStart: () => {},
-        onComplete: () => {},
-        onError: () => {}
-      };
-      this.append(operation, type);
+    let execute;
+    const promise = new Promise(resolve => {
+      execute = resolve;
     });
-  }
-  unblockAudio(op) {
-    const queue = this.queues.audio;
-    if (queue[0] === op) {
-      this.shiftAndExecuteNext('audio');
-    }
+    const operation = {
+      execute,
+      onStart: () => {},
+      onComplete: () => {},
+      onError: () => {}
+    };
+    this.append(operation, type);
+    return promise;
   }
   executeNext(type) {
     const queue = this.queues[type];
@@ -6981,9 +6943,8 @@ class BufferOperationQueue {
 }
 
 const VIDEO_CODEC_PROFILE_REPLACE = /(avc[1234]|hvc1|hev1|dvh[1e]|vp09|av01)(?:\.[^.,]+)+/;
-class BufferController extends Logger {
-  constructor(hls, fragmentTracker) {
-    super('buffer-controller', hls.logger);
+class BufferController {
+  constructor(hls) {
     // The level details used to determine duration, target-duration and live
     this.details = null;
     // cache the self generated object url to detect hijack of video tag
@@ -6993,7 +6954,6 @@ class BufferController extends Logger {
     // References to event listeners for each SourceBuffer, so that they can be referenced for event removal
     this.listeners = void 0;
     this.hls = void 0;
-    this.fragmentTracker = void 0;
     // The number of BUFFER_CODEC events received before any sourceBuffers are created
     this.bufferCodecEventsExpected = 0;
     // The total number of BUFFER_CODEC events received
@@ -7004,10 +6964,6 @@ class BufferController extends Logger {
     this.mediaSource = null;
     // Last MP3 audio chunk appended
     this.lastMpegAudioChunk = null;
-    // Audio fragment blocked from appending until corresponding video appends or context changes
-    this.blockedAudioAppend = null;
-    // Keep track of video append position for unblocking audio
-    this.lastVideoAppendEnd = 0;
     this.appendSource = void 0;
     // counters
     this.appendErrors = {
@@ -7018,6 +6974,9 @@ class BufferController extends Logger {
     this.tracks = {};
     this.pendingTracks = {};
     this.sourceBuffer = void 0;
+    this.log = void 0;
+    this.warn = void 0;
+    this.error = void 0;
     this._onEndStreaming = event => {
       if (!this.hls) {
         return;
@@ -7039,10 +6998,7 @@ class BufferController extends Logger {
       this.log('Media source opened');
       if (media) {
         media.removeEventListener('emptied', this._onMediaEmptied);
-        const durationAndRange = this.getDurationAndRange();
-        if (durationAndRange) {
-          this.updateMediaSource(durationAndRange);
-        }
+        this.updateMediaElementDuration();
         this.hls.trigger(Events.MEDIA_ATTACHED, {
           media,
           mediaSource: mediaSource
@@ -7066,12 +7022,15 @@ class BufferController extends Logger {
         _objectUrl
       } = this;
       if (mediaSrc !== _objectUrl) {
-        this.error(`Media element src was set while attaching MediaSource (${_objectUrl} > ${mediaSrc})`);
+        logger.error(`Media element src was set while attaching MediaSource (${_objectUrl} > ${mediaSrc})`);
       }
     };
     this.hls = hls;
-    this.fragmentTracker = fragmentTracker;
-    this.appendSource = hls.config.preferManagedMediaSource;
+    const logPrefix = '[buffer-controller]';
+    this.appendSource = hls.config.preferManagedMediaSource && typeof self !== 'undefined' && self.ManagedMediaSource;
+    this.log = logger.log.bind(logger, logPrefix);
+    this.warn = logger.warn.bind(logger, logPrefix);
+    this.error = logger.error.bind(logger, logPrefix);
     this._initSourceBuffer();
     this.registerListeners();
   }
@@ -7083,13 +7042,7 @@ class BufferController extends Logger {
     this.details = null;
     this.lastMpegAudioChunk = null;
     // @ts-ignore
-    this.hls = this.fragmentTracker = null;
-    // @ts-ignore
-    this._onMediaSourceOpen = this._onMediaSourceClose = null;
-    // @ts-ignore
-    this._onMediaSourceEnded = null;
-    // @ts-ignore
-    this._onStartStreaming = this._onEndStreaming = null;
+    this.hls = null;
   }
   registerListeners() {
     const {
@@ -7139,8 +7092,6 @@ class BufferController extends Logger {
       audiovideo: 0
     };
     this.lastMpegAudioChunk = null;
-    this.blockedAudioAppend = null;
-    this.lastVideoAppendEnd = 0;
   }
   onManifestLoading() {
     this.bufferCodecEventsExpected = this._bufferCodecEventsTotal = 0;
@@ -7169,8 +7120,10 @@ class BufferController extends Logger {
       ms.addEventListener('sourceopen', this._onMediaSourceOpen);
       ms.addEventListener('sourceended', this._onMediaSourceEnded);
       ms.addEventListener('sourceclose', this._onMediaSourceClose);
-      ms.addEventListener('startstreaming', this._onStartStreaming);
-      ms.addEventListener('endstreaming', this._onEndStreaming);
+      if (this.appendSource) {
+        ms.addEventListener('startstreaming', this._onStartStreaming);
+        ms.addEventListener('endstreaming', this._onEndStreaming);
+      }
 
       // cache the locally generated object url
       const objectUrl = this._objectUrl = self.URL.createObjectURL(ms);
@@ -7217,8 +7170,10 @@ class BufferController extends Logger {
       mediaSource.removeEventListener('sourceopen', this._onMediaSourceOpen);
       mediaSource.removeEventListener('sourceended', this._onMediaSourceEnded);
       mediaSource.removeEventListener('sourceclose', this._onMediaSourceClose);
-      mediaSource.removeEventListener('startstreaming', this._onStartStreaming);
-      mediaSource.removeEventListener('endstreaming', this._onEndStreaming);
+      if (this.appendSource) {
+        mediaSource.removeEventListener('startstreaming', this._onStartStreaming);
+        mediaSource.removeEventListener('endstreaming', this._onEndStreaming);
+      }
 
       // Detach properly the MediaSource from the HTMLMediaElement as
       // suggested in https://github.com/w3c/media-source/issues/53.
@@ -7254,7 +7209,6 @@ class BufferController extends Logger {
       this.resetBuffer(type);
     });
     this._initSourceBuffer();
-    this.hls.resumeBuffering();
   }
   resetBuffer(type) {
     const sb = this.sourceBuffer[type];
@@ -7278,10 +7232,9 @@ class BufferController extends Logger {
     const trackNames = Object.keys(data);
     trackNames.forEach(trackName => {
       if (sourceBufferCount) {
-        var _track$buffer;
         // check if SourceBuffer codec needs to change
         const track = this.tracks[trackName];
-        if (track && typeof ((_track$buffer = track.buffer) == null ? void 0 : _track$buffer.changeType) === 'function') {
+        if (track && typeof track.buffer.changeType === 'function') {
           var _trackCodec;
           const {
             id,
@@ -7296,7 +7249,7 @@ class BufferController extends Logger {
           const nextCodec = (_trackCodec = trackCodec) == null ? void 0 : _trackCodec.replace(VIDEO_CODEC_PROFILE_REPLACE, '$1');
           if (trackCodec && currentCodec !== nextCodec) {
             if (trackName.slice(0, 5) === 'audio') {
-              trackCodec = getCodecCompatibleName(trackCodec, this.hls.config.preferManagedMediaSource);
+              trackCodec = getCodecCompatibleName(trackCodec, this.appendSource);
             }
             const mimeType = `${container};codecs=${trackCodec}`;
             this.appendChangeType(trackName, mimeType);
@@ -7351,54 +7304,20 @@ class BufferController extends Logger {
     };
     operationQueue.append(operation, type, !!this.pendingTracks[type]);
   }
-  blockAudio(partOrFrag) {
-    var _this$fragmentTracker;
-    const pStart = partOrFrag.start;
-    const pTime = pStart + partOrFrag.duration * 0.05;
-    const atGap = ((_this$fragmentTracker = this.fragmentTracker.getAppendedFrag(pStart, PlaylistLevelType.MAIN)) == null ? void 0 : _this$fragmentTracker.gap) === true;
-    if (atGap) {
-      return;
-    }
-    const op = {
-      execute: () => {
-        var _this$fragmentTracker2;
-        if (this.lastVideoAppendEnd > pTime || this.sourceBuffer.video && BufferHelper.isBuffered(this.sourceBuffer.video, pTime) || ((_this$fragmentTracker2 = this.fragmentTracker.getAppendedFrag(pTime, PlaylistLevelType.MAIN)) == null ? void 0 : _this$fragmentTracker2.gap) === true) {
-          this.blockedAudioAppend = null;
-          this.operationQueue.shiftAndExecuteNext('audio');
-        }
-      },
-      onStart: () => {},
-      onComplete: () => {},
-      onError: () => {}
-    };
-    this.blockedAudioAppend = {
-      op,
-      frag: partOrFrag
-    };
-    this.operationQueue.append(op, 'audio', true);
-  }
-  unblockAudio() {
-    const blockedAudioAppend = this.blockedAudioAppend;
-    if (blockedAudioAppend) {
-      this.blockedAudioAppend = null;
-      this.operationQueue.unblockAudio(blockedAudioAppend.op);
-    }
-  }
   onBufferAppending(event, eventData) {
     const {
+      hls,
       operationQueue,
       tracks
     } = this;
     const {
       data,
       type,
-      parent,
       frag,
       part,
       chunkMeta
     } = eventData;
     const chunkStats = chunkMeta.buffering[type];
-    const sn = frag.sn;
     const bufferAppendingStart = self.performance.now();
     chunkStats.start = bufferAppendingStart;
     const fragBuffering = frag.stats.buffering;
@@ -7421,36 +7340,7 @@ class BufferController extends Logger {
       checkTimestampOffset = !this.lastMpegAudioChunk || chunkMeta.id === 1 || this.lastMpegAudioChunk.sn !== chunkMeta.sn;
       this.lastMpegAudioChunk = chunkMeta;
     }
-
-    // Block audio append until overlapping video append
-    const videoSb = this.sourceBuffer.video;
-    if (videoSb && sn !== 'initSegment') {
-      const partOrFrag = part || frag;
-      const blockedAudioAppend = this.blockedAudioAppend;
-      if (type === 'audio' && parent !== 'main' && !this.blockedAudioAppend) {
-        const pStart = partOrFrag.start;
-        const pTime = pStart + partOrFrag.duration * 0.05;
-        const vbuffered = videoSb.buffered;
-        const vappending = this.operationQueue.current('video');
-        if (!vbuffered.length && !vappending) {
-          // wait for video before appending audio
-          this.blockAudio(partOrFrag);
-        } else if (!vappending && !BufferHelper.isBuffered(videoSb, pTime) && this.lastVideoAppendEnd < pTime) {
-          // audio is ahead of video
-          this.blockAudio(partOrFrag);
-        }
-      } else if (type === 'video') {
-        const videoAppendEnd = partOrFrag.end;
-        if (blockedAudioAppend) {
-          const audioStart = blockedAudioAppend.frag.start;
-          if (videoAppendEnd > audioStart || videoAppendEnd < this.lastVideoAppendEnd || BufferHelper.isBuffered(videoSb, audioStart)) {
-            this.unblockAudio();
-          }
-        }
-        this.lastVideoAppendEnd = videoAppendEnd;
-      }
-    }
-    const fragStart = (part || frag).start;
+    const fragStart = frag.start;
     const operation = {
       execute: () => {
         chunkStats.executeStart = self.performance.now();
@@ -7459,7 +7349,7 @@ class BufferController extends Logger {
           if (sb) {
             const delta = fragStart - sb.timestampOffset;
             if (Math.abs(delta) >= 0.1) {
-              this.log(`Updating audio SourceBuffer timestampOffset to ${fragStart} (delta: ${delta}) sn: ${sn})`);
+              this.log(`Updating audio SourceBuffer timestampOffset to ${fragStart} (delta: ${delta}) sn: ${frag.sn})`);
               sb.timestampOffset = fragStart;
             }
           }
@@ -7526,21 +7416,22 @@ class BufferController extends Logger {
           /* with UHD content, we could get loop of quota exceeded error until
             browser is able to evict some data from sourcebuffer. Retrying can help recover.
           */
-          this.warn(`Failed ${appendErrorCount}/${this.hls.config.appendErrorMaxRetry} times to append segment in "${type}" sourceBuffer`);
-          if (appendErrorCount >= this.hls.config.appendErrorMaxRetry) {
+          this.warn(`Failed ${appendErrorCount}/${hls.config.appendErrorMaxRetry} times to append segment in "${type}" sourceBuffer`);
+          if (appendErrorCount >= hls.config.appendErrorMaxRetry) {
             event.fatal = true;
           }
         }
-        this.hls.trigger(Events.ERROR, event);
+        hls.trigger(Events.ERROR, event);
       }
     };
     operationQueue.append(operation, type, !!this.pendingTracks[type]);
   }
-  getFlushOp(type, start, end) {
-    return {
-      execute: () => {
-        this.removeExecutor(type, start, end);
-      },
+  onBufferFlushing(event, data) {
+    const {
+      operationQueue
+    } = this;
+    const flushOperation = type => ({
+      execute: this.removeExecutor.bind(this, type, data.startOffset, data.endOffset),
       onStart: () => {
         // logger.debug(`[buffer-controller]: Started flushing ${data.startOffset} -> ${data.endOffset} for ${type} Source Buffer`);
       },
@@ -7553,22 +7444,12 @@ class BufferController extends Logger {
       onError: error => {
         this.warn(`Failed to remove from ${type} SourceBuffer`, error);
       }
-    };
-  }
-  onBufferFlushing(event, data) {
-    const {
-      operationQueue
-    } = this;
-    const {
-      type,
-      startOffset,
-      endOffset
-    } = data;
-    if (type) {
-      operationQueue.append(this.getFlushOp(type, startOffset, endOffset), type);
+    });
+    if (data.type) {
+      operationQueue.append(flushOperation(data.type), data.type);
     } else {
-      this.getSourceBufferTypes().forEach(sbType => {
-        operationQueue.append(this.getFlushOp(sbType, startOffset, endOffset), sbType);
+      this.getSourceBufferTypes().forEach(type => {
+        operationQueue.append(flushOperation(type), type);
       });
     }
   }
@@ -7615,9 +7496,6 @@ class BufferController extends Logger {
   // on BUFFER_EOS mark matching sourcebuffer(s) as ended and trigger checkEos()
   // an undefined data.type will mark all buffers as EOS.
   onBufferEos(event, data) {
-    if (data.type === 'video') {
-      this.unblockAudio();
-    }
     const ended = this.getSourceBufferTypes().reduce((acc, type) => {
       const sb = this.sourceBuffer[type];
       if (sb && (!data.type || data.type === type)) {
@@ -7660,14 +7538,10 @@ class BufferController extends Logger {
       return;
     }
     this.details = details;
-    const durationAndRange = this.getDurationAndRange();
-    if (!durationAndRange) {
-      return;
-    }
     if (this.getSourceBufferTypes().length) {
-      this.blockBuffers(() => this.updateMediaSource(durationAndRange));
+      this.blockBuffers(this.updateMediaElementDuration.bind(this));
     } else {
-      this.updateMediaSource(durationAndRange);
+      this.updateMediaElementDuration();
     }
   }
   trimBuffers() {
@@ -7772,9 +7646,9 @@ class BufferController extends Logger {
    * 'liveDurationInfinity` is set to `true`
    * More details: https://github.com/video-dev/hls.js/issues/355
    */
-  getDurationAndRange() {
+  updateMediaElementDuration() {
     if (!this.details || !this.media || !this.mediaSource || this.mediaSource.readyState !== 'open') {
-      return null;
+      return;
     }
     const {
       details,
@@ -7788,41 +7662,25 @@ class BufferController extends Logger {
     if (details.live && hls.config.liveDurationInfinity) {
       // Override duration to Infinity
       mediaSource.duration = Infinity;
-      const len = details.fragments.length;
-      if (len && details.live && !!mediaSource.setLiveSeekableRange) {
-        const start = Math.max(0, details.fragments[0].start);
-        const end = Math.max(start, start + details.totalduration);
-        return {
-          duration: Infinity,
-          start,
-          end
-        };
-      }
-      return {
-        duration: Infinity
-      };
+      this.updateSeekableRange(details);
     } else if (levelDuration > msDuration && levelDuration > mediaDuration || !isFiniteNumber(mediaDuration)) {
-      return {
-        duration: levelDuration
-      };
+      // levelDuration was the last value we set.
+      // not using mediaSource.duration as the browser may tweak this value
+      // only update Media Source duration if its value increase, this is to avoid
+      // flushing already buffered portion when switching between quality level
+      this.log(`Updating Media Source duration to ${levelDuration.toFixed(3)}`);
+      mediaSource.duration = levelDuration;
     }
-    return null;
   }
-  updateMediaSource({
-    duration,
-    start,
-    end
-  }) {
-    if (!this.media || !this.mediaSource || this.mediaSource.readyState !== 'open') {
-      return;
-    }
-    if (isFiniteNumber(duration)) {
-      this.log(`Updating Media Source duration to ${duration.toFixed(3)}`);
-    }
-    this.mediaSource.duration = duration;
-    if (start !== undefined && end !== undefined) {
-      this.log(`Media Source duration is set to ${this.mediaSource.duration}. Setting seekable range to ${start}-${end}.`);
-      this.mediaSource.setLiveSeekableRange(start, end);
+  updateSeekableRange(levelDetails) {
+    const mediaSource = this.mediaSource;
+    const fragments = levelDetails.fragments;
+    const len = fragments.length;
+    if (len && levelDetails.live && mediaSource != null && mediaSource.setLiveSeekableRange) {
+      const start = Math.max(0, fragments[0].start);
+      const end = Math.max(start, start + levelDetails.totalduration);
+      this.log(`Media Source duration is set to ${mediaSource.duration}. Setting seekable range to ${start}-${end}.`);
+      mediaSource.setLiveSeekableRange(start, end);
     }
   }
   checkPendingTracks() {
@@ -7880,7 +7738,7 @@ class BufferController extends Logger {
         let codec = track.levelCodec || track.codec;
         if (codec) {
           if (trackName.slice(0, 5) === 'audio') {
-            codec = getCodecCompatibleName(codec, this.hls.config.preferManagedMediaSource);
+            codec = getCodecCompatibleName(codec, this.appendSource);
           }
         }
         const mimeType = `${track.container};codecs=${codec}`;
@@ -7892,15 +7750,17 @@ class BufferController extends Logger {
           this.addBufferListener(sbName, 'updateend', this._onSBUpdateEnd);
           this.addBufferListener(sbName, 'error', this._onSBUpdateError);
           // ManagedSourceBuffer bufferedchange event
-          this.addBufferListener(sbName, 'bufferedchange', (type, event) => {
-            // If media was ejected check for a change. Added ranges are redundant with changes on 'updateend' event.
-            const removedRanges = event.removedRanges;
-            if (removedRanges != null && removedRanges.length) {
-              this.hls.trigger(Events.BUFFER_FLUSHED, {
-                type: trackName
-              });
-            }
-          });
+          if (this.appendSource) {
+            this.addBufferListener(sbName, 'bufferedchange', (type, event) => {
+              // If media was ejected check for a change. Added ranges are redundant with changes on 'updateend' event.
+              const removedRanges = event.removedRanges;
+              if (removedRanges != null && removedRanges.length) {
+                this.hls.trigger(Events.BUFFER_FLUSHED, {
+                  type: trackName
+                });
+              }
+            });
+          }
           this.tracks[trackName] = {
             buffer: sb,
             codec: codec,
@@ -8005,7 +7865,6 @@ class BufferController extends Logger {
       }
       return;
     }
-    sb.ending = false;
     sb.ended = false;
     sb.appendBuffer(data);
   }
@@ -8025,14 +7884,10 @@ class BufferController extends Logger {
 
     // logger.debug(`[buffer-controller]: Blocking ${buffers} SourceBuffer`);
     const blockingOperations = buffers.map(type => operationQueue.appendBlocker(type));
-    const audioBlocked = buffers.length > 1 && !!this.blockedAudioAppend;
-    if (audioBlocked) {
-      this.unblockAudio();
-    }
-    Promise.all(blockingOperations).then(result => {
+    Promise.all(blockingOperations).then(() => {
       // logger.debug(`[buffer-controller]: Blocking operation resolved; unblocking ${buffers} SourceBuffer`);
       onUnblocked();
-      buffers.forEach((type, i) => {
+      buffers.forEach(type => {
         const sb = this.sourceBuffer[type];
         // Only cycle the queue if the SB is not updating. There's a bug in Chrome which sets the SB updating flag to
         // true when changing the MediaSource duration (https://bugs.chromium.org/p/chromium/issues/detail?id=959359&can=2&q=mediasource%20duration)
@@ -8193,10 +8048,10 @@ class CapLevelController {
         const hls = this.hls;
         const maxLevel = this.getMaxLevel(levels.length - 1);
         if (maxLevel !== this.autoLevelCapping) {
-          hls.logger.log(`Setting autoLevelCapping to ${maxLevel}: ${levels[maxLevel].height}p@${levels[maxLevel].bitrate} for media ${this.mediaWidth}x${this.mediaHeight}`);
+          logger.log(`Setting autoLevelCapping to ${maxLevel}: ${levels[maxLevel].height}p@${levels[maxLevel].bitrate} for media ${this.mediaWidth}x${this.mediaHeight}`);
         }
         hls.autoLevelCapping = maxLevel;
-        if (hls.autoLevelEnabled && hls.autoLevelCapping > this.autoLevelCapping && this.streamController) {
+        if (hls.autoLevelCapping > this.autoLevelCapping && this.streamController) {
           // if auto level capping has a higher value for the previous one, flush the buffer using nextLevelSwitch
           // usually happen when the user go to the fullscreen mode.
           this.streamController.nextLevelSwitch();
@@ -8371,10 +8226,10 @@ class FPSController {
           totalDroppedFrames: droppedFrames
         });
         if (droppedFPS > 0) {
-          // hls.logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
+          // logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
           if (currentDropped > hls.config.fpsDroppedMonitoringThreshold * currentDecoded) {
             let currentLevel = hls.currentLevel;
-            hls.logger.warn('drop FPS ratio greater than max allowed value for currentLevel: ' + currentLevel);
+            logger.warn('drop FPS ratio greater than max allowed value for currentLevel: ' + currentLevel);
             if (currentLevel > 0 && (hls.autoLevelCapping === -1 || hls.autoLevelCapping >= currentLevel)) {
               currentLevel = currentLevel - 1;
               hls.trigger(Events.FPS_DROP_LEVEL_CAPPING, {
@@ -8407,10 +8262,10 @@ class FPSController {
 }
 
 const PATHWAY_PENALTY_DURATION_MS = 300000;
-class ContentSteeringController extends Logger {
+class ContentSteeringController {
   constructor(hls) {
-    super('content-steering', hls.logger);
     this.hls = void 0;
+    this.log = void 0;
     this.loader = null;
     this.uri = null;
     this.pathwayId = '.';
@@ -8425,6 +8280,7 @@ class ContentSteeringController extends Logger {
     this.subtitleTracks = null;
     this.penalizedPathways = {};
     this.hls = hls;
+    this.log = logger.log.bind(logger, `[content-steering]:`);
     this.registerListeners();
   }
   registerListeners() {
@@ -8548,7 +8404,7 @@ class ContentSteeringController extends Logger {
         errorAction.resolved = this.pathwayId !== errorPathway;
       }
       if (!errorAction.resolved) {
-        this.warn(`Could not resolve ${data.details} ("${data.error.message}") with content-steering for Pathway: ${errorPathway} levels: ${levels ? levels.length : levels} priorities: ${JSON.stringify(pathwayPriority)} penalized: ${JSON.stringify(this.penalizedPathways)}`);
+        logger.warn(`Could not resolve ${data.details} ("${data.error.message}") with content-steering for Pathway: ${errorPathway} levels: ${levels ? levels.length : levels} priorities: ${JSON.stringify(pathwayPriority)} penalized: ${JSON.stringify(this.penalizedPathways)}`);
       }
     }
   }
@@ -8719,7 +8575,7 @@ class ContentSteeringController extends Logger {
       onSuccess: (response, stats, context, networkDetails) => {
         this.log(`Loaded steering manifest: "${url}"`);
         const steeringData = response.data;
-        if ((steeringData == null ? void 0 : steeringData.VERSION) !== 1) {
+        if (steeringData.VERSION !== 1) {
           this.log(`Steering VERSION ${steeringData.VERSION} not supported!`);
           return;
         }
@@ -9627,7 +9483,7 @@ const hlsDefaultConfig = _objectSpread2(_objectSpread2({
 });
 function timelineConfig() {
   return {
-    cueHandler: HevcVideoParser,
+    cueHandler: Cues,
     // used by timeline-controller
     enableWebVTT: false,
     // used by timeline-controller
@@ -9658,7 +9514,7 @@ function timelineConfig() {
 /**
  * @ignore
  */
-function mergeConfig(defaultConfig, userConfig, logger) {
+function mergeConfig(defaultConfig, userConfig) {
   if ((userConfig.liveSyncDurationCount || userConfig.liveMaxLatencyDurationCount) && (userConfig.liveSyncDuration || userConfig.liveMaxLatencyDuration)) {
     throw new Error("Illegal hls.js config: don't mix up liveSyncDurationCount/liveMaxLatencyDurationCount and liveSyncDuration/liveMaxLatencyDuration");
   }
@@ -9728,7 +9584,7 @@ function deepCpy(obj) {
 /**
  * @ignore
  */
-function enableStreamingMode(config, logger) {
+function enableStreamingMode(config) {
   const currentLoader = config.loader;
   if (currentLoader !== FetchLoader && currentLoader !== XhrLoader) {
     // If a developer has configured their own loader, respect that choice
@@ -9745,9 +9601,10 @@ function enableStreamingMode(config, logger) {
   }
 }
 
+let chromeOrFirefox;
 class LevelController extends BasePlaylistController {
   constructor(hls, contentSteeringController) {
-    super(hls, 'level-controller');
+    super(hls, '[level-controller]');
     this._levels = [];
     this._firstLevel = -1;
     this._maxAutoLevel = -1;
@@ -9818,15 +9675,23 @@ class LevelController extends BasePlaylistController {
     let videoCodecFound = false;
     let audioCodecFound = false;
     data.levels.forEach(levelParsed => {
-      var _videoCodec;
+      var _audioCodec, _videoCodec;
       const attributes = levelParsed.attrs;
+
+      // erase audio codec info if browser does not support mp4a.40.34.
+      // demuxer will autodetect codec and fallback to mpeg/audio
       let {
         audioCodec,
         videoCodec
       } = levelParsed;
+      if (((_audioCodec = audioCodec) == null ? void 0 : _audioCodec.indexOf('mp4a.40.34')) !== -1) {
+        chromeOrFirefox || (chromeOrFirefox = /chrome|firefox/i.test(navigator.userAgent));
+        if (chromeOrFirefox) {
+          levelParsed.audioCodec = audioCodec = undefined;
+        }
+      }
       if (audioCodec) {
-        // Returns empty and set to undefined for 'mp4a.40.34' with fallback to 'audio/mpeg' SourceBuffer
-        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource) || undefined;
+        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource);
       }
       if (((_videoCodec = videoCodec) == null ? void 0 : _videoCodec.indexOf('avc1')) === 0) {
         videoCodec = levelParsed.videoCodec = convertAVC1ToAVCOTI(videoCodec);
@@ -10168,12 +10033,7 @@ class LevelController extends BasePlaylistController {
       if (curLevel.fragmentError === 0) {
         curLevel.loadError = 0;
       }
-      // Ignore matching details populated by loading a Media Playlist directly
-      let previousDetails = curLevel.details;
-      if (previousDetails === data.details && previousDetails.advanced) {
-        previousDetails = undefined;
-      }
-      this.playlistLoaded(level, data, previousDetails);
+      this.playlistLoaded(level, data, curLevel.details);
     } else if ((_data$deliveryDirecti2 = data.deliveryDirectives) != null && _data$deliveryDirecti2.skip) {
       // received a delta playlist update that cannot be merged
       details.deltaUpdateFailed = true;
@@ -10351,16 +10211,13 @@ class FragmentTracker {
    * If not found any Fragment, return null
    */
   getBufferedFrag(position, levelType) {
-    return this.getFragAtPos(position, levelType, true);
-  }
-  getFragAtPos(position, levelType, buffered) {
     const {
       fragments
     } = this;
     const keys = Object.keys(fragments);
     for (let i = keys.length; i--;) {
       const fragmentEntity = fragments[keys[i]];
-      if ((fragmentEntity == null ? void 0 : fragmentEntity.body.type) === levelType && (!buffered || fragmentEntity.buffered)) {
+      if ((fragmentEntity == null ? void 0 : fragmentEntity.body.type) === levelType && fragmentEntity.buffered) {
         const frag = fragmentEntity.body;
         if (frag.start <= position && position <= frag.end) {
           return frag;
@@ -10615,8 +10472,7 @@ class FragmentTracker {
     const {
       frag,
       part,
-      timeRanges,
-      type
+      timeRanges
     } = data;
     if (frag.sn === 'initSegment') {
       return;
@@ -10631,8 +10487,10 @@ class FragmentTracker {
     }
     // Store the latest timeRanges loaded in the buffer
     this.timeRanges = timeRanges;
-    const timeRange = timeRanges[type];
-    this.detectEvictedFragments(type, timeRange, playlistType, part);
+    Object.keys(timeRanges).forEach(elementaryStream => {
+      const timeRange = timeRanges[elementaryStream];
+      this.detectEvictedFragments(elementaryStream, timeRange, playlistType, part);
+    });
   }
   onFragBuffered(event, data) {
     this.detectPartialFragments(data);
@@ -10961,8 +10819,8 @@ function createLoaderContext(frag, part = null) {
     var _frag$decryptdata;
     let byteRangeStart = start;
     let byteRangeEnd = end;
-    if (frag.sn === 'initSegment' && isMethodFullSegmentAesCbc((_frag$decryptdata = frag.decryptdata) == null ? void 0 : _frag$decryptdata.method)) {
-      // MAP segment encrypted with method 'AES-128' or 'AES-256' (cbc), when served with HTTP Range,
+    if (frag.sn === 'initSegment' && ((_frag$decryptdata = frag.decryptdata) == null ? void 0 : _frag$decryptdata.method) === 'AES-128') {
+      // MAP segment encrypted with method 'AES-128', when served with HTTP Range,
       // has the unencrypted size specified in the range.
       // Ref: https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-6.3.6
       const fragmentLen = end - start;
@@ -10995,9 +10853,6 @@ function createGapLoadError(frag, part) {
   (part ? part : frag).stats.aborted = true;
   return new LoadError(errorData);
 }
-function isMethodFullSegmentAesCbc(method) {
-  return method === 'AES-128' || method === 'AES-256';
-}
 class LoadError extends Error {
   constructor(data) {
     super(data.error.message);
@@ -11143,8 +10998,6 @@ class KeyLoader {
         }
         return this.loadKeyEME(keyInfo, frag);
       case 'AES-128':
-      case 'AES-256':
-      case 'AES-256-CTR':
         return this.loadKeyHTTP(keyInfo, frag);
       default:
         return Promise.reject(this.createKeyLoadError(frag, ErrorDetails.KEY_LOAD_ERROR, new Error(`Key supplied with unsupported METHOD: "${decryptdata.method}"`)));
@@ -11280,9 +11133,8 @@ class KeyLoader {
  * we are limiting the task execution per call stack to exactly one, but scheduling/post-poning further
  * task processing on the next main loop iteration (also known as "next tick" in the Node/JS runtime lingo).
  */
-class TaskLoop extends Logger {
-  constructor(label, logger) {
-    super(label, logger);
+class TaskLoop {
+  constructor() {
     this._boundTick = void 0;
     this._tickTimer = null;
     this._tickInterval = null;
@@ -11550,61 +11402,33 @@ function alignMediaPlaylistByPDT(details, refDetails) {
 }
 
 class AESCrypto {
-  constructor(subtle, iv, aesMode) {
+  constructor(subtle, iv) {
     this.subtle = void 0;
     this.aesIV = void 0;
-    this.aesMode = void 0;
     this.subtle = subtle;
     this.aesIV = iv;
-    this.aesMode = aesMode;
   }
   decrypt(data, key) {
-    switch (this.aesMode) {
-      case DecrypterAesMode.cbc:
-        return this.subtle.decrypt({
-          name: 'AES-CBC',
-          iv: this.aesIV
-        }, key, data);
-      case DecrypterAesMode.ctr:
-        return this.subtle.decrypt({
-          name: 'AES-CTR',
-          counter: this.aesIV,
-          length: 64
-        },
-        //64 : NIST SP800-38A standard suggests that the counter should occupy half of the counter block
-        key, data);
-      default:
-        throw new Error(`[AESCrypto] invalid aes mode ${this.aesMode}`);
-    }
+    return this.subtle.decrypt({
+      name: 'AES-CBC',
+      iv: this.aesIV
+    }, key, data);
   }
 }
 
 class FastAESKey {
-  constructor(subtle, key, aesMode) {
+  constructor(subtle, key) {
     this.subtle = void 0;
     this.key = void 0;
-    this.aesMode = void 0;
     this.subtle = subtle;
     this.key = key;
-    this.aesMode = aesMode;
   }
   expandKey() {
-    const subtleAlgoName = getSubtleAlgoName(this.aesMode);
     return this.subtle.importKey('raw', this.key, {
-      name: subtleAlgoName
+      name: 'AES-CBC'
     }, false, ['encrypt', 'decrypt']);
   }
 }
-function getSubtleAlgoName(aesMode) {
-  switch (aesMode) {
-    case DecrypterAesMode.cbc:
-      return 'AES-CBC';
-    case DecrypterAesMode.ctr:
-      return 'AES-CTR';
-    default:
-      throw new Error(`[FastAESKey] invalid aes mode ${aesMode}`);
-  }
-}
 
 // PKCS7
 function removePadding(array) {
@@ -11854,8 +11678,7 @@ class Decrypter {
     this.currentIV = null;
     this.currentResult = null;
     this.useSoftware = void 0;
-    this.enableSoftwareAES = void 0;
-    this.enableSoftwareAES = config.enableSoftwareAES;
+    this.useSoftware = config.enableSoftwareAES;
     this.removePKCS7Padding = removePKCS7Padding;
     // built in decryptor expects PKCS7 padding
     if (removePKCS7Padding) {
@@ -11868,7 +11691,9 @@ class Decrypter {
         /* no-op */
       }
     }
-    this.useSoftware = this.subtle === null;
+    if (this.subtle === null) {
+      this.useSoftware = true;
+    }
   }
   destroy() {
     this.subtle = null;
@@ -11906,10 +11731,10 @@ class Decrypter {
       this.softwareDecrypter = null;
     }
   }
-  decrypt(data, key, iv, aesMode) {
+  decrypt(data, key, iv) {
     if (this.useSoftware) {
       return new Promise((resolve, reject) => {
-        this.softwareDecrypt(new Uint8Array(data), key, iv, aesMode);
+        this.softwareDecrypt(new Uint8Array(data), key, iv);
         const decryptResult = this.flush();
         if (decryptResult) {
           resolve(decryptResult.buffer);
@@ -11918,21 +11743,17 @@ class Decrypter {
         }
       });
     }
-    return this.webCryptoDecrypt(new Uint8Array(data), key, iv, aesMode);
+    return this.webCryptoDecrypt(new Uint8Array(data), key, iv);
   }
 
   // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
   // data is handled in the flush() call
-  softwareDecrypt(data, key, iv, aesMode) {
+  softwareDecrypt(data, key, iv) {
     const {
       currentIV,
       currentResult,
       remainderData
     } = this;
-    if (aesMode !== DecrypterAesMode.cbc || key.byteLength !== 16) {
-      logger.warn('SoftwareDecrypt: can only handle AES-128-CBC');
-      return null;
-    }
     this.logOnce('JS AES decrypt');
     // The output is staggered during progressive parsing - the current result is cached, and emitted on the next call
     // This is done in order to strip PKCS7 padding, which is found at the end of each segment. We only know we've reached
@@ -11965,11 +11786,11 @@ class Decrypter {
     }
     return result;
   }
-  webCryptoDecrypt(data, key, iv, aesMode) {
+  webCryptoDecrypt(data, key, iv) {
     const subtle = this.subtle;
     if (this.key !== key || !this.fastAesKey) {
       this.key = key;
-      this.fastAesKey = new FastAESKey(subtle, key, aesMode);
+      this.fastAesKey = new FastAESKey(subtle, key);
     }
     return this.fastAesKey.expandKey().then(aesKey => {
       // decrypt using web crypto
@@ -11977,25 +11798,22 @@ class Decrypter {
         return Promise.reject(new Error('web crypto not initialized'));
       }
       this.logOnce('WebCrypto AES decrypt');
-      const crypto = new AESCrypto(subtle, new Uint8Array(iv), aesMode);
+      const crypto = new AESCrypto(subtle, new Uint8Array(iv));
       return crypto.decrypt(data.buffer, aesKey);
     }).catch(err => {
       logger.warn(`[decrypter]: WebCrypto Error, disable WebCrypto API, ${err.name}: ${err.message}`);
-      return this.onWebCryptoError(data, key, iv, aesMode);
+      return this.onWebCryptoError(data, key, iv);
     });
   }
-  onWebCryptoError(data, key, iv, aesMode) {
-    const enableSoftwareAES = this.enableSoftwareAES;
-    if (enableSoftwareAES) {
-      this.useSoftware = true;
-      this.logEnabled = true;
-      this.softwareDecrypt(data, key, iv, aesMode);
-      const decryptResult = this.flush();
-      if (decryptResult) {
-        return decryptResult.buffer;
-      }
+  onWebCryptoError(data, key, iv) {
+    this.useSoftware = true;
+    this.logEnabled = true;
+    this.softwareDecrypt(data, key, iv);
+    const decryptResult = this.flush();
+    if (decryptResult) {
+      return decryptResult.buffer;
     }
-    throw new Error('WebCrypto' + (enableSoftwareAES ? ' and softwareDecrypt' : '') + ': failed to decrypt data');
+    throw new Error('WebCrypto and softwareDecrypt: failed to decrypt data');
   }
   getValidChunk(data) {
     let currentChunk = data;
@@ -12046,7 +11864,7 @@ const State = {
 };
 class BaseStreamController extends TaskLoop {
   constructor(hls, fragmentTracker, keyLoader, logPrefix, playlistType) {
-    super(logPrefix, hls.logger);
+    super();
     this.hls = void 0;
     this.fragPrevious = null;
     this.fragCurrent = null;
@@ -12071,98 +11889,22 @@ class BaseStreamController extends TaskLoop {
     this.startFragRequested = false;
     this.decrypter = void 0;
     this.initPTS = [];
-    this.buffering = true;
-    this.loadingParts = false;
-    this.onMediaSeeking = () => {
-      const {
-        config,
-        fragCurrent,
-        media,
-        mediaBuffer,
-        state
-      } = this;
-      const currentTime = media ? media.currentTime : 0;
-      const bufferInfo = BufferHelper.bufferInfo(mediaBuffer ? mediaBuffer : media, currentTime, config.maxBufferHole);
-      this.log(`media seeking to ${isFiniteNumber(currentTime) ? currentTime.toFixed(3) : currentTime}, state: ${state}`);
-      if (this.state === State.ENDED) {
-        this.resetLoadingState();
-      } else if (fragCurrent) {
-        // Seeking while frag load is in progress
-        const tolerance = config.maxFragLookUpTolerance;
-        const fragStartOffset = fragCurrent.start - tolerance;
-        const fragEndOffset = fragCurrent.start + fragCurrent.duration + tolerance;
-        // if seeking out of buffered range or into new one
-        if (!bufferInfo.len || fragEndOffset < bufferInfo.start || fragStartOffset > bufferInfo.end) {
-          const pastFragment = currentTime > fragEndOffset;
-          // if the seek position is outside the current fragment range
-          if (currentTime < fragStartOffset || pastFragment) {
-            if (pastFragment && fragCurrent.loader) {
-              this.log('seeking outside of buffer while fragment load in progress, cancel fragment load');
-              fragCurrent.abortRequests();
-              this.resetLoadingState();
-            }
-            this.fragPrevious = null;
-          }
-        }
-      }
-      if (media) {
-        // Remove gap fragments
-        this.fragmentTracker.removeFragmentsInRange(currentTime, Infinity, this.playlistType, true);
-        this.lastCurrentTime = currentTime;
-        if (!this.loadingParts) {
-          const bufferEnd = Math.max(bufferInfo.end, currentTime);
-          const shouldLoadParts = this.shouldLoadParts(this.getLevelDetails(), bufferEnd);
-          if (shouldLoadParts) {
-            this.log(`LL-Part loading ON after seeking to ${currentTime.toFixed(2)} with buffer @${bufferEnd.toFixed(2)}`);
-            this.loadingParts = shouldLoadParts;
-          }
-        }
-      }
-
-      // in case seeking occurs although no media buffered, adjust startPosition and nextLoadPosition to seek target
-      if (!this.loadedmetadata && !bufferInfo.len) {
-        this.nextLoadPosition = this.startPosition = currentTime;
-      }
-
-      // Async tick to speed up processing
-      this.tickImmediate();
-    };
-    this.onMediaEnded = () => {
-      // reset startPosition and lastCurrentTime to restart playback @ stream beginning
-      this.startPosition = this.lastCurrentTime = 0;
-      if (this.playlistType === PlaylistLevelType.MAIN) {
-        this.hls.trigger(Events.MEDIA_ENDED, {
-          stalled: false
-        });
-      }
-    };
+    this.onvseeking = null;
+    this.onvended = null;
+    this.logPrefix = '';
+    this.log = void 0;
+    this.warn = void 0;
     this.playlistType = playlistType;
+    this.logPrefix = logPrefix;
+    this.log = logger.log.bind(logger, `${logPrefix}:`);
+    this.warn = logger.warn.bind(logger, `${logPrefix}:`);
     this.hls = hls;
     this.fragmentLoader = new FragmentLoader(hls.config);
     this.keyLoader = keyLoader;
     this.fragmentTracker = fragmentTracker;
     this.config = hls.config;
     this.decrypter = new Decrypter(hls.config);
-  }
-  registerListeners() {
-    const {
-      hls
-    } = this;
-    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
-    hls.on(Events.ERROR, this.onError, this);
-  }
-  unregisterListeners() {
-    const {
-      hls
-    } = this;
-    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
-    hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
-    hls.off(Events.ERROR, this.onError, this);
   }
   doTick() {
     this.onTickEnd();
@@ -12186,12 +11928,6 @@ class BaseStreamController extends TaskLoop {
     this.clearNextTick();
     this.state = State.STOPPED;
   }
-  pauseBuffering() {
-    this.buffering = false;
-  }
-  resumeBuffering() {
-    this.buffering = true;
-  }
   _streamEnded(bufferInfo, levelDetails) {
     // If playlist is live, there is another buffered range after the current range, nothing buffered, media is detached,
     // of nothing loading/loaded return false
@@ -12222,8 +11958,10 @@ class BaseStreamController extends TaskLoop {
   }
   onMediaAttached(event, data) {
     const media = this.media = this.mediaBuffer = data.media;
-    media.addEventListener('seeking', this.onMediaSeeking);
-    media.addEventListener('ended', this.onMediaEnded);
+    this.onvseeking = this.onMediaSeeking.bind(this);
+    this.onvended = this.onMediaEnded.bind(this);
+    media.addEventListener('seeking', this.onvseeking);
+    media.addEventListener('ended', this.onvended);
     const config = this.config;
     if (this.levels && config.autoStartLoad && this.state === State.STOPPED) {
       this.startLoad(config.startPosition);
@@ -12237,9 +11975,10 @@ class BaseStreamController extends TaskLoop {
     }
 
     // remove video listeners
-    if (media) {
-      media.removeEventListener('seeking', this.onMediaSeeking);
-      media.removeEventListener('ended', this.onMediaEnded);
+    if (media && this.onvseeking && this.onvended) {
+      media.removeEventListener('seeking', this.onvseeking);
+      media.removeEventListener('ended', this.onvended);
+      this.onvseeking = this.onvended = null;
     }
     if (this.keyLoader) {
       this.keyLoader.detach();
@@ -12249,8 +11988,56 @@ class BaseStreamController extends TaskLoop {
     this.fragmentTracker.removeAllFragments();
     this.stopLoad();
   }
-  onManifestLoading() {}
-  onError(event, data) {}
+  onMediaSeeking() {
+    const {
+      config,
+      fragCurrent,
+      media,
+      mediaBuffer,
+      state
+    } = this;
+    const currentTime = media ? media.currentTime : 0;
+    const bufferInfo = BufferHelper.bufferInfo(mediaBuffer ? mediaBuffer : media, currentTime, config.maxBufferHole);
+    this.log(`media seeking to ${isFiniteNumber(currentTime) ? currentTime.toFixed(3) : currentTime}, state: ${state}`);
+    if (this.state === State.ENDED) {
+      this.resetLoadingState();
+    } else if (fragCurrent) {
+      // Seeking while frag load is in progress
+      const tolerance = config.maxFragLookUpTolerance;
+      const fragStartOffset = fragCurrent.start - tolerance;
+      const fragEndOffset = fragCurrent.start + fragCurrent.duration + tolerance;
+      // if seeking out of buffered range or into new one
+      if (!bufferInfo.len || fragEndOffset < bufferInfo.start || fragStartOffset > bufferInfo.end) {
+        const pastFragment = currentTime > fragEndOffset;
+        // if the seek position is outside the current fragment range
+        if (currentTime < fragStartOffset || pastFragment) {
+          if (pastFragment && fragCurrent.loader) {
+            this.log('seeking outside of buffer while fragment load in progress, cancel fragment load');
+            fragCurrent.abortRequests();
+            this.resetLoadingState();
+          }
+          this.fragPrevious = null;
+        }
+      }
+    }
+    if (media) {
+      // Remove gap fragments
+      this.fragmentTracker.removeFragmentsInRange(currentTime, Infinity, this.playlistType, true);
+      this.lastCurrentTime = currentTime;
+    }
+
+    // in case seeking occurs although no media buffered, adjust startPosition and nextLoadPosition to seek target
+    if (!this.loadedmetadata && !bufferInfo.len) {
+      this.nextLoadPosition = this.startPosition = currentTime;
+    }
+
+    // Async tick to speed up processing
+    this.tickImmediate();
+  }
+  onMediaEnded() {
+    // reset startPosition and lastCurrentTime to restart playback @ stream beginning
+    this.startPosition = this.lastCurrentTime = 0;
+  }
   onManifestLoaded(event, data) {
     this.startTimeOffset = data.startTimeOffset;
     this.initPTS = [];
@@ -12260,7 +12047,7 @@ class BaseStreamController extends TaskLoop {
     this.stopLoad();
     super.onHandlerDestroying();
     // @ts-ignore
-    this.hls = this.onMediaSeeking = this.onMediaEnded = null;
+    this.hls = null;
   }
   onHandlerDestroyed() {
     this.state = State.STOPPED;
@@ -12391,10 +12178,10 @@ class BaseStreamController extends TaskLoop {
       const decryptData = frag.decryptdata;
 
       // check to see if the payload needs to be decrypted
-      if (payload && payload.byteLength > 0 && decryptData != null && decryptData.key && decryptData.iv && isFullSegmentEncryption(decryptData.method)) {
+      if (payload && payload.byteLength > 0 && decryptData != null && decryptData.key && decryptData.iv && decryptData.method === 'AES-128') {
         const startTime = self.performance.now();
         // decrypt init segment data
-        return this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer, getAesModeFromFullSegmentMethod(decryptData.method)).catch(err => {
+        return this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer).catch(err => {
           hls.trigger(Events.ERROR, {
             type: ErrorTypes.MEDIA_ERROR,
             details: ErrorDetails.FRAG_DECRYPT_ERROR,
@@ -12506,7 +12293,7 @@ class BaseStreamController extends TaskLoop {
     }
     let keyLoadingPromise = null;
     if (frag.encrypted && !((_frag$decryptdata = frag.decryptdata) != null && _frag$decryptdata.key)) {
-      this.log(`Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'} ${frag.level}`);
+      this.log(`Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${this.logPrefix === '[stream-controller]' ? 'level' : 'track'} ${frag.level}`);
       this.state = State.KEY_LOADING;
       this.fragCurrent = frag;
       keyLoadingPromise = this.keyLoader.load(frag).then(keyLoadedData => {
@@ -12527,16 +12314,8 @@ class BaseStreamController extends TaskLoop {
     } else if (!frag.encrypted && details.encryptedFragments.length) {
       this.keyLoader.loadClear(frag, details.encryptedFragments);
     }
-    const fragPrevious = this.fragPrevious;
-    if (frag.sn !== 'initSegment' && (!fragPrevious || frag.sn !== fragPrevious.sn)) {
-      const shouldLoadParts = this.shouldLoadParts(level.details, frag.end);
-      if (shouldLoadParts !== this.loadingParts) {
-        this.log(`LL-Part loading ${shouldLoadParts ? 'ON' : 'OFF'} loading sn ${fragPrevious == null ? void 0 : fragPrevious.sn}->${frag.sn}`);
-        this.loadingParts = shouldLoadParts;
-      }
-    }
     targetBufferTime = Math.max(frag.start, targetBufferTime || 0);
-    if (this.loadingParts && frag.sn !== 'initSegment') {
+    if (this.config.lowLatencyMode && frag.sn !== 'initSegment') {
       const partList = details.partList;
       if (partList && progressCallback) {
         if (targetBufferTime > frag.end && details.fragmentHint) {
@@ -12545,7 +12324,7 @@ class BaseStreamController extends TaskLoop {
         const partIndex = this.getNextPart(partList, frag, targetBufferTime);
         if (partIndex > -1) {
           const part = partList[partIndex];
-          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.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
+          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))}`);
           this.nextLoadPosition = part.start + part.duration;
           this.state = State.FRAG_LOADING;
           let _result;
@@ -12574,14 +12353,7 @@ class BaseStreamController extends TaskLoop {
         }
       }
     }
-    if (frag.sn !== 'initSegment' && this.loadingParts) {
-      this.log(`LL-Part loading OFF after next part miss @${targetBufferTime.toFixed(2)}`);
-      this.loadingParts = false;
-    } else if (!frag.url) {
-      // Selected fragment hint for part but not loading parts
-      return Promise.resolve(null);
-    }
-    this.log(`Loading fragment ${frag.sn} cc: ${frag.cc} ${details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : ''}${this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
+    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))}`);
     // Don't update nextLoadPosition for fragments which are not buffered
     if (isFiniteNumber(frag.sn) && !this.bitrateTest) {
       this.nextLoadPosition = frag.start + frag.duration;
@@ -12679,36 +12451,8 @@ class BaseStreamController extends TaskLoop {
     if (part) {
       part.stats.parsing.end = now;
     }
-    // See if part loading should be disabled/enabled based on buffer and playback position.
-    if (frag.sn !== 'initSegment') {
-      const levelDetails = this.getLevelDetails();
-      const loadingPartsAtEdge = levelDetails && frag.sn > levelDetails.endSN;
-      const shouldLoadParts = loadingPartsAtEdge || this.shouldLoadParts(levelDetails, frag.end);
-      if (shouldLoadParts !== this.loadingParts) {
-        this.log(`LL-Part loading ${shouldLoadParts ? 'ON' : 'OFF'} after parsing segment ending @${frag.end.toFixed(2)}`);
-        this.loadingParts = shouldLoadParts;
-      }
-    }
     this.updateLevelTiming(frag, part, level, chunkMeta.partial);
   }
-  shouldLoadParts(details, bufferEnd) {
-    if (this.config.lowLatencyMode) {
-      if (!details) {
-        return this.loadingParts;
-      }
-      if (details != null && details.partList) {
-        var _details$fragmentHint;
-        // Buffer must be ahead of first part + duration of parts after last segment
-        // and playback must be at or past segment adjacent to part list
-        const firstPart = details.partList[0];
-        const safePartStart = firstPart.end + (((_details$fragmentHint = details.fragmentHint) == null ? void 0 : _details$fragmentHint.duration) || 0);
-        if (bufferEnd >= safePartStart && this.lastCurrentTime > firstPart.start - firstPart.fragment.duration) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
   getCurrentContext(chunkMeta) {
     const {
       levels,
@@ -12809,7 +12553,7 @@ class BaseStreamController extends TaskLoop {
     // Workaround flaw in getting forward buffer when maxBufferHole is smaller than gap at current pos
     if (bufferInfo.len === 0 && bufferInfo.nextStart !== undefined) {
       const bufferedFragAtPos = this.fragmentTracker.getBufferedFrag(pos, type);
-      if (bufferedFragAtPos && (bufferInfo.nextStart <= bufferedFragAtPos.end || bufferedFragAtPos.gap)) {
+      if (bufferedFragAtPos && bufferInfo.nextStart < bufferedFragAtPos.end) {
         return BufferHelper.bufferInfo(bufferable, pos, Math.max(bufferInfo.nextStart, maxBufferHole));
       }
     }
@@ -12857,8 +12601,7 @@ class BaseStreamController extends TaskLoop {
       config
     } = this;
     const start = fragments[0].start;
-    const canLoadParts = config.lowLatencyMode && !!levelDetails.partList;
-    let frag = null;
+    let frag;
     if (levelDetails.live) {
       const initialLiveManifestSize = config.initialLiveManifestSize;
       if (fragLen < initialLiveManifestSize) {
@@ -12870,10 +12613,6 @@ class BaseStreamController extends TaskLoop {
       // Do not load using live logic if the starting frag is requested - we want to use getFragmentAtPosition() so that
       // we get the fragment matching that start time
       if (!levelDetails.PTSKnown && !this.startFragRequested && this.startPosition === -1 || pos < start) {
-        if (canLoadParts && !this.loadingParts) {
-          this.log(`LL-Part loading ON for initial live fragment`);
-          this.loadingParts = true;
-        }
         frag = this.getInitialLiveFragment(levelDetails, fragments);
         this.startPosition = this.nextLoadPosition = frag ? this.hls.liveSyncPosition || frag.start : pos;
       }
@@ -12884,7 +12623,7 @@ class BaseStreamController extends TaskLoop {
 
     // If we haven't run into any special cases already, just load the fragment most closely matching the requested position
     if (!frag) {
-      const end = this.loadingParts ? levelDetails.partEnd : levelDetails.fragmentEnd;
+      const end = config.lowLatencyMode ? levelDetails.partEnd : levelDetails.fragmentEnd;
       frag = this.getFragmentAtPosition(pos, end, levelDetails);
     }
     return this.mapToInitFragWhenRequired(frag);
@@ -13006,7 +12745,7 @@ class BaseStreamController extends TaskLoop {
     } = levelDetails;
     const tolerance = config.maxFragLookUpTolerance;
     const partList = levelDetails.partList;
-    const loadingParts = !!(this.loadingParts && partList != null && partList.length && fragmentHint);
+    const loadingParts = !!(config.lowLatencyMode && partList != null && partList.length && fragmentHint);
     if (loadingParts && fragmentHint && !this.bitrateTest) {
       // Include incomplete fragment with parts at end
       fragments = fragments.concat(fragmentHint);
@@ -13199,7 +12938,7 @@ class BaseStreamController extends TaskLoop {
           errorAction.resolved = true;
         }
       } else {
-        this.warn(`${data.details} reached or exceeded max retry (${retryCount})`);
+        logger.warn(`${data.details} reached or exceeded max retry (${retryCount})`);
         return;
       }
     } else if ((errorAction == null ? void 0 : errorAction.action) === NetworkErrorAction.SendAlternateToPenaltyBox) {
@@ -13267,9 +13006,7 @@ class BaseStreamController extends TaskLoop {
     this.log('Reset loading state');
     this.fragCurrent = null;
     this.fragPrevious = null;
-    if (this.state !== State.STOPPED) {
-      this.state = State.IDLE;
-    }
+    this.state = State.IDLE;
   }
   resetStartWhenNotLoaded(level) {
     // if loadedmetadata is not set, it means that first frag request failed
@@ -13596,7 +13333,6 @@ const initPTSFn = (timestamp, timeOffset, initPTS) => {
  */
 function getAudioConfig(observer, data, offset, audioCodec) {
   let adtsObjectType;
-  let originalAdtsObjectType;
   let adtsExtensionSamplingIndex;
   let adtsChannelConfig;
   let config;
@@ -13604,7 +13340,7 @@ function getAudioConfig(observer, data, offset, audioCodec) {
   const manifestCodec = audioCodec;
   const adtsSamplingRates = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
   // byte 2
-  adtsObjectType = originalAdtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
+  adtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
   const adtsSamplingIndex = (data[offset + 2] & 0x3c) >>> 2;
   if (adtsSamplingIndex > adtsSamplingRates.length - 1) {
     const error = new Error(`invalid ADTS sampling index:${adtsSamplingIndex}`);
@@ -13621,8 +13357,8 @@ function getAudioConfig(observer, data, offset, audioCodec) {
   // byte 3
   adtsChannelConfig |= (data[offset + 3] & 0xc0) >>> 6;
   logger.log(`manifest codec:${audioCodec}, ADTS type:${adtsObjectType}, samplingIndex:${adtsSamplingIndex}`);
-  // Firefox and Pale Moon: freq less than 24kHz = AAC SBR (HE-AAC)
-  if (/firefox|palemoon/i.test(userAgent)) {
+  // firefox: freq less than 24kHz = AAC SBR (HE-AAC)
+  if (/firefox/i.test(userAgent)) {
     if (adtsSamplingIndex >= 6) {
       adtsObjectType = 5;
       config = new Array(4);
@@ -13716,7 +13452,6 @@ function getAudioConfig(observer, data, offset, audioCodec) {
     samplerate: adtsSamplingRates[adtsSamplingIndex],
     channelCount: adtsChannelConfig,
     codec: 'mp4a.40.' + adtsObjectType,
-    parsedCodec: 'mp4a.40.' + originalAdtsObjectType,
     manifestCodec
   };
 }
@@ -13771,8 +13506,7 @@ function initTrackConfig(track, observer, data, offset, audioCodec) {
     track.channelCount = config.channelCount;
     track.codec = config.codec;
     track.manifestCodec = config.manifestCodec;
-    track.parsedCodec = config.parsedCodec;
-    logger.log(`parsed codec:${track.parsedCodec}, codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`);
+    logger.log(`parsed codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`);
   }
 }
 function getFrameDuration(samplerate) {
@@ -14250,110 +13984,6 @@ class BaseVideoParser {
       logger.log(VideoSample.pts + '/' + VideoSample.dts + ':' + VideoSample.debug);
     }
   }
-  parseNALu(track, array) {
-    const len = array.byteLength;
-    let state = track.naluState || 0;
-    const lastState = state;
-    const units = [];
-    let i = 0;
-    let value;
-    let overflow;
-    let unitType;
-    let lastUnitStart = -1;
-    let lastUnitType = 0;
-    // logger.log('PES:' + Hex.hexDump(array));
-
-    if (state === -1) {
-      // special use case where we found 3 or 4-byte start codes exactly at the end of previous PES packet
-      lastUnitStart = 0;
-      // NALu type is value read from offset 0
-      lastUnitType = this.getNALuType(array, 0);
-      state = 0;
-      i = 1;
-    }
-    while (i < len) {
-      value = array[i++];
-      // optimization. state 0 and 1 are the predominant case. let's handle them outside of the switch/case
-      if (!state) {
-        state = value ? 0 : 1;
-        continue;
-      }
-      if (state === 1) {
-        state = value ? 0 : 2;
-        continue;
-      }
-      // here we have state either equal to 2 or 3
-      if (!value) {
-        state = 3;
-      } else if (value === 1) {
-        overflow = i - state - 1;
-        if (lastUnitStart >= 0) {
-          const unit = {
-            data: array.subarray(lastUnitStart, overflow),
-            type: lastUnitType
-          };
-          // logger.log('pushing NALU, type/size:' + unit.type + '/' + unit.data.byteLength);
-          units.push(unit);
-        } else {
-          // lastUnitStart is undefined => this is the first start code found in this PES packet
-          // first check if start code delimiter is overlapping between 2 PES packets,
-          // ie it started in last packet (lastState not zero)
-          // and ended at the beginning of this PES packet (i <= 4 - lastState)
-          const lastUnit = this.getLastNalUnit(track.samples);
-          if (lastUnit) {
-            if (lastState && i <= 4 - lastState) {
-              // start delimiter overlapping between PES packets
-              // strip start delimiter bytes from the end of last NAL unit
-              // check if lastUnit had a state different from zero
-              if (lastUnit.state) {
-                // strip last bytes
-                lastUnit.data = lastUnit.data.subarray(0, lastUnit.data.byteLength - lastState);
-              }
-            }
-            // If NAL units are not starting right at the beginning of the PES packet, push preceding data into previous NAL unit.
-
-            if (overflow > 0) {
-              // logger.log('first NALU found with overflow:' + overflow);
-              lastUnit.data = appendUint8Array(lastUnit.data, array.subarray(0, overflow));
-              lastUnit.state = 0;
-            }
-          }
-        }
-        // check if we can read unit type
-        if (i < len) {
-          unitType = this.getNALuType(array, i);
-          // logger.log('find NALU @ offset:' + i + ',type:' + unitType);
-          lastUnitStart = i;
-          lastUnitType = unitType;
-          state = 0;
-        } else {
-          // not enough byte to read unit type. let's read it on next PES parsing
-          state = -1;
-        }
-      } else {
-        state = 0;
-      }
-    }
-    if (lastUnitStart >= 0 && state >= 0) {
-      const unit = {
-        data: array.subarray(lastUnitStart, len),
-        type: lastUnitType,
-        state: state
-      };
-      units.push(unit);
-      // logger.log('pushing NALU, type/size/state:' + unit.type + '/' + unit.data.byteLength + '/' + state);
-    }
-    // no NALu found
-    if (units.length === 0) {
-      // append pes.data to previous NAL unit
-      const lastUnit = this.getLastNalUnit(track.samples);
-      if (lastUnit) {
-        lastUnit.data = appendUint8Array(lastUnit.data, array);
-      }
-    }
-    track.naluState = state;
-    return units;
-  }
 }
 
 /**
@@ -14496,11 +14126,194 @@ class ExpGolomb {
   readUInt() {
     return this.readBits(32);
   }
+
+  /**
+   * Advance the ExpGolomb decoder past a scaling list. The scaling
+   * list is optionally transmitted as part of a sequence parameter
+   * set and is not relevant to transmuxing.
+   * @param count the number of entries in this scaling list
+   * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
+   */
+  skipScalingList(count) {
+    let lastScale = 8;
+    let nextScale = 8;
+    let deltaScale;
+    for (let j = 0; j < count; j++) {
+      if (nextScale !== 0) {
+        deltaScale = this.readEG();
+        nextScale = (lastScale + deltaScale + 256) % 256;
+      }
+      lastScale = nextScale === 0 ? lastScale : nextScale;
+    }
+  }
+
+  /**
+   * Read a sequence parameter set and return some interesting video
+   * properties. A sequence parameter set is the H264 metadata that
+   * describes the properties of upcoming video frames.
+   * @returns an object with configuration parsed from the
+   * sequence parameter set, including the dimensions of the
+   * associated video frames.
+   */
+  readSPS() {
+    let frameCropLeftOffset = 0;
+    let frameCropRightOffset = 0;
+    let frameCropTopOffset = 0;
+    let frameCropBottomOffset = 0;
+    let numRefFramesInPicOrderCntCycle;
+    let scalingListCount;
+    let i;
+    const readUByte = this.readUByte.bind(this);
+    const readBits = this.readBits.bind(this);
+    const readUEG = this.readUEG.bind(this);
+    const readBoolean = this.readBoolean.bind(this);
+    const skipBits = this.skipBits.bind(this);
+    const skipEG = this.skipEG.bind(this);
+    const skipUEG = this.skipUEG.bind(this);
+    const skipScalingList = this.skipScalingList.bind(this);
+    readUByte();
+    const profileIdc = readUByte(); // profile_idc
+    readBits(5); // profileCompat constraint_set[0-4]_flag, u(5)
+    skipBits(3); // reserved_zero_3bits u(3),
+    readUByte(); // level_idc u(8)
+    skipUEG(); // seq_parameter_set_id
+    // some profiles have more optional data we don't need
+    if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
+      const chromaFormatIdc = readUEG();
+      if (chromaFormatIdc === 3) {
+        skipBits(1);
+      } // separate_colour_plane_flag
+
+      skipUEG(); // bit_depth_luma_minus8
+      skipUEG(); // bit_depth_chroma_minus8
+      skipBits(1); // qpprime_y_zero_transform_bypass_flag
+      if (readBoolean()) {
+        // seq_scaling_matrix_present_flag
+        scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
+        for (i = 0; i < scalingListCount; i++) {
+          if (readBoolean()) {
+            // seq_scaling_list_present_flag[ i ]
+            if (i < 6) {
+              skipScalingList(16);
+            } else {
+              skipScalingList(64);
+            }
+          }
+        }
+      }
+    }
+    skipUEG(); // log2_max_frame_num_minus4
+    const picOrderCntType = readUEG();
+    if (picOrderCntType === 0) {
+      readUEG(); // log2_max_pic_order_cnt_lsb_minus4
+    } else if (picOrderCntType === 1) {
+      skipBits(1); // delta_pic_order_always_zero_flag
+      skipEG(); // offset_for_non_ref_pic
+      skipEG(); // offset_for_top_to_bottom_field
+      numRefFramesInPicOrderCntCycle = readUEG();
+      for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
+        skipEG();
+      } // offset_for_ref_frame[ i ]
+    }
+    skipUEG(); // max_num_ref_frames
+    skipBits(1); // gaps_in_frame_num_value_allowed_flag
+    const picWidthInMbsMinus1 = readUEG();
+    const picHeightInMapUnitsMinus1 = readUEG();
+    const frameMbsOnlyFlag = readBits(1);
+    if (frameMbsOnlyFlag === 0) {
+      skipBits(1);
+    } // mb_adaptive_frame_field_flag
+
+    skipBits(1); // direct_8x8_inference_flag
+    if (readBoolean()) {
+      // frame_cropping_flag
+      frameCropLeftOffset = readUEG();
+      frameCropRightOffset = readUEG();
+      frameCropTopOffset = readUEG();
+      frameCropBottomOffset = readUEG();
+    }
+    let pixelRatio = [1, 1];
+    if (readBoolean()) {
+      // vui_parameters_present_flag
+      if (readBoolean()) {
+        // aspect_ratio_info_present_flag
+        const aspectRatioIdc = readUByte();
+        switch (aspectRatioIdc) {
+          case 1:
+            pixelRatio = [1, 1];
+            break;
+          case 2:
+            pixelRatio = [12, 11];
+            break;
+          case 3:
+            pixelRatio = [10, 11];
+            break;
+          case 4:
+            pixelRatio = [16, 11];
+            break;
+          case 5:
+            pixelRatio = [40, 33];
+            break;
+          case 6:
+            pixelRatio = [24, 11];
+            break;
+          case 7:
+            pixelRatio = [20, 11];
+            break;
+          case 8:
+            pixelRatio = [32, 11];
+            break;
+          case 9:
+            pixelRatio = [80, 33];
+            break;
+          case 10:
+            pixelRatio = [18, 11];
+            break;
+          case 11:
+            pixelRatio = [15, 11];
+            break;
+          case 12:
+            pixelRatio = [64, 33];
+            break;
+          case 13:
+            pixelRatio = [160, 99];
+            break;
+          case 14:
+            pixelRatio = [4, 3];
+            break;
+          case 15:
+            pixelRatio = [3, 2];
+            break;
+          case 16:
+            pixelRatio = [2, 1];
+            break;
+          case 255:
+            {
+              pixelRatio = [readUByte() << 8 | readUByte(), readUByte() << 8 | readUByte()];
+              break;
+            }
+        }
+      }
+    }
+    return {
+      width: Math.ceil((picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2),
+      height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset),
+      pixelRatio: pixelRatio
+    };
+  }
+  readSliceType() {
+    // skip NALu type
+    this.readUByte();
+    // discard first_mb_in_slice
+    this.readUEG();
+    // return slice_type
+    return this.readUEG();
+  }
 }
 
 class AvcVideoParser extends BaseVideoParser {
-  parsePES(track, textTrack, pes, last, duration) {
-    const units = this.parseNALu(track, pes.data);
+  parseAVCPES(track, textTrack, pes, last, duration) {
+    const units = this.parseAVCNALu(track, pes.data);
     let VideoSample = this.VideoSample;
     let push;
     let spsfound = false;
@@ -14525,7 +14338,7 @@ class AvcVideoParser extends BaseVideoParser {
             // only check slice type to detect KF in case SPS found in same packet (any keyframe is preceded by SPS ...)
             if (spsfound && data.length > 4) {
               // retrieve slice type by parsing beginning of NAL unit (follow H264 spec, slice_header definition) to detect keyframe embedded in NDR
-              const sliceType = this.readSliceType(data);
+              const sliceType = new ExpGolomb(data).readSliceType();
               // 2 : I slice, 4 : SI slice, 7 : I slice, 9: SI slice
               // SI slice : A slice that is coded using intra prediction only and using quantisation of the prediction samples.
               // An SI slice can be coded such that its decoded samples can be constructed identically to an SP slice.
@@ -14579,7 +14392,8 @@ class AvcVideoParser extends BaseVideoParser {
             push = true;
             spsfound = true;
             const sps = unit.data;
-            const config = this.readSPS(sps);
+            const expGolombDecoder = new ExpGolomb(sps);
+            const config = expGolombDecoder.readSPS();
             if (!track.sps || track.width !== config.width || track.height !== config.height || ((_track$pixelRatio = track.pixelRatio) == null ? void 0 : _track$pixelRatio[0]) !== config.pixelRatio[0] || ((_track$pixelRatio2 = track.pixelRatio) == null ? void 0 : _track$pixelRatio2[1]) !== config.pixelRatio[1]) {
               track.width = config.width;
               track.height = config.height;
@@ -14635,192 +14449,109 @@ class AvcVideoParser extends BaseVideoParser {
       this.VideoSample = null;
     }
   }
-  getNALuType(data, offset) {
-    return data[offset] & 0x1f;
-  }
-  readSliceType(data) {
-    const eg = new ExpGolomb(data);
-    // skip NALu type
-    eg.readUByte();
-    // discard first_mb_in_slice
-    eg.readUEG();
-    // return slice_type
-    return eg.readUEG();
-  }
+  parseAVCNALu(track, array) {
+    const len = array.byteLength;
+    let state = track.naluState || 0;
+    const lastState = state;
+    const units = [];
+    let i = 0;
+    let value;
+    let overflow;
+    let unitType;
+    let lastUnitStart = -1;
+    let lastUnitType = 0;
+    // logger.log('PES:' + Hex.hexDump(array));
 
-  /**
-   * The scaling list is optionally transmitted as part of a sequence parameter
-   * set and is not relevant to transmuxing.
-   * @param count the number of entries in this scaling list
-   * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
-   */
-  skipScalingList(count, reader) {
-    let lastScale = 8;
-    let nextScale = 8;
-    let deltaScale;
-    for (let j = 0; j < count; j++) {
-      if (nextScale !== 0) {
-        deltaScale = reader.readEG();
-        nextScale = (lastScale + deltaScale + 256) % 256;
-      }
-      lastScale = nextScale === 0 ? lastScale : nextScale;
+    if (state === -1) {
+      // special use case where we found 3 or 4-byte start codes exactly at the end of previous PES packet
+      lastUnitStart = 0;
+      // NALu type is value read from offset 0
+      lastUnitType = array[0] & 0x1f;
+      state = 0;
+      i = 1;
     }
-  }
-
-  /**
-   * Read a sequence parameter set and return some interesting video
-   * properties. A sequence parameter set is the H264 metadata that
-   * describes the properties of upcoming video frames.
-   * @returns an object with configuration parsed from the
-   * sequence parameter set, including the dimensions of the
-   * associated video frames.
-   */
-  readSPS(sps) {
-    const eg = new ExpGolomb(sps);
-    let frameCropLeftOffset = 0;
-    let frameCropRightOffset = 0;
-    let frameCropTopOffset = 0;
-    let frameCropBottomOffset = 0;
-    let numRefFramesInPicOrderCntCycle;
-    let scalingListCount;
-    let i;
-    const readUByte = eg.readUByte.bind(eg);
-    const readBits = eg.readBits.bind(eg);
-    const readUEG = eg.readUEG.bind(eg);
-    const readBoolean = eg.readBoolean.bind(eg);
-    const skipBits = eg.skipBits.bind(eg);
-    const skipEG = eg.skipEG.bind(eg);
-    const skipUEG = eg.skipUEG.bind(eg);
-    const skipScalingList = this.skipScalingList.bind(this);
-    readUByte();
-    const profileIdc = readUByte(); // profile_idc
-    readBits(5); // profileCompat constraint_set[0-4]_flag, u(5)
-    skipBits(3); // reserved_zero_3bits u(3),
-    readUByte(); // level_idc u(8)
-    skipUEG(); // seq_parameter_set_id
-    // some profiles have more optional data we don't need
-    if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
-      const chromaFormatIdc = readUEG();
-      if (chromaFormatIdc === 3) {
-        skipBits(1);
-      } // separate_colour_plane_flag
+    while (i < len) {
+      value = array[i++];
+      // optimization. state 0 and 1 are the predominant case. let's handle them outside of the switch/case
+      if (!state) {
+        state = value ? 0 : 1;
+        continue;
+      }
+      if (state === 1) {
+        state = value ? 0 : 2;
+        continue;
+      }
+      // here we have state either equal to 2 or 3
+      if (!value) {
+        state = 3;
+      } else if (value === 1) {
+        overflow = i - state - 1;
+        if (lastUnitStart >= 0) {
+          const unit = {
+            data: array.subarray(lastUnitStart, overflow),
+            type: lastUnitType
+          };
+          // logger.log('pushing NALU, type/size:' + unit.type + '/' + unit.data.byteLength);
+          units.push(unit);
+        } else {
+          // lastUnitStart is undefined => this is the first start code found in this PES packet
+          // first check if start code delimiter is overlapping between 2 PES packets,
+          // ie it started in last packet (lastState not zero)
+          // and ended at the beginning of this PES packet (i <= 4 - lastState)
+          const lastUnit = this.getLastNalUnit(track.samples);
+          if (lastUnit) {
+            if (lastState && i <= 4 - lastState) {
+              // start delimiter overlapping between PES packets
+              // strip start delimiter bytes from the end of last NAL unit
+              // check if lastUnit had a state different from zero
+              if (lastUnit.state) {
+                // strip last bytes
+                lastUnit.data = lastUnit.data.subarray(0, lastUnit.data.byteLength - lastState);
+              }
+            }
+            // If NAL units are not starting right at the beginning of the PES packet, push preceding data into previous NAL unit.
 
-      skipUEG(); // bit_depth_luma_minus8
-      skipUEG(); // bit_depth_chroma_minus8
-      skipBits(1); // qpprime_y_zero_transform_bypass_flag
-      if (readBoolean()) {
-        // seq_scaling_matrix_present_flag
-        scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
-        for (i = 0; i < scalingListCount; i++) {
-          if (readBoolean()) {
-            // seq_scaling_list_present_flag[ i ]
-            if (i < 6) {
-              skipScalingList(16, eg);
-            } else {
-              skipScalingList(64, eg);
+            if (overflow > 0) {
+              // logger.log('first NALU found with overflow:' + overflow);
+              lastUnit.data = appendUint8Array(lastUnit.data, array.subarray(0, overflow));
+              lastUnit.state = 0;
             }
           }
         }
+        // check if we can read unit type
+        if (i < len) {
+          unitType = array[i] & 0x1f;
+          // logger.log('find NALU @ offset:' + i + ',type:' + unitType);
+          lastUnitStart = i;
+          lastUnitType = unitType;
+          state = 0;
+        } else {
+          // not enough byte to read unit type. let's read it on next PES parsing
+          state = -1;
+        }
+      } else {
+        state = 0;
       }
     }
-    skipUEG(); // log2_max_frame_num_minus4
-    const picOrderCntType = readUEG();
-    if (picOrderCntType === 0) {
-      readUEG(); // log2_max_pic_order_cnt_lsb_minus4
-    } else if (picOrderCntType === 1) {
-      skipBits(1); // delta_pic_order_always_zero_flag
-      skipEG(); // offset_for_non_ref_pic
-      skipEG(); // offset_for_top_to_bottom_field
-      numRefFramesInPicOrderCntCycle = readUEG();
-      for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
-        skipEG();
-      } // offset_for_ref_frame[ i ]
-    }
-    skipUEG(); // max_num_ref_frames
-    skipBits(1); // gaps_in_frame_num_value_allowed_flag
-    const picWidthInMbsMinus1 = readUEG();
-    const picHeightInMapUnitsMinus1 = readUEG();
-    const frameMbsOnlyFlag = readBits(1);
-    if (frameMbsOnlyFlag === 0) {
-      skipBits(1);
-    } // mb_adaptive_frame_field_flag
-
-    skipBits(1); // direct_8x8_inference_flag
-    if (readBoolean()) {
-      // frame_cropping_flag
-      frameCropLeftOffset = readUEG();
-      frameCropRightOffset = readUEG();
-      frameCropTopOffset = readUEG();
-      frameCropBottomOffset = readUEG();
+    if (lastUnitStart >= 0 && state >= 0) {
+      const unit = {
+        data: array.subarray(lastUnitStart, len),
+        type: lastUnitType,
+        state: state
+      };
+      units.push(unit);
+      // logger.log('pushing NALU, type/size/state:' + unit.type + '/' + unit.data.byteLength + '/' + state);
     }
-    let pixelRatio = [1, 1];
-    if (readBoolean()) {
-      // vui_parameters_present_flag
-      if (readBoolean()) {
-        // aspect_ratio_info_present_flag
-        const aspectRatioIdc = readUByte();
-        switch (aspectRatioIdc) {
-          case 1:
-            pixelRatio = [1, 1];
-            break;
-          case 2:
-            pixelRatio = [12, 11];
-            break;
-          case 3:
-            pixelRatio = [10, 11];
-            break;
-          case 4:
-            pixelRatio = [16, 11];
-            break;
-          case 5:
-            pixelRatio = [40, 33];
-            break;
-          case 6:
-            pixelRatio = [24, 11];
-            break;
-          case 7:
-            pixelRatio = [20, 11];
-            break;
-          case 8:
-            pixelRatio = [32, 11];
-            break;
-          case 9:
-            pixelRatio = [80, 33];
-            break;
-          case 10:
-            pixelRatio = [18, 11];
-            break;
-          case 11:
-            pixelRatio = [15, 11];
-            break;
-          case 12:
-            pixelRatio = [64, 33];
-            break;
-          case 13:
-            pixelRatio = [160, 99];
-            break;
-          case 14:
-            pixelRatio = [4, 3];
-            break;
-          case 15:
-            pixelRatio = [3, 2];
-            break;
-          case 16:
-            pixelRatio = [2, 1];
-            break;
-          case 255:
-            {
-              pixelRatio = [readUByte() << 8 | readUByte(), readUByte() << 8 | readUByte()];
-              break;
-            }
-        }
+    // no NALu found
+    if (units.length === 0) {
+      // append pes.data to previous NAL unit
+      const lastUnit = this.getLastNalUnit(track.samples);
+      if (lastUnit) {
+        lastUnit.data = appendUint8Array(lastUnit.data, array);
       }
     }
-    return {
-      width: Math.ceil((picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2),
-      height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset),
-      pixelRatio: pixelRatio
-    };
+    track.naluState = state;
+    return units;
   }
 }
 
@@ -14838,7 +14569,7 @@ class SampleAesDecrypter {
     });
   }
   decryptBuffer(encryptedData) {
-    return this.decrypter.decrypt(encryptedData, this.keyData.key.buffer, this.keyData.iv.buffer, DecrypterAesMode.cbc);
+    return this.decrypter.decrypt(encryptedData, this.keyData.key.buffer, this.keyData.iv.buffer);
   }
 
   // AAC - encrypt all full 16 bytes blocks starting from offset 16
@@ -14952,7 +14683,7 @@ class TSDemuxer {
     this.observer = observer;
     this.config = config;
     this.typeSupported = typeSupported;
-    this.videoParser = null;
+    this.videoParser = new AvcVideoParser();
   }
   static probe(data) {
     const syncOffset = TSDemuxer.syncOffset(data);
@@ -15117,16 +14848,7 @@ class TSDemuxer {
           case videoPid:
             if (stt) {
               if (videoData && (pes = parsePES(videoData))) {
-                if (this.videoParser === null) {
-                  switch (videoTrack.segmentCodec) {
-                    case 'avc':
-                      this.videoParser = new AvcVideoParser();
-                      break;
-                  }
-                }
-                if (this.videoParser !== null) {
-                  this.videoParser.parsePES(videoTrack, textTrack, pes, false, this._duration);
-                }
+                this.videoParser.parseAVCPES(videoTrack, textTrack, pes, false, this._duration);
               }
               videoData = {
                 data: [],
@@ -15288,17 +15010,8 @@ class TSDemuxer {
     // try to parse last PES packets
     let pes;
     if (videoData && (pes = parsePES(videoData))) {
-      if (this.videoParser === null) {
-        switch (videoTrack.segmentCodec) {
-          case 'avc':
-            this.videoParser = new AvcVideoParser();
-            break;
-        }
-      }
-      if (this.videoParser !== null) {
-        this.videoParser.parsePES(videoTrack, textTrack, pes, true, this._duration);
-        videoTrack.pesData = null;
-      }
+      this.videoParser.parseAVCPES(videoTrack, textTrack, pes, true, this._duration);
+      videoTrack.pesData = null;
     } else {
       // either avcData null or PES truncated, keep it for next frag parsing
       videoTrack.pesData = videoData;
@@ -15601,10 +15314,7 @@ function parsePMT(data, offset, typeSupported, isSampleAes) {
         logger.warn('Unsupported EC-3 in M2TS found');
         break;
       case 0x24:
-        // ITU-T Rec. H.265 and ISO/IEC 23008-2 (HEVC)
-        {
-          logger.warn('Unsupported HEVC in M2TS found');
-        }
+        logger.warn('Unsupported HEVC in M2TS found');
         break;
     }
     // move to the next table entry
@@ -15827,8 +15537,6 @@ class MP4 {
       avc1: [],
       // codingname
       avcC: [],
-      hvc1: [],
-      hvcC: [],
       btrt: [],
       dinf: [],
       dref: [],
@@ -16253,10 +15961,8 @@ class MP4 {
         return MP4.box(MP4.types.stsd, MP4.STSD, MP4.ac3(track));
       }
       return MP4.box(MP4.types.stsd, MP4.STSD, MP4.mp4a(track));
-    } else if (track.segmentCodec === 'avc') {
-      return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
     } else {
-      return MP4.box(MP4.types.stsd, MP4.STSD, MP4.hvc1(track));
+      return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
     }
   }
   static tkhd(track) {
@@ -16394,84 +16100,6 @@ class MP4 {
     const result = appendUint8Array(MP4.FTYP, movie);
     return result;
   }
-  static hvc1(track) {
-    const ps = track.params;
-    const units = [track.vps, track.sps, track.pps];
-    const NALuLengthSize = 4;
-    const config = new Uint8Array([0x01, ps.general_profile_space << 6 | (ps.general_tier_flag ? 32 : 0) | ps.general_profile_idc, ps.general_profile_compatibility_flags[0], ps.general_profile_compatibility_flags[1], ps.general_profile_compatibility_flags[2], ps.general_profile_compatibility_flags[3], ps.general_constraint_indicator_flags[0], ps.general_constraint_indicator_flags[1], ps.general_constraint_indicator_flags[2], ps.general_constraint_indicator_flags[3], ps.general_constraint_indicator_flags[4], ps.general_constraint_indicator_flags[5], ps.general_level_idc, 240 | ps.min_spatial_segmentation_idc >> 8, 255 & ps.min_spatial_segmentation_idc, 252 | ps.parallelismType, 252 | ps.chroma_format_idc, 248 | ps.bit_depth_luma_minus8, 248 | ps.bit_depth_chroma_minus8, 0x00, parseInt(ps.frame_rate.fps), NALuLengthSize - 1 | ps.temporal_id_nested << 2 | ps.num_temporal_layers << 3 | (ps.frame_rate.fixed ? 64 : 0), units.length]);
-
-    // compute hvcC size in bytes
-    let length = config.length;
-    for (let i = 0; i < units.length; i += 1) {
-      length += 3;
-      for (let j = 0; j < units[i].length; j += 1) {
-        length += 2 + units[i][j].length;
-      }
-    }
-    const hvcC = new Uint8Array(length);
-    hvcC.set(config, 0);
-    length = config.length;
-    // append parameter set units: one vps, one or more sps and pps
-    const iMax = units.length - 1;
-    for (let i = 0; i < units.length; i += 1) {
-      hvcC.set(new Uint8Array([32 + i | (i === iMax ? 128 : 0), 0x00, units[i].length]), length);
-      length += 3;
-      for (let j = 0; j < units[i].length; j += 1) {
-        hvcC.set(new Uint8Array([units[i][j].length >> 8, units[i][j].length & 255]), length);
-        length += 2;
-        hvcC.set(units[i][j], length);
-        length += units[i][j].length;
-      }
-    }
-    const hvcc = MP4.box(MP4.types.hvcC, hvcC);
-    const width = track.width;
-    const height = track.height;
-    const hSpacing = track.pixelRatio[0];
-    const vSpacing = track.pixelRatio[1];
-    return MP4.box(MP4.types.hvc1, new Uint8Array([0x00, 0x00, 0x00,
-    // reserved
-    0x00, 0x00, 0x00,
-    // reserved
-    0x00, 0x01,
-    // data_reference_index
-    0x00, 0x00,
-    // pre_defined
-    0x00, 0x00,
-    // reserved
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // pre_defined
-    width >> 8 & 0xff, width & 0xff,
-    // width
-    height >> 8 & 0xff, height & 0xff,
-    // height
-    0x00, 0x48, 0x00, 0x00,
-    // horizresolution
-    0x00, 0x48, 0x00, 0x00,
-    // vertresolution
-    0x00, 0x00, 0x00, 0x00,
-    // reserved
-    0x00, 0x01,
-    // frame_count
-    0x12, 0x64, 0x61, 0x69, 0x6c,
-    // dailymotion/hls.js
-    0x79, 0x6d, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x68, 0x6c, 0x73, 0x2e, 0x6a, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    // compressorname
-    0x00, 0x18,
-    // depth = 24
-    0x11, 0x11]),
-    // pre_defined = -1
-    hvcc, MP4.box(MP4.types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80,
-    // bufferSizeDB
-    0x00, 0x2d, 0xc6, 0xc0,
-    // maxBitrate
-    0x00, 0x2d, 0xc6, 0xc0])),
-    // avgBitrate
-    MP4.box(MP4.types.pasp, new Uint8Array([hSpacing >> 24,
-    // hSpacing
-    hSpacing >> 16 & 0xff, hSpacing >> 8 & 0xff, hSpacing & 0xff, vSpacing >> 24,
-    // vSpacing
-    vSpacing >> 16 & 0xff, vSpacing >> 8 & 0xff, vSpacing & 0xff])));
-  }
 }
 MP4.types = void 0;
 MP4.HDLR_TYPES = void 0;
@@ -16847,9 +16475,9 @@ class MP4Remuxer {
       const foundOverlap = delta < -1;
       if (foundHole || foundOverlap) {
         if (foundHole) {
-          logger.warn(`${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(delta, true)} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(3)}`);
+          logger.warn(`AVC: ${toMsFromMpegTsClock(delta, true)} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(3)}`);
         } else {
-          logger.warn(`${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(-delta, true)} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(3)}`);
+          logger.warn(`AVC: ${toMsFromMpegTsClock(-delta, true)} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(3)}`);
         }
         if (!foundOverlap || nextAvcDts >= inputSamples[0].pts || chromeVersion) {
           firstDTS = nextAvcDts;
@@ -16858,24 +16486,12 @@ class MP4Remuxer {
             inputSamples[0].dts = firstDTS;
             inputSamples[0].pts = firstPTS;
           } else {
-            let isPTSOrderRetained = true;
             for (let i = 0; i < inputSamples.length; i++) {
-              if (inputSamples[i].dts > firstPTS && isPTSOrderRetained) {
+              if (inputSamples[i].dts > firstPTS) {
                 break;
               }
-              const prevPTS = inputSamples[i].pts;
               inputSamples[i].dts -= delta;
               inputSamples[i].pts -= delta;
-
-              // check to see if this sample's PTS order has changed
-              // relative to the next one
-              if (i < inputSamples.length - 1) {
-                const nextSamplePTS = inputSamples[i + 1].pts;
-                const currentSamplePTS = inputSamples[i].pts;
-                const currentOrder = nextSamplePTS <= currentSamplePTS;
-                const prevOrder = nextSamplePTS <= prevPTS;
-                isPTSOrderRetained = currentOrder == prevOrder;
-              }
             }
           }
           logger.log(`Video: Initial PTS/DTS adjusted: ${toMsFromMpegTsClock(firstPTS, true)}/${toMsFromMpegTsClock(firstDTS, true)}, delta: ${toMsFromMpegTsClock(delta, true)} ms`);
@@ -17023,7 +16639,7 @@ class MP4Remuxer {
         }
       }
     }
-    // next AVC/HEVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
+    // next AVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
     mp4SampleDuration = stretchedLastFrame || !mp4SampleDuration ? averageSampleDuration : mp4SampleDuration;
     this.nextAvcDts = nextAvcDts = lastDTS + mp4SampleDuration;
     this.videoSampleDuration = mp4SampleDuration;
@@ -17156,7 +16772,7 @@ class MP4Remuxer {
           logger.warn(`[mp4-remuxer]: Injecting ${missing} audio frame @ ${(nextPts / inputTimeScale).toFixed(3)}s due to ${Math.round(1000 * delta / inputTimeScale)} ms gap.`);
           for (let j = 0; j < missing; j++) {
             const newStamp = Math.max(nextPts, 0);
-            let fillFrame = AAC.getSilentFrame(track.parsedCodec || track.manifestCodec || track.codec, track.channelCount);
+            let fillFrame = AAC.getSilentFrame(track.manifestCodec || track.codec, track.channelCount);
             if (!fillFrame) {
               logger.log('[mp4-remuxer]: Unable to get silent frame for given audio codec; duplicating last frame instead.');
               fillFrame = sample.unit.subarray();
@@ -17284,7 +16900,7 @@ class MP4Remuxer {
     // samples count of this segment's duration
     const nbSamples = Math.ceil((endDTS - startDTS) / frameDuration);
     // silent frame
-    const silentFrame = AAC.getSilentFrame(track.parsedCodec || track.manifestCodec || track.codec, track.channelCount);
+    const silentFrame = AAC.getSilentFrame(track.manifestCodec || track.codec, track.channelCount);
     logger.warn('[mp4-remuxer]: remux empty Audio');
     // Can't remux if we can't generate a silent frame...
     if (!silentFrame) {
@@ -17675,15 +17291,13 @@ class Transmuxer {
       initSegmentData
     } = transmuxConfig;
     const keyData = getEncryptionType(uintData, decryptdata);
-    if (keyData && isFullSegmentEncryption(keyData.method)) {
+    if (keyData && keyData.method === 'AES-128') {
       const decrypter = this.getDecrypter();
-      const aesMode = getAesModeFromFullSegmentMethod(keyData.method);
-
       // Software decryption is synchronous; webCrypto is not
       if (decrypter.isSync()) {
         // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
         // data is handled in the flush() call
-        let decryptedData = decrypter.softwareDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode);
+        let decryptedData = decrypter.softwareDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer);
         // For Low-Latency HLS Parts, decrypt in place, since part parsing is expected on push progress
         const loadingParts = chunkMeta.part > -1;
         if (loadingParts) {
@@ -17695,7 +17309,7 @@ class Transmuxer {
         }
         uintData = new Uint8Array(decryptedData);
       } else {
-        this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode).then(decryptedData => {
+        this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer).then(decryptedData => {
           // Calling push here is important; if flush() is called while this is still resolving, this ensures that
           // the decrypted data has been transmuxed
           const result = this.push(decryptedData, null, chunkMeta);
@@ -18349,7 +17963,14 @@ class TransmuxerInterface {
     this.observer = new EventEmitter();
     this.observer.on(Events.FRAG_DECRYPTED, forwardMessage);
     this.observer.on(Events.ERROR, forwardMessage);
-    const m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
+    const MediaSource = getMediaSource(config.preferManagedMediaSource) || {
+      isTypeSupported: () => false
+    };
+    const m2tsTypeSupported = {
+      mpeg: MediaSource.isTypeSupported('audio/mpeg'),
+      mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
+      ac3: false
+    };
 
     // navigator.vendor is not always available in Web Worker
     // refer to https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/navigator
@@ -18613,9 +18234,8 @@ const STALL_MINIMUM_DURATION_MS = 250;
 const MAX_START_GAP_JUMP = 2.0;
 const SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
 const SKIP_BUFFER_RANGE_START = 0.05;
-class GapController extends Logger {
+class GapController {
   constructor(config, media, fragmentTracker, hls) {
-    super('gap-controller', hls.logger);
     this.config = void 0;
     this.media = null;
     this.fragmentTracker = void 0;
@@ -18625,7 +18245,6 @@ class GapController extends Logger {
     this.stalled = null;
     this.moved = false;
     this.seeking = false;
-    this.ended = 0;
     this.config = config;
     this.media = media;
     this.fragmentTracker = fragmentTracker;
@@ -18643,7 +18262,7 @@ class GapController extends Logger {
    *
    * @param lastCurrentTime - Previously read playhead position
    */
-  poll(lastCurrentTime, activeFrag, levelDetails, state) {
+  poll(lastCurrentTime, activeFrag) {
     const {
       config,
       media,
@@ -18662,7 +18281,6 @@ class GapController extends Logger {
 
     // The playhead is moving, no-op
     if (currentTime !== lastCurrentTime) {
-      this.ended = 0;
       this.moved = true;
       if (!seeking) {
         this.nudgeRetry = 0;
@@ -18671,7 +18289,7 @@ class GapController extends Logger {
         // The playhead is now moving, but was previously stalled
         if (this.stallReported) {
           const _stalledDuration = self.performance.now() - stalled;
-          this.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(_stalledDuration)}ms`);
+          logger.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(_stalledDuration)}ms`);
           this.stallReported = false;
         }
         this.stalled = null;
@@ -18707,6 +18325,7 @@ class GapController extends Logger {
     // Skip start gaps if we haven't played, but the last poll detected the start of a stall
     // The addition poll gives the browser a chance to jump the gap for us
     if (!this.moved && this.stalled !== null) {
+      var _level$details;
       // There is no playable buffer (seeked, waiting for buffer)
       const isBuffered = bufferInfo.len > 0;
       if (!isBuffered && !nextStart) {
@@ -18718,8 +18337,9 @@ class GapController extends Logger {
       // When joining a live stream with audio tracks, account for live playlist window sliding by allowing
       // a larger jump over start gaps caused by the audio-stream-controller buffering a start fragment
       // that begins over 1 target duration after the video start position.
-      const isLive = !!(levelDetails != null && levelDetails.live);
-      const maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
+      const level = this.hls.levels ? this.hls.levels[this.hls.currentLevel] : null;
+      const isLive = level == null ? void 0 : (_level$details = level.details) == null ? void 0 : _level$details.live;
+      const maxStartGapJump = isLive ? level.details.targetduration * 2 : MAX_START_GAP_JUMP;
       const partialOrGap = this.fragmentTracker.getPartialFragment(currentTime);
       if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
         if (!media.paused) {
@@ -18737,17 +18357,6 @@ class GapController extends Logger {
     }
     const stalledDuration = tnow - stalled;
     if (!seeking && stalledDuration >= STALL_MINIMUM_DURATION_MS) {
-      // Dispatch MEDIA_ENDED when media.ended/ended event is not signalled at end of stream
-      if (state === State.ENDED && !(levelDetails && levelDetails.live) && Math.abs(currentTime - ((levelDetails == null ? void 0 : levelDetails.edge) || 0)) < 1) {
-        if (stalledDuration < 1000 || this.ended) {
-          return;
-        }
-        this.ended = currentTime;
-        this.hls.trigger(Events.MEDIA_ENDED, {
-          stalled: true
-        });
-        return;
-      }
       // Report stalling after trying to fix
       this._reportStall(bufferInfo);
       if (!this.media) {
@@ -18791,7 +18400,7 @@ class GapController extends Logger {
     // needs to cross some sort of threshold covering all source-buffers content
     // to start playing properly.
     if ((bufferInfo.len > config.maxBufferHole || bufferInfo.nextStart && bufferInfo.nextStart - currentTime < config.maxBufferHole) && stalledDurationMs > config.highBufferWatchdogPeriod * 1000) {
-      this.warn('Trying to nudge playhead over buffer-hole');
+      logger.warn('Trying to nudge playhead over buffer-hole');
       // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
       // We only try to jump the hole if it's under the configured size
       // Reset stalled so to rearm watchdog timer
@@ -18815,7 +18424,7 @@ class GapController extends Logger {
       // Report stalled error once
       this.stallReported = true;
       const error = new Error(`Playback stalling at @${media.currentTime} due to low buffer (${JSON.stringify(bufferInfo)})`);
-      this.warn(error.message);
+      logger.warn(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -18883,7 +18492,7 @@ class GapController extends Logger {
           }
         }
         const targetTime = Math.max(startTime + SKIP_BUFFER_RANGE_START, currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS);
-        this.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
+        logger.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
         this.moved = true;
         this.stalled = null;
         media.currentTime = targetTime;
@@ -18924,7 +18533,7 @@ class GapController extends Logger {
       const targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
       // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
       const error = new Error(`Nudging 'currentTime' from ${currentTime} to ${targetTime}`);
-      this.warn(error.message);
+      logger.warn(error.message);
       media.currentTime = targetTime;
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
@@ -18934,7 +18543,7 @@ class GapController extends Logger {
       });
     } else {
       const error = new Error(`Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`);
-      this.error(error.message);
+      logger.error(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -18949,7 +18558,7 @@ const TICK_INTERVAL = 100; // how often to tick in ms
 
 class StreamController extends BaseStreamController {
   constructor(hls, fragmentTracker, keyLoader) {
-    super(hls, fragmentTracker, keyLoader, 'stream-controller', PlaylistLevelType.MAIN);
+    super(hls, fragmentTracker, keyLoader, '[stream-controller]', PlaylistLevelType.MAIN);
     this.audioCodecSwap = false;
     this.gapController = null;
     this.level = -1;
@@ -18957,43 +18566,27 @@ class StreamController extends BaseStreamController {
     this.altAudio = false;
     this.audioOnly = false;
     this.fragPlaying = null;
+    this.onvplaying = null;
+    this.onvseeked = null;
     this.fragLastKbps = 0;
     this.couldBacktrack = false;
     this.backtrackFragment = null;
     this.audioCodecSwitch = false;
     this.videoBuffer = null;
-    this.onMediaPlaying = () => {
-      // tick to speed up FRAG_CHANGED triggering
-      this.tick();
-    };
-    this.onMediaSeeked = () => {
-      const media = this.media;
-      const currentTime = media ? media.currentTime : null;
-      if (isFiniteNumber(currentTime)) {
-        this.log(`Media seeked to ${currentTime.toFixed(3)}`);
-      }
-
-      // If seeked was issued before buffer was appended do not tick immediately
-      const bufferInfo = this.getMainFwdBufferInfo();
-      if (bufferInfo === null || bufferInfo.len === 0) {
-        this.warn(`Main forward buffer length on "seeked" event ${bufferInfo ? bufferInfo.len : 'empty'})`);
-        return;
-      }
-
-      // tick to speed up FRAG_CHANGED triggering
-      this.tick();
-    };
-    this.registerListeners();
+    this._registerListeners();
   }
-  registerListeners() {
-    super.registerListeners();
+  _registerListeners() {
     const {
       hls
     } = this;
+    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.MANIFEST_PARSED, this.onManifestParsed, this);
     hls.on(Events.LEVEL_LOADING, this.onLevelLoading, this);
     hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.on(Events.FRAG_LOAD_EMERGENCY_ABORTED, this.onFragLoadEmergencyAborted, this);
+    hls.on(Events.ERROR, this.onError, this);
     hls.on(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.on(Events.AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
     hls.on(Events.BUFFER_CREATED, this.onBufferCreated, this);
@@ -19001,14 +18594,17 @@ class StreamController extends BaseStreamController {
     hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
-  unregisterListeners() {
-    super.unregisterListeners();
+  _unregisterListeners() {
     const {
       hls
     } = this;
+    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
     hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.off(Events.FRAG_LOAD_EMERGENCY_ABORTED, this.onFragLoadEmergencyAborted, this);
+    hls.off(Events.ERROR, this.onError, this);
     hls.off(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.off(Events.AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
     hls.off(Events.BUFFER_CREATED, this.onBufferCreated, this);
@@ -19017,9 +18613,7 @@ class StreamController extends BaseStreamController {
     hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
   onHandlerDestroying() {
-    // @ts-ignore
-    this.onMediaPlaying = this.onMediaSeeked = null;
-    this.unregisterListeners();
+    this._unregisterListeners();
     super.onHandlerDestroying();
   }
   startLoad(startPosition) {
@@ -19117,9 +18711,6 @@ class StreamController extends BaseStreamController {
     this.checkFragmentChanged();
   }
   doTickIdle() {
-    if (!this.buffering) {
-      return;
-    }
     const {
       hls,
       levelLastLoaded,
@@ -19347,17 +18938,20 @@ class StreamController extends BaseStreamController {
   onMediaAttached(event, data) {
     super.onMediaAttached(event, data);
     const media = data.media;
-    media.addEventListener('playing', this.onMediaPlaying);
-    media.addEventListener('seeked', this.onMediaSeeked);
+    this.onvplaying = this.onMediaPlaying.bind(this);
+    this.onvseeked = this.onMediaSeeked.bind(this);
+    media.addEventListener('playing', this.onvplaying);
+    media.addEventListener('seeked', this.onvseeked);
     this.gapController = new GapController(this.config, media, this.fragmentTracker, this.hls);
   }
   onMediaDetaching() {
     const {
       media
     } = this;
-    if (media) {
-      media.removeEventListener('playing', this.onMediaPlaying);
-      media.removeEventListener('seeked', this.onMediaSeeked);
+    if (media && this.onvplaying && this.onvseeked) {
+      media.removeEventListener('playing', this.onvplaying);
+      media.removeEventListener('seeked', this.onvseeked);
+      this.onvplaying = this.onvseeked = null;
       this.videoBuffer = null;
     }
     this.fragPlaying = null;
@@ -19367,6 +18961,27 @@ class StreamController extends BaseStreamController {
     }
     super.onMediaDetaching();
   }
+  onMediaPlaying() {
+    // tick to speed up FRAG_CHANGED triggering
+    this.tick();
+  }
+  onMediaSeeked() {
+    const media = this.media;
+    const currentTime = media ? media.currentTime : null;
+    if (isFiniteNumber(currentTime)) {
+      this.log(`Media seeked to ${currentTime.toFixed(3)}`);
+    }
+
+    // If seeked was issued before buffer was appended do not tick immediately
+    const bufferInfo = this.getMainFwdBufferInfo();
+    if (bufferInfo === null || bufferInfo.len === 0) {
+      this.warn(`Main forward buffer length on "seeked" event ${bufferInfo ? bufferInfo.len : 'empty'})`);
+      return;
+    }
+
+    // tick to speed up FRAG_CHANGED triggering
+    this.tick();
+  }
   onManifestLoading() {
     // reset buffer on manifest loading
     this.log('Trigger BUFFER_RESET');
@@ -19658,10 +19273,8 @@ class StreamController extends BaseStreamController {
     }
     if (this.loadedmetadata || !BufferHelper.getBuffered(media).length) {
       // Resolve gaps using the main buffer, whose ranges are the intersections of the A/V sourcebuffers
-      const state = this.state;
-      const activeFrag = state !== State.IDLE ? this.fragCurrent : null;
-      const levelDetails = this.getLevelDetails();
-      gapController.poll(this.lastCurrentTime, activeFrag, levelDetails, state);
+      const activeFrag = this.state !== State.IDLE ? this.fragCurrent : null;
+      gapController.poll(this.lastCurrentTime, activeFrag);
     }
     this.lastCurrentTime = media.currentTime;
   }
@@ -19994,17 +19607,6 @@ class StreamController extends BaseStreamController {
   getMainFwdBufferInfo() {
     return this.getFwdBufferInfo(this.mediaBuffer ? this.mediaBuffer : this.media, PlaylistLevelType.MAIN);
   }
-  get maxBufferLength() {
-    const {
-      levels,
-      level
-    } = this;
-    const levelInfo = levels == null ? void 0 : levels[level];
-    if (!levelInfo) {
-      return this.config.maxBufferLength;
-    }
-    return this.getMaxBufferLength(levelInfo.maxBitrate);
-  }
   backtrack(frag) {
     this.couldBacktrack = true;
     // Causes findFragments to backtrack through fragments to find the keyframe
@@ -20110,7 +19712,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.7-0.canary.10040";
+    return "1.5.7";
   }
 
   /**
@@ -20173,12 +19775,9 @@ class Hls {
      * The configuration object provided on player instantiation.
      */
     this.userConfig = void 0;
-    /**
-     * The logger functions used by this player instance, configured on player instantiation.
-     */
-    this.logger = void 0;
     this.coreComponents = void 0;
     this.networkControllers = void 0;
+    this.started = false;
     this._emitter = new EventEmitter();
     this._autoLevelCapping = -1;
     this._maxHdcpLevel = null;
@@ -20195,11 +19794,11 @@ class Hls {
     this._media = null;
     this.url = null;
     this.triggeringException = void 0;
-    const logger = this.logger = enableLogs(userConfig.debug || false, 'Hls instance');
-    const config = this.config = mergeConfig(Hls.DefaultConfig, userConfig, logger);
+    enableLogs(userConfig.debug || false, 'Hls instance');
+    const config = this.config = mergeConfig(Hls.DefaultConfig, userConfig);
     this.userConfig = userConfig;
     if (config.progressive) {
-      enableStreamingMode(config, logger);
+      enableStreamingMode(config);
     }
 
     // core controllers and network loaders
@@ -20212,9 +19811,7 @@ class Hls {
     } = config;
     const errorController = new ConfigErrorController(this);
     const abrController = this.abrController = new ConfigAbrController(this);
-    // FragmentTracker must be defined before StreamController because the order of event handling is important
-    const fragmentTracker = new FragmentTracker(this);
-    const bufferController = this.bufferController = new ConfigBufferController(this, fragmentTracker);
+    const bufferController = this.bufferController = new ConfigBufferController(this);
     const capLevelController = this.capLevelController = new ConfigCapLevelController(this);
     const fpsController = new ConfigFpsController(this);
     const playListLoader = new PlaylistLoader(this);
@@ -20223,6 +19820,8 @@ class Hls {
     // ConentSteeringController is defined before LevelController to receive Multivariant Playlist events first
     const contentSteering = ConfigContentSteeringController ? new ConfigContentSteeringController(this) : null;
     const levelController = this.levelController = new LevelController(this, contentSteering);
+    // FragmentTracker must be defined before StreamController because the order of event handling is important
+    const fragmentTracker = new FragmentTracker(this);
     const keyLoader = new KeyLoader(this.config);
     const streamController = this.streamController = new StreamController(this, fragmentTracker, keyLoader);
 
@@ -20298,7 +19897,7 @@ class Hls {
       try {
         return this.emit(event, event, eventObject);
       } catch (error) {
-        this.logger.error('An internal error happened while handling event ' + event + '. Error message: "' + error.message + '". Here is a stacktrace:', error);
+        logger.error('An internal error happened while handling event ' + event + '. Error message: "' + error.message + '". Here is a stacktrace:', error);
         // Prevent recursion in error event handlers that throw #5497
         if (!this.triggeringException) {
           this.triggeringException = true;
@@ -20324,7 +19923,7 @@ class Hls {
    * Dispose of the instance
    */
   destroy() {
-    this.logger.log('destroy');
+    logger.log('destroy');
     this.trigger(Events.DESTROYING, undefined);
     this.detachMedia();
     this.removeAllListeners();
@@ -20345,7 +19944,7 @@ class Hls {
    * Attaches Hls.js to a media element
    */
   attachMedia(media) {
-    this.logger.log('attachMedia');
+    logger.log('attachMedia');
     this._media = media;
     this.trigger(Events.MEDIA_ATTACHING, {
       media: media
@@ -20356,7 +19955,7 @@ class Hls {
    * Detach Hls.js from the media
    */
   detachMedia() {
-    this.logger.log('detachMedia');
+    logger.log('detachMedia');
     this.trigger(Events.MEDIA_DETACHING, undefined);
     this._media = null;
   }
@@ -20373,7 +19972,7 @@ class Hls {
     });
     this._autoLevelCapping = -1;
     this._maxHdcpLevel = null;
-    this.logger.log(`loadSource:${loadingSource}`);
+    logger.log(`loadSource:${loadingSource}`);
     if (media && loadedSource && (loadedSource !== loadingSource || this.bufferController.hasSourceTypes())) {
       this.detachMedia();
       this.attachMedia(media);
@@ -20392,7 +19991,8 @@ class Hls {
    * Defaults to -1 (None: starts from earliest point)
    */
   startLoad(startPosition = -1) {
-    this.logger.log(`startLoad(${startPosition})`);
+    logger.log(`startLoad(${startPosition})`);
+    this.started = true;
     this.networkControllers.forEach(controller => {
       controller.startLoad(startPosition);
     });
@@ -20402,31 +20002,34 @@ class Hls {
    * Stop loading of any stream data.
    */
   stopLoad() {
-    this.logger.log('stopLoad');
+    logger.log('stopLoad');
+    this.started = false;
     this.networkControllers.forEach(controller => {
       controller.stopLoad();
     });
   }
 
   /**
-   * Resumes stream controller segment loading after `pauseBuffering` has been called.
+   * Resumes stream controller segment loading if previously started.
    */
   resumeBuffering() {
-    this.networkControllers.forEach(controller => {
-      if (controller.resumeBuffering) {
-        controller.resumeBuffering();
-      }
-    });
+    if (this.started) {
+      this.networkControllers.forEach(controller => {
+        if ('fragmentLoader' in controller) {
+          controller.startLoad(-1);
+        }
+      });
+    }
   }
 
   /**
-   * Prevents stream controller from loading new segments until `resumeBuffering` is called.
+   * Stops stream controller segment loading without changing 'started' state like stopLoad().
    * This allows for media buffering to be paused without interupting playlist loading.
    */
   pauseBuffering() {
     this.networkControllers.forEach(controller => {
-      if (controller.pauseBuffering) {
-        controller.pauseBuffering();
+      if ('fragmentLoader' in controller) {
+        controller.stopLoad();
       }
     });
   }
@@ -20435,7 +20038,7 @@ class Hls {
    * Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
    */
   swapAudioCodec() {
-    this.logger.log('swapAudioCodec');
+    logger.log('swapAudioCodec');
     this.streamController.swapAudioCodec();
   }
 
@@ -20446,7 +20049,7 @@ class Hls {
    * Automatic recovery of media-errors by this process is configurable.
    */
   recoverMediaError() {
-    this.logger.log('recoverMediaError');
+    logger.log('recoverMediaError');
     const media = this._media;
     this.detachMedia();
     if (media) {
@@ -20476,7 +20079,7 @@ class Hls {
    * Set quality level index immediately. This will flush the current buffer to replace the quality asap. That means playback will interrupt at least shortly to re-buffer and re-sync eventually. Set to -1 for automatic level selection.
    */
   set currentLevel(newLevel) {
-    this.logger.log(`set currentLevel:${newLevel}`);
+    logger.log(`set currentLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
     this.streamController.immediateLevelSwitch();
   }
@@ -20495,7 +20098,7 @@ class Hls {
    * @param newLevel - Pass -1 for automatic level selection
    */
   set nextLevel(newLevel) {
-    this.logger.log(`set nextLevel:${newLevel}`);
+    logger.log(`set nextLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
     this.streamController.nextLevelSwitch();
   }
@@ -20514,7 +20117,7 @@ class Hls {
    * @param newLevel - Pass -1 for automatic level selection
    */
   set loadLevel(newLevel) {
-    this.logger.log(`set loadLevel:${newLevel}`);
+    logger.log(`set loadLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
   }
 
@@ -20545,7 +20148,7 @@ class Hls {
    * Sets "first-level", see getter.
    */
   set firstLevel(newLevel) {
-    this.logger.log(`set firstLevel:${newLevel}`);
+    logger.log(`set firstLevel:${newLevel}`);
     this.levelController.firstLevel = newLevel;
   }
 
@@ -20570,7 +20173,7 @@ class Hls {
    * (determined from download of first segment)
    */
   set startLevel(newLevel) {
-    this.logger.log(`set startLevel:${newLevel}`);
+    logger.log(`set startLevel:${newLevel}`);
     // if not in automatic start level detection, ensure startLevel is greater than minAutoLevel
     if (newLevel !== -1) {
       newLevel = Math.max(newLevel, this.minAutoLevel);
@@ -20645,7 +20248,7 @@ class Hls {
    */
   set autoLevelCapping(newLevel) {
     if (this._autoLevelCapping !== newLevel) {
-      this.logger.log(`set autoLevelCapping:${newLevel}`);
+      logger.log(`set autoLevelCapping:${newLevel}`);
       this._autoLevelCapping = newLevel;
       this.levelController.checkMaxAutoUpdated();
     }
@@ -20750,9 +20353,6 @@ class Hls {
   get mainForwardBufferInfo() {
     return this.streamController.getMainFwdBufferInfo();
   }
-  get maxBufferLength() {
-    return this.streamController.maxBufferLength;
-  }
 
   /**
    * Find and select the best matching audio track, making a level switch when a Group change is necessary.
@@ -20927,5 +20527,5 @@ var KeySystemFormats = empty.KeySystemFormats;
 var KeySystems = empty.KeySystems;
 var SubtitleStreamController = empty.SubtitleStreamController;
 var TimelineController = empty.TimelineController;
-export { AbrController, AttrList, HevcVideoParser as AudioStreamController, HevcVideoParser as AudioTrackController, BasePlaylistController, BaseSegment, BaseStreamController, BufferController, HevcVideoParser as CMCDController, CapLevelController, ChunkMetadata, ContentSteeringController, DateRange, HevcVideoParser as EMEController, ErrorActionFlags, ErrorController, ErrorDetails, ErrorTypes, Events, FPSController, Fragment, Hls, HlsSkip, HlsUrlParameters, KeySystemFormats, KeySystems, Level, LevelDetails, LevelKey, LoadStats, MetadataSchema, NetworkErrorAction, Part, PlaylistLevelType, SubtitleStreamController, HevcVideoParser as SubtitleTrackController, TimelineController, Hls as default, getMediaSource, isMSESupported, isSupported };
+export { AbrController, AttrList, Cues as AudioStreamController, Cues as AudioTrackController, BasePlaylistController, BaseSegment, BaseStreamController, BufferController, Cues as CMCDController, CapLevelController, ChunkMetadata, ContentSteeringController, DateRange, Cues as EMEController, ErrorActionFlags, ErrorController, ErrorDetails, ErrorTypes, Events, FPSController, Fragment, Hls, HlsSkip, HlsUrlParameters, KeySystemFormats, KeySystems, Level, LevelDetails, LevelKey, LoadStats, MetadataSchema, NetworkErrorAction, Part, PlaylistLevelType, SubtitleStreamController, Cues as SubtitleTrackController, TimelineController, Hls as default, getMediaSource, isMSESupported, isSupported };
 //# sourceMappingURL=hls.light.mjs.map