hls.js 1.5.2-0.canary.9924 → 1.5.2

package/dist/hls.light.js

@@ -476,21 +476,6 @@
     return ErrorDetails;
   }({});
 
-  var Logger = function Logger(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;
-    var 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);
-  };
   var noop = function noop() {};
   var fakeLogger = {
     trace: noop,
@@ -500,9 +485,7 @@
     info: noop,
     error: noop
   };
-  function createLogger() {
-    return _extends({}, fakeLogger);
-  }
+  var exportedLogger = fakeLogger;
 
   // let lastCallTime;
   // function formatMsgWithTimeInfo(type, msg) {
@@ -513,36 +496,38 @@
   //   return msg;
   // }
 
-  function consolePrintFn(type, id) {
+  function consolePrintFn(type) {
     var 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) {
+    for (var _len = arguments.length, functions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      functions[_key - 1] = arguments[_key];
+    }
+    functions.forEach(function (type) {
+      exportedLogger[type] = debugConfig[type] ? debugConfig[type].bind(debugConfig) : consolePrintFn(type);
+    });
   }
-  var exportedLogger = createLogger();
-  function enableLogs(debugConfig, context, id) {
+  function enableLogs(debugConfig, id) {
     // check that console is available
-    var newLogger = createLogger();
     if (typeof console === 'object' && debugConfig === true || typeof debugConfig === 'object') {
-      var keys = [
+      exportLoggerFunctions(debugConfig,
       // Remove out from list here to hard-disable a log-level
       // 'trace',
-      'debug', 'log', 'info', 'warn', 'error'];
-      keys.forEach(function (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.9924");
+        exportedLogger.log("Debug logs enabled for \"" + id + "\" in hls.js version " + "1.5.2");
       } catch (e) {
-        /* log fn threw an exception. All logger methods are no-ops. */
-        return createLogger();
+        exportedLogger = fakeLogger;
       }
+    } else {
+      exportedLogger = fakeLogger;
     }
-    exportedLogger = newLogger;
-    return newLogger;
   }
   var logger = exportedLogger;
 
@@ -1188,26 +1173,6 @@
     return 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;
@@ -2649,13 +2614,13 @@
       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';
     }
     var _proto = LevelKey.prototype;
     _proto.isSupported = function 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') {
@@ -2669,13 +2634,14 @@
       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;
         }
@@ -2837,28 +2803,23 @@
     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
     var 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 (var 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;
   }
-  var AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
+  var AUDIO_CODEC_REGEXP = /flac|opus/i;
   function getCodecCompatibleName(codec, preferManagedMediaSource) {
     if (preferManagedMediaSource === void 0) {
       preferManagedMediaSource = true;
@@ -2886,18 +2847,6 @@
     }
     return codec;
   }
-  function getM2TSSupportedAudioTypes(preferManagedMediaSource) {
-    var MediaSource = getMediaSource(preferManagedMediaSource) || {
-      isTypeSupported: function isTypeSupported() {
-        return false;
-      }
-    };
-    return {
-      mpeg: MediaSource.isTypeSupported('audio/mpeg'),
-      mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
-      ac3: false
-    };
-  }
 
   var 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;
   var MASTER_PLAYLIST_MEDIA_REGEX = /#EXT-X-MEDIA:(.*)/g;
@@ -4472,43 +4421,8 @@
       this.currentTime = 0;
       this.stallCount = 0;
       this._latency = null;
-      this.onTimeupdate = function () {
-        var media = _this.media,
-          levelDetails = _this.levelDetails;
-        if (!media || !levelDetails) {
-          return;
-        }
-        _this.currentTime = media.currentTime;
-        var latency = _this.computeLatency();
-        if (latency === null) {
-          return;
-        }
-        _this._latency = latency;
-
-        // Adapt playbackRate to meet target latency in low-latency mode
-        var _this$config = _this.config,
-          lowLatencyMode = _this$config.lowLatencyMode,
-          maxLiveSyncPlaybackRate = _this$config.maxLiveSyncPlaybackRate;
-        if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
-          return;
-        }
-        var targetLatency = _this.targetLatency;
-        if (targetLatency === null) {
-          return;
-        }
-        var 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.
-        var liveMinLatencyDuration = Math.min(_this.maxLatency, targetLatency + levelDetails.targetduration);
-        var inLiveRange = distanceFromTarget < liveMinLatencyDuration;
-        if (inLiveRange && distanceFromTarget > 0.05 && _this.forwardBufferLength > 1) {
-          var max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
-          var 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 = function () {
+        return _this.timeupdate();
       };
       this.hls = hls;
       this.config = hls.config;
@@ -4520,7 +4434,7 @@
       this.onMediaDetaching();
       this.levelDetails = null;
       // @ts-ignore
-      this.hls = null;
+      this.hls = this.timeupdateHandler = null;
     };
     _proto.registerListeners = function registerListeners() {
       this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
@@ -4538,11 +4452,11 @@
     };
     _proto.onMediaAttached = function onMediaAttached(event, data) {
       this.media = data.media;
-      this.media.addEventListener('timeupdate', this.onTimeupdate);
+      this.media.addEventListener('timeupdate', this.timeupdateHandler);
     };
     _proto.onMediaDetaching = function onMediaDetaching() {
       if (this.media) {
-        this.media.removeEventListener('timeupdate', this.onTimeupdate);
+        this.media.removeEventListener('timeupdate', this.timeupdateHandler);
         this.media = null;
       }
     };
@@ -4555,10 +4469,10 @@
       var details = _ref.details;
       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);
       }
     };
     _proto.onError = function onError(event, data) {
@@ -4568,7 +4482,45 @@
       }
       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');
+      }
+    };
+    _proto.timeupdate = function timeupdate() {
+      var media = this.media,
+        levelDetails = this.levelDetails;
+      if (!media || !levelDetails) {
+        return;
+      }
+      this.currentTime = media.currentTime;
+      var latency = this.computeLatency();
+      if (latency === null) {
+        return;
+      }
+      this._latency = latency;
+
+      // Adapt playbackRate to meet target latency in low-latency mode
+      var _this$config = this.config,
+        lowLatencyMode = _this$config.lowLatencyMode,
+        maxLiveSyncPlaybackRate = _this$config.maxLiveSyncPlaybackRate;
+      if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
+        return;
+      }
+      var targetLatency = this.targetLatency;
+      if (targetLatency === null) {
+        return;
+      }
+      var 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.
+      var liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
+      var inLiveRange = distanceFromTarget < liveMinLatencyDuration;
+      if (inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
+        var max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
+        var 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;
       }
     };
     _proto.estimateLiveEdge = function estimateLiveEdge() {
@@ -5476,17 +5428,19 @@
     MoveAllAlternatesMatchingHDCP: 2,
     SwitchToSDR: 4
   }; // Reserved for future use
