hls.js 1.5.5 → 1.5.6-0.canary.10003

package/dist/hls.mjs

@@ -256,6 +256,7 @@ 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";
@@ -369,58 +370,6 @@ 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.5"}`);
-    } catch (e) {
-      exportedLogger = fakeLogger;
-    }
-  } else {
-    exportedLogger = fakeLogger;
-  }
-}
-const logger = exportedLogger;
-
 const DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/;
 const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
 
@@ -502,6 +451,79 @@ 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.10003"}`);
+    } 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) {
@@ -1036,6 +1058,26 @@ 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;
 
@@ -2686,12 +2728,12 @@ class LevelKey {
     this.keyFormatVersions = formatversions;
     this.iv = iv;
     this.encrypted = method ? method !== 'NONE' : false;
-    this.isCommonEncryption = this.encrypted && method !== 'AES-128';
+    this.isCommonEncryption = this.encrypted && !isFullSegmentEncryption(method);
   }
   isSupported() {
     // If it's Segment encryption or No encryption, just select that key system
     if (this.method) {
-      if (this.method === 'AES-128' || this.method === 'NONE') {
+      if (isFullSegmentEncryption(this.method) || this.method === 'NONE') {
         return true;
       }
       if (this.keyFormat === 'identity') {
@@ -2713,14 +2755,13 @@ class LevelKey {
     if (!this.encrypted || !this.uri) {
       return null;
     }
-    if (this.method === 'AES-128' && this.uri && !this.iv) {
+    if (isFullSegmentEncryption(this.method) && 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
+        // If the segment was encrypted with AES-128/256
         // It must have an IV defined. We cannot substitute the Segment Number in.
-        if (this.method === 'AES-128' && !this.iv) {
-          logger.warn(`missing IV for initialization segment with method="${this.method}" - compliance issue`);
-        }
+        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;
       }
@@ -2999,23 +3040,28 @@ 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']
+    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']
   }[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/i;
+const AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
 function getCodecCompatibleName(codec, preferManagedMediaSource = true) {
   return codec.replace(AUDIO_CODEC_REGEXP, m => getCodecCompatibleNameLower(m.toLowerCase(), preferManagedMediaSource));
 }
@@ -3038,6 +3084,16 @@ 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;
@@ -3887,10 +3943,10 @@ class PlaylistLoader {
       const loaderContext = loader.context;
       if (loaderContext && loaderContext.url === context.url && loaderContext.level === context.level) {
         // same URL can't overlap
-        logger.trace('[playlist-loader]: playlist request ongoing');
+        this.hls.logger.trace('[playlist-loader]: playlist request ongoing');
         return;
       }
-      logger.log(`[playlist-loader]: aborting previous loader for type: ${context.type}`);
+      this.hls.logger.log(`[playlist-loader]: aborting previous loader for type: ${context.type}`);
       loader.abort();
     }
 
@@ -4000,7 +4056,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) {
-        logger.log('[playlist-loader]: audio codec signaled in quality level, but no embedded audio track signaled, create one');
+        this.hls.logger.log('[playlist-loader]: audio codec signaled in quality level, but no embedded audio track signaled, create one');
         audioTracks.unshift({
           type: 'main',
           name: 'main',
@@ -4099,7 +4155,7 @@ class PlaylistLoader {
       message += ` id: ${context.id} group-id: "${context.groupId}"`;
     }
     const error = new Error(message);
-    logger.warn(`[playlist-loader]: ${message}`);
+    this.hls.logger.warn(`[playlist-loader]: ${message}`);
     let details = ErrorDetails.UNKNOWN;
     let fatal = false;
     const loader = this.getInternalLoader(context);
@@ -4704,7 +4760,47 @@ class LatencyController {
     this.currentTime = 0;
     this.stallCount = 0;
     this._latency = null;
-    this.timeupdateHandler = () => this.timeupdate();
+    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.hls = hls;
     this.config = hls.config;
     this.registerListeners();
@@ -4796,7 +4892,7 @@ class LatencyController {
     this.onMediaDetaching();
     this.levelDetails = null;
     // @ts-ignore
-    this.hls = this.timeupdateHandler = null;
+    this.hls = null;
   }
   registerListeners() {
     this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
@@ -4814,11 +4910,11 @@ class LatencyController {
   }
   onMediaAttached(event, data) {
     this.media = data.media;
-    this.media.addEventListener('timeupdate', this.timeupdateHandler);
+    this.media.addEventListener('timeupdate', this.onTimeupdate);
   }
   onMediaDetaching() {
     if (this.media) {
-      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
+      this.media.removeEventListener('timeupdate', this.onTimeupdate);
       this.media = null;
     }
   }
@@ -4832,10 +4928,10 @@ class LatencyController {
   }) {
     this.levelDetails = details;
     if (details.advanced) {
-      this.timeupdate();
+      this.onTimeupdate();
     }
     if (!details.live && this.media) {
-      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
+      this.media.removeEventListener('timeupdate', this.onTimeupdate);
     }
   }
   onError(event, data) {
@@ -4845,48 +4941,7 @@ class LatencyController {
     }
     this.stallCount++;
     if ((_this$levelDetails = this.levelDetails) != null && _this$levelDetails.live) {
-      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;
+      this.hls.logger.warn('[latency-controller]: Stall detected, adjusting target latency');
     }
   }
   estimateLiveEdge() {
@@ -5658,18 +5713,13 @@ var ErrorActionFlags = {
   MoveAllAlternatesMatchingHDCP: 2,
   SwitchToSDR: 4
 }; // Reserved for future use
-class ErrorController {
+class ErrorController extends Logger {
   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() {
@@ -6021,16 +6071,13 @@ class ErrorController {
   }
 }
 
-class BasePlaylistController {
+class BasePlaylistController extends Logger {
   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() {
@@ -6063,7 +6110,7 @@ class BasePlaylistController {
         try {
           uri = new self.URL(attr.URI, previous.url).href;
         } catch (error) {
-          logger.warn(`Could not construct new URL for Rendition Report: ${error}`);
+          this.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
@@ -6150,7 +6197,12 @@ class BasePlaylistController {
         const cdnAge = lastAdvanced + details.ageHeader;
         let currentGoal = Math.min(cdnAge - details.partTarget, details.targetduration * 1.5);
         if (currentGoal > 0) {
-          if (previousDetails && currentGoal > previousDetails.tuneInGoal) {
+          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 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}`);
@@ -6822,8 +6874,9 @@ function searchDownAndUpList(arr, searchIndex, predicate) {
   return -1;
 }
 
-class AbrController {
+class AbrController extends Logger {
   constructor(_hls) {
+    super('abr', _hls.logger);
     this.hls = void 0;
     this.lastLevelLoadSec = 0;
     this.lastLoadedFragLevel = -1;
@@ -6937,7 +6990,7 @@ class AbrController {
         this.resetEstimator(nextLoadLevelBitrate);
       }
       this.clearTimer();
-      logger.warn(`[abr] Fragment ${frag.sn}${part ? ' part ' + part.index : ''} of level ${frag.level} is loading too slowly;
+      this.warn(`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
@@ -6957,7 +7010,7 @@ class AbrController {
   }
   resetEstimator(abrEwmaDefaultEstimate) {
     if (abrEwmaDefaultEstimate) {
-      logger.log(`setting initial bwe to ${abrEwmaDefaultEstimate}`);
+      this.log(`setting initial bwe to ${abrEwmaDefaultEstimate}`);
       this.hls.config.abrEwmaDefaultEstimate = abrEwmaDefaultEstimate;
     }
     this.firstSelection = -1;
@@ -7189,7 +7242,7 @@ class AbrController {
     }
     const firstLevel = this.hls.firstLevel;
     const clamped = Math.min(Math.max(firstLevel, minAutoLevel), maxAutoLevel);
-    logger.warn(`[abr] Could not find best starting auto level. Defaulting to first in playlist ${firstLevel} clamped to ${clamped}`);
+    this.warn(`Could not find best starting auto level. Defaulting to first in playlist ${firstLevel} clamped to ${clamped}`);
     return clamped;
   }
   get forcedAutoLevel() {
@@ -7274,13 +7327,13 @@ class AbrController {
         // 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;
-        logger.info(`[abr] bitrate test took ${Math.round(1000 * bitrateTestDelay)}ms, set first fragment max fetchDuration to ${Math.round(1000 * maxStarvationDelay)} ms`);
+        this.info(`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);
-    logger.info(`[abr] ${bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty'}, optimal quality level ${bestLevel}`);
+    this.info(`${bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty'}, optimal quality level ${bestLevel}`);
     if (bestLevel > -1) {
       return bestLevel;
     }
@@ -7342,7 +7395,7 @@ class AbrController {
       currentVideoRange = preferHDR ? videoRanges[videoRanges.length - 1] : videoRanges[0];
       currentFrameRate = minFramerate;
       currentBw = Math.max(currentBw, minBitrate);
-      logger.log(`[abr] picked start tier ${JSON.stringify(startTier)}`);
+      this.log(`picked start tier ${JSON.stringify(startTier)}`);
     } else {
       currentCodecSet = level == null ? void 0 : level.codecSet;
       currentVideoRange = level == null ? void 0 : level.videoRange;
@@ -7366,11 +7419,11 @@ class AbrController {
             const levels = this.hls.levels;
             const index = levels.indexOf(levelInfo);
             if (decodingInfo.error) {
-              logger.warn(`[abr] MediaCapabilities decodingInfo error: "${decodingInfo.error}" for level ${index} ${JSON.stringify(decodingInfo)}`);
+              this.warn(`MediaCapabilities decodingInfo error: "${decodingInfo.error}" for level ${index} ${JSON.stringify(decodingInfo)}`);
             } else if (!decodingInfo.supported) {
-              logger.warn(`[abr] Unsupported MediaCapabilities decodingInfo result for level ${index} ${JSON.stringify(decodingInfo)}`);
+              this.warn(`Unsupported MediaCapabilities decodingInfo result for level ${index} ${JSON.stringify(decodingInfo)}`);
               if (index > -1 && levels.length > 1) {
-                logger.log(`[abr] Removing unsupported level ${index}`);
+                this.log(`Removing unsupported level ${index}`);
                 this.hls.removeLevel(index);
               }
             }
@@ -7417,9 +7470,9 @@ class AbrController {
         const forcedAutoLevel = this.forcedAutoLevel;
         if (i !== loadLevel && (forcedAutoLevel === -1 || forcedAutoLevel !== loadLevel)) {
           if (levelsSkipped.length) {
-            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.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.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}`);
+          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}`);
         }
         if (firstSelection) {
           this.firstSelection = i;
@@ -7473,8 +7526,9 @@ class AbrController {
  * 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 {
-  constructor() {
+class TaskLoop extends Logger {
+  constructor(label, logger) {
+    super(label, logger);
     this._boundTick = void 0;
     this._tickTimer = null;
     this._tickInterval = null;
@@ -8565,8 +8619,8 @@ function createLoaderContext(frag, part = null) {
     var _frag$decryptdata;
     let byteRangeStart = start;
     let byteRangeEnd = end;
-    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,
+    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,
       // 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;
@@ -8599,6 +8653,9 @@ 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);
@@ -8608,33 +8665,61 @@ class LoadError extends Error {
 }
 
 class AESCrypto {
-  constructor(subtle, iv) {
+  constructor(subtle, iv, aesMode) {
     this.subtle = void 0;
     this.aesIV = void 0;
+    this.aesMode = void 0;
     this.subtle = subtle;
     this.aesIV = iv;
+    this.aesMode = aesMode;
   }
   decrypt(data, key) {
-    return this.subtle.decrypt({
-      name: 'AES-CBC',
-      iv: this.aesIV
-    }, key, data);
+    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}`);
+    }
   }
 }
 
 class FastAESKey {
-  constructor(subtle, key) {
+  constructor(subtle, key, aesMode) {
     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: 'AES-CBC'
+      name: subtleAlgoName
     }, 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) {
@@ -8884,7 +8969,8 @@ class Decrypter {
     this.currentIV = null;
     this.currentResult = null;
     this.useSoftware = void 0;
-    this.useSoftware = config.enableSoftwareAES;
+    this.enableSoftwareAES = void 0;
+    this.enableSoftwareAES = config.enableSoftwareAES;
     this.removePKCS7Padding = removePKCS7Padding;
     // built in decryptor expects PKCS7 padding
     if (removePKCS7Padding) {
@@ -8897,9 +8983,7 @@ class Decrypter {
         /* no-op */
       }
     }
-    if (this.subtle === null) {
-      this.useSoftware = true;
-    }
+    this.useSoftware = this.subtle === null;
   }
   destroy() {
     this.subtle = null;
@@ -8937,10 +9021,10 @@ class Decrypter {
       this.softwareDecrypter = null;
     }
   }
-  decrypt(data, key, iv) {
+  decrypt(data, key, iv, aesMode) {
     if (this.useSoftware) {
       return new Promise((resolve, reject) => {
-        this.softwareDecrypt(new Uint8Array(data), key, iv);
+        this.softwareDecrypt(new Uint8Array(data), key, iv, aesMode);
         const decryptResult = this.flush();
         if (decryptResult) {
           resolve(decryptResult.buffer);
@@ -8949,17 +9033,21 @@ class Decrypter {
         }
       });
     }
-    return this.webCryptoDecrypt(new Uint8Array(data), key, iv);
+    return this.webCryptoDecrypt(new Uint8Array(data), key, iv, aesMode);
   }
 
   // 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) {
+  softwareDecrypt(data, key, iv, aesMode) {
     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
@@ -8992,11 +9080,11 @@ class Decrypter {
     }
     return result;
   }
-  webCryptoDecrypt(data, key, iv) {
+  webCryptoDecrypt(data, key, iv, aesMode) {
     const subtle = this.subtle;
     if (this.key !== key || !this.fastAesKey) {
       this.key = key;
-      this.fastAesKey = new FastAESKey(subtle, key);
+      this.fastAesKey = new FastAESKey(subtle, key, aesMode);
     }
     return this.fastAesKey.expandKey().then(aesKey => {
       // decrypt using web crypto
@@ -9004,22 +9092,25 @@ class Decrypter {
         return Promise.reject(new Error('web crypto not initialized'));
       }
       this.logOnce('WebCrypto AES decrypt');
-      const crypto = new AESCrypto(subtle, new Uint8Array(iv));
+      const crypto = new AESCrypto(subtle, new Uint8Array(iv), aesMode);
       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);
+      return this.onWebCryptoError(data, key, iv, aesMode);
     });
   }
-  onWebCryptoError(data, key, iv) {
-    this.useSoftware = true;
-    this.logEnabled = true;
-    this.softwareDecrypt(data, key, iv);
-    const decryptResult = this.flush();
-    if (decryptResult) {
-      return decryptResult.buffer;
+  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;
+      }
     }
-    throw new Error('WebCrypto and softwareDecrypt: failed to decrypt data');
+    throw new Error('WebCrypto' + (enableSoftwareAES ? ' and softwareDecrypt' : '') + ': failed to decrypt data');
   }
   getValidChunk(data) {
     let currentChunk = data;
@@ -9070,7 +9161,7 @@ const State = {
 };
 class BaseStreamController extends TaskLoop {
   constructor(hls, fragmentTracker, keyLoader, logPrefix, playlistType) {
-    super();
+    super(logPrefix, hls.logger);
     this.hls = void 0;
     this.fragPrevious = null;
     this.fragCurrent = null;
@@ -9095,22 +9186,98 @@ class BaseStreamController extends TaskLoop {
     this.startFragRequested = false;
     this.decrypter = void 0;
     this.initPTS = [];
-    this.onvseeking = null;
-    this.onvended = null;
-    this.logPrefix = '';
-    this.log = void 0;
-    this.warn = void 0;
+    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.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();
@@ -9134,6 +9301,12 @@ 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
@@ -9164,10 +9337,8 @@ class BaseStreamController extends TaskLoop {
   }
   onMediaAttached(event, data) {
     const media = this.media = this.mediaBuffer = data.media;
-    this.onvseeking = this.onMediaSeeking.bind(this);
-    this.onvended = this.onMediaEnded.bind(this);
-    media.addEventListener('seeking', this.onvseeking);
-    media.addEventListener('ended', this.onvended);
+    media.addEventListener('seeking', this.onMediaSeeking);
+    media.addEventListener('ended', this.onMediaEnded);
     const config = this.config;
     if (this.levels && config.autoStartLoad && this.state === State.STOPPED) {
       this.startLoad(config.startPosition);
@@ -9181,10 +9352,9 @@ class BaseStreamController extends TaskLoop {
     }
 
     // remove video listeners
-    if (media && this.onvseeking && this.onvended) {
-      media.removeEventListener('seeking', this.onvseeking);
-      media.removeEventListener('ended', this.onvended);
-      this.onvseeking = this.onvended = null;
+    if (media) {
+      media.removeEventListener('seeking', this.onMediaSeeking);
+      media.removeEventListener('ended', this.onMediaEnded);
     }
     if (this.keyLoader) {
       this.keyLoader.detach();
@@ -9194,56 +9364,8 @@ class BaseStreamController extends TaskLoop {
     this.fragmentTracker.removeAllFragments();
     this.stopLoad();
   }
-  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;
-  }
+  onManifestLoading() {}
+  onError(event, data) {}
   onManifestLoaded(event, data) {
     this.startTimeOffset = data.startTimeOffset;
     this.initPTS = [];
@@ -9253,7 +9375,7 @@ class BaseStreamController extends TaskLoop {
     this.stopLoad();
     super.onHandlerDestroying();
     // @ts-ignore
-    this.hls = null;
+    this.hls = this.onMediaSeeking = this.onMediaEnded = null;
   }
   onHandlerDestroyed() {
     this.state = State.STOPPED;
@@ -9384,10 +9506,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 && decryptData.method === 'AES-128') {
+      if (payload && payload.byteLength > 0 && decryptData != null && decryptData.key && decryptData.iv && isFullSegmentEncryption(decryptData.method)) {
         const startTime = self.performance.now();
         // decrypt init segment data
-        return this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer).catch(err => {
+        return this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer, getAesModeFromFullSegmentMethod(decryptData.method)).catch(err => {
           hls.trigger(Events.ERROR, {
             type: ErrorTypes.MEDIA_ERROR,
             details: ErrorDetails.FRAG_DECRYPT_ERROR,
@@ -9499,7 +9621,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.logPrefix === '[stream-controller]' ? 'level' : 'track'} ${frag.level}`);
+      this.log(`Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'} ${frag.level}`);
       this.state = State.KEY_LOADING;
       this.fragCurrent = frag;
       keyLoadingPromise = this.keyLoader.load(frag).then(keyLoadedData => {
@@ -9520,8 +9642,16 @@ 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.config.lowLatencyMode && frag.sn !== 'initSegment') {
+    if (this.loadingParts && frag.sn !== 'initSegment') {
       const partList = details.partList;
       if (partList && progressCallback) {
         if (targetBufferTime > frag.end && details.fragmentHint) {
@@ -9530,7 +9660,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.logPrefix === '[stream-controller]' ? '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.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
           this.nextLoadPosition = part.start + part.duration;
           this.state = State.FRAG_LOADING;
           let _result;
@@ -9559,7 +9689,14 @@ class BaseStreamController extends TaskLoop {
         }
       }
     }
-    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))}`);
+    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))}`);
     // Don't update nextLoadPosition for fragments which are not buffered
     if (isFiniteNumber(frag.sn) && !this.bitrateTest) {
       this.nextLoadPosition = frag.start + frag.duration;
@@ -9657,8 +9794,36 @@ 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,
@@ -9807,7 +9972,8 @@ class BaseStreamController extends TaskLoop {
       config
     } = this;
     const start = fragments[0].start;
-    let frag;
+    const canLoadParts = config.lowLatencyMode && !!levelDetails.partList;
+    let frag = null;
     if (levelDetails.live) {
       const initialLiveManifestSize = config.initialLiveManifestSize;
       if (fragLen < initialLiveManifestSize) {
@@ -9819,6 +9985,10 @@ 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;
       }
@@ -9829,7 +9999,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 = config.lowLatencyMode ? levelDetails.partEnd : levelDetails.fragmentEnd;
+      const end = this.loadingParts ? levelDetails.partEnd : levelDetails.fragmentEnd;
       frag = this.getFragmentAtPosition(pos, end, levelDetails);
     }
     return this.mapToInitFragWhenRequired(frag);
@@ -9951,7 +10121,7 @@ class BaseStreamController extends TaskLoop {
     } = levelDetails;
     const tolerance = config.maxFragLookUpTolerance;
     const partList = levelDetails.partList;
-    const loadingParts = !!(config.lowLatencyMode && partList != null && partList.length && fragmentHint);
+    const loadingParts = !!(this.loadingParts && partList != null && partList.length && fragmentHint);
     if (loadingParts && fragmentHint && !this.bitrateTest) {
       // Include incomplete fragment with parts at end
       fragments = fragments.concat(fragmentHint);
@@ -10144,7 +10314,7 @@ class BaseStreamController extends TaskLoop {
           errorAction.resolved = true;
         }
       } else {
-        logger.warn(`${data.details} reached or exceeded max retry (${retryCount})`);
+        this.warn(`${data.details} reached or exceeded max retry (${retryCount})`);
         return;
       }
     } else if ((errorAction == null ? void 0 : errorAction.action) === NetworkErrorAction.SendAlternateToPenaltyBox) {
@@ -10553,6 +10723,7 @@ const initPTSFn = (timestamp, timeOffset, initPTS) => {
  */
 function getAudioConfig(observer, data, offset, audioCodec) {
   let adtsObjectType;
+  let originalAdtsObjectType;
   let adtsExtensionSamplingIndex;
   let adtsChannelConfig;
   let config;
@@ -10560,7 +10731,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 = ((data[offset + 2] & 0xc0) >>> 6) + 1;
+  adtsObjectType = originalAdtsObjectType = ((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}`);
@@ -10577,8 +10748,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: freq less than 24kHz = AAC SBR (HE-AAC)
-  if (/firefox/i.test(userAgent)) {
+  // Firefox and Pale Moon: freq less than 24kHz = AAC SBR (HE-AAC)
+  if (/firefox|palemoon/i.test(userAgent)) {
     if (adtsSamplingIndex >= 6) {
       adtsObjectType = 5;
       config = new Array(4);
@@ -10672,6 +10843,7 @@ function getAudioConfig(observer, data, offset, audioCodec) {
     samplerate: adtsSamplingRates[adtsSamplingIndex],
     channelCount: adtsChannelConfig,
     codec: 'mp4a.40.' + adtsObjectType,
+    parsedCodec: 'mp4a.40.' + originalAdtsObjectType,
     manifestCodec
   };
 }
@@ -10726,7 +10898,8 @@ function initTrackConfig(track, observer, data, offset, audioCodec) {
     track.channelCount = config.channelCount;
     track.codec = config.codec;
     track.manifestCodec = config.manifestCodec;
-    logger.log(`parsed codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`);
+    track.parsedCodec = config.parsedCodec;
+    logger.log(`parsed codec:${track.parsedCodec}, codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`);
   }
 }
 function getFrameDuration(samplerate) {
@@ -11317,11 +11490,115 @@ class BaseVideoParser {
       logger.log(VideoSample.pts + '/' + VideoSample.dts + ':' + VideoSample.debug);
     }
   }
-}
-
-/**
- * Parser for exponential Golomb codes, a variable-bitwidth number encoding scheme used by h264.
- */
+  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.
+ */
 
 class ExpGolomb {
   constructor(data) {
@@ -11459,21 +11736,171 @@ 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();
+  }
 
   /**
-   * Advance the ExpGolomb decoder past a scaling list. The scaling
-   * list is optionally transmitted as part of a sequence parameter
+   * 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) {
+  skipScalingList(count, reader) {
     let lastScale = 8;
     let nextScale = 8;
     let deltaScale;
     for (let j = 0; j < count; j++) {
       if (nextScale !== 0) {
-        deltaScale = this.readEG();
+        deltaScale = reader.readEG();
         nextScale = (lastScale + deltaScale + 256) % 256;
       }
       lastScale = nextScale === 0 ? lastScale : nextScale;
@@ -11488,7 +11915,8 @@ class ExpGolomb {
    * sequence parameter set, including the dimensions of the
    * associated video frames.
    */
-  readSPS() {
+  readSPS(sps) {
+    const eg = new ExpGolomb(sps);
     let frameCropLeftOffset = 0;
     let frameCropRightOffset = 0;
     let frameCropTopOffset = 0;
@@ -11496,13 +11924,13 @@ class ExpGolomb {
     let numRefFramesInPicOrderCntCycle;
     let scalingListCount;
     let i;
-    const readUByte = this.readUByte.bind(this);
-    const readBits = this.readBits.bind(this);
-    const readUEG = this.readUEG.bind(this);
-    const readBoolean = this.readBoolean.bind(this);
-    const skipBits = this.skipBits.bind(this);
-    const skipEG = this.skipEG.bind(this);
-    const skipUEG = this.skipUEG.bind(this);
+    const readUByte = eg.readUByte.bind(eg);
+    const readBits = eg.readBits.bind(eg);
+    const readUEG = eg.readUEG.bind(eg);
+    const readBoolean = eg.readBoolean.bind(eg);
+    const skipBits = eg.skipBits.bind(eg);
+    const skipEG = eg.skipEG.bind(eg);
+    const skipUEG = eg.skipUEG.bind(eg);
     const skipScalingList = this.skipScalingList.bind(this);
     readUByte();
     const profileIdc = readUByte(); // profile_idc
@@ -11527,9 +11955,9 @@ class ExpGolomb {
           if (readBoolean()) {
             // seq_scaling_list_present_flag[ i ]
             if (i < 6) {
-              skipScalingList(16);
+              skipScalingList(16, eg);
             } else {
-              skipScalingList(64);
+              skipScalingList(64, eg);
             }
           }
         }
@@ -11634,19 +12062,15 @@ class ExpGolomb {
       pixelRatio: pixelRatio
     };
   }
-  readSliceType() {
-    // skip NALu type
-    this.readUByte();
-    // discard first_mb_in_slice
-    this.readUEG();
-    // return slice_type
-    return this.readUEG();
-  }
 }
 
-class AvcVideoParser extends BaseVideoParser {
-  parseAVCPES(track, textTrack, pes, last, duration) {
-    const units = this.parseAVCNALu(track, pes.data);
+class HevcVideoParser extends BaseVideoParser {
+  constructor(...args) {
+    super(...args);
+    this.initVPS = null;
+  }
+  parsePES(track, textTrack, pes, last, duration) {
+    const units = this.parseNALu(track, pes.data);
     let VideoSample = this.VideoSample;
     let push;
     let spsfound = false;
@@ -11662,42 +12086,49 @@ class AvcVideoParser extends BaseVideoParser {
     units.forEach(unit => {
       var _VideoSample2;
       switch (unit.type) {
-        // NDR
+        // NON-IDR, NON RANDOM ACCESS SLICE
+        case 0:
         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 = 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, '');
+        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;
             }
-            VideoSample.frame = true;
-            VideoSample.key = iskey;
-            break;
-            // IDR
           }
-        case 5:
+          if (!VideoSample) {
+            VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
+          }
+          VideoSample.key = true;
+          VideoSample.frame = true;
+          break;
+
+        // IDR
+        case 19:
+        case 20:
           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
@@ -11711,180 +12142,518 @@ class AvcVideoParser extends BaseVideoParser {
           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 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;
-              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:
+        case 39:
           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, '');
+          parseSEIMessageFromNALu(unit.data, 2,
+          // NALu header size
+          pes.pts, textTrack.samples);
           break;
-        // Filler Data
-        case 12:
+
+        // VPS
+        case 32:
           push = true;
-          break;
-        default:
-          push = false;
-          if (VideoSample) {
-            VideoSample.debug += 'unknown NAL ' + unit.type + ' ';
+          if (!track.vps) {
+            const config = this.readVPS(unit.data);
+            track.params = _objectSpread2({}, config);
+            this.initVPS = unit.data;
           }
+          track.vps = [unit.data];
           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;
-    }
-  }
-  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));
 
-    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);
+        // 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);
+              track.width = config.width;
+              track.height = config.height;
+              track.pixelRatio = config.pixelRatio;
+              track.duration = duration;
+              track.codec = config.codecString;
+              track.sps = [];
+              for (const prop in config.params) {
+                track.params[prop] = config.params[prop];
               }
             }
-            // If NAL units are not starting right at the beginning of the PES packet, push preceding data into previous NAL unit.
+            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, '');
+          }
+          VideoSample.key = true;
+          break;
 
-            if (overflow > 0) {
-              // logger.log('first NALU found with overflow:' + overflow);
-              lastUnit.data = appendUint8Array(lastUnit.data, array.subarray(0, overflow));
-              lastUnit.state = 0;
+        // PPS
+        case 34:
+          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);
             }
           }
+          break;
+
+        // ACCESS UNIT DELIMITER
+        case 35:
+          push = true;
+          track.audFound = true;
+          if (VideoSample) {
+            this.pushAccessUnit(VideoSample, track);
+          }
+          VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts, '');
+          break;
+        default:
+          push = false;
+          if (VideoSample) {
+            VideoSample.debug += 'unknown or irrelevant 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] & 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;
         }
-        // check if we can read unit type
-        if (i < len) {
-          unitType = array[i] & 0x1f;
-          // logger.log('find NALU @ offset:' + i + ',type:' + unitType);
-          lastUnitStart = i;
-          lastUnitType = unitType;
-          state = 0;
-        } else {
-          // not enough byte to read unit type. let's read it on next PES parsing
-          state = -1;
-        }
-      } else {
-        state = 0;
       }
+      dst[dstIdx] = arr[i];
+      dstIdx++;
     }
-    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);
+    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
+
+    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();
+              }
+            }
+          }
+        }
+      }
     }
-    // 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);
+    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++;
+          }
+        }
+        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);
+              }
+            }
+          }
+        }
       }
+      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
     }
-    track.naluState = state;
-    return units;
+    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);
   }
 }
 
@@ -11902,7 +12671,7 @@ class SampleAesDecrypter {
     });
   }
   decryptBuffer(encryptedData) {
-    return this.decrypter.decrypt(encryptedData, this.keyData.key.buffer, this.keyData.iv.buffer);
+    return this.decrypter.decrypt(encryptedData, this.keyData.key.buffer, this.keyData.iv.buffer, DecrypterAesMode.cbc);
   }
 
   // AAC - encrypt all full 16 bytes blocks starting from offset 16
@@ -12016,7 +12785,7 @@ class TSDemuxer {
     this.observer = observer;
     this.config = config;
     this.typeSupported = typeSupported;
-    this.videoParser = new AvcVideoParser();
+    this.videoParser = null;
   }
   static probe(data) {
     const syncOffset = TSDemuxer.syncOffset(data);
@@ -12181,7 +12950,21 @@ class TSDemuxer {
           case videoPid:
             if (stt) {
               if (videoData && (pes = parsePES(videoData))) {
-                this.videoParser.parseAVCPES(videoTrack, textTrack, pes, false, this._duration);
+                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);
+                }
               }
               videoData = {
                 data: [],
@@ -12348,8 +13131,22 @@ class TSDemuxer {
     // try to parse last PES packets
     let pes;
     if (videoData && (pes = parsePES(videoData))) {
-      this.videoParser.parseAVCPES(videoTrack, textTrack, pes, true, this._duration);
-      videoTrack.pesData = null;
+      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;
+      }
     } else {
       // either avcData null or PES truncated, keep it for next frag parsing
       videoTrack.pesData = videoData;
@@ -12682,7 +13479,14 @@ function parsePMT(data, offset, typeSupported, isSampleAes) {
         logger.warn('Unsupported EC-3 in M2TS found');
         break;
       case 0x24:
-        logger.warn('Unsupported HEVC in M2TS found');
+        // 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');
+          }
+        }
         break;
     }
     // move to the next table entry
@@ -12905,6 +13709,8 @@ class MP4 {
       avc1: [],
       // codingname
       avcC: [],
+      hvc1: [],
+      hvcC: [],
       btrt: [],
       dinf: [],
       dref: [],
@@ -13329,8 +14135,10 @@ 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 {
+    } 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));
     }
   }
   static tkhd(track) {
@@ -13468,6 +14276,84 @@ 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;
@@ -13849,9 +14735,9 @@ class MP4Remuxer {
       const foundOverlap = delta < -1;
       if (foundHole || foundOverlap) {
         if (foundHole) {
-          logger.warn(`AVC: ${toMsFromMpegTsClock(delta, true)} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(3)}`);
+          logger.warn(`${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(delta, true)} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(3)}`);
         } else {
-          logger.warn(`AVC: ${toMsFromMpegTsClock(-delta, true)} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(3)}`);
+          logger.warn(`${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(-delta, true)} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(3)}`);
         }
         if (!foundOverlap || nextAvcDts >= inputSamples[0].pts || chromeVersion) {
           firstDTS = nextAvcDts;
@@ -13860,12 +14746,24 @@ 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) {
+              if (inputSamples[i].dts > firstPTS && isPTSOrderRetained) {
                 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`);
@@ -14013,7 +14911,7 @@ class MP4Remuxer {
         }
       }
     }
-    // next AVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
+    // next AVC/HEVC 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;
@@ -14146,7 +15044,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.manifestCodec || track.codec, track.channelCount);
+            let fillFrame = AAC.getSilentFrame(track.parsedCodec || 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();
@@ -14274,7 +15172,7 @@ class MP4Remuxer {
     // samples count of this segment's duration
     const nbSamples = Math.ceil((endDTS - startDTS) / frameDuration);
     // silent frame
-    const silentFrame = AAC.getSilentFrame(track.manifestCodec || track.codec, track.channelCount);
+    const silentFrame = AAC.getSilentFrame(track.parsedCodec || 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) {
@@ -14668,13 +15566,15 @@ class Transmuxer {
       initSegmentData
     } = transmuxConfig;
     const keyData = getEncryptionType(uintData, decryptdata);
-    if (keyData && keyData.method === 'AES-128') {
+    if (keyData && isFullSegmentEncryption(keyData.method)) {
       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);
+        let decryptedData = decrypter.softwareDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode);
         // For Low-Latency HLS Parts, decrypt in place, since part parsing is expected on push progress
         const loadingParts = chunkMeta.part > -1;
         if (loadingParts) {
@@ -14686,7 +15586,7 @@ class Transmuxer {
         }
         uintData = new Uint8Array(decryptedData);
       } else {
-        this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer).then(decryptedData => {
+        this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode).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);
@@ -15340,14 +16240,7 @@ class TransmuxerInterface {
     this.observer = new EventEmitter();
     this.observer.on(Events.FRAG_DECRYPTED, forwardMessage);
     this.observer.on(Events.ERROR, forwardMessage);
-    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"') 
-    };
+    const m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
 
     // navigator.vendor is not always available in Web Worker
     // refer to https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/navigator
@@ -15635,7 +16528,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;
@@ -15647,27 +16540,24 @@ 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() {
+  registerListeners() {
+    super.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);
@@ -15675,18 +16565,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;
-    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
+    if (!hls) {
+      return;
+    }
+    super.unregisterListeners();
     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);
@@ -15855,12 +16745,13 @@ class AudioStreamController extends BaseStreamController {
     } = this;
     const config = hls.config;
 
-    // 1. if video not attached AND
+    // 1. if buffering is suspended
+    // 2. if video not attached AND
     //    start fragment already requested OR start frag prefetch not enabled
-    // 2. if tracks or track not loaded and selected
+    // 3. 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 (!media && (this.startFragRequested || !config.startFragPrefetch) || !(levels != null && levels[trackId])) {
+    if (!this.buffering || !media && (this.startFragRequested || !config.startFragPrefetch) || !(levels != null && levels[trackId])) {
       return;
     }
     const levelInfo = levels[trackId];
@@ -16418,7 +17309,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 = [];
@@ -16737,26 +17628,23 @@ 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() {
+  registerListeners() {
+    super.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);
@@ -16764,15 +17652,12 @@ class SubtitleStreamController extends BaseStreamController {
     hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
-  _unregisterListeners() {
+  unregisterListeners() {
+    super.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);
@@ -16999,10 +17884,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 && decryptData.method === 'AES-128') {
+    if (payload && payload.byteLength > 0 && decryptData != null && decryptData.key && decryptData.iv && isFullSegmentEncryption(decryptData.method)) {
       const startTime = performance.now();
       // decrypt the subtitles
-      this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer).catch(err => {
+      this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer, getAesModeFromFullSegmentMethod(decryptData.method)).catch(err => {
         hls.trigger(Events.ERROR, {
           type: ErrorTypes.MEDIA_ERROR,
           details: ErrorDetails.FRAG_DECRYPT_ERROR,
@@ -17136,7 +18021,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;
@@ -17145,10 +18030,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);
@@ -17182,6 +18067,7 @@ class SubtitleTrackController extends BasePlaylistController {
     this.tracks.length = 0;
     this.tracksInGroup.length = 0;
     this.currentTrack = null;
+    // @ts-ignore
     this.onTextTracksChanged = this.asyncPollTrackChange = null;
     super.destroy();
   }
@@ -17642,8 +18528,9 @@ class BufferOperationQueue {
 }
 
 const VIDEO_CODEC_PROFILE_REPLACE = /(avc[1234]|hvc1|hev1|dvh[1e]|vp09|av01)(?:\.[^.,]+)+/;
-class BufferController {
+class BufferController extends Logger {
   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
@@ -17673,9 +18560,6 @@ class BufferController {
     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;
@@ -17721,15 +18605,11 @@ class BufferController {
         _objectUrl
       } = this;
       if (mediaSrc !== _objectUrl) {
-        logger.error(`Media element src was set while attaching MediaSource (${_objectUrl} > ${mediaSrc})`);
+        this.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();
   }
@@ -17742,6 +18622,12 @@ class BufferController {
     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 {
@@ -17904,6 +18790,7 @@ class BufferController {
       this.resetBuffer(type);
     });
     this._initSourceBuffer();
+    this.hls.resumeBuffering();
   }
   resetBuffer(type) {
     const sb = this.sourceBuffer[type];
@@ -21006,14 +21893,12 @@ class TimelineController {
     this.cea608Parser1 = this.cea608Parser2 = undefined;
   }
   initCea608Parsers() {
-    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);
-    }
+    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
@@ -21251,7 +22136,7 @@ class TimelineController {
         if (inUseTracks != null && inUseTracks.length) {
           const unusedTextTracks = inUseTracks.filter(t => t !== null).map(t => t.label);
           if (unusedTextTracks.length) {
-            logger.warn(`Media element contains unused subtitle tracks: ${unusedTextTracks.join(', ')}. Replace media element for each source to clear TextTracks and captions menu.`);
+            this.hls.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) {
@@ -21296,26 +22181,23 @@ 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 (data.frag.type === PlaylistLevelType.MAIN) {
+    if (this.enabled && 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 == 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)) {
+      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)) {
         cea608Parser1.reset();
         cea608Parser2.reset();
       }
@@ -21372,7 +22254,7 @@ class TimelineController {
         frag: frag
       });
     }, error => {
-      logger.log(`Failed to parse IMSC1: ${error}`);
+      hls.logger.log(`Failed to parse IMSC1: ${error}`);
       hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
         success: false,
         frag: frag,
@@ -21413,7 +22295,7 @@ class TimelineController {
         this._fallbackToIMSC1(frag, payload);
       }
       // Something went wrong while parsing. Trigger event with success false.
-      logger.log(`Failed to parse VTT cue: ${error}`);
+      hls.logger.log(`Failed to parse VTT cue: ${error}`);
       if (missingInitPTS && maxAvCC > frag.cc) {
         return;
       }
@@ -21474,12 +22356,7 @@ class TimelineController {
     this.captionsTracks = {};
   }
   onFragParsingUserdata(event, data) {
-    this.initCea608Parsers();
-    const {
-      cea608Parser1,
-      cea608Parser2
-    } = this;
-    if (!this.enabled || !cea608Parser1 || !cea608Parser2) {
+    if (!this.enabled || !this.config.enableCEA708Captions) {
       return;
     }
     const {
@@ -21494,9 +22371,12 @@ 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);
-        cea608Parser1.addData(samples[i].pts, ccdatas[0]);
-        cea608Parser2.addData(samples[i].pts, ccdatas[1]);
+        this.cea608Parser1.addData(samples[i].pts, ccdatas[0]);
+        this.cea608Parser2.addData(samples[i].pts, ccdatas[1]);
       }
     }
   }
@@ -21692,7 +22572,7 @@ class CapLevelController {
         const hls = this.hls;
         const maxLevel = this.getMaxLevel(levels.length - 1);
         if (maxLevel !== this.autoLevelCapping) {
-          logger.log(`Setting autoLevelCapping to ${maxLevel}: ${levels[maxLevel].height}p@${levels[maxLevel].bitrate} for media ${this.mediaWidth}x${this.mediaHeight}`);
+          hls.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) {
@@ -21870,10 +22750,10 @@ class FPSController {
           totalDroppedFrames: droppedFrames
         });
         if (droppedFPS > 0) {
-          // logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
+          // hls.logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
           if (currentDropped > hls.config.fpsDroppedMonitoringThreshold * currentDecoded) {
             let currentLevel = hls.currentLevel;
-            logger.warn('drop FPS ratio greater than max allowed value for currentLevel: ' + currentLevel);
+            hls.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, {
@@ -21905,7 +22785,6 @@ 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
@@ -21913,8 +22792,9 @@ const LOGGER_PREFIX = '[eme]';
  * @class
  * @constructor
  */
-class EMEController {
+class EMEController extends Logger {
   constructor(hls) {
+    super('eme', hls.logger);
     this.hls = void 0;
     this.config = void 0;
     this.media = null;
@@ -21924,12 +22804,100 @@ class EMEController {
     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.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`);
+    };
     this.hls = hls;
     this.config = hls.config;
     this.registerListeners();
@@ -21943,9 +22911,9 @@ class EMEController {
     config.licenseXhrSetup = config.licenseResponseCallback = undefined;
     config.drmSystems = config.drmSystemOptions = {};
     // @ts-ignore
-    this.hls = this.onMediaEncrypted = this.onWaitingForKey = this.keyIdToKeySessionPromise = null;
+    this.hls = this.config = this.keyIdToKeySessionPromise = null;
     // @ts-ignore
-    this.config = null;
+    this.onMediaEncrypted = this.onWaitingForKey = null;
   }
   registerListeners() {
     this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
@@ -22209,100 +23177,6 @@ class EMEController {
     }
     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}"`);
@@ -22895,20 +23769,6 @@ 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) {
@@ -22932,29 +23792,27 @@ function throwError(action, src, type, cause) {
   });
 }
 
-const BARE_ITEM = 'Bare Item';
-
-const BOOLEAN = 'Boolean';
-
-const BYTES = 'Byte Sequence';
-
-const DECIMAL = 'Decimal';
-
-const INTEGER = 'Integer';
-
-function isInvalidInt(value) {
-  return value < -999999999999999 || 999999999999999 < value;
+function serializeError(src, type, cause) {
+  return throwError('serialize', src, type, cause);
 }
 
-const STRING_REGEX = /[\x00-\x1f\x7f]+/; // eslint-disable-line no-control-regex
-
-const TOKEN = 'Token';
+/**
+ * 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 KEY = 'Key';
+const BARE_ITEM = 'Bare Item';
 
-function serializeError(src, type, cause) {
-  return throwError('serialize', src, type, cause);
-}
+const BOOLEAN = 'Boolean';
 
 // 4.1.9.  Serializing a Boolean
 //
@@ -22993,6 +23851,8 @@ 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
@@ -23024,6 +23884,12 @@ 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
@@ -23089,6 +23955,8 @@ function roundToEven(value, precision) {
   }
 }
 
+const DECIMAL = 'Decimal';
+
 // 4.1.5.  Serializing a Decimal
 //
 // Given a decimal number as input_decimal, return an ASCII string
@@ -23134,6 +24002,8 @@ 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
@@ -23169,6 +24039,8 @@ 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) {
@@ -23236,6 +24108,8 @@ 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
@@ -23477,36 +24351,6 @@ 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) {
@@ -23732,6 +24576,36 @@ 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
@@ -23775,7 +24649,7 @@ class CMCDController {
           su: !this.initialized
         });
       } catch (error) {
-        logger.warn('Could not generate manifest CMCD data.', error);
+        this.hls.logger.warn('Could not generate manifest CMCD data.', error);
       }
     };
     /**
@@ -23795,9 +24669,15 @@ 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) {
-        logger.warn('Could not generate segment CMCD data.', error);
+        this.hls.logger.warn('Could not generate segment CMCD data.', error);
       }
     };
     this.hls = hls;
@@ -23887,7 +24767,7 @@ class CMCDController {
       data.su = this.buffering;
     }
 
-    // TODO: Implement rtp, nrr, nor, dl
+    // TODO: Implement rtp, nrr, dl
 
     const {
       includeKeys
@@ -23898,15 +24778,28 @@ class CMCDController {
         return acc;
       }, {});
     }
+    const options = {
+      baseUrl: context.url
+    };
     if (this.useHeaders) {
       if (!context.headers) {
         context.headers = {};
       }
-      appendCmcdHeaders(context.headers, data);
+      appendCmcdHeaders(context.headers, data, options);
     } else {
-      context.url = appendCmcdQuery(context.url, data);
+      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];
     }
+    return undefined;
   }
+
   /**
    * The CMCD object type.
    */
@@ -24035,10 +24928,10 @@ class CMCDController {
 }
 
 const PATHWAY_PENALTY_DURATION_MS = 300000;
-class ContentSteeringController {
+class ContentSteeringController extends Logger {
   constructor(hls) {
+    super('content-steering', hls.logger);
     this.hls = void 0;
-    this.log = void 0;
     this.loader = null;
     this.uri = null;
     this.pathwayId = '.';
@@ -24053,7 +24946,6 @@ class ContentSteeringController {
     this.subtitleTracks = null;
     this.penalizedPathways = {};
     this.hls = hls;
-    this.log = logger.log.bind(logger, `[content-steering]:`);
     this.registerListeners();
   }
   registerListeners() {
@@ -24177,7 +25069,7 @@ class ContentSteeringController {
         errorAction.resolved = this.pathwayId !== errorPathway;
       }
       if (!errorAction.resolved) {
-        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)}`);
+        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)}`);
       }
     }
   }
@@ -24348,7 +25240,7 @@ class ContentSteeringController {
       onSuccess: (response, stats, context, networkDetails) => {
         this.log(`Loaded steering manifest: "${url}"`);
         const steeringData = response.data;
-        if (steeringData.VERSION !== 1) {
+        if ((steeringData == null ? void 0 : steeringData.VERSION) !== 1) {
           this.log(`Steering VERSION ${steeringData.VERSION} not supported!`);
           return;
         }
@@ -25318,7 +26210,7 @@ function timelineConfig() {
 /**
  * @ignore
  */
-function mergeConfig(defaultConfig, userConfig) {
+function mergeConfig(defaultConfig, userConfig, logger) {
   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");
   }
@@ -25388,7 +26280,7 @@ function deepCpy(obj) {
 /**
  * @ignore
  */
-function enableStreamingMode(config) {
+function enableStreamingMode(config, logger) {
   const currentLoader = config.loader;
   if (currentLoader !== FetchLoader && currentLoader !== XhrLoader) {
     // If a developer has configured their own loader, respect that choice
@@ -25405,10 +26297,9 @@ function enableStreamingMode(config) {
   }
 }
 
-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;
@@ -25479,23 +26370,15 @@ class LevelController extends BasePlaylistController {
     let videoCodecFound = false;
     let audioCodecFound = false;
     data.levels.forEach(levelParsed => {
-      var _audioCodec, _videoCodec;
+      var _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) {
-        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource);
+        // Returns empty and set to undefined for 'mp4a.40.34' with fallback to 'audio/mpeg' SourceBuffer
+        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource) || undefined;
       }
       if (((_videoCodec = videoCodec) == null ? void 0 : _videoCodec.indexOf('avc1')) === 0) {
         videoCodec = levelParsed.videoCodec = convertAVC1ToAVCOTI(videoCodec);
@@ -25837,7 +26720,12 @@ class LevelController extends BasePlaylistController {
       if (curLevel.fragmentError === 0) {
         curLevel.loadError = 0;
       }
-      this.playlistLoaded(level, data, curLevel.details);
+      // 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);
     } else if ((_data$deliveryDirecti2 = data.deliveryDirectives) != null && _data$deliveryDirecti2.skip) {
       // received a delta playlist update that cannot be merged
       details.deltaUpdateFailed = true;
@@ -26081,6 +26969,8 @@ 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}"`)));
@@ -26218,8 +27108,9 @@ 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 {
+class GapController extends Logger {
   constructor(config, media, fragmentTracker, hls) {
+    super('gap-controller', hls.logger);
     this.config = void 0;
     this.media = null;
     this.fragmentTracker = void 0;
@@ -26229,6 +27120,7 @@ class GapController {
     this.stalled = null;
     this.moved = false;
     this.seeking = false;
+    this.ended = 0;
     this.config = config;
     this.media = media;
     this.fragmentTracker = fragmentTracker;
@@ -26246,7 +27138,7 @@ class GapController {
    *
    * @param lastCurrentTime - Previously read playhead position
    */
-  poll(lastCurrentTime, activeFrag) {
+  poll(lastCurrentTime, activeFrag, levelDetails, state) {
     const {
       config,
       media,
@@ -26265,6 +27157,7 @@ class GapController {
 
     // The playhead is moving, no-op
     if (currentTime !== lastCurrentTime) {
+      this.ended = 0;
       this.moved = true;
       if (!seeking) {
         this.nudgeRetry = 0;
@@ -26273,7 +27166,7 @@ class GapController {
         // The playhead is now moving, but was previously stalled
         if (this.stallReported) {
           const _stalledDuration = self.performance.now() - stalled;
-          logger.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(_stalledDuration)}ms`);
+          this.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(_stalledDuration)}ms`);
           this.stallReported = false;
         }
         this.stalled = null;
@@ -26309,7 +27202,6 @@ class GapController {
     // 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) {
@@ -26321,9 +27213,8 @@ class GapController {
       // 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 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 isLive = !!(levelDetails != null && levelDetails.live);
+      const maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
       const partialOrGap = this.fragmentTracker.getPartialFragment(currentTime);
       if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
         if (!media.paused) {
@@ -26341,6 +27232,17 @@ class GapController {
     }
     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) {
@@ -26384,7 +27286,7 @@ class GapController {
     // 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) {
-      logger.warn('Trying to nudge playhead over buffer-hole');
+      this.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
@@ -26408,7 +27310,7 @@ class GapController {
       // Report stalled error once
       this.stallReported = true;
       const error = new Error(`Playback stalling at @${media.currentTime} due to low buffer (${JSON.stringify(bufferInfo)})`);
-      logger.warn(error.message);
+      this.warn(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -26476,7 +27378,7 @@ class GapController {
           }
         }
         const targetTime = Math.max(startTime + SKIP_BUFFER_RANGE_START, currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS);
-        logger.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
+        this.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
         this.moved = true;
         this.stalled = null;
         media.currentTime = targetTime;
@@ -26517,7 +27419,7 @@ class GapController {
       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}`);
-      logger.warn(error.message);
+      this.warn(error.message);
       media.currentTime = targetTime;
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
@@ -26527,7 +27429,7 @@ class GapController {
       });
     } else {
       const error = new Error(`Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`);
-      logger.error(error.message);
+      this.error(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -26542,7 +27444,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;
@@ -26550,27 +27452,43 @@ 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._registerListeners();
+    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();
   }
-  _registerListeners() {
+  registerListeners() {
+    super.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);
@@ -26578,17 +27496,14 @@ class StreamController extends BaseStreamController {
     hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
-  _unregisterListeners() {
+  unregisterListeners() {
+    super.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);
@@ -26597,7 +27512,9 @@ class StreamController extends BaseStreamController {
     hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
   onHandlerDestroying() {
-    this._unregisterListeners();
+    // @ts-ignore
+    this.onMediaPlaying = this.onMediaSeeked = null;
+    this.unregisterListeners();
     super.onHandlerDestroying();
   }
   startLoad(startPosition) {
@@ -26717,7 +27634,7 @@ class StreamController extends BaseStreamController {
     if (this.altAudio && this.audioOnly) {
       return;
     }
-    if (!(levels != null && levels[level])) {
+    if (!this.buffering || !(levels != null && levels[level])) {
       return;
     }
     const levelInfo = levels[level];
@@ -26925,20 +27842,17 @@ class StreamController extends BaseStreamController {
   onMediaAttached(event, data) {
     super.onMediaAttached(event, data);
     const media = data.media;
-    this.onvplaying = this.onMediaPlaying.bind(this);
-    this.onvseeked = this.onMediaSeeked.bind(this);
-    media.addEventListener('playing', this.onvplaying);
-    media.addEventListener('seeked', this.onvseeked);
+    media.addEventListener('playing', this.onMediaPlaying);
+    media.addEventListener('seeked', this.onMediaSeeked);
     this.gapController = new GapController(this.config, media, this.fragmentTracker, this.hls);
   }
   onMediaDetaching() {
     const {
       media
     } = this;
-    if (media && this.onvplaying && this.onvseeked) {
-      media.removeEventListener('playing', this.onvplaying);
-      media.removeEventListener('seeked', this.onvseeked);
-      this.onvplaying = this.onvseeked = null;
+    if (media) {
+      media.removeEventListener('playing', this.onMediaPlaying);
+      media.removeEventListener('seeked', this.onMediaSeeked);
       this.videoBuffer = null;
     }
     this.fragPlaying = null;
@@ -26948,27 +27862,6 @@ 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');
@@ -27260,8 +28153,10 @@ 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 activeFrag = this.state !== State.IDLE ? this.fragCurrent : null;
-      gapController.poll(this.lastCurrentTime, activeFrag);
+      const state = this.state;
+      const activeFrag = state !== State.IDLE ? this.fragCurrent : null;
+      const levelDetails = this.getLevelDetails();
+      gapController.poll(this.lastCurrentTime, activeFrag, levelDetails, state);
     }
     this.lastCurrentTime = media.currentTime;
   }
@@ -27699,7 +28594,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.5";
+    return "1.5.6-0.canary.10003";
   }
 
   /**
@@ -27762,9 +28657,12 @@ 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;
@@ -27781,11 +28679,11 @@ class Hls {
     this._media = null;
     this.url = null;
     this.triggeringException = void 0;
-    enableLogs(userConfig.debug || false, 'Hls instance');
-    const config = this.config = mergeConfig(Hls.DefaultConfig, userConfig);
+    const logger = this.logger = enableLogs(userConfig.debug || false, 'Hls instance');
+    const config = this.config = mergeConfig(Hls.DefaultConfig, userConfig, logger);
     this.userConfig = userConfig;
     if (config.progressive) {
-      enableStreamingMode(config);
+      enableStreamingMode(config, logger);
     }
 
     // core controllers and network loaders
@@ -27884,7 +28782,7 @@ class Hls {
       try {
         return this.emit(event, event, eventObject);
       } catch (error) {
-        logger.error('An internal error happened while handling event ' + event + '. Error message: "' + error.message + '". Here is a stacktrace:', error);
+        this.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;
@@ -27910,7 +28808,7 @@ class Hls {
    * Dispose of the instance
    */
   destroy() {
-    logger.log('destroy');
+    this.logger.log('destroy');
     this.trigger(Events.DESTROYING, undefined);
     this.detachMedia();
     this.removeAllListeners();
@@ -27931,7 +28829,7 @@ class Hls {
    * Attaches Hls.js to a media element
    */
   attachMedia(media) {
-    logger.log('attachMedia');
+    this.logger.log('attachMedia');
     this._media = media;
     this.trigger(Events.MEDIA_ATTACHING, {
       media: media
@@ -27942,7 +28840,7 @@ class Hls {
    * Detach Hls.js from the media
    */
   detachMedia() {
-    logger.log('detachMedia');
+    this.logger.log('detachMedia');
     this.trigger(Events.MEDIA_DETACHING, undefined);
     this._media = null;
   }
@@ -27959,7 +28857,7 @@ class Hls {
     });
     this._autoLevelCapping = -1;
     this._maxHdcpLevel = null;
-    logger.log(`loadSource:${loadingSource}`);
+    this.logger.log(`loadSource:${loadingSource}`);
     if (media && loadedSource && (loadedSource !== loadingSource || this.bufferController.hasSourceTypes())) {
       this.detachMedia();
       this.attachMedia(media);
@@ -27978,8 +28876,7 @@ class Hls {
    * Defaults to -1 (None: starts from earliest point)
    */
   startLoad(startPosition = -1) {
-    logger.log(`startLoad(${startPosition})`);
-    this.started = true;
+    this.logger.log(`startLoad(${startPosition})`);
     this.networkControllers.forEach(controller => {
       controller.startLoad(startPosition);
     });
@@ -27989,34 +28886,31 @@ class Hls {
    * Stop loading of any stream data.
    */
   stopLoad() {
-    logger.log('stopLoad');
-    this.started = false;
+    this.logger.log('stopLoad');
     this.networkControllers.forEach(controller => {
       controller.stopLoad();
     });
   }
 
   /**
-   * Resumes stream controller segment loading if previously started.
+   * Resumes stream controller segment loading after `pauseBuffering` has been called.
    */
   resumeBuffering() {
-    if (this.started) {
-      this.networkControllers.forEach(controller => {
-        if ('fragmentLoader' in controller) {
-          controller.startLoad(-1);
-        }
-      });
-    }
+    this.networkControllers.forEach(controller => {
+      if (controller.resumeBuffering) {
+        controller.resumeBuffering();
+      }
+    });
   }
 
   /**
-   * Stops stream controller segment loading without changing 'started' state like stopLoad().
+   * Prevents stream controller from loading new segments until `resumeBuffering` is called.
    * This allows for media buffering to be paused without interupting playlist loading.
    */
   pauseBuffering() {
     this.networkControllers.forEach(controller => {
-      if ('fragmentLoader' in controller) {
-        controller.stopLoad();
+      if (controller.pauseBuffering) {
+        controller.pauseBuffering();
       }
     });
   }
@@ -28025,7 +28919,7 @@ class Hls {
    * Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
    */
   swapAudioCodec() {
-    logger.log('swapAudioCodec');
+    this.logger.log('swapAudioCodec');
     this.streamController.swapAudioCodec();
   }
 
@@ -28036,7 +28930,7 @@ class Hls {
    * Automatic recovery of media-errors by this process is configurable.
    */
   recoverMediaError() {
-    logger.log('recoverMediaError');
+    this.logger.log('recoverMediaError');
     const media = this._media;
     this.detachMedia();
     if (media) {
@@ -28066,7 +28960,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) {
-    logger.log(`set currentLevel:${newLevel}`);
+    this.logger.log(`set currentLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
     this.streamController.immediateLevelSwitch();
   }
@@ -28085,7 +28979,7 @@ class Hls {
    * @param newLevel - Pass -1 for automatic level selection
    */
   set nextLevel(newLevel) {
-    logger.log(`set nextLevel:${newLevel}`);
+    this.logger.log(`set nextLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
     this.streamController.nextLevelSwitch();
   }
@@ -28104,7 +28998,7 @@ class Hls {
    * @param newLevel - Pass -1 for automatic level selection
    */
   set loadLevel(newLevel) {
-    logger.log(`set loadLevel:${newLevel}`);
+    this.logger.log(`set loadLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
   }
 
@@ -28135,7 +29029,7 @@ class Hls {
    * Sets "first-level", see getter.
    */
   set firstLevel(newLevel) {
-    logger.log(`set firstLevel:${newLevel}`);
+    this.logger.log(`set firstLevel:${newLevel}`);
     this.levelController.firstLevel = newLevel;
   }
 
@@ -28160,7 +29054,7 @@ class Hls {
    * (determined from download of first segment)
    */
   set startLevel(newLevel) {
-    logger.log(`set startLevel:${newLevel}`);
+    this.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);
@@ -28235,7 +29129,7 @@ class Hls {
    */
   set autoLevelCapping(newLevel) {
     if (this._autoLevelCapping !== newLevel) {
-      logger.log(`set autoLevelCapping:${newLevel}`);
+      this.logger.log(`set autoLevelCapping:${newLevel}`);
       this._autoLevelCapping = newLevel;
       this.levelController.checkMaxAutoUpdated();
     }