hls.js 1.5.2-0.canary.9934 → 1.5.3

package/dist/hls.light.mjs

@@ -256,7 +256,6 @@ let Events = /*#__PURE__*/function (Events) {
   Events["MEDIA_ATTACHED"] = "hlsMediaAttached";
   Events["MEDIA_DETACHING"] = "hlsMediaDetaching";
   Events["MEDIA_DETACHED"] = "hlsMediaDetached";
-  Events["MEDIA_ENDED"] = "hlsMediaEnded";
   Events["BUFFER_RESET"] = "hlsBufferReset";
   Events["BUFFER_CODECS"] = "hlsBufferCodecs";
   Events["BUFFER_CREATED"] = "hlsBufferCreated";
@@ -370,23 +369,6 @@ let ErrorDetails = /*#__PURE__*/function (ErrorDetails) {
   return ErrorDetails;
 }({});
 
-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,
@@ -396,9 +378,7 @@ const fakeLogger = {
   info: noop,
   error: noop
 };
-function createLogger() {
-  return _extends({}, fakeLogger);
-}
+let exportedLogger = fakeLogger;
 
 // let lastCallTime;
 // function formatMsgWithTimeInfo(type, msg) {
@@ -409,36 +389,35 @@ function createLogger() {
 //   return msg;
 // }
 
-function consolePrintFn(type, id) {
+function consolePrintFn(type) {
   const func = self.console[type];
-  return func ? func.bind(self.console, `${id ? '[' + id + '] ' : ''}[${type}] >`) : noop;
+  if (func) {
+    return func.bind(self.console, `[${type}] >`);
+  }
+  return noop;
 }
-function getLoggerFn(key, debugConfig, id) {
-  return debugConfig[key] ? debugConfig[key].bind(debugConfig) : consolePrintFn(key, id);
+function exportLoggerFunctions(debugConfig, ...functions) {
+  functions.forEach(function (type) {
+    exportedLogger[type] = debugConfig[type] ? debugConfig[type].bind(debugConfig) : consolePrintFn(type);
+  });
 }
-let exportedLogger = createLogger();
-function enableLogs(debugConfig, context, id) {
+function enableLogs(debugConfig, id) {
   // check that console is available
-  const newLogger = createLogger();
   if (typeof console === 'object' && debugConfig === true || typeof debugConfig === 'object') {
-    const keys = [
+    exportLoggerFunctions(debugConfig,
     // 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);
-    });
+    'debug', 'log', 'info', 'warn', 'error');
     // 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.2-0.canary.9934"}`);
+      exportedLogger.log(`Debug logs enabled for "${id}" in hls.js version ${"1.5.3"}`);
     } catch (e) {
-      /* log fn threw an exception. All logger methods are no-ops. */
-      return createLogger();
+      exportedLogger = fakeLogger;
     }
+  } else {
+    exportedLogger = fakeLogger;
   }
-  exportedLogger = newLogger;
-  return newLogger;
 }
 const logger = exportedLogger;
 
@@ -1012,26 +991,6 @@ 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;
@@ -2460,12 +2419,12 @@ class LevelKey {
     this.keyFormatVersions = formatversions;
     this.iv = iv;
     this.encrypted = method ? method !== 'NONE' : false;
-    this.isCommonEncryption = this.encrypted && !isFullSegmentEncryption(method);
+    this.isCommonEncryption = this.encrypted && method !== 'AES-128';
   }
   isSupported() {
     // If it's Segment encryption or No encryption, just select that key system
     if (this.method) {
-      if (isFullSegmentEncryption(this.method) || this.method === 'NONE') {
+      if (this.method === 'AES-128' || this.method === 'NONE') {
         return true;
       }
       if (this.keyFormat === 'identity') {
@@ -2479,13 +2438,14 @@ class LevelKey {
     if (!this.encrypted || !this.uri) {
       return null;
     }
-    if (isFullSegmentEncryption(this.method) && this.uri && !this.iv) {
+    if (this.method === 'AES-128' && this.uri && !this.iv) {
       if (typeof sn !== 'number') {
         // We are fetching decryption data for a initialization segment
-        // If the segment was encrypted with AES-128/256
+        // If the segment was encrypted with AES-128
         // It must have an IV defined. We cannot substitute the Segment Number in.
-        logger.warn(`missing IV for initialization segment with method="${this.method}" - compliance issue`);
-
+        if (this.method === 'AES-128' && !this.iv) {
+          logger.warn(`missing IV for initialization segment with method="${this.method}" - compliance issue`);
+        }
         // Explicitly set sn to resulting value from implicit conversions 'initSegment' values for IV generation.
         sn = 0;
       }
@@ -2632,28 +2592,23 @@ function getCodecCompatibleNameLower(lowerCaseCodec, preferManagedMediaSource =
   if (CODEC_COMPATIBLE_NAMES[lowerCaseCodec]) {
     return CODEC_COMPATIBLE_NAMES[lowerCaseCodec];
   }
+
+  // Idealy fLaC and Opus would be first (spec-compliant) but
+  // some browsers will report that fLaC is supported then fail.
+  // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
   const codecsToCheck = {
-    // Idealy fLaC and Opus would be first (spec-compliant) but
-    // some browsers will report that fLaC is supported then fail.
-    // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
     flac: ['flac', 'fLaC', 'FLAC'],
-    opus: ['opus', 'Opus'],
-    // Replace audio codec info if browser does not support mp4a.40.34,
-    // and demuxer can fallback to 'audio/mpeg' or 'audio/mp4;codecs="mp3"'
-    'mp4a.40.34': ['mp3']
+    opus: ['opus', 'Opus']
   }[lowerCaseCodec];
   for (let i = 0; i < codecsToCheck.length; i++) {
-    var _getMediaSource;
     if (isCodecMediaSourceSupported(codecsToCheck[i], 'audio', preferManagedMediaSource)) {
       CODEC_COMPATIBLE_NAMES[lowerCaseCodec] = codecsToCheck[i];
       return codecsToCheck[i];
-    } else if (codecsToCheck[i] === 'mp3' && (_getMediaSource = getMediaSource(preferManagedMediaSource)) != null && _getMediaSource.isTypeSupported('audio/mpeg')) {
-      return '';
     }
   }
   return lowerCaseCodec;
 }
-const AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
+const AUDIO_CODEC_REGEXP = /flac|opus/i;
 function getCodecCompatibleName(codec, preferManagedMediaSource = true) {
   return codec.replace(AUDIO_CODEC_REGEXP, m => getCodecCompatibleNameLower(m.toLowerCase(), preferManagedMediaSource));
 }
@@ -2676,16 +2631,6 @@ function convertAVC1ToAVCOTI(codec) {
   }
   return codec;
 }
-function getM2TSSupportedAudioTypes(preferManagedMediaSource) {
-  const MediaSource = getMediaSource(preferManagedMediaSource) || {
-    isTypeSupported: () => false
-  };
-  return {
-    mpeg: MediaSource.isTypeSupported('audio/mpeg'),
-    mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
-    ac3: false
-  };
-}
 
 const MASTER_PLAYLIST_REGEX = /#EXT-X-STREAM-INF:([^\r\n]*)(?:[\r\n](?:#[^\r\n]*)?)*([^\r\n]+)|#EXT-X-(SESSION-DATA|SESSION-KEY|DEFINE|CONTENT-STEERING|START):([^\r\n]*)[\r\n]+/g;
 const MASTER_PLAYLIST_MEDIA_REGEX = /#EXT-X-MEDIA:(.*)/g;
@@ -4263,47 +4208,7 @@ class LatencyController {
     this.currentTime = 0;
     this.stallCount = 0;
     this._latency = null;
-    this.onTimeupdate = () => {
-      const {
-        media,
-        levelDetails
-      } = this;
-      if (!media || !levelDetails) {
-        return;
-      }
-      this.currentTime = media.currentTime;
-      const latency = this.computeLatency();
-      if (latency === null) {
-        return;
-      }
-      this._latency = latency;
-
-      // Adapt playbackRate to meet target latency in low-latency mode
-      const {
-        lowLatencyMode,
-        maxLiveSyncPlaybackRate
-      } = this.config;
-      if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
-        return;
-      }
-      const targetLatency = this.targetLatency;
-      if (targetLatency === null) {
-        return;
-      }
-      const distanceFromTarget = latency - targetLatency;
-      // Only adjust playbackRate when within one target duration of targetLatency
-      // and more than one second from under-buffering.
-      // Playback further than one target duration from target can be considered DVR playback.
-      const liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
-      const inLiveRange = distanceFromTarget < liveMinLatencyDuration;
-      if (inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
-        const max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
-        const rate = Math.round(2 / (1 + Math.exp(-0.75 * distanceFromTarget - this.edgeStalled)) * 20) / 20;
-        media.playbackRate = Math.min(max, Math.max(1, rate));
-      } else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
-        media.playbackRate = 1;
-      }
-    };
+    this.timeupdateHandler = () => this.timeupdate();
     this.hls = hls;
     this.config = hls.config;
     this.registerListeners();
@@ -4395,7 +4300,7 @@ class LatencyController {
     this.onMediaDetaching();
     this.levelDetails = null;
     // @ts-ignore
-    this.hls = null;
+    this.hls = this.timeupdateHandler = null;
   }
   registerListeners() {
     this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
@@ -4413,11 +4318,11 @@ class LatencyController {
   }
   onMediaAttached(event, data) {
     this.media = data.media;
-    this.media.addEventListener('timeupdate', this.onTimeupdate);
+    this.media.addEventListener('timeupdate', this.timeupdateHandler);
   }
   onMediaDetaching() {
     if (this.media) {
-      this.media.removeEventListener('timeupdate', this.onTimeupdate);
+      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
       this.media = null;
     }
   }
@@ -4431,10 +4336,10 @@ class LatencyController {
   }) {
     this.levelDetails = details;
     if (details.advanced) {
-      this.onTimeupdate();
+      this.timeupdate();
     }
     if (!details.live && this.media) {
-      this.media.removeEventListener('timeupdate', this.onTimeupdate);
+      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
     }
   }
   onError(event, data) {
@@ -4444,7 +4349,48 @@ class LatencyController {
     }
     this.stallCount++;
     if ((_this$levelDetails = this.levelDetails) != null && _this$levelDetails.live) {
-      this.hls.logger.warn('[latency-controller]: Stall detected, adjusting target latency');
+      logger.warn('[playback-rate-controller]: Stall detected, adjusting target latency');
+    }
+  }
+  timeupdate() {
+    const {
+      media,
+      levelDetails
+    } = this;
+    if (!media || !levelDetails) {
+      return;
+    }
+    this.currentTime = media.currentTime;
+    const latency = this.computeLatency();
+    if (latency === null) {
+      return;
+    }
+    this._latency = latency;
+
+    // Adapt playbackRate to meet target latency in low-latency mode
+    const {
+      lowLatencyMode,
+      maxLiveSyncPlaybackRate
+    } = this.config;
+    if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
+      return;
+    }
+    const targetLatency = this.targetLatency;
+    if (targetLatency === null) {
+      return;
+    }
+    const distanceFromTarget = latency - targetLatency;
+    // Only adjust playbackRate when within one target duration of targetLatency
+    // and more than one second from under-buffering.
+    // Playback further than one target duration from target can be considered DVR playback.
+    const liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
+    const inLiveRange = distanceFromTarget < liveMinLatencyDuration;
+    if (inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
+      const max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
+      const rate = Math.round(2 / (1 + Math.exp(-0.75 * distanceFromTarget - this.edgeStalled)) * 20) / 20;
+      media.playbackRate = Math.min(max, Math.max(1, rate));
+    } else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
+      media.playbackRate = 1;
     }
   }
   estimateLiveEdge() {
@@ -5216,13 +5162,18 @@ var ErrorActionFlags = {
   MoveAllAlternatesMatchingHDCP: 2,
   SwitchToSDR: 4
 }; // Reserved for future use
-class ErrorController extends Logger {
+class ErrorController {
   constructor(hls) {
-    super('error-controller', hls.logger);
     this.hls = void 0;
     this.playlistError = 0;
     this.penalizedRenditions = {};
+    this.log = void 0;
+    this.warn = void 0;
+    this.error = void 0;
     this.hls = hls;
+    this.log = logger.log.bind(logger, `[info]:`);
+    this.warn = logger.warn.bind(logger, `[warning]:`);
+    this.error = logger.error.bind(logger, `[error]:`);
     this.registerListeners();
   }
   registerListeners() {
@@ -5574,13 +5525,16 @@ class ErrorController extends Logger {
   }
 }
 
-class BasePlaylistController extends Logger {
+class BasePlaylistController {
   constructor(hls, logPrefix) {
-    super(logPrefix, hls.logger);
     this.hls = void 0;
     this.timer = -1;
     this.requestScheduled = -1;
     this.canLoad = false;
+    this.log = void 0;
+    this.warn = void 0;
+    this.log = logger.log.bind(logger, `${logPrefix}:`);
+    this.warn = logger.warn.bind(logger, `${logPrefix}:`);
     this.hls = hls;
   }
   destroy() {
@@ -5613,7 +5567,7 @@ class BasePlaylistController extends Logger {
         try {
           uri = new self.URL(attr.URI, previous.url).href;
         } catch (error) {
-          this.warn(`Could not construct new URL for Rendition Report: ${error}`);
+          logger.warn(`Could not construct new URL for Rendition Report: ${error}`);
           uri = attr.URI || '';
         }
         // Use exact match. Otherwise, the last partial match, if any, will be used
@@ -6159,9 +6113,8 @@ function getCodecTiers(levels, audioTracksByGroup, minAutoLevel, maxAutoLevel) {
   }, {});
 }
 
-class AbrController extends Logger {
+class AbrController {
   constructor(_hls) {
-    super('abr', _hls.logger);
     this.hls = void 0;
     this.lastLevelLoadSec = 0;
     this.lastLoadedFragLevel = -1;
@@ -6275,7 +6228,7 @@ class AbrController extends Logger {
         this.resetEstimator(nextLoadLevelBitrate);
       }
       this.clearTimer();
-      this.warn(`Fragment ${frag.sn}${part ? ' part ' + part.index : ''} of level ${frag.level} is loading too slowly;
+      logger.warn(`[abr] Fragment ${frag.sn}${part ? ' part ' + part.index : ''} of level ${frag.level} is loading too slowly;
       Time to underbuffer: ${bufferStarvationDelay.toFixed(3)} s
       Estimated load time for current fragment: ${fragLoadedDelay.toFixed(3)} s
       Estimated load time for down switch fragment: ${fragLevelNextLoadedDelay.toFixed(3)} s
@@ -6295,7 +6248,7 @@ class AbrController extends Logger {
   }
   resetEstimator(abrEwmaDefaultEstimate) {
     if (abrEwmaDefaultEstimate) {
-      this.log(`setting initial bwe to ${abrEwmaDefaultEstimate}`);
+      logger.log(`setting initial bwe to ${abrEwmaDefaultEstimate}`);
       this.hls.config.abrEwmaDefaultEstimate = abrEwmaDefaultEstimate;
     }
     this.firstSelection = -1;
@@ -6527,7 +6480,7 @@ class AbrController extends Logger {
     }
     const firstLevel = this.hls.firstLevel;
     const clamped = Math.min(Math.max(firstLevel, minAutoLevel), maxAutoLevel);
-    this.warn(`Could not find best starting auto level. Defaulting to first in playlist ${firstLevel} clamped to ${clamped}`);
+    logger.warn(`[abr] Could not find best starting auto level. Defaulting to first in playlist ${firstLevel} clamped to ${clamped}`);
     return clamped;
   }
   get forcedAutoLevel() {
@@ -6612,13 +6565,13 @@ class AbrController extends Logger {
         // cap maxLoadingDelay and ensure it is not bigger 'than bitrate test' frag duration
         const maxLoadingDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxLoadingDelay) : config.maxLoadingDelay;
         maxStarvationDelay = maxLoadingDelay - bitrateTestDelay;
-        this.info(`bitrate test took ${Math.round(1000 * bitrateTestDelay)}ms, set first fragment max fetchDuration to ${Math.round(1000 * maxStarvationDelay)} ms`);
+        logger.info(`[abr] bitrate test took ${Math.round(1000 * bitrateTestDelay)}ms, set first fragment max fetchDuration to ${Math.round(1000 * maxStarvationDelay)} ms`);
         // don't use conservative factor on bitrate test
         bwFactor = bwUpFactor = 1;
       }
     }
     const bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, maxStarvationDelay, bwFactor, bwUpFactor);
-    this.info(`${bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty'}, optimal quality level ${bestLevel}`);
+    logger.info(`[abr] ${bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty'}, optimal quality level ${bestLevel}`);
     if (bestLevel > -1) {
       return bestLevel;
     }
@@ -6680,7 +6633,7 @@ class AbrController extends Logger {
       currentVideoRange = preferHDR ? videoRanges[videoRanges.length - 1] : videoRanges[0];
       currentFrameRate = minFramerate;
       currentBw = Math.max(currentBw, minBitrate);
-      this.log(`picked start tier ${JSON.stringify(startTier)}`);
+      logger.log(`[abr] picked start tier ${JSON.stringify(startTier)}`);
     } else {
       currentCodecSet = level == null ? void 0 : level.codecSet;
       currentVideoRange = level == null ? void 0 : level.videoRange;
@@ -6689,7 +6642,7 @@ class AbrController extends Logger {
     const ttfbEstimateSec = this.bwEstimator.getEstimateTTFB() / 1000;
     const levelsSkipped = [];
     for (let i = maxAutoLevel; i >= minAutoLevel; i--) {
-      var _levelInfo$supportedR, _levelInfo$supportedR2;
+      var _levelInfo$supportedR;
       const levelInfo = levels[i];
       const upSwitch = i > selectionBaseLevel;
       if (!levelInfo) {
@@ -6698,7 +6651,7 @@ class AbrController extends Logger {
 
       // skip candidates which change codec-family or video-range,
       // and which decrease or increase frame-rate for up and down-switch respectfully
-      if (currentCodecSet && levelInfo.codecSet !== currentCodecSet || currentVideoRange && levelInfo.videoRange !== currentVideoRange || upSwitch && currentFrameRate > levelInfo.frameRate || !upSwitch && currentFrameRate > 0 && currentFrameRate < levelInfo.frameRate || !((_levelInfo$supportedR = levelInfo.supportedResult) != null && (_levelInfo$supportedR2 = _levelInfo$supportedR.decodingInfoResults) != null && _levelInfo$supportedR2[0].smooth)) {
+      if (currentCodecSet && levelInfo.codecSet !== currentCodecSet || currentVideoRange && levelInfo.videoRange !== currentVideoRange || upSwitch && currentFrameRate > levelInfo.frameRate || !upSwitch && currentFrameRate > 0 && currentFrameRate < levelInfo.frameRate || levelInfo.supportedResult && !((_levelInfo$supportedR = levelInfo.supportedResult.decodingInfoResults) != null && _levelInfo$supportedR[0].smooth)) {
         levelsSkipped.push(i);
         continue;
       }
@@ -6733,9 +6686,9 @@ class AbrController extends Logger {
         const forcedAutoLevel = this.forcedAutoLevel;
         if (i !== loadLevel && (forcedAutoLevel === -1 || forcedAutoLevel !== loadLevel)) {
           if (levelsSkipped.length) {
-            this.trace(`Skipped level(s) ${levelsSkipped.join(',')} of ${maxAutoLevel} max with CODECS and VIDEO-RANGE:"${levels[levelsSkipped[0]].codecs}" ${levels[levelsSkipped[0]].videoRange}; not compatible with "${level.codecs}" ${currentVideoRange}`);
+            logger.trace(`[abr] Skipped level(s) ${levelsSkipped.join(',')} of ${maxAutoLevel} max with CODECS and VIDEO-RANGE:"${levels[levelsSkipped[0]].codecs}" ${levels[levelsSkipped[0]].videoRange}; not compatible with "${level.codecs}" ${currentVideoRange}`);
           }
-          this.info(`switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${currentCodecSet} videoRange:${currentVideoRange} hls.loadLevel:${loadLevel}`);
+          logger.info(`[abr] switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${currentCodecSet} videoRange:${currentVideoRange} hls.loadLevel:${loadLevel}`);
         }
         if (firstSelection) {
           this.firstSelection = i;
@@ -6967,9 +6920,8 @@ class BufferOperationQueue {
 }
 
 const VIDEO_CODEC_PROFILE_REPLACE = /(avc[1234]|hvc1|hev1|dvh[1e]|vp09|av01)(?:\.[^.,]+)+/;
-class BufferController extends Logger {
+class BufferController {
   constructor(hls) {
-    super('buffer-controller', hls.logger);
     // The level details used to determine duration, target-duration and live
     this.details = null;
     // cache the self generated object url to detect hijack of video tag
@@ -6999,6 +6951,9 @@ class BufferController extends Logger {
     this.tracks = {};
     this.pendingTracks = {};
     this.sourceBuffer = void 0;
+    this.log = void 0;
+    this.warn = void 0;
+    this.error = void 0;
     this._onEndStreaming = event => {
       if (!this.hls) {
         return;
@@ -7044,11 +6999,15 @@ class BufferController extends Logger {
         _objectUrl
       } = this;
       if (mediaSrc !== _objectUrl) {
-        this.error(`Media element src was set while attaching MediaSource (${_objectUrl} > ${mediaSrc})`);
+        logger.error(`Media element src was set while attaching MediaSource (${_objectUrl} > ${mediaSrc})`);
       }
     };
     this.hls = hls;
+    const logPrefix = '[buffer-controller]';
     this.appendSource = hls.config.preferManagedMediaSource;
+    this.log = logger.log.bind(logger, logPrefix);
+    this.warn = logger.warn.bind(logger, logPrefix);
+    this.error = logger.error.bind(logger, logPrefix);
     this._initSourceBuffer();
     this.registerListeners();
   }
@@ -7061,12 +7020,6 @@ class BufferController extends Logger {
     this.lastMpegAudioChunk = null;
     // @ts-ignore
     this.hls = null;
-    // @ts-ignore
-    this._onMediaSourceOpen = this._onMediaSourceClose = null;
-    // @ts-ignore
-    this._onMediaSourceEnded = null;
-    // @ts-ignore
-    this._onStartStreaming = this._onEndStreaming = null;
   }
   registerListeners() {
     const {
@@ -8066,7 +8019,7 @@ class CapLevelController {
         const hls = this.hls;
         const maxLevel = this.getMaxLevel(levels.length - 1);
         if (maxLevel !== this.autoLevelCapping) {
-          hls.logger.log(`Setting autoLevelCapping to ${maxLevel}: ${levels[maxLevel].height}p@${levels[maxLevel].bitrate} for media ${this.mediaWidth}x${this.mediaHeight}`);
+          logger.log(`Setting autoLevelCapping to ${maxLevel}: ${levels[maxLevel].height}p@${levels[maxLevel].bitrate} for media ${this.mediaWidth}x${this.mediaHeight}`);
         }
         hls.autoLevelCapping = maxLevel;
         if (hls.autoLevelCapping > this.autoLevelCapping && this.streamController) {
@@ -8244,10 +8197,10 @@ class FPSController {
           totalDroppedFrames: droppedFrames
         });
         if (droppedFPS > 0) {
-          // hls.logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
+          // logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
           if (currentDropped > hls.config.fpsDroppedMonitoringThreshold * currentDecoded) {
             let currentLevel = hls.currentLevel;
-            hls.logger.warn('drop FPS ratio greater than max allowed value for currentLevel: ' + currentLevel);
+            logger.warn('drop FPS ratio greater than max allowed value for currentLevel: ' + currentLevel);
             if (currentLevel > 0 && (hls.autoLevelCapping === -1 || hls.autoLevelCapping >= currentLevel)) {
               currentLevel = currentLevel - 1;
               hls.trigger(Events.FPS_DROP_LEVEL_CAPPING, {
@@ -8280,10 +8233,10 @@ class FPSController {
 }
 
 const PATHWAY_PENALTY_DURATION_MS = 300000;
-class ContentSteeringController extends Logger {
+class ContentSteeringController {
   constructor(hls) {
-    super('content-steering', hls.logger);
     this.hls = void 0;
+    this.log = void 0;
     this.loader = null;
     this.uri = null;
     this.pathwayId = '.';
@@ -8298,6 +8251,7 @@ class ContentSteeringController extends Logger {
     this.subtitleTracks = null;
     this.penalizedPathways = {};
     this.hls = hls;
+    this.log = logger.log.bind(logger, `[content-steering]:`);
     this.registerListeners();
   }
   registerListeners() {
@@ -8421,7 +8375,7 @@ class ContentSteeringController extends Logger {
         errorAction.resolved = this.pathwayId !== errorPathway;
       }
       if (!errorAction.resolved) {
-        this.warn(`Could not resolve ${data.details} ("${data.error.message}") with content-steering for Pathway: ${errorPathway} levels: ${levels ? levels.length : levels} priorities: ${JSON.stringify(pathwayPriority)} penalized: ${JSON.stringify(this.penalizedPathways)}`);
+        logger.warn(`Could not resolve ${data.details} ("${data.error.message}") with content-steering for Pathway: ${errorPathway} levels: ${levels ? levels.length : levels} priorities: ${JSON.stringify(pathwayPriority)} penalized: ${JSON.stringify(this.penalizedPathways)}`);
       }
     }
   }
@@ -8592,7 +8546,7 @@ class ContentSteeringController extends Logger {
       onSuccess: (response, stats, context, networkDetails) => {
         this.log(`Loaded steering manifest: "${url}"`);
         const steeringData = response.data;
-        if ((steeringData == null ? void 0 : steeringData.VERSION) !== 1) {
+        if (steeringData.VERSION !== 1) {
           this.log(`Steering VERSION ${steeringData.VERSION} not supported!`);
           return;
         }
@@ -9531,7 +9485,7 @@ function timelineConfig() {
 /**
  * @ignore
  */
-function mergeConfig(defaultConfig, userConfig, logger) {
+function mergeConfig(defaultConfig, userConfig) {
   if ((userConfig.liveSyncDurationCount || userConfig.liveMaxLatencyDurationCount) && (userConfig.liveSyncDuration || userConfig.liveMaxLatencyDuration)) {
     throw new Error("Illegal hls.js config: don't mix up liveSyncDurationCount/liveMaxLatencyDurationCount and liveSyncDuration/liveMaxLatencyDuration");
   }
@@ -9601,7 +9555,7 @@ function deepCpy(obj) {
 /**
  * @ignore
  */
-function enableStreamingMode(config, logger) {
+function enableStreamingMode(config) {
   const currentLoader = config.loader;
   if (currentLoader !== FetchLoader && currentLoader !== XhrLoader) {
     // If a developer has configured their own loader, respect that choice
@@ -9618,9 +9572,10 @@ function enableStreamingMode(config, logger) {
   }
 }
 
+let chromeOrFirefox;
 class LevelController extends BasePlaylistController {
   constructor(hls, contentSteeringController) {
-    super(hls, 'level-controller');
+    super(hls, '[level-controller]');
     this._levels = [];
     this._firstLevel = -1;
     this._maxAutoLevel = -1;
@@ -9691,15 +9646,23 @@ class LevelController extends BasePlaylistController {
     let videoCodecFound = false;
     let audioCodecFound = false;
     data.levels.forEach(levelParsed => {
-      var _videoCodec;
+      var _audioCodec, _videoCodec;
       const attributes = levelParsed.attrs;
+
+      // erase audio codec info if browser does not support mp4a.40.34.
+      // demuxer will autodetect codec and fallback to mpeg/audio
       let {
         audioCodec,
         videoCodec
       } = levelParsed;
+      if (((_audioCodec = audioCodec) == null ? void 0 : _audioCodec.indexOf('mp4a.40.34')) !== -1) {
+        chromeOrFirefox || (chromeOrFirefox = /chrome|firefox/i.test(navigator.userAgent));
+        if (chromeOrFirefox) {
+          levelParsed.audioCodec = audioCodec = undefined;
+        }
+      }
       if (audioCodec) {
-        // Returns empty and set to undefined for 'mp4a.40.34' with fallback to 'audio/mpeg' SourceBuffer
-        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource) || undefined;
+        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource);
       }
       if (((_videoCodec = videoCodec) == null ? void 0 : _videoCodec.indexOf('avc1')) === 0) {
         videoCodec = levelParsed.videoCodec = convertAVC1ToAVCOTI(videoCodec);
@@ -10827,8 +10790,8 @@ function createLoaderContext(frag, part = null) {
     var _frag$decryptdata;
     let byteRangeStart = start;
     let byteRangeEnd = end;
-    if (frag.sn === 'initSegment' && isMethodFullSegmentAesCbc((_frag$decryptdata = frag.decryptdata) == null ? void 0 : _frag$decryptdata.method)) {
-      // MAP segment encrypted with method 'AES-128' or 'AES-256' (cbc), when served with HTTP Range,
+    if (frag.sn === 'initSegment' && ((_frag$decryptdata = frag.decryptdata) == null ? void 0 : _frag$decryptdata.method) === 'AES-128') {
+      // MAP segment encrypted with method 'AES-128', when served with HTTP Range,
       // has the unencrypted size specified in the range.
       // Ref: https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-6.3.6
       const fragmentLen = end - start;
@@ -10861,9 +10824,6 @@ function createGapLoadError(frag, part) {
   (part ? part : frag).stats.aborted = true;
   return new LoadError(errorData);
 }
-function isMethodFullSegmentAesCbc(method) {
-  return method === 'AES-128' || method === 'AES-256';
-}
 class LoadError extends Error {
   constructor(data) {
     super(data.error.message);
@@ -11009,8 +10969,6 @@ class KeyLoader {
         }
         return this.loadKeyEME(keyInfo, frag);
       case 'AES-128':
-      case 'AES-256':
-      case 'AES-256-CTR':
         return this.loadKeyHTTP(keyInfo, frag);
       default:
         return Promise.reject(this.createKeyLoadError(frag, ErrorDetails.KEY_LOAD_ERROR, new Error(`Key supplied with unsupported METHOD: "${decryptdata.method}"`)));
@@ -11146,9 +11104,8 @@ class KeyLoader {
  * we are limiting the task execution per call stack to exactly one, but scheduling/post-poning further
  * task processing on the next main loop iteration (also known as "next tick" in the Node/JS runtime lingo).
  */
-class TaskLoop extends Logger {
-  constructor(label, logger) {
-    super(label, logger);
+class TaskLoop {
+  constructor() {
     this._boundTick = void 0;
     this._tickTimer = null;
     this._tickInterval = null;
@@ -11416,61 +11373,33 @@ function alignMediaPlaylistByPDT(details, refDetails) {
 }
 
 class AESCrypto {
-  constructor(subtle, iv, aesMode) {
+  constructor(subtle, iv) {
     this.subtle = void 0;
     this.aesIV = void 0;
-    this.aesMode = void 0;
     this.subtle = subtle;
     this.aesIV = iv;
-    this.aesMode = aesMode;
   }
   decrypt(data, key) {
-    switch (this.aesMode) {
-      case DecrypterAesMode.cbc:
-        return this.subtle.decrypt({
-          name: 'AES-CBC',
-          iv: this.aesIV
-        }, key, data);
-      case DecrypterAesMode.ctr:
-        return this.subtle.decrypt({
-          name: 'AES-CTR',
-          counter: this.aesIV,
-          length: 64
-        },
-        //64 : NIST SP800-38A standard suggests that the counter should occupy half of the counter block
-        key, data);
-      default:
-        throw new Error(`[AESCrypto] invalid aes mode ${this.aesMode}`);
-    }
+    return this.subtle.decrypt({
+      name: 'AES-CBC',
+      iv: this.aesIV
+    }, key, data);
   }
 }
 
 class FastAESKey {
-  constructor(subtle, key, aesMode) {
+  constructor(subtle, key) {
     this.subtle = void 0;
     this.key = void 0;
-    this.aesMode = void 0;
     this.subtle = subtle;
     this.key = key;
-    this.aesMode = aesMode;
   }
   expandKey() {
-    const subtleAlgoName = getSubtleAlgoName(this.aesMode);
     return this.subtle.importKey('raw', this.key, {
-      name: subtleAlgoName
+      name: 'AES-CBC'
     }, false, ['encrypt', 'decrypt']);
   }
 }
-function getSubtleAlgoName(aesMode) {
-  switch (aesMode) {
-    case DecrypterAesMode.cbc:
-      return 'AES-CBC';
-    case DecrypterAesMode.ctr:
-      return 'AES-CTR';
-    default:
-      throw new Error(`[FastAESKey] invalid aes mode ${aesMode}`);
-  }
-}
 
 // PKCS7
 function removePadding(array) {
@@ -11720,8 +11649,7 @@ class Decrypter {
     this.currentIV = null;
     this.currentResult = null;
     this.useSoftware = void 0;
-    this.enableSoftwareAES = void 0;
-    this.enableSoftwareAES = config.enableSoftwareAES;
+    this.useSoftware = config.enableSoftwareAES;
     this.removePKCS7Padding = removePKCS7Padding;
     // built in decryptor expects PKCS7 padding
     if (removePKCS7Padding) {
@@ -11734,7 +11662,9 @@ class Decrypter {
         /* no-op */
       }
     }
-    this.useSoftware = this.subtle === null;
+    if (this.subtle === null) {
+      this.useSoftware = true;
+    }
   }
   destroy() {
     this.subtle = null;
@@ -11772,10 +11702,10 @@ class Decrypter {
       this.softwareDecrypter = null;
     }
   }
-  decrypt(data, key, iv, aesMode) {
+  decrypt(data, key, iv) {
     if (this.useSoftware) {
       return new Promise((resolve, reject) => {
-        this.softwareDecrypt(new Uint8Array(data), key, iv, aesMode);
+        this.softwareDecrypt(new Uint8Array(data), key, iv);
         const decryptResult = this.flush();
         if (decryptResult) {
           resolve(decryptResult.buffer);
@@ -11784,21 +11714,17 @@ class Decrypter {
         }
       });
     }
-    return this.webCryptoDecrypt(new Uint8Array(data), key, iv, aesMode);
+    return this.webCryptoDecrypt(new Uint8Array(data), key, iv);
   }
 
   // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
   // data is handled in the flush() call
-  softwareDecrypt(data, key, iv, aesMode) {
+  softwareDecrypt(data, key, iv) {
     const {
       currentIV,
       currentResult,
       remainderData
     } = this;
-    if (aesMode !== DecrypterAesMode.cbc || key.byteLength !== 16) {
-      logger.warn('SoftwareDecrypt: can only handle AES-128-CBC');
-      return null;
-    }
     this.logOnce('JS AES decrypt');
     // The output is staggered during progressive parsing - the current result is cached, and emitted on the next call
     // This is done in order to strip PKCS7 padding, which is found at the end of each segment. We only know we've reached
@@ -11831,11 +11757,11 @@ class Decrypter {
     }
     return result;
   }
-  webCryptoDecrypt(data, key, iv, aesMode) {
+  webCryptoDecrypt(data, key, iv) {
     const subtle = this.subtle;
     if (this.key !== key || !this.fastAesKey) {
       this.key = key;
-      this.fastAesKey = new FastAESKey(subtle, key, aesMode);
+      this.fastAesKey = new FastAESKey(subtle, key);
     }
     return this.fastAesKey.expandKey().then(aesKey => {
       // decrypt using web crypto
@@ -11843,25 +11769,22 @@ class Decrypter {
         return Promise.reject(new Error('web crypto not initialized'));
       }
       this.logOnce('WebCrypto AES decrypt');
-      const crypto = new AESCrypto(subtle, new Uint8Array(iv), aesMode);
+      const crypto = new AESCrypto(subtle, new Uint8Array(iv));
       return crypto.decrypt(data.buffer, aesKey);
     }).catch(err => {
       logger.warn(`[decrypter]: WebCrypto Error, disable WebCrypto API, ${err.name}: ${err.message}`);
-      return this.onWebCryptoError(data, key, iv, aesMode);
+      return this.onWebCryptoError(data, key, iv);
     });
   }
-  onWebCryptoError(data, key, iv, aesMode) {
-    const enableSoftwareAES = this.enableSoftwareAES;
-    if (enableSoftwareAES) {
-      this.useSoftware = true;
-      this.logEnabled = true;
-      this.softwareDecrypt(data, key, iv, aesMode);
-      const decryptResult = this.flush();
-      if (decryptResult) {
-        return decryptResult.buffer;
-      }
+  onWebCryptoError(data, key, iv) {
+    this.useSoftware = true;
+    this.logEnabled = true;
+    this.softwareDecrypt(data, key, iv);
+    const decryptResult = this.flush();
+    if (decryptResult) {
+      return decryptResult.buffer;
     }
-    throw new Error('WebCrypto' + (enableSoftwareAES ? ' and softwareDecrypt' : '') + ': failed to decrypt data');
+    throw new Error('WebCrypto and softwareDecrypt: failed to decrypt data');
   }
   getValidChunk(data) {
     let currentChunk = data;
@@ -11912,7 +11835,7 @@ const State = {
 };
 class BaseStreamController extends TaskLoop {
   constructor(hls, fragmentTracker, keyLoader, logPrefix, playlistType) {
-    super(logPrefix, hls.logger);
+    super();
     this.hls = void 0;
     this.fragPrevious = null;
     this.fragCurrent = null;
@@ -11937,88 +11860,22 @@ class BaseStreamController extends TaskLoop {
     this.startFragRequested = false;
     this.decrypter = void 0;
     this.initPTS = [];
-    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;
-      }
-
-      // in case seeking occurs although no media buffered, adjust startPosition and nextLoadPosition to seek target
-      if (!this.loadedmetadata && !bufferInfo.len) {
-        this.nextLoadPosition = this.startPosition = currentTime;
-      }
-
-      // Async tick to speed up processing
-      this.tickImmediate();
-    };
-    this.onMediaEnded = () => {
-      // reset startPosition and lastCurrentTime to restart playback @ stream beginning
-      this.startPosition = this.lastCurrentTime = 0;
-      if (this.playlistType === PlaylistLevelType.MAIN) {
-        this.hls.trigger(Events.MEDIA_ENDED, {
-          stalled: false
-        });
-      }
-    };
+    this.onvseeking = null;
+    this.onvended = null;
+    this.logPrefix = '';
+    this.log = void 0;
+    this.warn = void 0;
     this.playlistType = playlistType;
+    this.logPrefix = logPrefix;
+    this.log = logger.log.bind(logger, `${logPrefix}:`);
+    this.warn = logger.warn.bind(logger, `${logPrefix}:`);
     this.hls = hls;
     this.fragmentLoader = new FragmentLoader(hls.config);
     this.keyLoader = keyLoader;
     this.fragmentTracker = fragmentTracker;
     this.config = hls.config;
     this.decrypter = new Decrypter(hls.config);
-  }
-  registerListeners() {
-    const {
-      hls
-    } = this;
-    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
-    hls.on(Events.ERROR, this.onError, this);
-  }
-  unregisterListeners() {
-    const {
-      hls
-    } = this;
-    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
-    hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
-    hls.off(Events.ERROR, this.onError, this);
   }
   doTick() {
     this.onTickEnd();
@@ -12072,8 +11929,10 @@ class BaseStreamController extends TaskLoop {
   }
   onMediaAttached(event, data) {
     const media = this.media = this.mediaBuffer = data.media;
-    media.addEventListener('seeking', this.onMediaSeeking);
-    media.addEventListener('ended', this.onMediaEnded);
+    this.onvseeking = this.onMediaSeeking.bind(this);
+    this.onvended = this.onMediaEnded.bind(this);
+    media.addEventListener('seeking', this.onvseeking);
+    media.addEventListener('ended', this.onvended);
     const config = this.config;
     if (this.levels && config.autoStartLoad && this.state === State.STOPPED) {
       this.startLoad(config.startPosition);
@@ -12087,9 +11946,10 @@ class BaseStreamController extends TaskLoop {
     }
 
     // remove video listeners
-    if (media) {
-      media.removeEventListener('seeking', this.onMediaSeeking);
-      media.removeEventListener('ended', this.onMediaEnded);
+    if (media && this.onvseeking && this.onvended) {
+      media.removeEventListener('seeking', this.onvseeking);
+      media.removeEventListener('ended', this.onvended);
+      this.onvseeking = this.onvended = null;
     }
     if (this.keyLoader) {
       this.keyLoader.detach();
@@ -12099,8 +11959,56 @@ class BaseStreamController extends TaskLoop {
     this.fragmentTracker.removeAllFragments();
     this.stopLoad();
   }
-  onManifestLoading() {}
-  onError(event, data) {}
+  onMediaSeeking() {
+    const {
+      config,
+      fragCurrent,
+      media,
+      mediaBuffer,
+      state
+    } = this;
+    const currentTime = media ? media.currentTime : 0;
+    const bufferInfo = BufferHelper.bufferInfo(mediaBuffer ? mediaBuffer : media, currentTime, config.maxBufferHole);
+    this.log(`media seeking to ${isFiniteNumber(currentTime) ? currentTime.toFixed(3) : currentTime}, state: ${state}`);
+    if (this.state === State.ENDED) {
+      this.resetLoadingState();
+    } else if (fragCurrent) {
+      // Seeking while frag load is in progress
+      const tolerance = config.maxFragLookUpTolerance;
+      const fragStartOffset = fragCurrent.start - tolerance;
+      const fragEndOffset = fragCurrent.start + fragCurrent.duration + tolerance;
+      // if seeking out of buffered range or into new one
+      if (!bufferInfo.len || fragEndOffset < bufferInfo.start || fragStartOffset > bufferInfo.end) {
+        const pastFragment = currentTime > fragEndOffset;
+        // if the seek position is outside the current fragment range
+        if (currentTime < fragStartOffset || pastFragment) {
+          if (pastFragment && fragCurrent.loader) {
+            this.log('seeking outside of buffer while fragment load in progress, cancel fragment load');
+            fragCurrent.abortRequests();
+            this.resetLoadingState();
+          }
+          this.fragPrevious = null;
+        }
+      }
+    }
+    if (media) {
+      // Remove gap fragments
+      this.fragmentTracker.removeFragmentsInRange(currentTime, Infinity, this.playlistType, true);
+      this.lastCurrentTime = currentTime;
+    }
+
+    // in case seeking occurs although no media buffered, adjust startPosition and nextLoadPosition to seek target
+    if (!this.loadedmetadata && !bufferInfo.len) {
+      this.nextLoadPosition = this.startPosition = currentTime;
+    }
+
+    // Async tick to speed up processing
+    this.tickImmediate();
+  }
+  onMediaEnded() {
+    // reset startPosition and lastCurrentTime to restart playback @ stream beginning
+    this.startPosition = this.lastCurrentTime = 0;
+  }
   onManifestLoaded(event, data) {
     this.startTimeOffset = data.startTimeOffset;
     this.initPTS = [];
@@ -12110,7 +12018,7 @@ class BaseStreamController extends TaskLoop {
     this.stopLoad();
     super.onHandlerDestroying();
     // @ts-ignore
-    this.hls = this.onMediaSeeking = this.onMediaEnded = null;
+    this.hls = null;
   }
   onHandlerDestroyed() {
     this.state = State.STOPPED;
@@ -12241,10 +12149,10 @@ class BaseStreamController extends TaskLoop {
       const decryptData = frag.decryptdata;
 
       // check to see if the payload needs to be decrypted
-      if (payload && payload.byteLength > 0 && decryptData != null && decryptData.key && decryptData.iv && isFullSegmentEncryption(decryptData.method)) {
+      if (payload && payload.byteLength > 0 && decryptData != null && decryptData.key && decryptData.iv && decryptData.method === 'AES-128') {
         const startTime = self.performance.now();
         // decrypt init segment data
-        return this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer, getAesModeFromFullSegmentMethod(decryptData.method)).catch(err => {
+        return this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer).catch(err => {
           hls.trigger(Events.ERROR, {
             type: ErrorTypes.MEDIA_ERROR,
             details: ErrorDetails.FRAG_DECRYPT_ERROR,
@@ -12356,7 +12264,7 @@ class BaseStreamController extends TaskLoop {
     }
     let keyLoadingPromise = null;
     if (frag.encrypted && !((_frag$decryptdata = frag.decryptdata) != null && _frag$decryptdata.key)) {
-      this.log(`Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'} ${frag.level}`);
+      this.log(`Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${this.logPrefix === '[stream-controller]' ? 'level' : 'track'} ${frag.level}`);
       this.state = State.KEY_LOADING;
       this.fragCurrent = frag;
       keyLoadingPromise = this.keyLoader.load(frag).then(keyLoadedData => {
@@ -12387,7 +12295,7 @@ class BaseStreamController extends TaskLoop {
         const partIndex = this.getNextPart(partList, frag, targetBufferTime);
         if (partIndex > -1) {
           const part = partList[partIndex];
-          this.log(`Loading part sn: ${frag.sn} p: ${part.index} cc: ${frag.cc} of playlist [${details.startSN}-${details.endSN}] parts [0-${partIndex}-${partList.length - 1}] ${this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
+          this.log(`Loading part sn: ${frag.sn} p: ${part.index} cc: ${frag.cc} of playlist [${details.startSN}-${details.endSN}] parts [0-${partIndex}-${partList.length - 1}] ${this.logPrefix === '[stream-controller]' ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
           this.nextLoadPosition = part.start + part.duration;
           this.state = State.FRAG_LOADING;
           let _result;
@@ -12416,7 +12324,7 @@ class BaseStreamController extends TaskLoop {
         }
       }
     }
-    this.log(`Loading fragment ${frag.sn} cc: ${frag.cc} ${details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : ''}${this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
+    this.log(`Loading fragment ${frag.sn} cc: ${frag.cc} ${details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : ''}${this.logPrefix === '[stream-controller]' ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
     // Don't update nextLoadPosition for fragments which are not buffered
     if (isFiniteNumber(frag.sn) && !this.bitrateTest) {
       this.nextLoadPosition = frag.start + frag.duration;
@@ -13001,7 +12909,7 @@ class BaseStreamController extends TaskLoop {
           errorAction.resolved = true;
         }
       } else {
-        this.warn(`${data.details} reached or exceeded max retry (${retryCount})`);
+        logger.warn(`${data.details} reached or exceeded max retry (${retryCount})`);
         return;
       }
     } else if ((errorAction == null ? void 0 : errorAction.action) === NetworkErrorAction.SendAlternateToPenaltyBox) {
@@ -13396,7 +13304,6 @@ const initPTSFn = (timestamp, timeOffset, initPTS) => {
  */
 function getAudioConfig(observer, data, offset, audioCodec) {
   let adtsObjectType;
-  let originalAdtsObjectType;
   let adtsExtensionSamplingIndex;
   let adtsChannelConfig;
   let config;
@@ -13404,7 +13311,7 @@ function getAudioConfig(observer, data, offset, audioCodec) {
   const manifestCodec = audioCodec;
   const adtsSamplingRates = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
   // byte 2
-  adtsObjectType = originalAdtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
+  adtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
   const adtsSamplingIndex = (data[offset + 2] & 0x3c) >>> 2;
   if (adtsSamplingIndex > adtsSamplingRates.length - 1) {
     const error = new Error(`invalid ADTS sampling index:${adtsSamplingIndex}`);
@@ -13421,8 +13328,8 @@ function getAudioConfig(observer, data, offset, audioCodec) {
   // byte 3
   adtsChannelConfig |= (data[offset + 3] & 0xc0) >>> 6;
   logger.log(`manifest codec:${audioCodec}, ADTS type:${adtsObjectType}, samplingIndex:${adtsSamplingIndex}`);
-  // Firefox and Pale Moon: freq less than 24kHz = AAC SBR (HE-AAC)
-  if (/firefox|palemoon/i.test(userAgent)) {
+  // firefox: freq less than 24kHz = AAC SBR (HE-AAC)
+  if (/firefox/i.test(userAgent)) {
     if (adtsSamplingIndex >= 6) {
       adtsObjectType = 5;
       config = new Array(4);
@@ -13516,7 +13423,6 @@ function getAudioConfig(observer, data, offset, audioCodec) {
     samplerate: adtsSamplingRates[adtsSamplingIndex],
     channelCount: adtsChannelConfig,
     codec: 'mp4a.40.' + adtsObjectType,
-    parsedCodec: 'mp4a.40.' + originalAdtsObjectType,
     manifestCodec
   };
 }
@@ -13571,8 +13477,7 @@ function initTrackConfig(track, observer, data, offset, audioCodec) {
     track.channelCount = config.channelCount;
     track.codec = config.codec;
     track.manifestCodec = config.manifestCodec;
-    track.parsedCodec = config.parsedCodec;
-    logger.log(`parsed codec:${track.parsedCodec}, codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`);
+    logger.log(`parsed codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`);
   }
 }
 function getFrameDuration(samplerate) {
@@ -14635,7 +14540,7 @@ class SampleAesDecrypter {
     });
   }
   decryptBuffer(encryptedData) {
-    return this.decrypter.decrypt(encryptedData, this.keyData.key.buffer, this.keyData.iv.buffer, DecrypterAesMode.cbc);
+    return this.decrypter.decrypt(encryptedData, this.keyData.key.buffer, this.keyData.iv.buffer);
   }
 
   // AAC - encrypt all full 16 bytes blocks starting from offset 16
@@ -16552,24 +16457,12 @@ class MP4Remuxer {
             inputSamples[0].dts = firstDTS;
             inputSamples[0].pts = firstPTS;
           } else {
-            let isPTSOrderRetained = true;
             for (let i = 0; i < inputSamples.length; i++) {
-              if (inputSamples[i].dts > firstPTS && isPTSOrderRetained) {
+              if (inputSamples[i].dts > firstPTS) {
                 break;
               }
-              const prevPTS = inputSamples[i].pts;
               inputSamples[i].dts -= delta;
               inputSamples[i].pts -= delta;
-
-              // check to see if this sample's PTS order has changed
-              // relative to the next one
-              if (i < inputSamples.length - 1) {
-                const nextSamplePTS = inputSamples[i + 1].pts;
-                const currentSamplePTS = inputSamples[i].pts;
-                const currentOrder = nextSamplePTS <= currentSamplePTS;
-                const prevOrder = nextSamplePTS <= prevPTS;
-                isPTSOrderRetained = currentOrder == prevOrder;
-              }
             }
           }
           logger.log(`Video: Initial PTS/DTS adjusted: ${toMsFromMpegTsClock(firstPTS, true)}/${toMsFromMpegTsClock(firstDTS, true)}, delta: ${toMsFromMpegTsClock(delta, true)} ms`);
@@ -16850,7 +16743,7 @@ class MP4Remuxer {
           logger.warn(`[mp4-remuxer]: Injecting ${missing} audio frame @ ${(nextPts / inputTimeScale).toFixed(3)}s due to ${Math.round(1000 * delta / inputTimeScale)} ms gap.`);
           for (let j = 0; j < missing; j++) {
             const newStamp = Math.max(nextPts, 0);
-            let fillFrame = AAC.getSilentFrame(track.parsedCodec || track.manifestCodec || track.codec, track.channelCount);
+            let fillFrame = AAC.getSilentFrame(track.manifestCodec || track.codec, track.channelCount);
             if (!fillFrame) {
               logger.log('[mp4-remuxer]: Unable to get silent frame for given audio codec; duplicating last frame instead.');
               fillFrame = sample.unit.subarray();
@@ -16978,7 +16871,7 @@ class MP4Remuxer {
     // samples count of this segment's duration
     const nbSamples = Math.ceil((endDTS - startDTS) / frameDuration);
     // silent frame
-    const silentFrame = AAC.getSilentFrame(track.parsedCodec || track.manifestCodec || track.codec, track.channelCount);
+    const silentFrame = AAC.getSilentFrame(track.manifestCodec || track.codec, track.channelCount);
     logger.warn('[mp4-remuxer]: remux empty Audio');
     // Can't remux if we can't generate a silent frame...
     if (!silentFrame) {
@@ -17369,15 +17262,13 @@ class Transmuxer {
       initSegmentData
     } = transmuxConfig;
     const keyData = getEncryptionType(uintData, decryptdata);
-    if (keyData && isFullSegmentEncryption(keyData.method)) {
+    if (keyData && keyData.method === 'AES-128') {
       const decrypter = this.getDecrypter();
-      const aesMode = getAesModeFromFullSegmentMethod(keyData.method);
-
       // Software decryption is synchronous; webCrypto is not
       if (decrypter.isSync()) {
         // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
         // data is handled in the flush() call
-        let decryptedData = decrypter.softwareDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode);
+        let decryptedData = decrypter.softwareDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer);
         // For Low-Latency HLS Parts, decrypt in place, since part parsing is expected on push progress
         const loadingParts = chunkMeta.part > -1;
         if (loadingParts) {
@@ -17389,7 +17280,7 @@ class Transmuxer {
         }
         uintData = new Uint8Array(decryptedData);
       } else {
-        this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode).then(decryptedData => {
+        this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer).then(decryptedData => {
           // Calling push here is important; if flush() is called while this is still resolving, this ensures that
           // the decrypted data has been transmuxed
           const result = this.push(decryptedData, null, chunkMeta);
@@ -18043,7 +17934,14 @@ class TransmuxerInterface {
     this.observer = new EventEmitter();
     this.observer.on(Events.FRAG_DECRYPTED, forwardMessage);
     this.observer.on(Events.ERROR, forwardMessage);
-    const m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
+    const MediaSource = getMediaSource(config.preferManagedMediaSource) || {
+      isTypeSupported: () => false
+    };
+    const m2tsTypeSupported = {
+      mpeg: MediaSource.isTypeSupported('audio/mpeg'),
+      mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
+      ac3: false
+    };
 
     // navigator.vendor is not always available in Web Worker
     // refer to https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/navigator
@@ -18307,9 +18205,8 @@ const STALL_MINIMUM_DURATION_MS = 250;
 const MAX_START_GAP_JUMP = 2.0;
 const SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
 const SKIP_BUFFER_RANGE_START = 0.05;
-class GapController extends Logger {
+class GapController {
   constructor(config, media, fragmentTracker, hls) {
-    super('gap-controller', hls.logger);
     this.config = void 0;
     this.media = null;
     this.fragmentTracker = void 0;
@@ -18319,7 +18216,6 @@ class GapController extends Logger {
     this.stalled = null;
     this.moved = false;
     this.seeking = false;
-    this.ended = 0;
     this.config = config;
     this.media = media;
     this.fragmentTracker = fragmentTracker;
@@ -18337,7 +18233,7 @@ class GapController extends Logger {
    *
    * @param lastCurrentTime - Previously read playhead position
    */
-  poll(lastCurrentTime, activeFrag, levelDetails, state) {
+  poll(lastCurrentTime, activeFrag) {
     const {
       config,
       media,
@@ -18356,7 +18252,6 @@ class GapController extends Logger {
 
     // The playhead is moving, no-op
     if (currentTime !== lastCurrentTime) {
-      this.ended = 0;
       this.moved = true;
       if (!seeking) {
         this.nudgeRetry = 0;
@@ -18365,7 +18260,7 @@ class GapController extends Logger {
         // The playhead is now moving, but was previously stalled
         if (this.stallReported) {
           const _stalledDuration = self.performance.now() - stalled;
-          this.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(_stalledDuration)}ms`);
+          logger.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(_stalledDuration)}ms`);
           this.stallReported = false;
         }
         this.stalled = null;
@@ -18401,6 +18296,7 @@ class GapController extends Logger {
     // Skip start gaps if we haven't played, but the last poll detected the start of a stall
     // The addition poll gives the browser a chance to jump the gap for us
     if (!this.moved && this.stalled !== null) {
+      var _level$details;
       // There is no playable buffer (seeked, waiting for buffer)
       const isBuffered = bufferInfo.len > 0;
       if (!isBuffered && !nextStart) {
@@ -18412,8 +18308,9 @@ class GapController extends Logger {
       // When joining a live stream with audio tracks, account for live playlist window sliding by allowing
       // a larger jump over start gaps caused by the audio-stream-controller buffering a start fragment
       // that begins over 1 target duration after the video start position.
-      const isLive = !!(levelDetails != null && levelDetails.live);
-      const maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
+      const level = this.hls.levels ? this.hls.levels[this.hls.currentLevel] : null;
+      const isLive = level == null ? void 0 : (_level$details = level.details) == null ? void 0 : _level$details.live;
+      const maxStartGapJump = isLive ? level.details.targetduration * 2 : MAX_START_GAP_JUMP;
       const partialOrGap = this.fragmentTracker.getPartialFragment(currentTime);
       if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
         if (!media.paused) {
@@ -18431,17 +18328,6 @@ class GapController extends Logger {
     }
     const stalledDuration = tnow - stalled;
     if (!seeking && stalledDuration >= STALL_MINIMUM_DURATION_MS) {
-      // Dispatch MEDIA_ENDED when media.ended/ended event is not signalled at end of stream
-      if (state === State.ENDED && !(levelDetails && levelDetails.live) && Math.abs(currentTime - ((levelDetails == null ? void 0 : levelDetails.edge) || 0)) < 1) {
-        if (stalledDuration < 1000 || this.ended) {
-          return;
-        }
-        this.ended = currentTime;
-        this.hls.trigger(Events.MEDIA_ENDED, {
-          stalled: true
-        });
-        return;
-      }
       // Report stalling after trying to fix
       this._reportStall(bufferInfo);
       if (!this.media) {
@@ -18485,7 +18371,7 @@ class GapController extends Logger {
     // needs to cross some sort of threshold covering all source-buffers content
     // to start playing properly.
     if ((bufferInfo.len > config.maxBufferHole || bufferInfo.nextStart && bufferInfo.nextStart - currentTime < config.maxBufferHole) && stalledDurationMs > config.highBufferWatchdogPeriod * 1000) {
-      this.warn('Trying to nudge playhead over buffer-hole');
+      logger.warn('Trying to nudge playhead over buffer-hole');
       // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
       // We only try to jump the hole if it's under the configured size
       // Reset stalled so to rearm watchdog timer
@@ -18509,7 +18395,7 @@ class GapController extends Logger {
       // Report stalled error once
       this.stallReported = true;
       const error = new Error(`Playback stalling at @${media.currentTime} due to low buffer (${JSON.stringify(bufferInfo)})`);
-      this.warn(error.message);
+      logger.warn(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -18577,7 +18463,7 @@ class GapController extends Logger {
           }
         }
         const targetTime = Math.max(startTime + SKIP_BUFFER_RANGE_START, currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS);
-        this.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
+        logger.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
         this.moved = true;
         this.stalled = null;
         media.currentTime = targetTime;
@@ -18618,7 +18504,7 @@ class GapController extends Logger {
       const targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
       // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
       const error = new Error(`Nudging 'currentTime' from ${currentTime} to ${targetTime}`);
-      this.warn(error.message);
+      logger.warn(error.message);
       media.currentTime = targetTime;
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
@@ -18628,7 +18514,7 @@ class GapController extends Logger {
       });
     } else {
       const error = new Error(`Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`);
-      this.error(error.message);
+      logger.error(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -18643,7 +18529,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;
@@ -18651,43 +18537,27 @@ class StreamController extends BaseStreamController {
     this.altAudio = false;
     this.audioOnly = false;
     this.fragPlaying = null;
+    this.onvplaying = null;
+    this.onvseeked = null;
     this.fragLastKbps = 0;
     this.couldBacktrack = false;
     this.backtrackFragment = null;
     this.audioCodecSwitch = false;
     this.videoBuffer = null;
-    this.onMediaPlaying = () => {
-      // tick to speed up FRAG_CHANGED triggering
-      this.tick();
-    };
-    this.onMediaSeeked = () => {
-      const media = this.media;
-      const currentTime = media ? media.currentTime : null;
-      if (isFiniteNumber(currentTime)) {
-        this.log(`Media seeked to ${currentTime.toFixed(3)}`);
-      }
-
-      // If seeked was issued before buffer was appended do not tick immediately
-      const bufferInfo = this.getMainFwdBufferInfo();
-      if (bufferInfo === null || bufferInfo.len === 0) {
-        this.warn(`Main forward buffer length on "seeked" event ${bufferInfo ? bufferInfo.len : 'empty'})`);
-        return;
-      }
-
-      // tick to speed up FRAG_CHANGED triggering
-      this.tick();
-    };
-    this.registerListeners();
+    this._registerListeners();
   }
-  registerListeners() {
-    super.registerListeners();
+  _registerListeners() {
     const {
       hls
     } = this;
+    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.MANIFEST_PARSED, this.onManifestParsed, this);
     hls.on(Events.LEVEL_LOADING, this.onLevelLoading, this);
     hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.on(Events.FRAG_LOAD_EMERGENCY_ABORTED, this.onFragLoadEmergencyAborted, this);
+    hls.on(Events.ERROR, this.onError, this);
     hls.on(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.on(Events.AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
     hls.on(Events.BUFFER_CREATED, this.onBufferCreated, this);
@@ -18695,14 +18565,17 @@ class StreamController extends BaseStreamController {
     hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
-  unregisterListeners() {
-    super.unregisterListeners();
+  _unregisterListeners() {
     const {
       hls
     } = this;
+    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
     hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.off(Events.FRAG_LOAD_EMERGENCY_ABORTED, this.onFragLoadEmergencyAborted, this);
+    hls.off(Events.ERROR, this.onError, this);
     hls.off(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.off(Events.AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
     hls.off(Events.BUFFER_CREATED, this.onBufferCreated, this);
@@ -18711,9 +18584,7 @@ class StreamController extends BaseStreamController {
     hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
   onHandlerDestroying() {
-    // @ts-ignore
-    this.onMediaPlaying = this.onMediaSeeked = null;
-    this.unregisterListeners();
+    this._unregisterListeners();
     super.onHandlerDestroying();
   }
   startLoad(startPosition) {
@@ -19040,17 +18911,20 @@ class StreamController extends BaseStreamController {
   onMediaAttached(event, data) {
     super.onMediaAttached(event, data);
     const media = data.media;
-    media.addEventListener('playing', this.onMediaPlaying);
-    media.addEventListener('seeked', this.onMediaSeeked);
+    this.onvplaying = this.onMediaPlaying.bind(this);
+    this.onvseeked = this.onMediaSeeked.bind(this);
+    media.addEventListener('playing', this.onvplaying);
+    media.addEventListener('seeked', this.onvseeked);
     this.gapController = new GapController(this.config, media, this.fragmentTracker, this.hls);
   }
   onMediaDetaching() {
     const {
       media
     } = this;
-    if (media) {
-      media.removeEventListener('playing', this.onMediaPlaying);
-      media.removeEventListener('seeked', this.onMediaSeeked);
+    if (media && this.onvplaying && this.onvseeked) {
+      media.removeEventListener('playing', this.onvplaying);
+      media.removeEventListener('seeked', this.onvseeked);
+      this.onvplaying = this.onvseeked = null;
       this.videoBuffer = null;
     }
     this.fragPlaying = null;
@@ -19060,6 +18934,27 @@ class StreamController extends BaseStreamController {
     }
     super.onMediaDetaching();
   }
+  onMediaPlaying() {
+    // tick to speed up FRAG_CHANGED triggering
+    this.tick();
+  }
+  onMediaSeeked() {
+    const media = this.media;
+    const currentTime = media ? media.currentTime : null;
+    if (isFiniteNumber(currentTime)) {
+      this.log(`Media seeked to ${currentTime.toFixed(3)}`);
+    }
+
+    // If seeked was issued before buffer was appended do not tick immediately
+    const bufferInfo = this.getMainFwdBufferInfo();
+    if (bufferInfo === null || bufferInfo.len === 0) {
+      this.warn(`Main forward buffer length on "seeked" event ${bufferInfo ? bufferInfo.len : 'empty'})`);
+      return;
+    }
+
+    // tick to speed up FRAG_CHANGED triggering
+    this.tick();
+  }
   onManifestLoading() {
     // reset buffer on manifest loading
     this.log('Trigger BUFFER_RESET');
@@ -19351,10 +19246,8 @@ class StreamController extends BaseStreamController {
     }
     if (this.loadedmetadata || !BufferHelper.getBuffered(media).length) {
       // Resolve gaps using the main buffer, whose ranges are the intersections of the A/V sourcebuffers
-      const state = this.state;
-      const activeFrag = state !== State.IDLE ? this.fragCurrent : null;
-      const levelDetails = this.getLevelDetails();
-      gapController.poll(this.lastCurrentTime, activeFrag, levelDetails, state);
+      const activeFrag = this.state !== State.IDLE ? this.fragCurrent : null;
+      gapController.poll(this.lastCurrentTime, activeFrag);
     }
     this.lastCurrentTime = media.currentTime;
   }
@@ -19792,7 +19685,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.2-0.canary.9934";
+    return "1.5.3";
   }
 
   /**
@@ -19855,10 +19748,6 @@ 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;
@@ -19878,11 +19767,11 @@ class Hls {
     this._media = null;
     this.url = null;
     this.triggeringException = void 0;
-    const logger = this.logger = enableLogs(userConfig.debug || false, 'Hls instance');
-    const config = this.config = mergeConfig(Hls.DefaultConfig, userConfig, logger);
+    enableLogs(userConfig.debug || false, 'Hls instance');
+    const config = this.config = mergeConfig(Hls.DefaultConfig, userConfig);
     this.userConfig = userConfig;
     if (config.progressive) {
-      enableStreamingMode(config, logger);
+      enableStreamingMode(config);
     }
 
     // core controllers and network loaders
@@ -19981,7 +19870,7 @@ class Hls {
       try {
         return this.emit(event, event, eventObject);
       } catch (error) {
-        this.logger.error('An internal error happened while handling event ' + event + '. Error message: "' + error.message + '". Here is a stacktrace:', error);
+        logger.error('An internal error happened while handling event ' + event + '. Error message: "' + error.message + '". Here is a stacktrace:', error);
         // Prevent recursion in error event handlers that throw #5497
         if (!this.triggeringException) {
           this.triggeringException = true;
@@ -20007,7 +19896,7 @@ class Hls {
    * Dispose of the instance
    */
   destroy() {
-    this.logger.log('destroy');
+    logger.log('destroy');
     this.trigger(Events.DESTROYING, undefined);
     this.detachMedia();
     this.removeAllListeners();
@@ -20028,7 +19917,7 @@ class Hls {
    * Attaches Hls.js to a media element
    */
   attachMedia(media) {
-    this.logger.log('attachMedia');
+    logger.log('attachMedia');
     this._media = media;
     this.trigger(Events.MEDIA_ATTACHING, {
       media: media
@@ -20039,7 +19928,7 @@ class Hls {
    * Detach Hls.js from the media
    */
   detachMedia() {
-    this.logger.log('detachMedia');
+    logger.log('detachMedia');
     this.trigger(Events.MEDIA_DETACHING, undefined);
     this._media = null;
   }
@@ -20056,7 +19945,7 @@ class Hls {
     });
     this._autoLevelCapping = -1;
     this._maxHdcpLevel = null;
-    this.logger.log(`loadSource:${loadingSource}`);
+    logger.log(`loadSource:${loadingSource}`);
     if (media && loadedSource && (loadedSource !== loadingSource || this.bufferController.hasSourceTypes())) {
       this.detachMedia();
       this.attachMedia(media);
@@ -20075,7 +19964,7 @@ class Hls {
    * Defaults to -1 (None: starts from earliest point)
    */
   startLoad(startPosition = -1) {
-    this.logger.log(`startLoad(${startPosition})`);
+    logger.log(`startLoad(${startPosition})`);
     this.started = true;
     this.networkControllers.forEach(controller => {
       controller.startLoad(startPosition);
@@ -20086,7 +19975,7 @@ class Hls {
    * Stop loading of any stream data.
    */
   stopLoad() {
-    this.logger.log('stopLoad');
+    logger.log('stopLoad');
     this.started = false;
     this.networkControllers.forEach(controller => {
       controller.stopLoad();
@@ -20122,7 +20011,7 @@ class Hls {
    * Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
    */
   swapAudioCodec() {
-    this.logger.log('swapAudioCodec');
+    logger.log('swapAudioCodec');
     this.streamController.swapAudioCodec();
   }
 
@@ -20133,7 +20022,7 @@ class Hls {
    * Automatic recovery of media-errors by this process is configurable.
    */
   recoverMediaError() {
-    this.logger.log('recoverMediaError');
+    logger.log('recoverMediaError');
     const media = this._media;
     this.detachMedia();
     if (media) {
@@ -20163,7 +20052,7 @@ class Hls {
    * Set quality level index immediately. This will flush the current buffer to replace the quality asap. That means playback will interrupt at least shortly to re-buffer and re-sync eventually. Set to -1 for automatic level selection.
    */
   set currentLevel(newLevel) {
-    this.logger.log(`set currentLevel:${newLevel}`);
+    logger.log(`set currentLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
     this.streamController.immediateLevelSwitch();
   }
@@ -20182,7 +20071,7 @@ class Hls {
    * @param newLevel - Pass -1 for automatic level selection
    */
   set nextLevel(newLevel) {
-    this.logger.log(`set nextLevel:${newLevel}`);
+    logger.log(`set nextLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
     this.streamController.nextLevelSwitch();
   }
@@ -20201,7 +20090,7 @@ class Hls {
    * @param newLevel - Pass -1 for automatic level selection
    */
   set loadLevel(newLevel) {
-    this.logger.log(`set loadLevel:${newLevel}`);
+    logger.log(`set loadLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
   }
 
@@ -20232,7 +20121,7 @@ class Hls {
    * Sets "first-level", see getter.
    */
   set firstLevel(newLevel) {
-    this.logger.log(`set firstLevel:${newLevel}`);
+    logger.log(`set firstLevel:${newLevel}`);
     this.levelController.firstLevel = newLevel;
   }
 
@@ -20257,7 +20146,7 @@ class Hls {
    * (determined from download of first segment)
    */
   set startLevel(newLevel) {
-    this.logger.log(`set startLevel:${newLevel}`);
+    logger.log(`set startLevel:${newLevel}`);
     // if not in automatic start level detection, ensure startLevel is greater than minAutoLevel
     if (newLevel !== -1) {
       newLevel = Math.max(newLevel, this.minAutoLevel);
@@ -20332,7 +20221,7 @@ class Hls {
    */
   set autoLevelCapping(newLevel) {
     if (this._autoLevelCapping !== newLevel) {
-      this.logger.log(`set autoLevelCapping:${newLevel}`);
+      logger.log(`set autoLevelCapping:${newLevel}`);
       this._autoLevelCapping = newLevel;
       this.levelController.checkMaxAutoUpdated();
     }