-  var ErrorController = /*#__PURE__*/function (_Logger) {
-    _inheritsLoose(ErrorController, _Logger);
+  var ErrorController = /*#__PURE__*/function () {
     function ErrorController(hls) {
-      var _this;
-      _this = _Logger.call(this, 'error-controller', hls.logger) || this;
-      _this.hls = void 0;
-      _this.playlistError = 0;
-      _this.penalizedRenditions = {};
-      _this.hls = hls;
-      _this.registerListeners();
-      return _this;
+      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();
     }
     var _proto = ErrorController.prototype;
     _proto.registerListeners = function registerListeners() {
@@ -5842,19 +5796,19 @@
       }
     };
     return ErrorController;
-  }(Logger);
+  }();
 
-  var BasePlaylistController = /*#__PURE__*/function (_Logger) {
-    _inheritsLoose(BasePlaylistController, _Logger);
+  var BasePlaylistController = /*#__PURE__*/function () {
     function BasePlaylistController(hls, logPrefix) {
-      var _this;
-      _this = _Logger.call(this, logPrefix, hls.logger) || this;
-      _this.hls = void 0;
-      _this.timer = -1;
-      _this.requestScheduled = -1;
-      _this.canLoad = false;
-      _this.hls = hls;
-      return _this;
+      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;
     }
     var _proto = BasePlaylistController.prototype;
     _proto.destroy = function destroy() {
@@ -5887,7 +5841,7 @@
           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
@@ -5926,7 +5880,7 @@
       return this.timer === -1 && this.requestScheduled === -1 && this.shouldLoadPlaylist(playlist);
     };
     _proto.playlistLoaded = function playlistLoaded(index, data, previousDetails) {
-      var _this2 = this;
+      var _this = this;
       var details = data.details,
         stats = data.stats;
 
@@ -6031,7 +5985,7 @@
         // );
 
         this.timer = self.setTimeout(function () {
-          return _this2.loadPlaylist(deliveryDirectives);
+          return _this.loadPlaylist(deliveryDirectives);
         }, estimatedTimeUntilUpdate);
       } else {
         this.clearTimer();
@@ -6047,7 +6001,7 @@
       return new HlsUrlParameters(msn, part, skip);
     };
     _proto.checkRetry = function checkRetry(errorEvent) {
-      var _this3 = this;
+      var _this2 = this;
       var errorDetails = errorEvent.details;
       var isTimeout = isTimeoutError(errorEvent);
       var errorAction = errorEvent.errorAction;
@@ -6071,7 +6025,7 @@
           var delay = getRetryDelay(retryConfig, retryCount);
           // Schedule level/track reload
           this.timer = self.setTimeout(function () {
-            return _this3.loadPlaylist();
+            return _this2.loadPlaylist();
           }, delay);
           this.warn("Retrying playlist loading " + (retryCount + 1) + "/" + retryConfig.maxNumRetry + " after \"" + errorDetails + "\" in " + delay + "ms");
         }
@@ -6082,7 +6036,7 @@
       return retry;
     };
     return BasePlaylistController;
-  }(Logger);
+  }();
 
   /*
    * compute an Exponential Weighted moving average
@@ -6456,33 +6410,30 @@
     }, {});
   }
 
-  var AbrController = /*#__PURE__*/function (_Logger) {
-    _inheritsLoose(AbrController, _Logger);
+  var AbrController = /*#__PURE__*/function () {
     function AbrController(_hls) {
-      var _this;
-      _this = _Logger.call(this, 'abr', _hls.logger) || this;
-      _this.hls = void 0;
-      _this.lastLevelLoadSec = 0;
-      _this.lastLoadedFragLevel = -1;
-      _this.firstSelection = -1;
-      _this._nextAutoLevel = -1;
-      _this.nextAutoLevelKey = '';
-      _this.audioTracksByGroup = null;
-      _this.codecTiers = null;
-      _this.timer = -1;
-      _this.fragCurrent = null;
-      _this.partCurrent = null;
-      _this.bitrateTestDelay = 0;
-      _this.bwEstimator = void 0;
+      var _this = this;
+      this.hls = void 0;
+      this.lastLevelLoadSec = 0;
+      this.lastLoadedFragLevel = -1;
+      this.firstSelection = -1;
+      this._nextAutoLevel = -1;
+      this.nextAutoLevelKey = '';
+      this.audioTracksByGroup = null;
+      this.codecTiers = null;
+      this.timer = -1;
+      this.fragCurrent = null;
+      this.partCurrent = null;
+      this.bitrateTestDelay = 0;
+      this.bwEstimator = void 0;
       /*
           This method monitors the download rate of the current fragment, and will downswitch if that fragment will not load
           quickly enough to prevent underbuffering
         */
-      _this._abandonRulesCheck = function () {
-        var _assertThisInitialize = _assertThisInitialized(_this),
-          frag = _assertThisInitialize.fragCurrent,
-          part = _assertThisInitialize.partCurrent,
-          hls = _assertThisInitialize.hls;
+      this._abandonRulesCheck = function () {
+        var frag = _this.fragCurrent,
+          part = _this.partCurrent,
+          hls = _this.hls;
         var autoLevelEnabled = hls.autoLevelEnabled,
           media = hls.media;
         if (!frag || !media) {
@@ -6523,7 +6474,7 @@
         var bwEstimate = _this.getBwEstimate();
         var levels = hls.levels;
         var level = levels[frag.level];
-        var expectedLen = stats.total || Math.max(stats.loaded, Math.round(duration * level.maxBitrate / 8));
+        var expectedLen = stats.total || Math.max(stats.loaded, Math.round(duration * level.averageBitrate / 8));
         var timeStreaming = loadedFirstByte ? timeLoading - ttfb : timeLoading;
         if (timeStreaming < 1 && loadedFirstByte) {
           timeStreaming = Math.min(timeLoading, stats.loaded * 8 / bwEstimate);
@@ -6566,27 +6517,26 @@
           // If there has been no loading progress, sample TTFB
           _this.bwEstimator.sampleTTFB(timeLoading);
         }
-        var nextLoadLevelBitrate = levels[nextLoadLevel].bitrate;
+        var nextLoadLevelBitrate = levels[nextLoadLevel].maxBitrate;
         if (_this.getBwEstimate() * _this.hls.config.abrBandWidthUpFactor > nextLoadLevelBitrate) {
           _this.resetEstimator(nextLoadLevelBitrate);
         }
         _this.clearTimer();
-        _this.warn("Fragment " + frag.sn + (part ? ' part ' + part.index : '') + " of level " + frag.level + " is loading too slowly;\n      Time to underbuffer: " + bufferStarvationDelay.toFixed(3) + " s\n      Estimated load time for current fragment: " + fragLoadedDelay.toFixed(3) + " s\n      Estimated load time for down switch fragment: " + fragLevelNextLoadedDelay.toFixed(3) + " s\n      TTFB estimate: " + (ttfb | 0) + " ms\n      Current BW estimate: " + (isFiniteNumber(bwEstimate) ? bwEstimate | 0 : 'Unknown') + " bps\n      New BW estimate: " + (_this.getBwEstimate() | 0) + " bps\n      Switching to level " + nextLoadLevel + " @ " + (nextLoadLevelBitrate | 0) + " bps");
+        logger.warn("[abr] Fragment " + frag.sn + (part ? ' part ' + part.index : '') + " of level " + frag.level + " is loading too slowly;\n      Time to underbuffer: " + bufferStarvationDelay.toFixed(3) + " s\n      Estimated load time for current fragment: " + fragLoadedDelay.toFixed(3) + " s\n      Estimated load time for down switch fragment: " + fragLevelNextLoadedDelay.toFixed(3) + " s\n      TTFB estimate: " + (ttfb | 0) + " ms\n      Current BW estimate: " + (isFiniteNumber(bwEstimate) ? bwEstimate | 0 : 'Unknown') + " bps\n      New BW estimate: " + (_this.getBwEstimate() | 0) + " bps\n      Switching to level " + nextLoadLevel + " @ " + (nextLoadLevelBitrate | 0) + " bps");
         hls.trigger(Events.FRAG_LOAD_EMERGENCY_ABORTED, {
           frag: frag,
           part: part,
           stats: stats
         });
       };
-      _this.hls = _hls;
-      _this.bwEstimator = _this.initEstimator();
-      _this.registerListeners();
-      return _this;
+      this.hls = _hls;
+      this.bwEstimator = this.initEstimator();
+      this.registerListeners();
     }
     var _proto = AbrController.prototype;
     _proto.resetEstimator = function 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;
@@ -6838,13 +6788,13 @@
           // cap maxLoadingDelay and ensure it is not bigger 'than bitrate test' frag duration
           var 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;
         }
       }
       var 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;
       }
@@ -6900,7 +6850,7 @@
         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;
@@ -6953,9 +6903,9 @@
             var forcedAutoLevel = _this2.forcedAutoLevel;
             if (i !== loadLevel && (forcedAutoLevel === -1 || forcedAutoLevel !== loadLevel)) {
               if (levelsSkipped.length) {
-                _this2.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);
               }
-              _this2.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) {
               _this2.firstSelection = i;
@@ -6989,7 +6939,7 @@
         }
         var firstLevel = this.hls.firstLevel;
         var 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;
       }
     }, {
@@ -7039,7 +6989,7 @@
       }
     }]);
     return AbrController;
