hls.js 1.5.6-0.canary.10011 → 1.5.6

package/dist/hls.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.6"}`);
+    } 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.6-0.canary.10011"}`);
-    } 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) {
@@ -1058,26 +1036,6 @@ function strToUtf8array(str) {
   return Uint8Array.from(unescape(encodeURIComponent(str)), c => c.charCodeAt(0));
 }
 
-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}`);
-  }
-}
-
 /** returns `undefined` is `self` is missing, e.g. in node */
 const optionalSelf = typeof self !== 'undefined' ? self : undefined;
 
@@ -2730,12 +2688,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') {
@@ -2757,13 +2715,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;
       }
@@ -3042,28 +3001,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));
 }
@@ -3086,16 +3040,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: MediaSource.isTypeSupported('audio/mp4; codecs="ac-3"') 
-  };
-}
 
 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;
@@ -3945,10 +3889,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();
     }
 
@@ -4058,7 +4002,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',
@@ -4157,7 +4101,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);
@@ -4762,47 +4706,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();
@@ -4894,7 +4798,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);
@@ -4912,11 +4816,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;
     }
   }
@@ -4930,10 +4834,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) {
@@ -4943,7 +4847,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() {
@@ -5715,13 +5660,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() {
@@ -6073,13 +6023,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() {
@@ -6112,7 +6065,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
@@ -6199,12 +6152,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}`);
@@ -6876,9 +6824,8 @@ function searchDownAndUpList(arr, searchIndex, predicate) {
   return -1;
 }
 
