hls.js 1.5.6 → 1.5.7-0.canary.10014

package/dist/hls.light.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.6"}`);
-    } 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.7-0.canary.10014"}`);
+    } 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) {
@@ -991,10 +1013,30 @@ class LevelDetails {
   }
 }
 
+var DecrypterAesMode = {
+  cbc: 0,
+  ctr: 1
+};
+
+function isFullSegmentEncryption(method) {
+  return method === 'AES-128' || method === 'AES-256' || method === 'AES-256-CTR';
+}
+function getAesModeFromFullSegmentMethod(method) {
+  switch (method) {
+    case 'AES-128':
+    case 'AES-256':
+      return DecrypterAesMode.cbc;
+    case 'AES-256-CTR':
+      return DecrypterAesMode.ctr;
+    default:
+      throw new Error(`invalid full segment method ${method}`);
+  }
+}
+
 // This file is inserted as a shim for modules which we do not want to include into the distro.
 // This replacement is done in the "alias" plugin of the rollup config.
 var empty = undefined;
-var Cues = /*@__PURE__*/getDefaultExportFromCjs(empty);
+var HevcVideoParser = /*@__PURE__*/getDefaultExportFromCjs(empty);
 
 function sliceUint8(array, start, end) {
   // @ts-expect-error This polyfills IE11 usage of Uint8Array slice.
@@ -2433,12 +2475,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') {
@@ -2452,14 +2494,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;
       }
@@ -2606,23 +2647,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));
 }
@@ -2645,6 +2691,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: false
+  };
+}
 
 const MASTER_PLAYLIST_REGEX = /#EXT-X-STREAM-INF:([^\r\n]*)(?:[\r\n](?:#[^\r\n]*)?)*([^\r\n]+)|#EXT-X-(SESSION-DATA|SESSION-KEY|DEFINE|CONTENT-STEERING|START):([^\r\n]*)[\r\n]+/g;
 const MASTER_PLAYLIST_MEDIA_REGEX = /#EXT-X-MEDIA:(.*)/g;
@@ -3445,10 +3501,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();
     }
 
@@ -3558,7 +3614,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',
@@ -3657,7 +3713,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);
@@ -4222,7 +4278,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();
@@ -4314,7 +4410,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);
@@ -4332,11 +4428,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;
     }
   }
@@ -4350,10 +4446,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) {
@@ -4363,48 +4459,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() {
@@ -5176,18 +5231,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() {
@@ -5539,16 +5589,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() {
@@ -5581,7 +5628,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
@@ -5668,7 +5715,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}`);
@@ -6127,8 +6179,9 @@ function getCodecTiers(levels, audioTracksByGroup, minAutoLevel, maxAutoLevel) {
   }, {});
 }
 
-class AbrController {
+class AbrController extends Logger {
   constructor(_hls) {
+    super('abr', _hls.logger);
     this.hls = void 0;
     this.lastLevelLoadSec = 0;
     this.lastLoadedFragLevel = -1;
@@ -6242,7 +6295,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
@@ -6262,7 +6315,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;
@@ -6494,7 +6547,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() {
@@ -6572,13 +6625,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;
     }
@@ -6652,7 +6705,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;
@@ -6705,9 +6758,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;
@@ -6943,8 +6996,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
@@ -6974,9 +7028,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;
@@ -7022,15 +7073,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();
   }
@@ -7043,6 +7090,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 {
@@ -7205,6 +7258,7 @@ class BufferController {
       this.resetBuffer(type);
     });
     this._initSourceBuffer();
+    this.hls.resumeBuffering();
   }
   resetBuffer(type) {
     const sb = this.sourceBuffer[type];
@@ -8042,7 +8096,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) {
@@ -8220,10 +8274,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, {
@@ -8256,10 +8310,10 @@ class FPSController {
 }
 
 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 = '.';
@@ -8274,7 +8328,6 @@ class ContentSteeringController {
     this.subtitleTracks = null;
     this.penalizedPathways = {};
     this.hls = hls;
-    this.log = logger.log.bind(logger, `[content-steering]:`);
     this.registerListeners();
   }
   registerListeners() {
@@ -8398,7 +8451,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)}`);
       }
     }
   }