-  }(Logger);
+  }();
 
   /**
    * Provides methods dealing with buffer length retrieval for example.
@@ -7260,57 +7210,57 @@
   }();
 
   var VIDEO_CODEC_PROFILE_REPLACE = /(avc[1234]|hvc1|hev1|dvh[1e]|vp09|av01)(?:\.[^.,]+)+/;
-  var BufferController = /*#__PURE__*/function (_Logger) {
-    _inheritsLoose(BufferController, _Logger);
+  var BufferController = /*#__PURE__*/function () {
     function BufferController(hls) {
-      var _this;
-      _this = _Logger.call(this, 'buffer-controller', hls.logger) || this;
+      var _this = this;
       // The level details used to determine duration, target-duration and live
-      _this.details = null;
+      this.details = null;
       // cache the self generated object url to detect hijack of video tag
-      _this._objectUrl = null;
+      this._objectUrl = null;
       // A queue of buffer operations which require the SourceBuffer to not be updating upon execution
-      _this.operationQueue = void 0;
+      this.operationQueue = void 0;
       // References to event listeners for each SourceBuffer, so that they can be referenced for event removal
-      _this.listeners = void 0;
-      _this.hls = void 0;
+      this.listeners = void 0;
+      this.hls = void 0;
       // The number of BUFFER_CODEC events received before any sourceBuffers are created
-      _this.bufferCodecEventsExpected = 0;
+      this.bufferCodecEventsExpected = 0;
       // The total number of BUFFER_CODEC events received
-      _this._bufferCodecEventsTotal = 0;
+      this._bufferCodecEventsTotal = 0;
       // A reference to the attached media element
-      _this.media = null;
+      this.media = null;
       // A reference to the active media source
-      _this.mediaSource = null;
+      this.mediaSource = null;
       // Last MP3 audio chunk appended
-      _this.lastMpegAudioChunk = null;
-      _this.appendSource = void 0;
+      this.lastMpegAudioChunk = null;
+      this.appendSource = void 0;
       // counters
-      _this.appendErrors = {
+      this.appendErrors = {
         audio: 0,
         video: 0,
         audiovideo: 0
       };
-      _this.tracks = {};
-      _this.pendingTracks = {};
-      _this.sourceBuffer = void 0;
-      _this._onEndStreaming = function (event) {
+      this.tracks = {};
+      this.pendingTracks = {};
+      this.sourceBuffer = void 0;
+      this.log = void 0;
+      this.warn = void 0;
+      this.error = void 0;
+      this._onEndStreaming = function (event) {
         if (!_this.hls) {
           return;
         }
         _this.hls.pauseBuffering();
       };
-      _this._onStartStreaming = function (event) {
+      this._onStartStreaming = function (event) {
         if (!_this.hls) {
           return;
         }
         _this.hls.resumeBuffering();
       };
       // Keep as arrow functions so that we can directly reference these functions directly as event listeners
-      _this._onMediaSourceOpen = function () {
-        var _assertThisInitialize = _assertThisInitialized(_this),
-          media = _assertThisInitialize.media,
-          mediaSource = _assertThisInitialize.mediaSource;
+      this._onMediaSourceOpen = function () {
+        var media = _this.media,
+          mediaSource = _this.mediaSource;
         _this.log('Media source opened');
         if (media) {
           media.removeEventListener('emptied', _this._onMediaEmptied);
@@ -7326,25 +7276,27 @@
         }
         _this.checkPendingTracks();
       };
-      _this._onMediaSourceClose = function () {
+      this._onMediaSourceClose = function () {
         _this.log('Media source closed');
       };
-      _this._onMediaSourceEnded = function () {
+      this._onMediaSourceEnded = function () {
         _this.log('Media source ended');
       };
-      _this._onMediaEmptied = function () {
-        var _assertThisInitialize2 = _assertThisInitialized(_this),
-          mediaSrc = _assertThisInitialize2.mediaSrc,
-          _objectUrl = _assertThisInitialize2._objectUrl;
+      this._onMediaEmptied = function () {
+        var mediaSrc = _this.mediaSrc,
+          _objectUrl = _this._objectUrl;
         if (mediaSrc !== _objectUrl) {
-          _this.error("Media element src was set while attaching MediaSource (" + _objectUrl + " > " + mediaSrc + ")");
+          logger.error("Media element src was set while attaching MediaSource (" + _objectUrl + " > " + mediaSrc + ")");
         }
       };
-      _this.hls = hls;
-      _this.appendSource = hls.config.preferManagedMediaSource;
-      _this._initSourceBuffer();
-      _this.registerListeners();
-      return _this;
+      this.hls = hls;
+      var 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();
     }
     var _proto = BufferController.prototype;
     _proto.hasSourceTypes = function hasSourceTypes() {
@@ -7356,12 +7308,6 @@
       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;
     };
     _proto.registerListeners = function registerListeners() {
       var hls = this.hls;
@@ -8222,7 +8168,7 @@
       }
     }]);
     return BufferController;
-  }(Logger);
+  }();
   function removeSourceChildren(node) {
     var sourceChildren = node.querySelectorAll('source');
     [].slice.call(sourceChildren).forEach(function (source) {
@@ -8346,7 +8292,7 @@
           var hls = this.hls;
           var 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) {
@@ -8536,10 +8482,10 @@
             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) {
               var 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, {
@@ -8573,28 +8519,26 @@
   }();
 
   var PATHWAY_PENALTY_DURATION_MS = 300000;
-  var ContentSteeringController = /*#__PURE__*/function (_Logger) {
-    _inheritsLoose(ContentSteeringController, _Logger);
+  var ContentSteeringController = /*#__PURE__*/function () {
     function ContentSteeringController(hls) {
-      var _this;
-      _this = _Logger.call(this, 'content-steering', hls.logger) || this;
-      _this.hls = void 0;
-      _this.loader = null;
-      _this.uri = null;
-      _this.pathwayId = '.';
-      _this.pathwayPriority = null;
-      _this.timeToLoad = 300;
-      _this.reloadTimer = -1;
-      _this.updated = 0;
-      _this.started = false;
-      _this.enabled = true;
-      _this.levels = null;
-      _this.audioTracks = null;
-      _this.subtitleTracks = null;
-      _this.penalizedPathways = {};
-      _this.hls = hls;
-      _this.registerListeners();
-      return _this;
+      this.hls = void 0;
+      this.log = void 0;
+      this.loader = null;
+      this.uri = null;
+      this.pathwayId = '.';
+      this.pathwayPriority = null;
+      this.timeToLoad = 300;
+      this.reloadTimer = -1;
+      this.updated = 0;
+      this.started = false;
+      this.enabled = true;
+      this.levels = null;
+      this.audioTracks = null;
+      this.subtitleTracks = null;
+      this.penalizedPathways = {};
+      this.hls = hls;
+      this.log = logger.log.bind(logger, "[content-steering]:");
+      this.registerListeners();
     }
     var _proto = ContentSteeringController.prototype;
     _proto.registerListeners = function registerListeners() {
@@ -8715,7 +8659,7 @@
           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));
         }
       }
     };
@@ -8795,7 +8739,7 @@
       return defaultPathway;
     };
     _proto.clonePathways = function clonePathways(pathwayClones) {
-      var _this2 = this;
+      var _this = this;
       var levels = this.levels;
       if (!levels) {
         return;
@@ -8811,7 +8755,7 @@
         })) {
           return;
         }
-        var clonedVariants = _this2.getLevelsForPathway(baseId).map(function (baseLevel) {
+        var clonedVariants = _this.getLevelsForPathway(baseId).map(function (baseLevel) {
           var attributes = new AttrList(baseLevel.attrs);
           attributes['PATHWAY-ID'] = cloneId;
           var clonedAudioGroupId = attributes.AUDIO && attributes.AUDIO + "_clone_" + cloneId;
@@ -8848,12 +8792,12 @@
           return clonedLevel;
         });
         levels.push.apply(levels, clonedVariants);
-        cloneRenditionGroups(_this2.audioTracks, audioGroupCloneMap, uriReplacement, cloneId);
-        cloneRenditionGroups(_this2.subtitleTracks, subtitleGroupCloneMap, uriReplacement, cloneId);
+        cloneRenditionGroups(_this.audioTracks, audioGroupCloneMap, uriReplacement, cloneId);
+        cloneRenditionGroups(_this.subtitleTracks, subtitleGroupCloneMap, uriReplacement, cloneId);
       });
     };
     _proto.loadSteeringManifest = function loadSteeringManifest(uri) {
-      var _this3 = this;
+      var _this2 = this;
       var config = this.hls.config;
       var Loader = config.loader;
       if (this.loader) {
@@ -8888,87 +8832,87 @@
       };
       var callbacks = {
         onSuccess: function onSuccess(response, stats, context, networkDetails) {
-          _this3.log("Loaded steering manifest: \"" + url + "\"");
+          _this2.log("Loaded steering manifest: \"" + url + "\"");
           var steeringData = response.data;
-          if ((steeringData == null ? void 0 : steeringData.VERSION) !== 1) {
-            _this3.log("Steering VERSION " + steeringData.VERSION + " not supported!");
+          if (steeringData.VERSION !== 1) {
+            _this2.log("Steering VERSION " + steeringData.VERSION + " not supported!");
             return;
           }
-          _this3.updated = performance.now();
-          _this3.timeToLoad = steeringData.TTL;
+          _this2.updated = performance.now();
+          _this2.timeToLoad = steeringData.TTL;
           var reloadUri = steeringData['RELOAD-URI'],
             pathwayClones = steeringData['PATHWAY-CLONES'],
             pathwayPriority = steeringData['PATHWAY-PRIORITY'];
           if (reloadUri) {
             try {
-              _this3.uri = new self.URL(reloadUri, url).href;
+              _this2.uri = new self.URL(reloadUri, url).href;
             } catch (error) {
-              _this3.enabled = false;
-              _this3.log("Failed to parse Steering Manifest RELOAD-URI: " + reloadUri);
+              _this2.enabled = false;
+              _this2.log("Failed to parse Steering Manifest RELOAD-URI: " + reloadUri);
               return;
             }
           }
-          _this3.scheduleRefresh(_this3.uri || context.url);
+          _this2.scheduleRefresh(_this2.uri || context.url);
           if (pathwayClones) {
-            _this3.clonePathways(pathwayClones);
+            _this2.clonePathways(pathwayClones);
           }
           var loadedSteeringData = {
             steeringManifest: steeringData,
             url: url.toString()
           };
-          _this3.hls.trigger(Events.STEERING_MANIFEST_LOADED, loadedSteeringData);
+          _this2.hls.trigger(Events.STEERING_MANIFEST_LOADED, loadedSteeringData);
           if (pathwayPriority) {
-            _this3.updatePathwayPriority(pathwayPriority);
+            _this2.updatePathwayPriority(pathwayPriority);
           }
         },
         onError: function onError(error, context, networkDetails, stats) {
-          _this3.log("Error loading steering manifest: " + error.code + " " + error.text + " (" + context.url + ")");
-          _this3.stopLoad();
+          _this2.log("Error loading steering manifest: " + error.code + " " + error.text + " (" + context.url + ")");
+          _this2.stopLoad();
           if (error.code === 410) {
-            _this3.enabled = false;
-            _this3.log("Steering manifest " + context.url + " no longer available");
+            _this2.enabled = false;
+            _this2.log("Steering manifest " + context.url + " no longer available");
             return;
           }
-          var ttl = _this3.timeToLoad * 1000;
+          var ttl = _this2.timeToLoad * 1000;
           if (error.code === 429) {
-            var loader = _this3.loader;
+            var loader = _this2.loader;
             if (typeof (loader == null ? void 0 : loader.getResponseHeader) === 'function') {
               var retryAfter = loader.getResponseHeader('Retry-After');
               if (retryAfter) {
                 ttl = parseFloat(retryAfter) * 1000;
               }
             }
-            _this3.log("Steering manifest " + context.url + " rate limited");
+            _this2.log("Steering manifest " + context.url + " rate limited");
             return;
           }
-          _this3.scheduleRefresh(_this3.uri || context.url, ttl);
+          _this2.scheduleRefresh(_this2.uri || context.url, ttl);
         },
         onTimeout: function onTimeout(stats, context, networkDetails) {
-          _this3.log("Timeout loading steering manifest (" + context.url + ")");
-          _this3.scheduleRefresh(_this3.uri || context.url);
+          _this2.log("Timeout loading steering manifest (" + context.url + ")");
+          _this2.scheduleRefresh(_this2.uri || context.url);
         }
       };
       this.log("Requesting steering manifest: " + url);
       this.loader.load(context, loaderConfig, callbacks);
     };
     _proto.scheduleRefresh = function scheduleRefresh(uri, ttlMs) {
-      var _this4 = this;
+      var _this3 = this;
       if (ttlMs === void 0) {
         ttlMs = this.timeToLoad * 1000;
       }
       this.clearTimeout();
       this.reloadTimer = self.setTimeout(function () {
-        var _this4$hls;
-        var media = (_this4$hls = _this4.hls) == null ? void 0 : _this4$hls.media;
+        var _this3$hls;
+        var media = (_this3$hls = _this3.hls) == null ? void 0 : _this3$hls.media;
         if (media && !media.ended) {
-          _this4.loadSteeringManifest(uri);
+          _this3.loadSteeringManifest(uri);
           return;
         }
-        _this4.scheduleRefresh(uri, _this4.timeToLoad * 1000);
+        _this3.scheduleRefresh(uri, _this3.timeToLoad * 1000);
       }, ttlMs);
     };
     return ContentSteeringController;
-  }(Logger);
+  }();
   function cloneRenditionGroups(tracks, groupCloneMap, uriReplacement, cloneId) {
     if (!tracks) {
       return;
@@ -9835,7 +9779,7 @@
   /**
    * @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");
     }
@@ -9905,7 +9849,7 @@
   /**
    * @ignore
    */
-  function enableStreamingMode(config, logger) {
+  function enableStreamingMode(config) {
     var currentLoader = config.loader;
     if (currentLoader !== FetchLoader && currentLoader !== XhrLoader) {
       // If a developer has configured their own loader, respect that choice
@@ -9922,11 +9866,12 @@
     }
   }
 
+  var chromeOrFirefox;
   var LevelController = /*#__PURE__*/function (_BasePlaylistControll) {
     _inheritsLoose(LevelController, _BasePlaylistControll);
     function LevelController(hls, contentSteeringController) {
       var _this;
-      _this = _BasePlaylistControll.call(this, hls, 'level-controller') || this;
+      _this = _BasePlaylistControll.call(this, hls, '[level-controller]') || this;
       _this._levels = [];
       _this._firstLevel = -1;
       _this._maxAutoLevel = -1;
@@ -9995,13 +9940,21 @@
       var videoCodecFound = false;
       var audioCodecFound = false;
       data.levels.forEach(function (levelParsed) {
-        var _videoCodec;
+        var _audioCodec, _videoCodec;
         var attributes = levelParsed.attrs;
+
+        // erase audio codec info if browser does not support mp4a.40.34.
+        // demuxer will autodetect codec and fallback to mpeg/audio
         var audioCodec = levelParsed.audioCodec,
           videoCodec = levelParsed.videoCodec;
+        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);
@@ -10124,8 +10077,8 @@
             return _valueB - _valueA;
           }
         }
-        if (a.bitrate !== b.bitrate) {
-          return a.bitrate - b.bitrate;
+        if (a.averageBitrate !== b.averageBitrate) {
+          return a.averageBitrate - b.averageBitrate;
         }
         return 0;
       });
@@ -11148,8 +11101,8 @@
       var _frag$decryptdata;
       var byteRangeStart = start;
       var 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
         var fragmentLen = end - start;
@@ -11182,9 +11135,6 @@
     (part ? part : frag).stats.aborted = true;
     return new LoadError(errorData);
   }
-  function isMethodFullSegmentAesCbc(method) {
-    return method === 'AES-128' || method === 'AES-256';
-  }
   var LoadError = /*#__PURE__*/function (_Error) {
     _inheritsLoose(LoadError, _Error);
     function LoadError(data) {
@@ -11341,8 +11291,6 @@
           }
           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 + "\"")));
@@ -11476,17 +11424,13 @@
    * 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).
    */