-class AbrController extends Logger {
+class AbrController {
   constructor(_hls) {
-    super('abr', _hls.logger);
     this.hls = void 0;
     this.lastLevelLoadSec = 0;
     this.lastLoadedFragLevel = -1;
@@ -6992,7 +6939,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
@@ -7012,7 +6959,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;
@@ -7244,7 +7191,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() {
@@ -7322,13 +7269,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;
     }
@@ -7402,7 +7349,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;
@@ -7429,11 +7376,11 @@ class AbrController extends Logger {
             const levels = this.hls.levels;
             const index = levels.indexOf(levelInfo);
             if (decodingInfo.error) {
-              this.warn(`MediaCapabilities decodingInfo error: "${decodingInfo.error}" for level ${index} ${JSON.stringify(decodingInfo)}`);
+              logger.warn(`[abr] MediaCapabilities decodingInfo error: "${decodingInfo.error}" for level ${index} ${JSON.stringify(decodingInfo)}`);
             } else if (!decodingInfo.supported) {
-              this.warn(`Unsupported MediaCapabilities decodingInfo result for level ${index} ${JSON.stringify(decodingInfo)}`);
+              logger.warn(`[abr] Unsupported MediaCapabilities decodingInfo result for level ${index} ${JSON.stringify(decodingInfo)}`);
               if (index > -1 && levels.length > 1) {
-                this.log(`Removing unsupported level ${index}`);
+                logger.log(`[abr] Removing unsupported level ${index}`);
                 this.hls.removeLevel(index);
               }
             }
@@ -7480,9 +7427,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;
@@ -7536,9 +7483,8 @@ class AbrController extends Logger {
  * 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;
@@ -8629,8 +8575,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;
@@ -8663,9 +8609,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);
@@ -8675,61 +8618,33 @@ class LoadError extends Error {
 }
 
 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) {
@@ -8979,8 +8894,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) {
@@ -8993,7 +8907,9 @@ class Decrypter {
         /* no-op */
       }
     }
-    this.useSoftware = this.subtle === null;
+    if (this.subtle === null) {
+      this.useSoftware = true;
+    }
   }
   destroy() {
     this.subtle = null;
@@ -9031,10 +8947,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);
@@ -9043,21 +8959,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
@@ -9090,11 +9002,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
@@ -9102,25 +9014,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;
@@ -9171,7 +9080,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;
@@ -9196,98 +9105,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();
@@ -9311,12 +9144,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
@@ -9347,8 +9174,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);
@@ -9362,9 +9191,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();
@@ -9374,8 +9204,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 = [];
@@ -9385,7 +9263,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;
@@ -9516,10 +9394,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,
@@ -9631,7 +9509,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 => {
@@ -9652,16 +9530,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) {
@@ -9670,7 +9540,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;
@@ -9699,14 +9569,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;
@@ -9804,36 +9667,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,
@@ -9982,8 +9817,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) {
@@ -9995,10 +9829,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;
       }
@@ -10009,7 +9839,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);
@@ -10131,7 +9961,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);
@@ -10324,7 +10154,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) {
@@ -10733,7 +10563,6 @@ const initPTSFn = (timestamp, timeOffset, initPTS) => {
  */
 function getAudioConfig(observer, data, offset, audioCodec) {
   let adtsObjectType;
-  let originalAdtsObjectType;
   let adtsExtensionSamplingIndex;
   let adtsChannelConfig;
   let config;
@@ -10741,7 +10570,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}`);
@@ -10758,8 +10587,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);
@@ -10853,7 +10682,6 @@ function getAudioConfig(observer, data, offset, audioCodec) {
     samplerate: adtsSamplingRates[adtsSamplingIndex],
     channelCount: adtsChannelConfig,
     codec: 'mp4a.40.' + adtsObjectType,
-    parsedCodec: 'mp4a.40.' + originalAdtsObjectType,
     manifestCodec
   };
 }
@@ -10908,8 +10736,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) {
@@ -11500,111 +11327,7 @@ 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;
-  }
-}
+}
 
 /**
  * Parser for exponential Golomb codes, a variable-bitwidth number encoding scheme used by h264.
@@ -11746,171 +11469,21 @@ class ExpGolomb {
   readUInt() {
     return this.readBits(32);
   }
-}
-
-class AvcVideoParser extends BaseVideoParser {
-  parsePES(track, textTrack, pes, last, duration) {
-    const units = this.parseNALu(track, pes.data);
-    let VideoSample = this.VideoSample;
-    let push;
-    let spsfound = false;
-    // free pes.data to save up some memory
-    pes.data = null;
-
-    // if new NAL units found and last sample still there, let's push ...
-    // this helps parsing streams with missing AUD (only do this if AUD never found)
-    if (VideoSample && units.length && !track.audFound) {
-      this.pushAccessUnit(VideoSample, track);
-      VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts, '');
-    }
-    units.forEach(unit => {
-      var _VideoSample2;
-      switch (unit.type) {
-        // NDR
-        case 1:
-          {
-            let iskey = false;
-            push = true;
-            const data = unit.data;
-            // 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);
-              // 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.
-              // I slice: A slice that is not an SI slice that is decoded using intra prediction only.
-              // if (sliceType === 2 || sliceType === 7) {
-              if (sliceType === 2 || sliceType === 4 || sliceType === 7 || sliceType === 9) {
-                iskey = true;
-              }
-            }
-            if (iskey) {
-              var _VideoSample;
-              // if we have non-keyframe data already, that cannot belong to the same frame as a keyframe, so force a push
-              if ((_VideoSample = VideoSample) != null && _VideoSample.frame && !VideoSample.key) {
-                this.pushAccessUnit(VideoSample, track);
-                VideoSample = this.VideoSample = null;
-              }
-            }
-            if (!VideoSample) {
-              VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
-            }
-            VideoSample.frame = true;
-            VideoSample.key = iskey;
-            break;
-            // IDR
-          }
-        case 5:
-          push = true;
-          // handle PES not starting with AUD
-          // if we have frame data already, that cannot belong to the same frame, so force a push
-          if ((_VideoSample2 = VideoSample) != null && _VideoSample2.frame && !VideoSample.key) {
-            this.pushAccessUnit(VideoSample, track);
-            VideoSample = this.VideoSample = null;
-          }
-          if (!VideoSample) {
-            VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
-          }
-          VideoSample.key = true;
-          VideoSample.frame = true;
-          break;
-        // SEI
-        case 6:
-          {
-            push = true;
-            parseSEIMessageFromNALu(unit.data, 1, pes.pts, textTrack.samples);
-            break;
-            // SPS
-          }
-        case 7:
-          {
-            var _track$pixelRatio, _track$pixelRatio2;
-            push = true;
-            spsfound = true;
-            const sps = unit.data;
-            const config = this.readSPS(sps);
-            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;
-              track.pixelRatio = config.pixelRatio;
-              track.sps = [sps];
-              track.duration = duration;
-              const codecarray = sps.subarray(1, 4);
-              let codecstring = 'avc1.';
-              for (let i = 0; i < 3; i++) {
-                let h = codecarray[i].toString(16);
-                if (h.length < 2) {
-                  h = '0' + h;
-                }
-                codecstring += h;
-              }
-              track.codec = codecstring;
-            }
-            break;
-          }
-        // PPS
-        case 8:
-          push = true;
-          track.pps = [unit.data];
-          break;
-        // AUD
-        case 9:
-          push = true;
-          track.audFound = true;
-          if (VideoSample) {
-            this.pushAccessUnit(VideoSample, track);
-          }
-          VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts, '');
-          break;
-        // Filler Data
-        case 12:
-          push = true;
-          break;
-        default:
-          push = false;
-          if (VideoSample) {
-            VideoSample.debug += 'unknown NAL ' + unit.type + ' ';
-          }
-          break;
-      }
-      if (VideoSample && push) {
-        const units = VideoSample.units;
-        units.push(unit);
-      }
-    });
-    // if last PES packet, push samples
-    if (last && VideoSample) {
-      this.pushAccessUnit(VideoSample, track);
-      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();
-  }
 
   /**
-   * The scaling list is optionally transmitted as part of a sequence parameter
+   * 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, reader) {
+  skipScalingList(count) {
     let lastScale = 8;
     let nextScale = 8;
     let deltaScale;
     for (let j = 0; j < count; j++) {
       if (nextScale !== 0) {
-        deltaScale = reader.readEG();
+        deltaScale = this.readEG();
         nextScale = (lastScale + deltaScale + 256) % 256;
       }
       lastScale = nextScale === 0 ? lastScale : nextScale;
@@ -11925,8 +11498,7 @@ class AvcVideoParser extends BaseVideoParser {
    * sequence parameter set, including the dimensions of the
    * associated video frames.
    */
-  readSPS(sps) {
-    const eg = new ExpGolomb(sps);
+  readSPS() {
     let frameCropLeftOffset = 0;
     let frameCropRightOffset = 0;
     let frameCropTopOffset = 0;
@@ -11934,13 +11506,13 @@ class AvcVideoParser extends BaseVideoParser {
     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 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
@@ -11965,9 +11537,9 @@ class AvcVideoParser extends BaseVideoParser {
           if (readBoolean()) {
             // seq_scaling_list_present_flag[ i ]
             if (i < 6) {
-              skipScalingList(16, eg);
+              skipScalingList(16);
             } else {
-              skipScalingList(64, eg);
+              skipScalingList(64);
             }
           }
         }
@@ -12072,15 +11644,19 @@ class AvcVideoParser extends BaseVideoParser {
       pixelRatio: pixelRatio
     };
   }
+  readSliceType() {
+    // skip NALu type
+    this.readUByte();
+    // discard first_mb_in_slice
+    this.readUEG();
+    // return slice_type
+    return this.readUEG();
+  }
 }
 
-class HevcVideoParser extends BaseVideoParser {
-  constructor(...args) {
-    super(...args);
-    this.initVPS = null;
-  }
-  parsePES(track, textTrack, pes, last, duration) {
-    const units = this.parseNALu(track, pes.data);
+class AvcVideoParser extends BaseVideoParser {
+  parseAVCPES(track, textTrack, pes, last, duration) {
+    const units = this.parseAVCNALu(track, pes.data);
     let VideoSample = this.VideoSample;
     let push;
     let spsfound = false;
@@ -12096,49 +11672,42 @@ class HevcVideoParser extends BaseVideoParser {
     units.forEach(unit => {
       var _VideoSample2;
       switch (unit.type) {
-        // NON-IDR, NON RANDOM ACCESS SLICE
-        case 0:
+        // NDR
         case 1:
-        case 2:
-        case 3:
-        case 4:
-        case 5:
-        case 6:
-        case 7:
-        case 8:
-        case 9:
-          if (!VideoSample) {
-            VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts, '');
-          }
-          VideoSample.frame = true;
-          push = true;
-          break;
-
-        // CRA, BLA (random access picture)
-        case 16:
-        case 17:
-        case 18:
-        case 21:
-          push = true;
-          if (spsfound) {
-            var _VideoSample;
-            // handle PES not starting with AUD
-            // if we have frame data already, that cannot belong to the same frame, so force a push
-            if ((_VideoSample = VideoSample) != null && _VideoSample.frame && !VideoSample.key) {
-              this.pushAccessUnit(VideoSample, track);
-              VideoSample = this.VideoSample = null;
+          {
+            let iskey = false;
+            push = true;
+            const data = unit.data;
+            // 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 = 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.
+              // I slice: A slice that is not an SI slice that is decoded using intra prediction only.
+              // if (sliceType === 2 || sliceType === 7) {
+              if (sliceType === 2 || sliceType === 4 || sliceType === 7 || sliceType === 9) {
+                iskey = true;
+              }
             }
+            if (iskey) {
+              var _VideoSample;
+              // if we have non-keyframe data already, that cannot belong to the same frame as a keyframe, so force a push
+              if ((_VideoSample = VideoSample) != null && _VideoSample.frame && !VideoSample.key) {
+                this.pushAccessUnit(VideoSample, track);
+                VideoSample = this.VideoSample = null;
+              }
+            }
+            if (!VideoSample) {
+              VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
+            }
+            VideoSample.frame = true;
+            VideoSample.key = iskey;
+            break;
+            // IDR
           }
-          if (!VideoSample) {
-            VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
-          }
-          VideoSample.key = true;
-          VideoSample.frame = true;
-          break;
-
-        // IDR
-        case 19:
-        case 20:
+        case 5:
           push = true;
           // handle PES not starting with AUD
           // if we have frame data already, that cannot belong to the same frame, so force a push
@@ -12152,76 +11721,48 @@ class HevcVideoParser extends BaseVideoParser {
           VideoSample.key = true;
           VideoSample.frame = true;
           break;
-
         // SEI
-        case 39:
-          push = true;
-          parseSEIMessageFromNALu(unit.data, 2,
-          // NALu header size
-          pes.pts, textTrack.samples);
-          break;
-
-        // VPS
-        case 32:
-          push = true;
-          if (!track.vps) {
-            const config = this.readVPS(unit.data);
-            track.params = _objectSpread2({}, config);
-            this.initVPS = unit.data;
+        case 6:
+          {
+            push = true;
+            parseSEIMessageFromNALu(unit.data, 1, pes.pts, textTrack.samples);
+            break;
+            // SPS
           }
-          track.vps = [unit.data];
-          break;
-
-        // SPS
-        case 33:
-          push = true;
-          spsfound = true;
-          if (typeof track.params === 'object') {
-            if (track.vps !== undefined && track.vps[0] !== this.initVPS && track.sps !== undefined && !this.matchSPS(track.sps[0], unit.data)) {
-              this.initVPS = track.vps[0];
-              track.sps = track.pps = undefined;
-            }
-            if (!track.sps) {
-              const config = this.readSPS(unit.data);
+        case 7:
+          {
+            var _track$pixelRatio, _track$pixelRatio2;
+            push = true;
+            spsfound = true;
+            const sps = unit.data;
+            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;
               track.pixelRatio = config.pixelRatio;
+              track.sps = [sps];
               track.duration = duration;
-              track.codec = config.codecString;
-              track.sps = [];
-              for (const prop in config.params) {
-                track.params[prop] = config.params[prop];
+              const codecarray = sps.subarray(1, 4);
+              let codecstring = 'avc1.';
+              for (let i = 0; i < 3; i++) {
+                let h = codecarray[i].toString(16);
+                if (h.length < 2) {
+                  h = '0' + h;
+                }
+                codecstring += h;
               }
+              track.codec = codecstring;
             }
-            if (track.vps !== undefined && track.vps[0] === this.initVPS) {
-              track.sps.push(unit.data);
-            }
-          }
-          if (!VideoSample) {
-            VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
+            break;
           }
-          VideoSample.key = true;
-          break;
-
         // PPS
-        case 34:
+        case 8:
           push = true;
-          if (typeof track.params === 'object') {
-            if (!track.pps) {
-              track.pps = [];
-              const config = this.readPPS(unit.data);
-              for (const prop in config) {
-                track.params[prop] = config[prop];
-              }
-            }
-            if (this.initVPS !== null || track.pps.length === 0) {
-              track.pps.push(unit.data);
-            }
-          }
+          track.pps = [unit.data];
           break;
-
-        // ACCESS UNIT DELIMITER
-        case 35:
+        // AUD
+        case 9:
           push = true;
           track.audFound = true;
           if (VideoSample) {
@@ -12229,10 +11770,14 @@ class HevcVideoParser extends BaseVideoParser {
           }
           VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts, '');
           break;
+        // Filler Data
+        case 12:
+          push = true;
+          break;
         default:
           push = false;
           if (VideoSample) {
-            VideoSample.debug += 'unknown or irrelevant NAL ' + unit.type + ' ';
+            VideoSample.debug += 'unknown NAL ' + unit.type + ' ';
           }
           break;
       }
@@ -12247,423 +11792,109 @@ class HevcVideoParser extends BaseVideoParser {
       this.VideoSample = null;
     }
   }
-  getNALuType(data, offset) {
-    return (data[offset] & 0x7e) >>> 1;
-  }
-  ebsp2rbsp(arr) {
-    const dst = new Uint8Array(arr.byteLength);
-    let dstIdx = 0;
-    for (let i = 0; i < arr.byteLength; i++) {
-      if (i >= 2) {
-        // Unescape: Skip 0x03 after 00 00
-        if (arr[i] === 0x03 && arr[i - 1] === 0x00 && arr[i - 2] === 0x00) {
-          continue;
-        }
-      }
-      dst[dstIdx] = arr[i];
-      dstIdx++;
-    }
-    return new Uint8Array(dst.buffer, 0, dstIdx);
-  }
-  readVPS(vps) {
-    const eg = new ExpGolomb(vps);
-    // remove header
-    eg.readUByte();
-    eg.readUByte();
-    eg.readBits(4); // video_parameter_set_id
-    eg.skipBits(2);
-    eg.readBits(6); // max_layers_minus1
-    const max_sub_layers_minus1 = eg.readBits(3);
-    const temporal_id_nesting_flag = eg.readBoolean();
-    // ...vui fps can be here, but empty fps value is not critical for metadata
+  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));
 
-    return {
-      numTemporalLayers: max_sub_layers_minus1 + 1,
-      temporalIdNested: temporal_id_nesting_flag
-    };
-  }
-  readSPS(sps) {
-    const eg = new ExpGolomb(this.ebsp2rbsp(sps));
-    eg.readUByte();
-    eg.readUByte();
-    eg.readBits(4); //video_parameter_set_id
-    const max_sub_layers_minus1 = eg.readBits(3);
-    eg.readBoolean(); // temporal_id_nesting_flag
-
-    // profile_tier_level
-    const general_profile_space = eg.readBits(2);
-    const general_tier_flag = eg.readBoolean();
-    const general_profile_idc = eg.readBits(5);
-    const general_profile_compatibility_flags_1 = eg.readUByte();
-    const general_profile_compatibility_flags_2 = eg.readUByte();
-    const general_profile_compatibility_flags_3 = eg.readUByte();
-    const general_profile_compatibility_flags_4 = eg.readUByte();
-    const general_constraint_indicator_flags_1 = eg.readUByte();
-    const general_constraint_indicator_flags_2 = eg.readUByte();
-    const general_constraint_indicator_flags_3 = eg.readUByte();
-    const general_constraint_indicator_flags_4 = eg.readUByte();
-    const general_constraint_indicator_flags_5 = eg.readUByte();
-    const general_constraint_indicator_flags_6 = eg.readUByte();
-    const general_level_idc = eg.readUByte();
-    const sub_layer_profile_present_flags = [];
-    const sub_layer_level_present_flags = [];
-    for (let i = 0; i < max_sub_layers_minus1; i++) {
-      sub_layer_profile_present_flags.push(eg.readBoolean());
-      sub_layer_level_present_flags.push(eg.readBoolean());
-    }
-    if (max_sub_layers_minus1 > 0) {
-      for (let i = max_sub_layers_minus1; i < 8; i++) {
-        eg.readBits(2);
-      }
-    }
-    for (let i = 0; i < max_sub_layers_minus1; i++) {
-      if (sub_layer_profile_present_flags[i]) {
-        eg.readUByte(); // sub_layer_profile_space, sub_layer_tier_flag, sub_layer_profile_idc
-        eg.readUByte();
-        eg.readUByte();
-        eg.readUByte();
-        eg.readUByte(); // sub_layer_profile_compatibility_flag
-        eg.readUByte();
-        eg.readUByte();
-        eg.readUByte();
-        eg.readUByte();
-        eg.readUByte();
-        eg.readUByte();
-      }
-      if (sub_layer_level_present_flags[i]) {
-        eg.readUByte();
-      }
-    }
-    eg.readUEG(); // seq_parameter_set_id
-    const chroma_format_idc = eg.readUEG();
-    if (chroma_format_idc == 3) {
-      eg.skipBits(1); //separate_colour_plane_flag
-    }
-    const pic_width_in_luma_samples = eg.readUEG();
-    const pic_height_in_luma_samples = eg.readUEG();
-    const conformance_window_flag = eg.readBoolean();
-    let pic_left_offset = 0,
-      pic_right_offset = 0,
-      pic_top_offset = 0,
-      pic_bottom_offset = 0;
-    if (conformance_window_flag) {
-      pic_left_offset += eg.readUEG();
-      pic_right_offset += eg.readUEG();
-      pic_top_offset += eg.readUEG();
-      pic_bottom_offset += eg.readUEG();
-    }
-    const bit_depth_luma_minus8 = eg.readUEG();
-    const bit_depth_chroma_minus8 = eg.readUEG();
-    const log2_max_pic_order_cnt_lsb_minus4 = eg.readUEG();
-    const sub_layer_ordering_info_present_flag = eg.readBoolean();
-    for (let i = sub_layer_ordering_info_present_flag ? 0 : max_sub_layers_minus1; i <= max_sub_layers_minus1; i++) {
-      eg.skipUEG(); // max_dec_pic_buffering_minus1[i]
-      eg.skipUEG(); // max_num_reorder_pics[i]
-      eg.skipUEG(); // max_latency_increase_plus1[i]
-    }
-    eg.skipUEG(); // log2_min_luma_coding_block_size_minus3
-    eg.skipUEG(); // log2_diff_max_min_luma_coding_block_size
-    eg.skipUEG(); // log2_min_transform_block_size_minus2
-    eg.skipUEG(); // log2_diff_max_min_transform_block_size
-    eg.skipUEG(); // max_transform_hierarchy_depth_inter
-    eg.skipUEG(); // max_transform_hierarchy_depth_intra
-    const scaling_list_enabled_flag = eg.readBoolean();
-    if (scaling_list_enabled_flag) {
-      const sps_scaling_list_data_present_flag = eg.readBoolean();
-      if (sps_scaling_list_data_present_flag) {
-        for (let sizeId = 0; sizeId < 4; sizeId++) {
-          for (let matrixId = 0; matrixId < (sizeId === 3 ? 2 : 6); matrixId++) {
-            const scaling_list_pred_mode_flag = eg.readBoolean();
-            if (!scaling_list_pred_mode_flag) {
-              eg.readUEG(); // scaling_list_pred_matrix_id_delta
-            } else {
-              const coefNum = Math.min(64, 1 << 4 + (sizeId << 1));
-              if (sizeId > 1) {
-                eg.readEG();
-              }
-              for (let i = 0; i < coefNum; i++) {
-                eg.readEG();
+    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;
+    }
+    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;
+            }
           }
         }
-      }
-    }
-    eg.readBoolean(); // amp_enabled_flag
-    eg.readBoolean(); // sample_adaptive_offset_enabled_flag
-    const pcm_enabled_flag = eg.readBoolean();
-    if (pcm_enabled_flag) {
-      eg.readUByte();
-      eg.skipUEG();
-      eg.skipUEG();
-      eg.readBoolean();
-    }
-    const num_short_term_ref_pic_sets = eg.readUEG();
-    let num_delta_pocs = 0;
-    for (let i = 0; i < num_short_term_ref_pic_sets; i++) {
-      let inter_ref_pic_set_prediction_flag = false;
-      if (i !== 0) {
-        inter_ref_pic_set_prediction_flag = eg.readBoolean();
-      }
-      if (inter_ref_pic_set_prediction_flag) {
-        if (i === num_short_term_ref_pic_sets) {
-          eg.readUEG();
-        }
-        eg.readBoolean();
-        eg.readUEG();
-        let next_num_delta_pocs = 0;
-        for (let j = 0; j <= num_delta_pocs; j++) {
-          const used_by_curr_pic_flag = eg.readBoolean();
-          let use_delta_flag = false;
-          if (!used_by_curr_pic_flag) {
-            use_delta_flag = eg.readBoolean();
-          }
-          if (used_by_curr_pic_flag || use_delta_flag) {
-            next_num_delta_pocs++;
-          }
+        // 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;
         }
-        num_delta_pocs = next_num_delta_pocs;
       } else {
-        const num_negative_pics = eg.readUEG();
-        const num_positive_pics = eg.readUEG();
-        num_delta_pocs = num_negative_pics + num_positive_pics;
-        for (let j = 0; j < num_negative_pics; j++) {
-          eg.readUEG();
-          eg.readBoolean();
-        }
-        for (let j = 0; j < num_positive_pics; j++) {
-          eg.readUEG();
-          eg.readBoolean();
-        }
-      }
-    }
-    const long_term_ref_pics_present_flag = eg.readBoolean();
-    if (long_term_ref_pics_present_flag) {
-      const num_long_term_ref_pics_sps = eg.readUEG();
-      for (let i = 0; i < num_long_term_ref_pics_sps; i++) {
-        for (let j = 0; j < log2_max_pic_order_cnt_lsb_minus4 + 4; j++) {
-          eg.readBits(1);
-        }
-        eg.readBits(1);
-      }
-    }
-    let min_spatial_segmentation_idc = 0;
-    let sar_width = 1,
-      sar_height = 1;
-    let fps_fixed = true,
-      fps_den = 1,
-      fps_num = 0;
-    eg.readBoolean(); // sps_temporal_mvp_enabled_flag
-    eg.readBoolean(); // strong_intra_smoothing_enabled_flag
-    let default_display_window_flag = false;
-    const vui_parameters_present_flag = eg.readBoolean();
-    if (vui_parameters_present_flag) {
-      const aspect_ratio_info_present_flag = eg.readBoolean();
-      if (aspect_ratio_info_present_flag) {
-        const aspect_ratio_idc = eg.readUByte();
-        const sar_width_table = [1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2];
-        const sar_height_table = [1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1];
-        if (aspect_ratio_idc > 0 && aspect_ratio_idc < 16) {
-          sar_width = sar_width_table[aspect_ratio_idc - 1];
-          sar_height = sar_height_table[aspect_ratio_idc - 1];
-        } else if (aspect_ratio_idc === 255) {
-          sar_width = eg.readBits(16);
-          sar_height = eg.readBits(16);
-        }
-      }
-      const overscan_info_present_flag = eg.readBoolean();
-      if (overscan_info_present_flag) {
-        eg.readBoolean();
-      }
-      const video_signal_type_present_flag = eg.readBoolean();
-      if (video_signal_type_present_flag) {
-        eg.readBits(3);
-        eg.readBoolean();
-        const colour_description_present_flag = eg.readBoolean();
-        if (colour_description_present_flag) {
-          eg.readUByte();
-          eg.readUByte();
-          eg.readUByte();
-        }
-      }
-      const chroma_loc_info_present_flag = eg.readBoolean();
-      if (chroma_loc_info_present_flag) {
-        eg.readUEG();
-        eg.readUEG();
-      }
-      eg.readBoolean(); // neutral_chroma_indication_flag
-      eg.readBoolean(); // field_seq_flag
-      eg.readBoolean(); // frame_field_info_present_flag
-      default_display_window_flag = eg.readBoolean();
-      if (default_display_window_flag) {
-        pic_left_offset += eg.readUEG();
-        pic_right_offset += eg.readUEG();
-        pic_top_offset += eg.readUEG();
-        pic_bottom_offset += eg.readUEG();
-      }
-      const vui_timing_info_present_flag = eg.readBoolean();
-      if (vui_timing_info_present_flag) {
-        fps_den = eg.readBits(32);
-        fps_num = eg.readBits(32);
-        const vui_poc_proportional_to_timing_flag = eg.readBoolean();
-        if (vui_poc_proportional_to_timing_flag) {
-          eg.readUEG();
-        }
-        const vui_hrd_parameters_present_flag = eg.readBoolean();
-        if (vui_hrd_parameters_present_flag) {
-          //const commonInfPresentFlag = true;
-          //if (commonInfPresentFlag) {
-          const nal_hrd_parameters_present_flag = eg.readBoolean();
-          const vcl_hrd_parameters_present_flag = eg.readBoolean();
-          let sub_pic_hrd_params_present_flag = false;
-          if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) {
-            sub_pic_hrd_params_present_flag = eg.readBoolean();
-            if (sub_pic_hrd_params_present_flag) {
-              eg.readUByte();
-              eg.readBits(5);
-              eg.readBoolean();
-              eg.readBits(5);
-            }
-            eg.readBits(4); // bit_rate_scale
-            eg.readBits(4); // cpb_size_scale
-            if (sub_pic_hrd_params_present_flag) {
-              eg.readBits(4);
-            }
-            eg.readBits(5);
-            eg.readBits(5);
-            eg.readBits(5);
-          }
-          //}
-          for (let i = 0; i <= max_sub_layers_minus1; i++) {
-            fps_fixed = eg.readBoolean(); // fixed_pic_rate_general_flag
-            const fixed_pic_rate_within_cvs_flag = fps_fixed || eg.readBoolean();
-            let low_delay_hrd_flag = false;
-            if (fixed_pic_rate_within_cvs_flag) {
-              eg.readEG();
-            } else {
-              low_delay_hrd_flag = eg.readBoolean();
-            }
-            const cpb_cnt = low_delay_hrd_flag ? 1 : eg.readUEG() + 1;
-            if (nal_hrd_parameters_present_flag) {
-              for (let j = 0; j < cpb_cnt; j++) {
-                eg.readUEG();
-                eg.readUEG();
-                if (sub_pic_hrd_params_present_flag) {
-                  eg.readUEG();
-                  eg.readUEG();
-                }
-                eg.skipBits(1);
-              }
-            }
-            if (vcl_hrd_parameters_present_flag) {
-              for (let j = 0; j < cpb_cnt; j++) {
-                eg.readUEG();
-                eg.readUEG();
-                if (sub_pic_hrd_params_present_flag) {
-                  eg.readUEG();
-                  eg.readUEG();
-                }
-                eg.skipBits(1);
-              }
-            }
-          }
-        }
+        state = 0;
       }
-      const bitstream_restriction_flag = eg.readBoolean();
-      if (bitstream_restriction_flag) {
-        eg.readBoolean(); // tiles_fixed_structure_flag
-        eg.readBoolean(); // motion_vectors_over_pic_boundaries_flag
-        eg.readBoolean(); // restricted_ref_pic_lists_flag
-        min_spatial_segmentation_idc = eg.readUEG();
-      }
-    }
-    let width = pic_width_in_luma_samples,
-      height = pic_height_in_luma_samples;
-    if (conformance_window_flag || default_display_window_flag) {
-      let chroma_scale_w = 1,
-        chroma_scale_h = 1;
-      if (chroma_format_idc === 1) {
-        // YUV 420
-        chroma_scale_w = chroma_scale_h = 2;
-      } else if (chroma_format_idc == 2) {
-        // YUV 422
-        chroma_scale_w = 2;
-      }
-      width = pic_width_in_luma_samples - chroma_scale_w * pic_right_offset - chroma_scale_w * pic_left_offset;
-      height = pic_height_in_luma_samples - chroma_scale_h * pic_bottom_offset - chroma_scale_h * pic_top_offset;
-    }
-    const profile_space_string = general_profile_space ? ['A', 'B', 'C'][general_profile_space] : '';
-    const profile_compatibility_buf = general_profile_compatibility_flags_1 << 24 | general_profile_compatibility_flags_2 << 16 | general_profile_compatibility_flags_3 << 8 | general_profile_compatibility_flags_4;
-    let profile_compatibility_rev = 0;
-    for (let i = 0; i < 32; i++) {
-      profile_compatibility_rev = (profile_compatibility_rev | (profile_compatibility_buf >> i & 1) << 31 - i) >>> 0; // reverse bit position (and cast as UInt32)
-    }
-    let profile_compatibility_flags_string = profile_compatibility_rev.toString(16);
-    if (general_profile_idc === 1 && profile_compatibility_flags_string === '2') {
-      profile_compatibility_flags_string = '6';
-    }
-    const tier_flag_string = general_tier_flag ? 'H' : 'L';
-    return {
-      codecString: `hvc1.${profile_space_string}${general_profile_idc}.${profile_compatibility_flags_string}.${tier_flag_string}${general_level_idc}.B0`,
-      params: {
-        general_tier_flag,
-        general_profile_idc,
-        general_profile_space,
-        general_profile_compatibility_flags: [general_profile_compatibility_flags_1, general_profile_compatibility_flags_2, general_profile_compatibility_flags_3, general_profile_compatibility_flags_4],
-        general_constraint_indicator_flags: [general_constraint_indicator_flags_1, general_constraint_indicator_flags_2, general_constraint_indicator_flags_3, general_constraint_indicator_flags_4, general_constraint_indicator_flags_5, general_constraint_indicator_flags_6],
-        general_level_idc,
-        bit_depth: bit_depth_luma_minus8 + 8,
-        bit_depth_luma_minus8,
-        bit_depth_chroma_minus8,
-        min_spatial_segmentation_idc,
-        chroma_format_idc: chroma_format_idc,
-        frame_rate: {
-          fixed: fps_fixed,
-          fps: fps_num / fps_den
-        }
-      },
-      width,
-      height,
-      pixelRatio: [sar_width, sar_height]
-    };
-  }
-  readPPS(pps) {
-    const eg = new ExpGolomb(this.ebsp2rbsp(pps));
-    eg.readUByte();
-    eg.readUByte();
-    eg.skipUEG(); // pic_parameter_set_id
-    eg.skipUEG(); // seq_parameter_set_id
-    eg.skipBits(2); // dependent_slice_segments_enabled_flag, output_flag_present_flag
-    eg.skipBits(3); // num_extra_slice_header_bits
-    eg.skipBits(2); // sign_data_hiding_enabled_flag, cabac_init_present_flag
-    eg.skipUEG();
-    eg.skipUEG();
-    eg.skipEG(); // init_qp_minus26
-    eg.skipBits(2); // constrained_intra_pred_flag, transform_skip_enabled_flag
-    const cu_qp_delta_enabled_flag = eg.readBoolean();
-    if (cu_qp_delta_enabled_flag) {
-      eg.skipUEG();
-    }
-    eg.skipEG(); // cb_qp_offset
-    eg.skipEG(); // cr_qp_offset
-    eg.skipBits(4); // pps_slice_chroma_qp_offsets_present_flag, weighted_pred_flag, weighted_bipred_flag, transquant_bypass_enabled_flag
-    const tiles_enabled_flag = eg.readBoolean();
-    const entropy_coding_sync_enabled_flag = eg.readBoolean();
-    let parallelismType = 1; // slice-based parallel decoding
-    if (entropy_coding_sync_enabled_flag && tiles_enabled_flag) {
-      parallelismType = 0; // mixed-type parallel decoding
-    } else if (entropy_coding_sync_enabled_flag) {
-      parallelismType = 3; // wavefront-based parallel decoding
-    } else if (tiles_enabled_flag) {
-      parallelismType = 2; // tile-based parallel decoding
     }
-    return {
-      parallelismType
-    };
-  }
-  matchSPS(sps1, sps2) {
-    // compare without headers and VPS related params
-    return String.fromCharCode.apply(null, sps1).substr(3) === String.fromCharCode.apply(null, sps2).substr(3);
+    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;
   }
 }
 
@@ -12681,7 +11912,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
@@ -12795,7 +12026,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);
@@ -12960,21 +12191,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;
-                    case 'hevc':
-                      {
-                        this.videoParser = new HevcVideoParser();
-                      }
-                      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: [],
@@ -13141,22 +12358,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;
-          case 'hevc':
-            {
-              this.videoParser = new HevcVideoParser();
-            }
-            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;
@@ -13489,14 +12692,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)
-        {
-          if (result.videoPid === -1) {
-            result.videoPid = pid;
-            result.segmentVideoCodec = 'hevc';
-            logger.log('HEVC in M2TS found');
-          }
-        }
+        logger.warn('Unsupported HEVC in M2TS found');
         break;
     }
     // move to the next table entry
@@ -13719,8 +12915,6 @@ class MP4 {
       avc1: [],
       // codingname
       avcC: [],
-      hvc1: [],
-      hvcC: [],
       btrt: [],
       dinf: [],
       dref: [],
@@ -14145,10 +13339,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) {
@@ -14286,84 +13478,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;
@@ -14745,9 +13859,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;
@@ -14756,24 +13870,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`);
@@ -14921,7 +14023,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;
@@ -15054,7 +14156,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();
@@ -15182,7 +14284,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) {
@@ -15576,15 +14678,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) {
@@ -15596,7 +14696,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);
@@ -16250,7 +15350,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: MediaSource.isTypeSupported('audio/mp4; codecs="ac-3"') 
+    };
 
     // navigator.vendor is not always available in Web Worker
     // refer to https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/navigator