@@ -8569,7 +8622,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;
         }
@@ -9477,7 +9530,7 @@ const hlsDefaultConfig = _objectSpread2(_objectSpread2({
 });
 function timelineConfig() {
   return {
-    cueHandler: Cues,
+    cueHandler: HevcVideoParser,
     // used by timeline-controller
     enableWebVTT: false,
     // used by timeline-controller
@@ -9508,7 +9561,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");
   }
@@ -9578,7 +9631,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
@@ -9595,10 +9648,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;
@@ -9669,23 +9721,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);
@@ -10027,7 +10071,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;
@@ -10813,8 +10862,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;
@@ -10847,6 +10896,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);
@@ -10992,6 +11044,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}"`)));
@@ -11127,8 +11181,9 @@ class KeyLoader {
  * we are limiting the task execution per call stack to exactly one, but scheduling/post-poning further
  * task processing on the next main loop iteration (also known as "next tick" in the Node/JS runtime lingo).
  */
-class TaskLoop {
-  constructor() {
+class TaskLoop extends Logger {
+  constructor(label, logger) {
+    super(label, logger);
     this._boundTick = void 0;
     this._tickTimer = null;
     this._tickInterval = null;
@@ -11396,33 +11451,61 @@ function alignMediaPlaylistByPDT(details, refDetails) {
 }
 
 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) {
@@ -11672,7 +11755,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) {
@@ -11685,9 +11769,7 @@ class Decrypter {
         /* no-op */
       }
     }
-    if (this.subtle === null) {
-      this.useSoftware = true;
-    }
+    this.useSoftware = this.subtle === null;
   }
   destroy() {
     this.subtle = null;
@@ -11725,10 +11807,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);
@@ -11737,17 +11819,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
@@ -11780,11 +11866,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
@@ -11792,22 +11878,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;
@@ -11858,7 +11947,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;
@@ -11883,22 +11972,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();
@@ -11922,6 +12087,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
@@ -11952,10 +12123,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);
@@ -11969,10 +12138,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();
@@ -11982,56 +12150,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 = [];
@@ -12041,7 +12161,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;
@@ -12172,10 +12292,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,
@@ -12287,7 +12407,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 => {
@@ -12308,8 +12428,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) {
@@ -12318,7 +12446,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;
@@ -12347,7 +12475,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;
@@ -12445,8 +12580,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,
@@ -12595,7 +12758,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) {
@@ -12607,6 +12771,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;
       }
@@ -12617,7 +12785,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);
@@ -12739,7 +12907,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);
@@ -12932,7 +13100,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) {
@@ -13327,6 +13495,7 @@ const initPTSFn = (timestamp, timeOffset, initPTS) => {
  */
 function getAudioConfig(observer, data, offset, audioCodec) {
   let adtsObjectType;
+  let originalAdtsObjectType;
   let adtsExtensionSamplingIndex;
   let adtsChannelConfig;
   let config;
@@ -13334,7 +13503,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}`);
@@ -13351,8 +13520,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);
@@ -13446,6 +13615,7 @@ function getAudioConfig(observer, data, offset, audioCodec) {
     samplerate: adtsSamplingRates[adtsSamplingIndex],
     channelCount: adtsChannelConfig,
     codec: 'mp4a.40.' + adtsObjectType,
+    parsedCodec: 'mp4a.40.' + originalAdtsObjectType,
     manifestCodec
   };
 }
@@ -13500,7 +13670,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) {
@@ -13978,17 +14149,121 @@ class BaseVideoParser {
       logger.log(VideoSample.pts + '/' + VideoSample.dts + ':' + VideoSample.debug);
     }
   }
-}
-
-/**
- * Parser for exponential Golomb codes, a variable-bitwidth number encoding scheme used by h264.
- */
-
-class ExpGolomb {
-  constructor(data) {
-    this.data = void 0;
-    this.bytesAvailable = void 0;
-    this.word = void 0;
+  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) {
+    this.data = void 0;
+    this.bytesAvailable = void 0;
+    this.word = void 0;
     this.bitsAvailable = void 0;
     this.data = data;
     // the number of bytes left to examine in this.data
@@ -14120,194 +14395,11 @@ class ExpGolomb {
   readUInt() {
     return this.readBits(32);
   }
-
-  /**
-   * Advance the ExpGolomb decoder past a scaling list. The scaling
-   * list is optionally transmitted as part of a sequence parameter
-   * set and is not relevant to transmuxing.
-   * @param count the number of entries in this scaling list
-   * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
-   */
-  skipScalingList(count) {
-    let lastScale = 8;
-    let nextScale = 8;
-    let deltaScale;
-    for (let j = 0; j < count; j++) {
-      if (nextScale !== 0) {
-        deltaScale = this.readEG();
-        nextScale = (lastScale + deltaScale + 256) % 256;
-      }
-      lastScale = nextScale === 0 ? lastScale : nextScale;
-    }
-  }
-
-  /**
-   * Read a sequence parameter set and return some interesting video
-   * properties. A sequence parameter set is the H264 metadata that
-   * describes the properties of upcoming video frames.
-   * @returns an object with configuration parsed from the
-   * sequence parameter set, including the dimensions of the
-   * associated video frames.
-   */
-  readSPS() {
-    let frameCropLeftOffset = 0;
-    let frameCropRightOffset = 0;
-    let frameCropTopOffset = 0;
-    let frameCropBottomOffset = 0;
-    let numRefFramesInPicOrderCntCycle;
-    let scalingListCount;
-    let i;
-    const readUByte = this.readUByte.bind(this);
-    const readBits = this.readBits.bind(this);
-    const readUEG = this.readUEG.bind(this);
-    const readBoolean = this.readBoolean.bind(this);
-    const skipBits = this.skipBits.bind(this);
-    const skipEG = this.skipEG.bind(this);
-    const skipUEG = this.skipUEG.bind(this);
-    const skipScalingList = this.skipScalingList.bind(this);
-    readUByte();
-    const profileIdc = readUByte(); // profile_idc
-    readBits(5); // profileCompat constraint_set[0-4]_flag, u(5)
-    skipBits(3); // reserved_zero_3bits u(3),
-    readUByte(); // level_idc u(8)
-    skipUEG(); // seq_parameter_set_id
-    // some profiles have more optional data we don't need
-    if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
-      const chromaFormatIdc = readUEG();
-      if (chromaFormatIdc === 3) {
-        skipBits(1);
-      } // separate_colour_plane_flag
-
-      skipUEG(); // bit_depth_luma_minus8
-      skipUEG(); // bit_depth_chroma_minus8
-      skipBits(1); // qpprime_y_zero_transform_bypass_flag
-      if (readBoolean()) {
-        // seq_scaling_matrix_present_flag
-        scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
-        for (i = 0; i < scalingListCount; i++) {
-          if (readBoolean()) {
-            // seq_scaling_list_present_flag[ i ]
-            if (i < 6) {
-              skipScalingList(16);
-            } else {
-              skipScalingList(64);
-            }
-          }
-        }
-      }
-    }
-    skipUEG(); // log2_max_frame_num_minus4
-    const picOrderCntType = readUEG();
-    if (picOrderCntType === 0) {
-      readUEG(); // log2_max_pic_order_cnt_lsb_minus4
-    } else if (picOrderCntType === 1) {
-      skipBits(1); // delta_pic_order_always_zero_flag
-      skipEG(); // offset_for_non_ref_pic
-      skipEG(); // offset_for_top_to_bottom_field
-      numRefFramesInPicOrderCntCycle = readUEG();
-      for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
-        skipEG();
-      } // offset_for_ref_frame[ i ]
-    }
-    skipUEG(); // max_num_ref_frames
-    skipBits(1); // gaps_in_frame_num_value_allowed_flag
-    const picWidthInMbsMinus1 = readUEG();
-    const picHeightInMapUnitsMinus1 = readUEG();
-    const frameMbsOnlyFlag = readBits(1);
-    if (frameMbsOnlyFlag === 0) {
-      skipBits(1);
-    } // mb_adaptive_frame_field_flag
-
-    skipBits(1); // direct_8x8_inference_flag
-    if (readBoolean()) {
-      // frame_cropping_flag
-      frameCropLeftOffset = readUEG();
-      frameCropRightOffset = readUEG();
-      frameCropTopOffset = readUEG();
-      frameCropBottomOffset = readUEG();
-    }
-    let pixelRatio = [1, 1];
-    if (readBoolean()) {
-      // vui_parameters_present_flag
-      if (readBoolean()) {
-        // aspect_ratio_info_present_flag
-        const aspectRatioIdc = readUByte();
-        switch (aspectRatioIdc) {
-          case 1:
-            pixelRatio = [1, 1];
-            break;
-          case 2:
-            pixelRatio = [12, 11];
-            break;
-          case 3:
-            pixelRatio = [10, 11];
-            break;
-          case 4:
-            pixelRatio = [16, 11];
-            break;
-          case 5:
-            pixelRatio = [40, 33];
-            break;
-          case 6:
-            pixelRatio = [24, 11];
-            break;
-          case 7:
-            pixelRatio = [20, 11];
-            break;
-          case 8:
-            pixelRatio = [32, 11];
-            break;
-          case 9:
-            pixelRatio = [80, 33];
-            break;
-          case 10:
-            pixelRatio = [18, 11];
-            break;
-          case 11:
-            pixelRatio = [15, 11];
-            break;
-          case 12:
-            pixelRatio = [64, 33];
-            break;
-          case 13:
-            pixelRatio = [160, 99];
-            break;
-          case 14:
-            pixelRatio = [4, 3];
-            break;
-          case 15:
-            pixelRatio = [3, 2];
-            break;
-          case 16:
-            pixelRatio = [2, 1];
-            break;
-          case 255:
-            {
-              pixelRatio = [readUByte() << 8 | readUByte(), readUByte() << 8 | readUByte()];
-              break;
-            }
-        }
-      }
-    }
-    return {
-      width: Math.ceil((picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2),
-      height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset),
-      pixelRatio: pixelRatio
-    };
-  }
-  readSliceType() {
-    // skip NALu type
-    this.readUByte();
-    // discard first_mb_in_slice
-    this.readUEG();
-    // return slice_type
-    return this.readUEG();
-  }
 }
 
 class AvcVideoParser extends BaseVideoParser {
-  parseAVCPES(track, textTrack, pes, last, duration) {
-    const units = this.parseAVCNALu(track, pes.data);
+  parsePES(track, textTrack, pes, last, duration) {
+    const units = this.parseNALu(track, pes.data);
     let VideoSample = this.VideoSample;
     let push;
     let spsfound = false;
@@ -14332,7 +14424,7 @@ class AvcVideoParser extends BaseVideoParser {
             // only check slice type to detect KF in case SPS found in same packet (any keyframe is preceded by SPS ...)
             if (spsfound && data.length > 4) {
               // retrieve slice type by parsing beginning of NAL unit (follow H264 spec, slice_header definition) to detect keyframe embedded in NDR
-              const sliceType = new ExpGolomb(data).readSliceType();
+              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.
@@ -14386,8 +14478,7 @@ class AvcVideoParser extends BaseVideoParser {
             push = true;
             spsfound = true;
             const sps = unit.data;
-            const expGolombDecoder = new ExpGolomb(sps);
-            const config = expGolombDecoder.readSPS();
+            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;
@@ -14443,109 +14534,192 @@ class AvcVideoParser extends BaseVideoParser {
       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));
+  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();
+  }
 
-    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;
+  /**
+   * The scaling list is optionally transmitted as part of a sequence parameter
+   * set and is not relevant to transmuxing.
+   * @param count the number of entries in this scaling list
+   * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
+   */
+  skipScalingList(count, reader) {
+    let lastScale = 8;
+    let nextScale = 8;
+    let deltaScale;
+    for (let j = 0; j < count; j++) {
+      if (nextScale !== 0) {
+        deltaScale = reader.readEG();
+        nextScale = (lastScale + deltaScale + 256) % 256;
       }
-      // 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.
+      lastScale = nextScale === 0 ? lastScale : nextScale;
+    }
+  }
 
-            if (overflow > 0) {
-              // logger.log('first NALU found with overflow:' + overflow);
-              lastUnit.data = appendUint8Array(lastUnit.data, array.subarray(0, overflow));
-              lastUnit.state = 0;
+  /**
+   * Read a sequence parameter set and return some interesting video
+   * properties. A sequence parameter set is the H264 metadata that
+   * describes the properties of upcoming video frames.
+   * @returns an object with configuration parsed from the
+   * sequence parameter set, including the dimensions of the
+   * associated video frames.
+   */
+  readSPS(sps) {
+    const eg = new ExpGolomb(sps);
+    let frameCropLeftOffset = 0;
+    let frameCropRightOffset = 0;
+    let frameCropTopOffset = 0;
+    let frameCropBottomOffset = 0;
+    let numRefFramesInPicOrderCntCycle;
+    let scalingListCount;
+    let i;
+    const readUByte = eg.readUByte.bind(eg);
+    const readBits = eg.readBits.bind(eg);
+    const readUEG = eg.readUEG.bind(eg);
+    const readBoolean = eg.readBoolean.bind(eg);
+    const skipBits = eg.skipBits.bind(eg);
+    const skipEG = eg.skipEG.bind(eg);
+    const skipUEG = eg.skipUEG.bind(eg);
+    const skipScalingList = this.skipScalingList.bind(this);
+    readUByte();
+    const profileIdc = readUByte(); // profile_idc
+    readBits(5); // profileCompat constraint_set[0-4]_flag, u(5)
+    skipBits(3); // reserved_zero_3bits u(3),
+    readUByte(); // level_idc u(8)
+    skipUEG(); // seq_parameter_set_id
+    // some profiles have more optional data we don't need
+    if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
+      const chromaFormatIdc = readUEG();
+      if (chromaFormatIdc === 3) {
+        skipBits(1);
+      } // separate_colour_plane_flag
+
+      skipUEG(); // bit_depth_luma_minus8
+      skipUEG(); // bit_depth_chroma_minus8
+      skipBits(1); // qpprime_y_zero_transform_bypass_flag
+      if (readBoolean()) {
+        // seq_scaling_matrix_present_flag
+        scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
+        for (i = 0; i < scalingListCount; i++) {
+          if (readBoolean()) {
+            // seq_scaling_list_present_flag[ i ]
+            if (i < 6) {
+              skipScalingList(16, eg);
+            } else {
+              skipScalingList(64, eg);
             }
           }
         }
-        // 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;
       }
     }
-    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);
+    skipUEG(); // log2_max_frame_num_minus4
+    const picOrderCntType = readUEG();
+    if (picOrderCntType === 0) {
+      readUEG(); // log2_max_pic_order_cnt_lsb_minus4
+    } else if (picOrderCntType === 1) {
+      skipBits(1); // delta_pic_order_always_zero_flag
+      skipEG(); // offset_for_non_ref_pic
+      skipEG(); // offset_for_top_to_bottom_field
+      numRefFramesInPicOrderCntCycle = readUEG();
+      for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
+        skipEG();
+      } // offset_for_ref_frame[ i ]
     }
-    // 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);
+    skipUEG(); // max_num_ref_frames
+    skipBits(1); // gaps_in_frame_num_value_allowed_flag
+    const picWidthInMbsMinus1 = readUEG();
+    const picHeightInMapUnitsMinus1 = readUEG();
+    const frameMbsOnlyFlag = readBits(1);
+    if (frameMbsOnlyFlag === 0) {
+      skipBits(1);
+    } // mb_adaptive_frame_field_flag
+
+    skipBits(1); // direct_8x8_inference_flag
+    if (readBoolean()) {
+      // frame_cropping_flag
+      frameCropLeftOffset = readUEG();
+      frameCropRightOffset = readUEG();
+      frameCropTopOffset = readUEG();
+      frameCropBottomOffset = readUEG();
+    }
+    let pixelRatio = [1, 1];
+    if (readBoolean()) {
+      // vui_parameters_present_flag
+      if (readBoolean()) {
+        // aspect_ratio_info_present_flag
+        const aspectRatioIdc = readUByte();
+        switch (aspectRatioIdc) {
+          case 1:
+            pixelRatio = [1, 1];
+            break;
+          case 2:
+            pixelRatio = [12, 11];
+            break;
+          case 3:
+            pixelRatio = [10, 11];
+            break;
+          case 4:
+            pixelRatio = [16, 11];
+            break;
+          case 5:
+            pixelRatio = [40, 33];
+            break;
+          case 6:
+            pixelRatio = [24, 11];
+            break;
+          case 7:
+            pixelRatio = [20, 11];
+            break;
+          case 8:
+            pixelRatio = [32, 11];
+            break;
+          case 9:
+            pixelRatio = [80, 33];
+            break;
+          case 10:
+            pixelRatio = [18, 11];
+            break;
+          case 11:
+            pixelRatio = [15, 11];
+            break;
+          case 12:
+            pixelRatio = [64, 33];
+            break;
+          case 13:
+            pixelRatio = [160, 99];
+            break;
+          case 14:
+            pixelRatio = [4, 3];
+            break;
+          case 15:
+            pixelRatio = [3, 2];
+            break;
+          case 16:
+            pixelRatio = [2, 1];
+            break;
+          case 255:
+            {
+              pixelRatio = [readUByte() << 8 | readUByte(), readUByte() << 8 | readUByte()];
+              break;
+            }
+        }
       }
     }
-    track.naluState = state;
-    return units;
+    return {
+      width: Math.ceil((picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2),
+      height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset),
+      pixelRatio: pixelRatio
+    };
   }
 }
 
@@ -14563,7 +14737,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
@@ -14677,7 +14851,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);
@@ -14842,7 +15016,16 @@ 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;
+                  }
+                }
+                if (this.videoParser !== null) {
+                  this.videoParser.parsePES(videoTrack, textTrack, pes, false, this._duration);
+                }
               }
               videoData = {
                 data: [],
@@ -15004,8 +15187,17 @@ 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;
+        }
+      }
+      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;
@@ -15308,7 +15500,10 @@ 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)
+        {
+          logger.warn('Unsupported HEVC in M2TS found');
+        }
         break;
     }
     // move to the next table entry
@@ -15531,6 +15726,8 @@ class MP4 {
       avc1: [],
       // codingname
       avcC: [],
+      hvc1: [],
+      hvcC: [],
       btrt: [],
       dinf: [],
       dref: [],
@@ -15955,8 +16152,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) {
@@ -16094,6 +16293,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;
@@ -16469,9 +16746,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;
@@ -16480,12 +16757,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`);
@@ -16633,7 +16922,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;
@@ -16766,7 +17055,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();
@@ -16894,7 +17183,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) {
@@ -17285,13 +17574,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) {
@@ -17303,7 +17594,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);
@@ -17957,14 +18248,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: false
-    };
+    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
@@ -18228,8 +18512,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;
@@ -18239,6 +18524,7 @@ class GapController {
     this.stalled = null;
     this.moved = false;
     this.seeking = false;
+    this.ended = 0;
     this.config = config;
     this.media = media;
     this.fragmentTracker = fragmentTracker;
@@ -18256,7 +18542,7 @@ class GapController {
    *
    * @param lastCurrentTime - Previously read playhead position
    */
-  poll(lastCurrentTime, activeFrag) {
+  poll(lastCurrentTime, activeFrag, levelDetails, state) {
     const {
       config,
       media,
@@ -18275,6 +18561,7 @@ class GapController {
 
     // The playhead is moving, no-op
     if (currentTime !== lastCurrentTime) {
+      this.ended = 0;
       this.moved = true;
       if (!seeking) {
         this.nudgeRetry = 0;
@@ -18283,7 +18570,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;
@@ -18319,7 +18606,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) {
@@ -18331,9 +18617,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) {
@@ -18351,6 +18636,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) {
@@ -18394,7 +18690,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
@@ -18418,7 +18714,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,
@@ -18486,7 +18782,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;
@@ -18527,7 +18823,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,
@@ -18537,7 +18833,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,
@@ -18552,7 +18848,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;
@@ -18560,27 +18856,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);
@@ -18588,17 +18900,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);
@@ -18607,7 +18916,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) {
@@ -18932,20 +19243,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;
@@ -18955,27 +19263,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');
@@ -19267,8 +19554,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;
   }
@@ -19706,7 +19995,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.6";
+    return "1.5.7-0.canary.10014";
   }
 
   /**
@@ -19769,9 +20058,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;
@@ -19788,11 +20080,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
@@ -19891,7 +20183,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;
@@ -19917,7 +20209,7 @@ class Hls {
    * Dispose of the instance
    */
   destroy() {
-    logger.log('destroy');
+    this.logger.log('destroy');
     this.trigger(Events.DESTROYING, undefined);
     this.detachMedia();
     this.removeAllListeners();
@@ -19938,7 +20230,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
@@ -19949,7 +20241,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;
   }
@@ -19966,7 +20258,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);
@@ -19985,8 +20277,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);
     });