-  var TaskLoop = /*#__PURE__*/function (_Logger) {
-    _inheritsLoose(TaskLoop, _Logger);
-    function TaskLoop(label, logger) {
-      var _this;
-      _this = _Logger.call(this, label, logger) || this;
-      _this._boundTick = void 0;
-      _this._tickTimer = null;
-      _this._tickInterval = null;
-      _this._tickCallCount = 0;
-      _this._boundTick = _this.tick.bind(_assertThisInitialized(_this));
-      return _this;
+  var TaskLoop = /*#__PURE__*/function () {
+    function TaskLoop() {
+      this._boundTick = void 0;
+      this._tickTimer = null;
+      this._tickInterval = null;
+      this._tickCallCount = 0;
+      this._boundTick = this.tick.bind(this);
     }
     var _proto = TaskLoop.prototype;
     _proto.destroy = function destroy() {
@@ -11572,7 +11516,7 @@
      */;
     _proto.doTick = function doTick() {};
     return TaskLoop;
-  }(Logger);
+  }();
 
   var ChunkMetadata = function ChunkMetadata(level, sn, id, size, part, partial) {
     if (size === void 0) {
@@ -11758,65 +11702,37 @@
   }
 
   var AESCrypto = /*#__PURE__*/function () {
-    function AESCrypto(subtle, iv, aesMode) {
+    function AESCrypto(subtle, iv) {
       this.subtle = void 0;
       this.aesIV = void 0;
-      this.aesMode = void 0;
       this.subtle = subtle;
       this.aesIV = iv;
-      this.aesMode = aesMode;
     }
     var _proto = AESCrypto.prototype;
     _proto.decrypt = function 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);
     };
     return AESCrypto;
   }();
 
   var FastAESKey = /*#__PURE__*/function () {
-    function FastAESKey(subtle, key, aesMode) {
+    function FastAESKey(subtle, key) {
       this.subtle = void 0;
       this.key = void 0;
-      this.aesMode = void 0;
       this.subtle = subtle;
       this.key = key;
-      this.aesMode = aesMode;
     }
     var _proto = FastAESKey.prototype;
     _proto.expandKey = function expandKey() {
-      var subtleAlgoName = getSubtleAlgoName(this.aesMode);
       return this.subtle.importKey('raw', this.key, {
-        name: subtleAlgoName
+        name: 'AES-CBC'
       }, false, ['encrypt', 'decrypt']);
     };
     return FastAESKey;
   }();
-  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) {
@@ -12069,8 +11985,7 @@
       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) {
@@ -12083,7 +11998,9 @@
           /* no-op */
         }
       }
-      this.useSoftware = this.subtle === null;
+      if (this.subtle === null) {
+        this.useSoftware = true;
+      }
     }
     var _proto = Decrypter.prototype;
     _proto.destroy = function destroy() {
@@ -12120,11 +12037,11 @@
         this.softwareDecrypter = null;
       }
     };