@@ -16538,7 +15645,7 @@ const TICK_INTERVAL$2 = 100; // how often to tick in ms
 
 class AudioStreamController extends BaseStreamController {
   constructor(hls, fragmentTracker, keyLoader) {
-    super(hls, fragmentTracker, keyLoader, 'audio-stream-controller', PlaylistLevelType.AUDIO);
+    super(hls, fragmentTracker, keyLoader, '[audio-stream-controller]', PlaylistLevelType.AUDIO);
     this.videoBuffer = null;
     this.videoTrackCC = -1;
     this.waitingVideoCC = -1;
@@ -16550,24 +15657,27 @@ class AudioStreamController extends BaseStreamController {
     this.flushing = false;
     this.bufferFlushed = false;
     this.cachedTrackLoadedData = null;
-    this.registerListeners();
+    this._registerListeners();
   }
   onHandlerDestroying() {
-    this.unregisterListeners();
+    this._unregisterListeners();
     super.onHandlerDestroying();
     this.mainDetails = null;
     this.bufferedTrack = null;
     this.switchingTrack = null;
   }
-  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.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.on(Events.AUDIO_TRACKS_UPDATED, this.onAudioTracksUpdated, this);
     hls.on(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.on(Events.AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
+    hls.on(Events.ERROR, this.onError, this);
     hls.on(Events.BUFFER_RESET, this.onBufferReset, this);
     hls.on(Events.BUFFER_CREATED, this.onBufferCreated, this);
     hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
@@ -16575,18 +15685,18 @@ class AudioStreamController extends BaseStreamController {
     hls.on(Events.INIT_PTS_FOUND, this.onInitPtsFound, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
-  unregisterListeners() {
+  _unregisterListeners() {
     const {
       hls
     } = this;
-    if (!hls) {
-      return;
-    }
-    super.unregisterListeners();
+    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.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.off(Events.AUDIO_TRACKS_UPDATED, this.onAudioTracksUpdated, this);
     hls.off(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.off(Events.AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
+    hls.off(Events.ERROR, this.onError, this);
     hls.off(Events.BUFFER_RESET, this.onBufferReset, this);
     hls.off(Events.BUFFER_CREATED, this.onBufferCreated, this);
     hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
@@ -16755,13 +15865,12 @@ class AudioStreamController extends BaseStreamController {
     } = this;
     const config = hls.config;
 
-    // 1. if buffering is suspended
-    // 2. if video not attached AND
+    // 1. if video not attached AND
     //    start fragment already requested OR start frag prefetch not enabled
-    // 3. if tracks or track not loaded and selected
+    // 2. if tracks or track not loaded and selected
     // then exit loop
     // => if media not attached but start frag prefetch is enabled and start frag not requested yet, we will not exit loop
-    if (!this.buffering || !media && (this.startFragRequested || !config.startFragPrefetch) || !(levels != null && levels[trackId])) {
+    if (!media && (this.startFragRequested || !config.startFragPrefetch) || !(levels != null && levels[trackId])) {
       return;
     }
     const levelInfo = levels[trackId];
@@ -17319,7 +16428,7 @@ class AudioStreamController extends BaseStreamController {
 
 class AudioTrackController extends BasePlaylistController {
   constructor(hls) {
-    super(hls, 'audio-track-controller');
+    super(hls, '[audio-track-controller]');
     this.tracks = [];
     this.groupIds = null;
     this.tracksInGroup = [];
@@ -17638,23 +16747,26 @@ const TICK_INTERVAL$1 = 500; // how often to tick in ms
 
 class SubtitleStreamController extends BaseStreamController {
   constructor(hls, fragmentTracker, keyLoader) {
-    super(hls, fragmentTracker, keyLoader, 'subtitle-stream-controller', PlaylistLevelType.SUBTITLE);
+    super(hls, fragmentTracker, keyLoader, '[subtitle-stream-controller]', PlaylistLevelType.SUBTITLE);
     this.currentTrackId = -1;
     this.tracksBuffered = [];
     this.mainDetails = null;
-    this.registerListeners();
+    this._registerListeners();
   }
   onHandlerDestroying() {
-    this.unregisterListeners();
+    this._unregisterListeners();
     super.onHandlerDestroying();
     this.mainDetails = null;
   }
-  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.LEVEL_LOADED, this.onLevelLoaded, this);
+    hls.on(Events.ERROR, this.onError, this);
     hls.on(Events.SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
     hls.on(Events.SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
     hls.on(Events.SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
@@ -17662,12 +16774,15 @@ class SubtitleStreamController extends BaseStreamController {
     hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, 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.LEVEL_LOADED, this.onLevelLoaded, this);
+    hls.off(Events.ERROR, this.onError, this);
     hls.off(Events.SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
     hls.off(Events.SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
     hls.off(Events.SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
@@ -17894,10 +17009,10 @@ class SubtitleStreamController extends BaseStreamController {
       return;
     }
     // 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 = performance.now();
       // decrypt the subtitles
-      this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer, getAesModeFromFullSegmentMethod(decryptData.method)).catch(err => {
+      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,
@@ -18031,7 +17146,7 @@ class BufferableInstance {
 
 class SubtitleTrackController extends BasePlaylistController {
   constructor(hls) {
-    super(hls, 'subtitle-track-controller');
+    super(hls, '[subtitle-track-controller]');
     this.media = null;
     this.tracks = [];
     this.groupIds = null;
@@ -18040,10 +17155,10 @@ class SubtitleTrackController extends BasePlaylistController {
     this.currentTrack = null;
     this.selectDefaultTrack = true;
     this.queuedDefaultTrack = -1;
+    this.asyncPollTrackChange = () => this.pollTrackChange(0);
     this.useTextTrackPolling = false;
     this.subtitlePollingInterval = -1;
     this._subtitleDisplay = true;
-    this.asyncPollTrackChange = () => this.pollTrackChange(0);
     this.onTextTracksChanged = () => {
       if (!this.useTextTrackPolling) {
         self.clearInterval(this.subtitlePollingInterval);
@@ -18077,7 +17192,6 @@ class SubtitleTrackController extends BasePlaylistController {
     this.tracks.length = 0;
     this.tracksInGroup.length = 0;
     this.currentTrack = null;
-    // @ts-ignore
     this.onTextTracksChanged = this.asyncPollTrackChange = null;
     super.destroy();
   }
@@ -18538,9 +17652,8 @@ class BufferOperationQueue {
 }
 
 const VIDEO_CODEC_PROFILE_REPLACE = /(avc[1234]|hvc1|hev1|dvh[1e]|vp09|av01)(?:\.[^.,]+)+/;
-class BufferController extends Logger {
+class BufferController {
   constructor(hls) {
-    super('buffer-controller', hls.logger);
     // 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
@@ -18570,6 +17683,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;
@@ -18615,11 +17731,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;
+    const logPrefix = '[buffer-controller]';
     this.appendSource = hls.config.preferManagedMediaSource;
+    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();
   }
@@ -18632,12 +17752,6 @@ class BufferController extends Logger {
     this.lastMpegAudioChunk = null;
     // @ts-ignore
     this.hls = null;
-    // @ts-ignore
-    this._onMediaSourceOpen = this._onMediaSourceClose = null;
-    // @ts-ignore
-    this._onMediaSourceEnded = null;
-    // @ts-ignore
-    this._onStartStreaming = this._onEndStreaming = null;
   }
   registerListeners() {
     const {
@@ -18800,7 +17914,6 @@ class BufferController extends Logger {
       this.resetBuffer(type);
     });
     this._initSourceBuffer();
-    this.hls.resumeBuffering();
   }
   resetBuffer(type) {
     const sb = this.sourceBuffer[type];
@@ -21903,12 +21016,14 @@ class TimelineController {
     this.cea608Parser1 = this.cea608Parser2 = undefined;
   }
   initCea608Parsers() {
-    const channel1 = new OutputFilter(this, 'textTrack1');
-    const channel2 = new OutputFilter(this, 'textTrack2');
-    const channel3 = new OutputFilter(this, 'textTrack3');
-    const channel4 = new OutputFilter(this, 'textTrack4');
-    this.cea608Parser1 = new Cea608Parser(1, channel1, channel2);
-    this.cea608Parser2 = new Cea608Parser(3, channel3, channel4);
+    if (this.config.enableCEA708Captions && (!this.cea608Parser1 || !this.cea608Parser2)) {
+      const channel1 = new OutputFilter(this, 'textTrack1');
+      const channel2 = new OutputFilter(this, 'textTrack2');
+      const channel3 = new OutputFilter(this, 'textTrack3');
+      const channel4 = new OutputFilter(this, 'textTrack4');
+      this.cea608Parser1 = new Cea608Parser(1, channel1, channel2);
+      this.cea608Parser2 = new Cea608Parser(3, channel3, channel4);
+    }
   }
   addCues(trackName, startTime, endTime, screen, cueRanges) {
     // skip cues which overlap more than 50% with previously parsed time ranges
@@ -22146,7 +21261,7 @@ class TimelineController {
         if (inUseTracks != null && inUseTracks.length) {
           const unusedTextTracks = inUseTracks.filter(t => t !== null).map(t => t.label);
           if (unusedTextTracks.length) {
-            this.hls.logger.warn(`Media element contains unused subtitle tracks: ${unusedTextTracks.join(', ')}. Replace media element for each source to clear TextTracks and captions menu.`);
+            logger.warn(`Media element contains unused subtitle tracks: ${unusedTextTracks.join(', ')}. Replace media element for each source to clear TextTracks and captions menu.`);
           }
         }
       } else if (this.tracks.length) {
@@ -22191,23 +21306,26 @@ class TimelineController {
     return level == null ? void 0 : level.attrs['CLOSED-CAPTIONS'];
   }
   onFragLoading(event, data) {
+    this.initCea608Parsers();
+    const {
+      cea608Parser1,
+      cea608Parser2,
+      lastCc,
+      lastSn,
+      lastPartIndex
+    } = this;
+    if (!this.enabled || !cea608Parser1 || !cea608Parser2) {
+      return;
+    }
     // if this frag isn't contiguous, clear the parser so cues with bad start/end times aren't added to the textTrack
-    if (this.enabled && data.frag.type === PlaylistLevelType.MAIN) {
+    if (data.frag.type === PlaylistLevelType.MAIN) {
       var _data$part$index, _data$part;
-      const {
-        cea608Parser1,
-        cea608Parser2,
-        lastSn
-      } = this;
-      if (!cea608Parser1 || !cea608Parser2) {
-        return;
-      }
       const {
         cc,
         sn
       } = data.frag;
-      const partIndex = (_data$part$index = (_data$part = data.part) == null ? void 0 : _data$part.index) != null ? _data$part$index : -1;
-      if (!(sn === lastSn + 1 || sn === lastSn && partIndex === this.lastPartIndex + 1 || cc === this.lastCc)) {
+      const partIndex = (_data$part$index = data == null ? void 0 : (_data$part = data.part) == null ? void 0 : _data$part.index) != null ? _data$part$index : -1;
+      if (!(sn === lastSn + 1 || sn === lastSn && partIndex === lastPartIndex + 1 || cc === lastCc)) {
         cea608Parser1.reset();
         cea608Parser2.reset();
       }
@@ -22264,7 +21382,7 @@ class TimelineController {
         frag: frag
       });
     }, error => {
-      hls.logger.log(`Failed to parse IMSC1: ${error}`);
+      logger.log(`Failed to parse IMSC1: ${error}`);
       hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
         success: false,
         frag: frag,
@@ -22305,7 +21423,7 @@ class TimelineController {
         this._fallbackToIMSC1(frag, payload);
       }
       // Something went wrong while parsing. Trigger event with success false.
-      hls.logger.log(`Failed to parse VTT cue: ${error}`);
+      logger.log(`Failed to parse VTT cue: ${error}`);
       if (missingInitPTS && maxAvCC > frag.cc) {
         return;
       }
@@ -22366,7 +21484,12 @@ class TimelineController {
     this.captionsTracks = {};
   }
   onFragParsingUserdata(event, data) {
-    if (!this.enabled || !this.config.enableCEA708Captions) {
+    this.initCea608Parsers();
+    const {
+      cea608Parser1,
+      cea608Parser2
+    } = this;
+    if (!this.enabled || !cea608Parser1 || !cea608Parser2) {
       return;
     }
     const {
@@ -22381,12 +21504,9 @@ class TimelineController {
     for (let i = 0; i < samples.length; i++) {
       const ccBytes = samples[i].bytes;
       if (ccBytes) {
-        if (!this.cea608Parser1) {
-          this.initCea608Parsers();
-        }
         const ccdatas = this.extractCea608Data(ccBytes);
-        this.cea608Parser1.addData(samples[i].pts, ccdatas[0]);
-        this.cea608Parser2.addData(samples[i].pts, ccdatas[1]);
+        cea608Parser1.addData(samples[i].pts, ccdatas[0]);
+        cea608Parser2.addData(samples[i].pts, ccdatas[1]);
       }
     }
   }
@@ -22582,7 +21702,7 @@ 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.autoLevelCapping > this.autoLevelCapping && this.streamController) {
@@ -22760,10 +21880,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, {
@@ -22795,119 +21915,31 @@ class FPSController {
   }
 }
 
+const LOGGER_PREFIX = '[eme]';
 /**
  * Controller to deal with encrypted media extensions (EME)
- * @see https://developer.mozilla.org/en-US/docs/Web/API/Encrypted_Media_Extensions_API
- *
- * @class
- * @constructor
- */
-class EMEController extends Logger {
-  constructor(hls) {
-    super('eme', hls.logger);
-    this.hls = void 0;
-    this.config = void 0;
-    this.media = null;
-    this.keyFormatPromise = null;
-    this.keySystemAccessPromises = {};
-    this._requestLicenseFailureCount = 0;
-    this.mediaKeySessions = [];
-    this.keyIdToKeySessionPromise = {};
-    this.setMediaKeysQueue = EMEController.CDMCleanupPromise ? [EMEController.CDMCleanupPromise] : [];
-    this.onMediaEncrypted = event => {
-      const {
-        initDataType,
-        initData
-      } = event;
-      this.debug(`"${event.type}" event: init data type: "${initDataType}"`);
-
-      // Ignore event when initData is null
-      if (initData === null) {
-        return;
-      }
-      let keyId;
-      let keySystemDomain;
-      if (initDataType === 'sinf' && this.config.drmSystems[KeySystems.FAIRPLAY]) {
-        // Match sinf keyId to playlist skd://keyId=
-        const json = bin2str(new Uint8Array(initData));
-        try {
-          const sinf = base64Decode(JSON.parse(json).sinf);
-          const tenc = parseSinf(new Uint8Array(sinf));
-          if (!tenc) {
-            return;
-          }
-          keyId = tenc.subarray(8, 24);
-          keySystemDomain = KeySystems.FAIRPLAY;
-        } catch (error) {
-          this.warn('Failed to parse sinf "encrypted" event message initData');
-          return;
-        }
-      } else {
-        // Support clear-lead key-session creation (otherwise depend on playlist keys)
-        const psshInfo = parsePssh(initData);
-        if (psshInfo === null) {
-          return;
-        }
-        if (psshInfo.version === 0 && psshInfo.systemId === KeySystemIds.WIDEVINE && psshInfo.data) {
-          keyId = psshInfo.data.subarray(8, 24);
-        }
-        keySystemDomain = keySystemIdToKeySystemDomain(psshInfo.systemId);
-      }
-      if (!keySystemDomain || !keyId) {
-        return;
-      }
-      const keyIdHex = Hex.hexDump(keyId);
-      const {
-        keyIdToKeySessionPromise,
-        mediaKeySessions
-      } = this;
-      let keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex];
-      for (let i = 0; i < mediaKeySessions.length; i++) {
-        // Match playlist key
-        const keyContext = mediaKeySessions[i];
-        const decryptdata = keyContext.decryptdata;
-        if (decryptdata.pssh || !decryptdata.keyId) {
-          continue;
-        }
-        const oldKeyIdHex = Hex.hexDump(decryptdata.keyId);
-        if (keyIdHex === oldKeyIdHex || decryptdata.uri.replace(/-/g, '').indexOf(keyIdHex) !== -1) {
-          keySessionContextPromise = keyIdToKeySessionPromise[oldKeyIdHex];
-          delete keyIdToKeySessionPromise[oldKeyIdHex];
-          decryptdata.pssh = new Uint8Array(initData);
-          decryptdata.keyId = keyId;
-          keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] = keySessionContextPromise.then(() => {
-            return this.generateRequestWithPreferredKeySession(keyContext, initDataType, initData, 'encrypted-event-key-match');
-          });
-          break;
-        }
-      }
-      if (!keySessionContextPromise) {
-        // Clear-lead key (not encountered in playlist)
-        keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] = this.getKeySystemSelectionPromise([keySystemDomain]).then(({
-          keySystem,
-          mediaKeys
-        }) => {
-          var _keySystemToKeySystem;
-          this.throwIfDestroyed();
-          const decryptdata = new LevelKey('ISO-23001-7', keyIdHex, (_keySystemToKeySystem = keySystemDomainToKeySystemFormat(keySystem)) != null ? _keySystemToKeySystem : '');
-          decryptdata.pssh = new Uint8Array(initData);
-          decryptdata.keyId = keyId;
-          return this.attemptSetMediaKeys(keySystem, mediaKeys).then(() => {
-            this.throwIfDestroyed();
-            const keySessionContext = this.createMediaKeySessionContext({
-              decryptdata,
-              keySystem,
-              mediaKeys
-            });
-            return this.generateRequestWithPreferredKeySession(keySessionContext, initDataType, initData, 'encrypted-event-no-match');
-          });
-        });
-      }
-      keySessionContextPromise.catch(error => this.handleError(error));
-    };
-    this.onWaitingForKey = event => {
-      this.log(`"${event.type}" event`);
-    };
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Encrypted_Media_Extensions_API
+ *
+ * @class
+ * @constructor
+ */
+class EMEController {
+  constructor(hls) {
+    this.hls = void 0;
+    this.config = void 0;
+    this.media = null;
+    this.keyFormatPromise = null;
+    this.keySystemAccessPromises = {};
+    this._requestLicenseFailureCount = 0;
+    this.mediaKeySessions = [];
+    this.keyIdToKeySessionPromise = {};
+    this.setMediaKeysQueue = EMEController.CDMCleanupPromise ? [EMEController.CDMCleanupPromise] : [];
+    this.onMediaEncrypted = this._onMediaEncrypted.bind(this);
+    this.onWaitingForKey = this._onWaitingForKey.bind(this);
+    this.debug = logger.debug.bind(logger, LOGGER_PREFIX);
+    this.log = logger.log.bind(logger, LOGGER_PREFIX);
+    this.warn = logger.warn.bind(logger, LOGGER_PREFIX);
+    this.error = logger.error.bind(logger, LOGGER_PREFIX);
     this.hls = hls;
     this.config = hls.config;
     this.registerListeners();
@@ -22921,9 +21953,9 @@ class EMEController extends Logger {
     config.licenseXhrSetup = config.licenseResponseCallback = undefined;
     config.drmSystems = config.drmSystemOptions = {};
     // @ts-ignore
-    this.hls = this.config = this.keyIdToKeySessionPromise = null;
+    this.hls = this.onMediaEncrypted = this.onWaitingForKey = this.keyIdToKeySessionPromise = null;
     // @ts-ignore
-    this.onMediaEncrypted = this.onWaitingForKey = null;
+    this.config = null;
   }
   registerListeners() {
     this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
@@ -23187,6 +22219,100 @@ class EMEController extends Logger {
     }
     return this.attemptKeySystemAccess(keySystemsToAttempt);
   }
+  _onMediaEncrypted(event) {
+    const {
+      initDataType,
+      initData
+    } = event;
+    this.debug(`"${event.type}" event: init data type: "${initDataType}"`);
+
+    // Ignore event when initData is null
+    if (initData === null) {
+      return;
+    }
+    let keyId;
+    let keySystemDomain;
+    if (initDataType === 'sinf' && this.config.drmSystems[KeySystems.FAIRPLAY]) {
+      // Match sinf keyId to playlist skd://keyId=
+      const json = bin2str(new Uint8Array(initData));
+      try {
+        const sinf = base64Decode(JSON.parse(json).sinf);
+        const tenc = parseSinf(new Uint8Array(sinf));
+        if (!tenc) {
+          return;
+        }
+        keyId = tenc.subarray(8, 24);
+        keySystemDomain = KeySystems.FAIRPLAY;
+      } catch (error) {
+        this.warn('Failed to parse sinf "encrypted" event message initData');
+        return;
+      }
+    } else {
+      // Support clear-lead key-session creation (otherwise depend on playlist keys)
+      const psshInfo = parsePssh(initData);
+      if (psshInfo === null) {
+        return;
+      }
+      if (psshInfo.version === 0 && psshInfo.systemId === KeySystemIds.WIDEVINE && psshInfo.data) {
+        keyId = psshInfo.data.subarray(8, 24);
+      }
+      keySystemDomain = keySystemIdToKeySystemDomain(psshInfo.systemId);
+    }
+    if (!keySystemDomain || !keyId) {
+      return;
+    }
+    const keyIdHex = Hex.hexDump(keyId);
+    const {
+      keyIdToKeySessionPromise,
+      mediaKeySessions
+    } = this;
+    let keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex];
+    for (let i = 0; i < mediaKeySessions.length; i++) {
+      // Match playlist key
+      const keyContext = mediaKeySessions[i];
+      const decryptdata = keyContext.decryptdata;
+      if (decryptdata.pssh || !decryptdata.keyId) {
+        continue;
+      }
+      const oldKeyIdHex = Hex.hexDump(decryptdata.keyId);
+      if (keyIdHex === oldKeyIdHex || decryptdata.uri.replace(/-/g, '').indexOf(keyIdHex) !== -1) {
+        keySessionContextPromise = keyIdToKeySessionPromise[oldKeyIdHex];
+        delete keyIdToKeySessionPromise[oldKeyIdHex];
+        decryptdata.pssh = new Uint8Array(initData);
+        decryptdata.keyId = keyId;
+        keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] = keySessionContextPromise.then(() => {
+          return this.generateRequestWithPreferredKeySession(keyContext, initDataType, initData, 'encrypted-event-key-match');
+        });
+        break;
+      }
+    }
+    if (!keySessionContextPromise) {
+      // Clear-lead key (not encountered in playlist)
+      keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] = this.getKeySystemSelectionPromise([keySystemDomain]).then(({
+        keySystem,
+        mediaKeys
+      }) => {
+        var _keySystemToKeySystem;
+        this.throwIfDestroyed();
+        const decryptdata = new LevelKey('ISO-23001-7', keyIdHex, (_keySystemToKeySystem = keySystemDomainToKeySystemFormat(keySystem)) != null ? _keySystemToKeySystem : '');
+        decryptdata.pssh = new Uint8Array(initData);
+        decryptdata.keyId = keyId;
+        return this.attemptSetMediaKeys(keySystem, mediaKeys).then(() => {
+          this.throwIfDestroyed();
+          const keySessionContext = this.createMediaKeySessionContext({
+            decryptdata,
+            keySystem,
+            mediaKeys
+          });
+          return this.generateRequestWithPreferredKeySession(keySessionContext, initDataType, initData, 'encrypted-event-no-match');
+        });
+      });
+    }
+    keySessionContextPromise.catch(error => this.handleError(error));
+  }
+  _onWaitingForKey(event) {
+    this.log(`"${event.type}" event`);
+  }
   attemptSetMediaKeys(keySystem, mediaKeys) {
     const queue = this.setMediaKeysQueue.slice();
     this.log(`Setting media-keys for "${keySystem}"`);
@@ -23779,6 +22905,20 @@ class SfItem {
   }
 }
 
+/**
+ * A class to represent structured field tokens when `Symbol` is not available.
+ *
+ * @group Structured Field
+ *
+ * @beta
+ */
+class SfToken {
+  constructor(description) {
+    this.description = void 0;
+    this.description = description;
+  }
+}
+
 const DICT = 'Dict';
 
 function format(value) {
@@ -23802,27 +22942,29 @@ function throwError(action, src, type, cause) {
   });
 }
 
-function serializeError(src, type, cause) {
-  return throwError('serialize', src, type, cause);
-}
+const BARE_ITEM = 'Bare Item';
 
-/**
- * A class to represent structured field tokens when `Symbol` is not available.
- *
- * @group Structured Field
- *
- * @beta
- */
-class SfToken {
-  constructor(description) {
-    this.description = void 0;
-    this.description = description;
-  }
+const BOOLEAN = 'Boolean';
+
+const BYTES = 'Byte Sequence';
+
+const DECIMAL = 'Decimal';
+
+const INTEGER = 'Integer';
+
+function isInvalidInt(value) {
+  return value < -999999999999999 || 999999999999999 < value;
 }
 
-const BARE_ITEM = 'Bare Item';
+const STRING_REGEX = /[\x00-\x1f\x7f]+/; // eslint-disable-line no-control-regex
 
-const BOOLEAN = 'Boolean';
+const TOKEN = 'Token';
+
+const KEY = 'Key';
+
+function serializeError(src, type, cause) {
+  return throwError('serialize', src, type, cause);
+}
 
 // 4.1.9.  Serializing a Boolean
 //
@@ -23861,8 +23003,6 @@ function base64encode(binary) {
   return btoa(String.fromCharCode(...binary));
 }
 
-const BYTES = 'Byte Sequence';
-
 // 4.1.8.  Serializing a Byte Sequence
 //
 // Given a Byte Sequence as input_bytes, return an ASCII string suitable
@@ -23894,12 +23034,6 @@ function serializeByteSequence(value) {
   return `:${base64encode(value)}:`;
 }
 
-const INTEGER = 'Integer';
-
-function isInvalidInt(value) {
-  return value < -999999999999999 || 999999999999999 < value;
-}
-
 // 4.1.4.  Serializing an Integer
 //
 // Given an Integer as input_integer, return an ASCII string suitable
@@ -23965,8 +23099,6 @@ function roundToEven(value, precision) {
   }
 }
 
-const DECIMAL = 'Decimal';
-
 // 4.1.5.  Serializing a Decimal
 //
 // Given a decimal number as input_decimal, return an ASCII string
@@ -24012,8 +23144,6 @@ function serializeDecimal(value) {
 
 const STRING = 'String';
 
-const STRING_REGEX = /[\x00-\x1f\x7f]+/; // eslint-disable-line no-control-regex
-
 // 4.1.6.  Serializing a String
 //
 // Given a String as input_string, return an ASCII string suitable for
@@ -24049,8 +23179,6 @@ function symbolToStr(symbol) {
   return symbol.description || symbol.toString().slice(7, -1);
 }
 
-const TOKEN = 'Token';
-
 function serializeToken(token) {
   const value = symbolToStr(token);
   if (/^([a-zA-Z*])([!#$%&'*+\-.^_`|~\w:/]*)$/.test(value) === false) {
@@ -24118,8 +23246,6 @@ function serializeBareItem(value) {
   }
 }
 
-const KEY = 'Key';
-
 // 4.1.1.3.  Serializing a Key
 //
 // Given a key as input_key, return an ASCII string suitable for use in
@@ -24361,6 +23487,36 @@ function urlToRelativePath(url, base) {
   return toPath.join('/');
 }
 
+/**
+ * Generate a random v4 UUID
+ *
+ * @returns A random v4 UUID
+ *
+ * @group Utils
+ *
+ * @beta
+ */
+function uuid() {
+  try {
+    return crypto.randomUUID();
+  } catch (error) {
+    try {
+      const url = URL.createObjectURL(new Blob());
+      const uuid = url.toString();
+      URL.revokeObjectURL(url);
+      return uuid.slice(uuid.lastIndexOf('/') + 1);
+    } catch (error) {
+      let dt = new Date().getTime();
+      const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = (dt + Math.random() * 16) % 16 | 0;
+        dt = Math.floor(dt / 16);
+        return (c == 'x' ? r : r & 0x3 | 0x8).toString(16);
+      });
+      return uuid;
+    }
+  }
+}
+
 const toRounded = value => Math.round(value);
 const toUrlSafe = (value, options) => {
   if (options != null && options.baseUrl) {
@@ -24586,36 +23742,6 @@ function appendCmcdQuery(url, cmcd, options) {
   return `${url}${separator}${query}`;
 }
 
-/**
- * Generate a random v4 UUID
- *
- * @returns A random v4 UUID
- *
- * @group Utils
- *
- * @beta
- */
-function uuid() {
-  try {
-    return crypto.randomUUID();
-  } catch (error) {
-    try {
-      const url = URL.createObjectURL(new Blob());
-      const uuid = url.toString();
-      URL.revokeObjectURL(url);
-      return uuid.slice(uuid.lastIndexOf('/') + 1);
-    } catch (error) {
-      let dt = new Date().getTime();
-      const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
-        const r = (dt + Math.random() * 16) % 16 | 0;
-        dt = Math.floor(dt / 16);
-        return (c == 'x' ? r : r & 0x3 | 0x8).toString(16);
-      });
-      return uuid;
-    }
-  }
-}
-
 /**
  * Controller to deal with Common Media Client Data (CMCD)
  * @see https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf
@@ -24659,7 +23785,7 @@ class CMCDController {
           su: !this.initialized
         });
       } catch (error) {
-        this.hls.logger.warn('Could not generate manifest CMCD data.', error);
+        logger.warn('Could not generate manifest CMCD data.', error);
       }
     };
     /**
@@ -24679,15 +23805,9 @@ class CMCDController {
           data.tb = this.getTopBandwidth(ot) / 1000;
           data.bl = this.getBufferLength(ot);
         }
-        const next = this.getNextFrag(fragment);
-        if (next) {
-          if (next.url && next.url !== fragment.url) {
-            data.nor = next.url;
-          }
-        }
         this.apply(context, data);
       } catch (error) {
-        this.hls.logger.warn('Could not generate segment CMCD data.', error);
+        logger.warn('Could not generate segment CMCD data.', error);
       }
     };
     this.hls = hls;
@@ -24777,7 +23897,7 @@ class CMCDController {
       data.su = this.buffering;
     }
 
-    // TODO: Implement rtp, nrr, dl
+    // TODO: Implement rtp, nrr, nor, dl
 
     const {
       includeKeys
@@ -24788,28 +23908,15 @@ class CMCDController {
         return acc;
       }, {});
     }
-    const options = {
-      baseUrl: context.url
-    };
     if (this.useHeaders) {
       if (!context.headers) {
         context.headers = {};
       }
-      appendCmcdHeaders(context.headers, data, options);
+      appendCmcdHeaders(context.headers, data);
     } else {
-      context.url = appendCmcdQuery(context.url, data, options);
-    }
-  }
-  getNextFrag(fragment) {
-    var _this$hls$levels$frag;
-    const levelDetails = (_this$hls$levels$frag = this.hls.levels[fragment.level]) == null ? void 0 : _this$hls$levels$frag.details;
-    if (levelDetails) {
-      const index = fragment.sn - levelDetails.startSN;
-      return levelDetails.fragments[index + 1];
+      context.url = appendCmcdQuery(context.url, data);
     }
-    return undefined;
   }
-
   /**
    * The CMCD object type.
    */
@@ -24938,10 +24045,10 @@ class CMCDController {
 }
 
 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 = '.';
@@ -24956,6 +24063,7 @@ class ContentSteeringController extends Logger {
     this.subtitleTracks = null;
     this.penalizedPathways = {};
     this.hls = hls;
+    this.log = logger.log.bind(logger, `[content-steering]:`);
     this.registerListeners();
   }
   registerListeners() {
@@ -25079,7 +24187,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)}`);
       }
     }
   }
@@ -25250,7 +24358,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;
         }
@@ -26220,7 +25328,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");
   }
@@ -26290,7 +25398,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
@@ -26307,9 +25415,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;
@@ -26380,15 +25489,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);
@@ -26730,12 +25847,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;
@@ -26979,8 +26091,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}"`)));
@@ -27118,9 +26228,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;
@@ -27130,7 +26239,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;
@@ -27148,7 +26256,7 @@ class GapController extends Logger {
    *
    * @param lastCurrentTime - Previously read playhead position
    */
-  poll(lastCurrentTime, activeFrag, levelDetails, state) {
+  poll(lastCurrentTime, activeFrag) {
     const {
       config,
       media,
@@ -27167,7 +26275,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;
@@ -27176,7 +26283,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;
@@ -27212,6 +26319,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) {
@@ -27223,8 +26331,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) {
@@ -27242,17 +26351,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) {
@@ -27296,7 +26394,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
@@ -27320,7 +26418,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,
@@ -27388,7 +26486,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;
@@ -27429,7 +26527,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,
@@ -27439,7 +26537,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,
@@ -27454,7 +26552,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;
@@ -27462,43 +26560,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);
@@ -27506,14 +26588,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);
@@ -27522,9 +26607,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) {
@@ -27641,7 +26724,7 @@ class StreamController extends BaseStreamController {
       return;
     }
     const level = hls.nextLoadLevel;
-    if (!this.buffering || !(levels != null && levels[level])) {
+    if (!(levels != null && levels[level])) {
       return;
     }
     const levelInfo = levels[level];
@@ -27849,17 +26932,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;
@@ -27869,6 +26955,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');
@@ -28160,10 +27267,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;
   }
@@ -28601,7 +27706,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.6-0.canary.10011";
+    return "1.5.6";
   }
 
   /**
@@ -28664,12 +27769,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;
@@ -28686,11 +27788,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
@@ -28789,7 +27891,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;
@@ -28815,7 +27917,7 @@ class Hls {
    * Dispose of the instance
    */
   destroy() {
-    this.logger.log('destroy');
+    logger.log('destroy');
     this.trigger(Events.DESTROYING, undefined);
     this.detachMedia();
     this.removeAllListeners();
@@ -28836,7 +27938,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
@@ -28847,7 +27949,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;
   }
@@ -28864,7 +27966,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);
@@ -28883,7 +27985,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);
     });
@@ -28893,31 +27996,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();
       }
     });
   }
@@ -28926,7 +28032,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();
   }
 
@@ -28937,7 +28043,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) {
@@ -28967,7 +28073,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();
   }
@@ -28986,7 +28092,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();
   }
@@ -29005,7 +28111,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;
   }
 
@@ -29036,7 +28142,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;
   }
 
@@ -29061,7 +28167,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);
@@ -29136,7 +28242,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();
     }