@@ -19996,34 +20287,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();
       }
     });
   }
@@ -20032,7 +20320,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();
   }
 
@@ -20043,7 +20331,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) {
@@ -20073,7 +20361,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();
   }
@@ -20092,7 +20380,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();
   }
@@ -20111,7 +20399,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;
   }
 
@@ -20142,7 +20430,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;
   }
 
@@ -20167,7 +20455,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);
@@ -20242,7 +20530,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();
     }
@@ -20521,5 +20809,5 @@ var KeySystemFormats = empty.KeySystemFormats;
 var KeySystems = empty.KeySystems;
 var SubtitleStreamController = empty.SubtitleStreamController;
 var TimelineController = empty.TimelineController;
-export { AbrController, AttrList, Cues as AudioStreamController, Cues as AudioTrackController, BasePlaylistController, BaseSegment, BaseStreamController, BufferController, Cues as CMCDController, CapLevelController, ChunkMetadata, ContentSteeringController, DateRange, Cues as EMEController, ErrorActionFlags, ErrorController, ErrorDetails, ErrorTypes, Events, FPSController, Fragment, Hls, HlsSkip, HlsUrlParameters, KeySystemFormats, KeySystems, Level, LevelDetails, LevelKey, LoadStats, MetadataSchema, NetworkErrorAction, Part, PlaylistLevelType, SubtitleStreamController, Cues as SubtitleTrackController, TimelineController, Hls as default, getMediaSource, isMSESupported, isSupported };
+export { AbrController, AttrList, HevcVideoParser as AudioStreamController, HevcVideoParser as AudioTrackController, BasePlaylistController, BaseSegment, BaseStreamController, BufferController, HevcVideoParser as CMCDController, CapLevelController, ChunkMetadata, ContentSteeringController, DateRange, HevcVideoParser as EMEController, ErrorActionFlags, ErrorController, ErrorDetails, ErrorTypes, Events, FPSController, Fragment, Hls, HlsSkip, HlsUrlParameters, KeySystemFormats, KeySystems, Level, LevelDetails, LevelKey, LoadStats, MetadataSchema, NetworkErrorAction, Part, PlaylistLevelType, SubtitleStreamController, HevcVideoParser as SubtitleTrackController, TimelineController, Hls as default, getMediaSource, isMSESupported, isSupported };
 //# sourceMappingURL=hls.light.mjs.map