-    _proto.decrypt = function decrypt(data, key, iv, aesMode) {
+    _proto.decrypt = function decrypt(data, key, iv) {
       var _this = this;
       if (this.useSoftware) {
         return new Promise(function (resolve, reject) {
-          _this.softwareDecrypt(new Uint8Array(data), key, iv, aesMode);
+          _this.softwareDecrypt(new Uint8Array(data), key, iv);
           var decryptResult = _this.flush();
           if (decryptResult) {
             resolve(decryptResult.buffer);
@@ -12133,20 +12050,16 @@
           }
         });
       }
-      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
     ;
-    _proto.softwareDecrypt = function softwareDecrypt(data, key, iv, aesMode) {
+    _proto.softwareDecrypt = function softwareDecrypt(data, key, iv) {
       var currentIV = this.currentIV,
         currentResult = this.currentResult,
         remainderData = this.remainderData;
-      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
@@ -12179,12 +12092,12 @@
       }
       return result;
     };
-    _proto.webCryptoDecrypt = function webCryptoDecrypt(data, key, iv, aesMode) {
+    _proto.webCryptoDecrypt = function webCryptoDecrypt(data, key, iv) {
       var _this2 = this;
       var 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(function (aesKey) {
         // decrypt using web crypto
@@ -12192,25 +12105,22 @@
           return Promise.reject(new Error('web crypto not initialized'));
         }
         _this2.logOnce('WebCrypto AES decrypt');
-        var crypto = new AESCrypto(subtle, new Uint8Array(iv), aesMode);
+        var crypto = new AESCrypto(subtle, new Uint8Array(iv));
         return crypto.decrypt(data.buffer, aesKey);
       }).catch(function (err) {
         logger.warn("[decrypter]: WebCrypto Error, disable WebCrypto API, " + err.name + ": " + err.message);
-        return _this2.onWebCryptoError(data, key, iv, aesMode);
+        return _this2.onWebCryptoError(data, key, iv);
       });
     };
-    _proto.onWebCryptoError = function onWebCryptoError(data, key, iv, aesMode) {
-      var enableSoftwareAES = this.enableSoftwareAES;
-      if (enableSoftwareAES) {
-        this.useSoftware = true;
-        this.logEnabled = true;
-        this.softwareDecrypt(data, key, iv, aesMode);
-        var decryptResult = this.flush();
-        if (decryptResult) {
-          return decryptResult.buffer;
-        }
+    _proto.onWebCryptoError = function onWebCryptoError(data, key, iv) {
+      this.useSoftware = true;
+      this.logEnabled = true;
+      this.softwareDecrypt(data, key, iv);
+      var 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');
     };
     _proto.getValidChunk = function getValidChunk(data) {
       var currentChunk = data;
@@ -12264,7 +12174,7 @@
     _inheritsLoose(BaseStreamController, _TaskLoop);
     function BaseStreamController(hls, fragmentTracker, keyLoader, logPrefix, playlistType) {
       var _this;
-      _this = _TaskLoop.call(this, logPrefix, hls.logger) || this;
+      _this = _TaskLoop.call(this) || this;
       _this.hls = void 0;
       _this.fragPrevious = null;
       _this.fragCurrent = null;
@@ -12289,81 +12199,25 @@
       _this.startFragRequested = false;
       _this.decrypter = void 0;
       _this.initPTS = [];
-      _this.onMediaSeeking = function () {
-        var _assertThisInitialize = _assertThisInitialized(_this),
-          config = _assertThisInitialize.config,
-          fragCurrent = _assertThisInitialize.fragCurrent,
-          media = _assertThisInitialize.media,
-          mediaBuffer = _assertThisInitialize.mediaBuffer,
-          state = _assertThisInitialize.state;
-        var currentTime = media ? media.currentTime : 0;
-        var 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
-          var tolerance = config.maxFragLookUpTolerance;
-          var fragStartOffset = fragCurrent.start - tolerance;
-          var 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) {
-            var 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 = function () {
-        // reset startPosition and lastCurrentTime to restart playback @ stream beginning
-        _this.startPosition = _this.lastCurrentTime = 0;
-      };
+      _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);
+      hls.on(Events.MANIFEST_LOADED, _this.onManifestLoaded, _assertThisInitialized(_this));
       return _this;
     }
     var _proto = BaseStreamController.prototype;
-    _proto.registerListeners = function registerListeners() {
-      var hls = this.hls;
-      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);
-    };
-    _proto.unregisterListeners = function unregisterListeners() {
-      var hls = this.hls;
-      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);
-    };
     _proto.doTick = function doTick() {
       this.onTickEnd();
     };
@@ -12417,8 +12271,10 @@
     };
     _proto.onMediaAttached = function onMediaAttached(event, data) {
       var 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);
       var config = this.config;
       if (this.levels && config.autoStartLoad && this.state === State.STOPPED) {
         this.startLoad(config.startPosition);
@@ -12432,9 +12288,10 @@
       }
 
       // 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();
@@ -12444,8 +12301,54 @@
       this.fragmentTracker.removeAllFragments();
       this.stopLoad();
     };
-    _proto.onManifestLoading = function onManifestLoading() {};
-    _proto.onError = function onError(event, data) {};
+    _proto.onMediaSeeking = function onMediaSeeking() {
+      var config = this.config,
+        fragCurrent = this.fragCurrent,
+        media = this.media,
+        mediaBuffer = this.mediaBuffer,
+        state = this.state;
+      var currentTime = media ? media.currentTime : 0;
+      var 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
+        var tolerance = config.maxFragLookUpTolerance;
+        var fragStartOffset = fragCurrent.start - tolerance;
+        var 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) {
+          var 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();
+    };
+    _proto.onMediaEnded = function onMediaEnded() {
+      // reset startPosition and lastCurrentTime to restart playback @ stream beginning
+      this.startPosition = this.lastCurrentTime = 0;
+    };
     _proto.onManifestLoaded = function onManifestLoaded(event, data) {
       this.startTimeOffset = data.startTimeOffset;
       this.initPTS = [];
@@ -12455,7 +12358,7 @@
       this.stopLoad();
       _TaskLoop.prototype.onHandlerDestroying.call(this);
       // @ts-ignore
-      this.hls = this.onMediaSeeking = this.onMediaEnded = null;
+      this.hls = null;
     };
     _proto.onHandlerDestroyed = function onHandlerDestroyed() {
       this.state = State.STOPPED;
@@ -12585,10 +12488,10 @@
         var 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') {
           var startTime = self.performance.now();
           // decrypt init segment data
-          return _this3.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer, getAesModeFromFullSegmentMethod(decryptData.method)).catch(function (err) {
+          return _this3.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer).catch(function (err) {
             hls.trigger(Events.ERROR, {
               type: ErrorTypes.MEDIA_ERROR,
               details: ErrorDetails.FRAG_DECRYPT_ERROR,
@@ -12701,7 +12604,7 @@
       }
       var 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(function (keyLoadedData) {
@@ -12732,7 +12635,7 @@
           var partIndex = this.getNextPart(partList, frag, targetBufferTime);
           if (partIndex > -1) {
             var 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;
             var _result;
@@ -12765,7 +12668,7 @@
           }
         }
       }
-      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;
@@ -13326,7 +13229,7 @@
             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) {
@@ -13716,7 +13619,6 @@
    */
   function getAudioConfig(observer, data, offset, audioCodec) {
     var adtsObjectType;
-    var originalAdtsObjectType;
     var adtsExtensionSamplingIndex;
     var adtsChannelConfig;
     var config;
@@ -13724,7 +13626,7 @@
     var manifestCodec = audioCodec;
     var 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;
     var adtsSamplingIndex = (data[offset + 2] & 0x3c) >>> 2;
     if (adtsSamplingIndex > adtsSamplingRates.length - 1) {
       var error = new Error("invalid ADTS sampling index:" + adtsSamplingIndex);
@@ -13741,8 +13643,8 @@
     // 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);
@@ -13836,7 +13738,6 @@
       samplerate: adtsSamplingRates[adtsSamplingIndex],
       channelCount: adtsChannelConfig,
       codec: 'mp4a.40.' + adtsObjectType,
-      parsedCodec: 'mp4a.40.' + originalAdtsObjectType,
       manifestCodec: manifestCodec
     };
   }
@@ -13891,8 +13792,7 @@
       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) {
@@ -14979,7 +14879,7 @@
     }
     var _proto = SampleAesDecrypter.prototype;
     _proto.decryptBuffer = function 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
@@ -17208,7 +17108,7 @@
             logger.warn("[mp4-remuxer]: Injecting " + missing + " audio frame @ " + (nextPts / inputTimeScale).toFixed(3) + "s due to " + Math.round(1000 * delta / inputTimeScale) + " ms gap.");
             for (var j = 0; j < missing; j++) {
               var newStamp = Math.max(nextPts, 0);
-              var fillFrame = AAC.getSilentFrame(track.parsedCodec || track.manifestCodec || track.codec, track.channelCount);
+              var 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();
@@ -17336,7 +17236,7 @@
       // samples count of this segment's duration
       var nbSamples = Math.ceil((endDTS - startDTS) / frameDuration);
       // silent frame
-      var silentFrame = AAC.getSilentFrame(track.parsedCodec || track.manifestCodec || track.codec, track.channelCount);
+      var 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) {
@@ -17723,15 +17623,13 @@
         duration = transmuxConfig.duration,
         initSegmentData = transmuxConfig.initSegmentData;
       var keyData = getEncryptionType(uintData, decryptdata);
-      if (keyData && isFullSegmentEncryption(keyData.method)) {
+      if (keyData && keyData.method === 'AES-128') {
         var decrypter = this.getDecrypter();
-        var 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
-          var decryptedData = decrypter.softwareDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode);
+          var 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
           var loadingParts = chunkMeta.part > -1;
           if (loadingParts) {
@@ -17743,7 +17641,7 @@
           }
           uintData = new Uint8Array(decryptedData);
         } else {
-          this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode).then(function (decryptedData) {
+          this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer).then(function (decryptedData) {
             // Calling push here is important; if flush() is called while this is still resolving, this ensures that
             // the decrypted data has been transmuxed
             var result = _this.push(decryptedData, null, chunkMeta);
@@ -18364,7 +18262,7 @@
     observer.on(Events.ERROR, forwardMessage);
 
     // forward logger events to main thread
-    var forwardWorkerLogs = function forwardWorkerLogs(logger) {
+    var forwardWorkerLogs = function forwardWorkerLogs() {
       var _loop = function _loop(logFn) {
         var func = function func(message) {
           forwardMessage('workerLog', {
@@ -18385,8 +18283,8 @@
           {
             var config = JSON.parse(data.config);
             self.transmuxer = new Transmuxer(observer, data.typeSupported, config, data.vendor, data.id);
-            var logger = enableLogs(config.debug, data.id);
-            forwardWorkerLogs(logger);
+            enableLogs(config.debug, data.id);
+            forwardWorkerLogs();
             forwardMessage('init', null);
             break;
           }
@@ -18560,7 +18458,16 @@
       this.observer = new EventEmitter();
       this.observer.on(Events.FRAG_DECRYPTED, forwardMessage);
       this.observer.on(Events.ERROR, forwardMessage);
-      var m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
+      var MediaSource = getMediaSource(config.preferManagedMediaSource) || {
+        isTypeSupported: function isTypeSupported() {
+          return false;
+        }
+      };
+      var 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
@@ -18817,25 +18724,21 @@
   var MAX_START_GAP_JUMP = 2.0;
   var SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
   var SKIP_BUFFER_RANGE_START = 0.05;
-  var GapController = /*#__PURE__*/function (_Logger) {
-    _inheritsLoose(GapController, _Logger);
+  var GapController = /*#__PURE__*/function () {
     function GapController(config, media, fragmentTracker, hls) {
-      var _this;
-      _this = _Logger.call(this, 'gap-controller', hls.logger) || this;
-      _this.config = void 0;
-      _this.media = null;
-      _this.fragmentTracker = void 0;
-      _this.hls = void 0;
-      _this.nudgeRetry = 0;
-      _this.stallReported = false;
-      _this.stalled = null;
-      _this.moved = false;
-      _this.seeking = false;
-      _this.config = config;
-      _this.media = media;
-      _this.fragmentTracker = fragmentTracker;
-      _this.hls = hls;
-      return _this;
+      this.config = void 0;
+      this.media = null;
+      this.fragmentTracker = void 0;
+      this.hls = void 0;
+      this.nudgeRetry = 0;
+      this.stallReported = false;
+      this.stalled = null;
+      this.moved = false;
+      this.seeking = false;
+      this.config = config;
+      this.media = media;
+      this.fragmentTracker = fragmentTracker;
+      this.hls = hls;
     }
     var _proto = GapController.prototype;
     _proto.destroy = function destroy() {
@@ -18873,7 +18776,7 @@
           // The playhead is now moving, but was previously stalled
           if (this.stallReported) {
             var _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;
@@ -18982,7 +18885,7 @@
       // 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
@@ -19004,7 +18907,7 @@
         // Report stalled error once
         this.stallReported = true;
         var 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,
@@ -19068,7 +18971,7 @@
             }
           }
           var 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;
@@ -19107,7 +19010,7 @@
         var targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
         // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
         var 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,
@@ -19117,7 +19020,7 @@
         });
       } else {
         var _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,
@@ -19127,14 +19030,14 @@
       }
     };
     return GapController;
-  }(Logger);
+  }();
 
   var TICK_INTERVAL = 100; // how often to tick in ms
   var StreamController = /*#__PURE__*/function (_BaseStreamController) {
     _inheritsLoose(StreamController, _BaseStreamController);
     function StreamController(hls, fragmentTracker, keyLoader) {
       var _this;
-      _this = _BaseStreamController.call(this, hls, fragmentTracker, keyLoader, 'stream-controller', PlaylistLevelType.MAIN) || this;
+      _this = _BaseStreamController.call(this, hls, fragmentTracker, keyLoader, '[stream-controller]', PlaylistLevelType.MAIN) || this;
       _this.audioCodecSwap = false;
       _this.gapController = null;
       _this.level = -1;
@@ -19142,43 +19045,27 @@
       _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 = function () {
-        // tick to speed up FRAG_CHANGED triggering
-        _this.tick();
-      };
-      _this.onMediaSeeked = function () {
-        var media = _this.media;
-        var 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
-        var 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();
       return _this;
     }
     var _proto = StreamController.prototype;
-    _proto.registerListeners = function registerListeners() {
-      _BaseStreamController.prototype.registerListeners.call(this);
+    _proto._registerListeners = function _registerListeners() {
       var hls = this.hls;
+      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);
@@ -19186,12 +19073,15 @@
       hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
       hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
     };
-    _proto.unregisterListeners = function unregisterListeners() {
-      _BaseStreamController.prototype.unregisterListeners.call(this);
+    _proto._unregisterListeners = function _unregisterListeners() {
       var hls = this.hls;
+      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);
@@ -19200,9 +19090,7 @@
       hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
     };
     _proto.onHandlerDestroying = function onHandlerDestroying() {
-      // @ts-ignore
-      this.onMediaPlaying = this.onMediaSeeked = null;
-      this.unregisterListeners();
+      this._unregisterListeners();
       _BaseStreamController.prototype.onHandlerDestroying.call(this);
     };
     _proto.startLoad = function startLoad(startPosition) {
@@ -19517,15 +19405,18 @@
     _proto.onMediaAttached = function onMediaAttached(event, data) {
       _BaseStreamController.prototype.onMediaAttached.call(this, event, data);
       var 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);
     };
     _proto.onMediaDetaching = function onMediaDetaching() {
       var media = this.media;
-      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;
@@ -19535,6 +19426,27 @@
       }
       _BaseStreamController.prototype.onMediaDetaching.call(this);
     };
+    _proto.onMediaPlaying = function onMediaPlaying() {
+      // tick to speed up FRAG_CHANGED triggering
+      this.tick();
+    };
+    _proto.onMediaSeeked = function onMediaSeeked() {
+      var media = this.media;
+      var 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
+      var 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();
+    };
     _proto.onManifestLoading = function onManifestLoading() {
       // reset buffer on manifest loading
       this.log('Trigger BUFFER_RESET');
@@ -20281,10 +20193,6 @@
        * 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;
@@ -20304,11 +20212,11 @@
       this._media = null;
       this.url = null;
       this.triggeringException = void 0;
-      var logger = this.logger = enableLogs(userConfig.debug || false, 'Hls instance');
-      var config = this.config = mergeConfig(Hls.DefaultConfig, userConfig, logger);
+      enableLogs(userConfig.debug || false, 'Hls instance');
+      var config = this.config = mergeConfig(Hls.DefaultConfig, userConfig);
       this.userConfig = userConfig;
       if (config.progressive) {
-        enableStreamingMode(config, logger);
+        enableStreamingMode(config);
       }
 
       // core controllers and network loaders
@@ -20416,7 +20324,7 @@
         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;
@@ -20442,7 +20350,7 @@
      * Dispose of the instance
      */;
     _proto.destroy = function destroy() {
-      this.logger.log('destroy');
+      logger.log('destroy');
       this.trigger(Events.DESTROYING, undefined);
       this.detachMedia();
       this.removeAllListeners();
@@ -20467,7 +20375,7 @@
      * Attaches Hls.js to a media element
      */;
     _proto.attachMedia = function attachMedia(media) {
-      this.logger.log('attachMedia');
+      logger.log('attachMedia');
       this._media = media;
       this.trigger(Events.MEDIA_ATTACHING, {
         media: media
@@ -20478,7 +20386,7 @@
      * Detach Hls.js from the media
      */;
     _proto.detachMedia = function detachMedia() {
-      this.logger.log('detachMedia');
+      logger.log('detachMedia');
       this.trigger(Events.MEDIA_DETACHING, undefined);
       this._media = null;
     }
@@ -20495,7 +20403,7 @@
       });
       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);
@@ -20517,7 +20425,7 @@
       if (startPosition === void 0) {
         startPosition = -1;
       }
-      this.logger.log("startLoad(" + startPosition + ")");
+      logger.log("startLoad(" + startPosition + ")");
       this.started = true;
       this.networkControllers.forEach(function (controller) {
         controller.startLoad(startPosition);
@@ -20528,7 +20436,7 @@
      * Stop loading of any stream data.
      */;
     _proto.stopLoad = function stopLoad() {
-      this.logger.log('stopLoad');
+      logger.log('stopLoad');
       this.started = false;
       this.networkControllers.forEach(function (controller) {
         controller.stopLoad();
@@ -20564,7 +20472,7 @@
      * Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
      */;
     _proto.swapAudioCodec = function swapAudioCodec() {
-      this.logger.log('swapAudioCodec');
+      logger.log('swapAudioCodec');
       this.streamController.swapAudioCodec();
     }
 
@@ -20575,7 +20483,7 @@
      * Automatic recovery of media-errors by this process is configurable.
      */;
     _proto.recoverMediaError = function recoverMediaError() {
-      this.logger.log('recoverMediaError');
+      logger.log('recoverMediaError');
       var media = this._media;
       this.detachMedia();
       if (media) {
@@ -20630,7 +20538,7 @@
        * 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: function set(newLevel) {
-        this.logger.log("set currentLevel:" + newLevel);
+        logger.log("set currentLevel:" + newLevel);
         this.levelController.manualLevel = newLevel;
         this.streamController.immediateLevelSwitch();
       }
@@ -20651,7 +20559,7 @@
        * @param newLevel - Pass -1 for automatic level selection
        */,
       set: function set(newLevel) {
-        this.logger.log("set nextLevel:" + newLevel);
+        logger.log("set nextLevel:" + newLevel);
         this.levelController.manualLevel = newLevel;
         this.streamController.nextLevelSwitch();
       }
@@ -20672,7 +20580,7 @@
        * @param newLevel - Pass -1 for automatic level selection
        */,
       set: function set(newLevel) {
-        this.logger.log("set loadLevel:" + newLevel);
+        logger.log("set loadLevel:" + newLevel);
         this.levelController.manualLevel = newLevel;
       }
 
@@ -20707,7 +20615,7 @@
        * Sets "first-level", see getter.
        */,
       set: function set(newLevel) {
-        this.logger.log("set firstLevel:" + newLevel);
+        logger.log("set firstLevel:" + newLevel);
         this.levelController.firstLevel = newLevel;
       }
 
@@ -20734,7 +20642,7 @@
        * (determined from download of first segment)
        */,
       set: function set(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);
@@ -20787,7 +20695,7 @@
        */
       function set(newLevel) {
         if (this._autoLevelCapping !== newLevel) {
-          this.logger.log("set autoLevelCapping:" + newLevel);
+          logger.log("set autoLevelCapping:" + newLevel);
           this._autoLevelCapping = newLevel;
           this.levelController.checkMaxAutoUpdated();
         }
@@ -21112,7 +21020,7 @@
        * Get the video-dev/hls.js package version.
        */
       function get() {
-        return "1.5.2-0.canary.9924";
+        return "1.5.2";
       }
     }, {
       key: "Events",