hls.js 1.5.9 → 1.5.10-0.canary.10320

package/dist/hls.light.mjs

@@ -176,6 +176,23 @@ var urlToolkit = {exports: {}};
 
 var urlToolkitExports = urlToolkit.exports;
 
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
 function ownKeys(e, r) {
   var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
@@ -209,35 +226,7 @@ function _toPrimitive(t, r) {
 }
 function _toPropertyKey(t) {
   var i = _toPrimitive(t, "string");
-  return "symbol" == typeof i ? i : String(i);
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-    return target;
-  };
-  return _extends.apply(this, arguments);
+  return "symbol" == typeof i ? i : i + "";
 }
 
 // https://caniuse.com/mdn-javascript_builtins_number_isfinite
@@ -256,6 +245,7 @@ let Events = /*#__PURE__*/function (Events) {
   Events["MEDIA_ATTACHED"] = "hlsMediaAttached";
   Events["MEDIA_DETACHING"] = "hlsMediaDetaching";
   Events["MEDIA_DETACHED"] = "hlsMediaDetached";
+  Events["MEDIA_ENDED"] = "hlsMediaEnded";
   Events["BUFFER_RESET"] = "hlsBufferReset";
   Events["BUFFER_CODECS"] = "hlsBufferCodecs";
   Events["BUFFER_CREATED"] = "hlsBufferCreated";
@@ -369,58 +359,6 @@ let ErrorDetails = /*#__PURE__*/function (ErrorDetails) {
   return ErrorDetails;
 }({});
 
-const noop = function noop() {};
-const fakeLogger = {
-  trace: noop,
-  debug: noop,
-  log: noop,
-  warn: noop,
-  info: noop,
-  error: noop
-};
-let exportedLogger = fakeLogger;
-
-// let lastCallTime;
-// function formatMsgWithTimeInfo(type, msg) {
-//   const now = Date.now();
-//   const diff = lastCallTime ? '+' + (now - lastCallTime) : '0';
-//   lastCallTime = now;
-//   msg = (new Date(now)).toISOString() + ' | [' +  type + '] > ' + msg + ' ( ' + diff + ' ms )';
-//   return msg;
-// }
-
-function consolePrintFn(type) {
-  const func = self.console[type];
-  if (func) {
-    return func.bind(self.console, `[${type}] >`);
-  }
-  return noop;
-}
-function exportLoggerFunctions(debugConfig, ...functions) {
-  functions.forEach(function (type) {
-    exportedLogger[type] = debugConfig[type] ? debugConfig[type].bind(debugConfig) : consolePrintFn(type);
-  });
-}
-function enableLogs(debugConfig, id) {
-  // check that console is available
-  if (typeof console === 'object' && debugConfig === true || typeof debugConfig === 'object') {
-    exportLoggerFunctions(debugConfig,
-    // Remove out from list here to hard-disable a log-level
-    // 'trace',
-    'debug', 'log', 'info', 'warn', 'error');
-    // Some browsers don't allow to use bind on console object anyway
-    // fallback to default if needed
-    try {
-      exportedLogger.log(`Debug logs enabled for "${id}" in hls.js version ${"1.5.9"}`);
-    } catch (e) {
-      exportedLogger = fakeLogger;
-    }
-  } else {
-    exportedLogger = fakeLogger;
-  }
-}
-const logger = exportedLogger;
-
 const DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/;
 const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
 
@@ -502,6 +440,84 @@ class AttrList {
   }
 }
 
+class Logger {
+  constructor(label, logger) {
+    this.trace = void 0;
+    this.debug = void 0;
+    this.log = void 0;
+    this.warn = void 0;
+    this.info = void 0;
+    this.error = void 0;
+    const lb = `[${label}]:`;
+    this.trace = noop;
+    this.debug = logger.debug.bind(null, lb);
+    this.log = logger.log.bind(null, lb);
+    this.warn = logger.warn.bind(null, lb);
+    this.info = logger.info.bind(null, lb);
+    this.error = logger.error.bind(null, lb);
+  }
+}
+const noop = function noop() {};
+const fakeLogger = {
+  trace: noop,
+  debug: noop,
+  log: noop,
+  warn: noop,
+  info: noop,
+  error: noop
+};
+function createLogger() {
+  return _extends({}, fakeLogger);
+}
+
+// let lastCallTime;
+// function formatMsgWithTimeInfo(type, msg) {
+//   const now = Date.now();
+//   const diff = lastCallTime ? '+' + (now - lastCallTime) : '0';
+//   lastCallTime = now;
+//   msg = (new Date(now)).toISOString() + ' | [' +  type + '] > ' + msg + ' ( ' + diff + ' ms )';
+//   return msg;
+// }
+
+function consolePrintFn(type, id) {
+  const func = self.console[type];
+  return func ? func.bind(self.console, `${''}[${type}] >`) : noop;
+}
+function getLoggerFn(key, debugConfig, id) {
+  return debugConfig[key] ? debugConfig[key].bind(debugConfig) : consolePrintFn(key);
+}
+const exportedLogger = createLogger();
+function enableLogs(debugConfig, context, id) {
+  // check that console is available
+  const newLogger = createLogger();
+  if (typeof console === 'object' && debugConfig === true || typeof debugConfig === 'object') {
+    const keys = [
+    // Remove out from list here to hard-disable a log-level
+    // 'trace',
+    'debug', 'log', 'info', 'warn', 'error'];
+    keys.forEach(key => {
+      newLogger[key] = getLoggerFn(key, debugConfig);
+    });
+    // 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.10-0.canary.10320"}`);
+    } catch (e) {
+      /* log fn threw an exception. All logger methods are no-ops. */
+      return createLogger();
+    }
+    // global exported logger uses the same functions as new logger without `id`
+    keys.forEach(key => {
+      exportedLogger[key] = getLoggerFn(key, debugConfig);
+    });
+  } else {
+    // Reset global exported logger
+    _extends(exportedLogger, newLogger);
+  }
+  return newLogger;
+}
+const logger = exportedLogger;
+
 // Avoid exporting const enum so that these values can be inlined
 
 function isDateRangeCueAttribute(attrName) {
@@ -991,10 +1007,32 @@ class LevelDetails {
   }
 }
 
+var DecrypterAesMode = {
+  cbc: 0,
+  ctr: 1
+};
+
+function isFullSegmentEncryption(method) {
+  return method === 'AES-128' || method === 'AES-256' || method === 'AES-256-CTR';
+}
+function getAesModeFromFullSegmentMethod(method) {
+  switch (method) {
+    case 'AES-128':
+    case 'AES-256':
+      return DecrypterAesMode.cbc;
+    case 'AES-256-CTR':
+      return DecrypterAesMode.ctr;
+    default:
+      throw new Error(`invalid full segment method ${method}`);
+  }
+}
+
 // This file is inserted as a shim for modules which we do not want to include into the distro.
 // This replacement is done in the "alias" plugin of the rollup config.
-var empty = undefined;
-var Cues = /*@__PURE__*/getDefaultExportFromCjs(empty);
+// Use a ES dedicated file as Rollup assigns an object in the output
+// For example: "var KeySystemFormats = emptyEs.KeySystemFormats;"
+var emptyEs = {};
+var HevcVideoParser = /*@__PURE__*/getDefaultExportFromCjs(emptyEs);
 
 function sliceUint8(array, start, end) {
   // @ts-expect-error This polyfills IE11 usage of Uint8Array slice.
@@ -1002,365 +1040,96 @@ function sliceUint8(array, start, end) {
   return Uint8Array.prototype.slice ? array.slice(start, end) : new Uint8Array(Array.prototype.slice.call(array, start, end));
 }
 
-// breaking up those two types in order to clarify what is happening in the decoding path.
-
-/**
- * Returns true if an ID3 header can be found at offset in data
- * @param data - The data to search
- * @param offset - The offset at which to start searching
+// http://stackoverflow.com/questions/8936984/uint8array-to-string-in-javascript/22373197
+// http://www.onicos.com/staff/iz/amuse/javascript/expert/utf.txt
+/* utf.js - UTF-8 <=> UTF-16 convertion
+ *
+ * Copyright (C) 1999 Masanao Izumo <iz@onicos.co.jp>
+ * Version: 1.0
+ * LastModified: Dec 25 1999
+ * This library is free.  You can redistribute it and/or modify it.
  */
-const isHeader$2 = (data, offset) => {
-  /*
-   * http://id3.org/id3v2.3.0
-   * [0]     = 'I'
-   * [1]     = 'D'
-   * [2]     = '3'
-   * [3,4]   = {Version}
-   * [5]     = {Flags}
-   * [6-9]   = {ID3 Size}
-   *
-   * An ID3v2 tag can be detected with the following pattern:
-   *  $49 44 33 yy yy xx zz zz zz zz
-   * Where yy is less than $FF, xx is the 'flags' byte and zz is less than $80
-   */
-  if (offset + 10 <= data.length) {
-    // look for 'ID3' identifier
-    if (data[offset] === 0x49 && data[offset + 1] === 0x44 && data[offset + 2] === 0x33) {
-      // check version is within range
-      if (data[offset + 3] < 0xff && data[offset + 4] < 0xff) {
-        // check size is within range
-        if (data[offset + 6] < 0x80 && data[offset + 7] < 0x80 && data[offset + 8] < 0x80 && data[offset + 9] < 0x80) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-};
-
 /**
- * Returns true if an ID3 footer can be found at offset in data
- * @param data - The data to search
- * @param offset - The offset at which to start searching
+ * Converts a UTF-8 array to a string.
+ *
+ * @param array - The UTF-8 array to convert
+ *
+ * @returns The string
+ *
+ * @group Utils
+ *
+ * @beta
  */
-const isFooter = (data, offset) => {
-  /*
-   * The footer is a copy of the header, but with a different identifier
-   */
-  if (offset + 10 <= data.length) {
-    // look for '3DI' identifier
-    if (data[offset] === 0x33 && data[offset + 1] === 0x44 && data[offset + 2] === 0x49) {
-      // check version is within range
-      if (data[offset + 3] < 0xff && data[offset + 4] < 0xff) {
-        // check size is within range
-        if (data[offset + 6] < 0x80 && data[offset + 7] < 0x80 && data[offset + 8] < 0x80 && data[offset + 9] < 0x80) {
-          return true;
-        }
-      }
+function utf8ArrayToStr(array, exitOnNull = false) {
+  if (typeof TextDecoder !== 'undefined') {
+    const decoder = new TextDecoder('utf-8');
+    const decoded = decoder.decode(array);
+    if (exitOnNull) {
+      // grab up to the first null
+      const idx = decoded.indexOf('\0');
+      return idx !== -1 ? decoded.substring(0, idx) : decoded;
     }
+    // remove any null characters
+    return decoded.replace(/\0/g, '');
   }
-  return false;
-};
-
-/**
- * Returns any adjacent ID3 tags found in data starting at offset, as one block of data
- * @param data - The data to search in
- * @param offset - The offset at which to start searching
- * @returns the block of data containing any ID3 tags found
- * or *undefined* if no header is found at the starting offset
- */
-const getID3Data = (data, offset) => {
-  const front = offset;
-  let length = 0;
-  while (isHeader$2(data, offset)) {
-    // ID3 header is 10 bytes
-    length += 10;
-    const size = readSize(data, offset + 6);
-    length += size;
-    if (isFooter(data, offset + 10)) {
-      // ID3 footer is 10 bytes
-      length += 10;
+  const len = array.length;
+  let c;
+  let char2;
+  let char3;
+  let out = '';
+  let i = 0;
+  while (i < len) {
+    c = array[i++];
+    if (c === 0x00 && exitOnNull) {
+      return out;
+    } else if (c === 0x00 || c === 0x03) {
+      // If the character is 3 (END_OF_TEXT) or 0 (NULL) then skip it
+      continue;
+    }
+    switch (c >> 4) {
+      case 0:
+      case 1:
+      case 2:
+      case 3:
+      case 4:
+      case 5:
+      case 6:
+      case 7:
+        // 0xxxxxxx
+        out += String.fromCharCode(c);
+        break;
+      case 12:
+      case 13:
+        // 110x xxxx   10xx xxxx
+        char2 = array[i++];
+        out += String.fromCharCode((c & 0x1f) << 6 | char2 & 0x3f);
+        break;
+      case 14:
+        // 1110 xxxx  10xx xxxx  10xx xxxx
+        char2 = array[i++];
+        char3 = array[i++];
+        out += String.fromCharCode((c & 0x0f) << 12 | (char2 & 0x3f) << 6 | (char3 & 0x3f) << 0);
+        break;
     }
-    offset += length;
-  }
-  if (length > 0) {
-    return data.subarray(front, front + length);
   }
-  return undefined;
-};
-const readSize = (data, offset) => {
-  let size = 0;
-  size = (data[offset] & 0x7f) << 21;
-  size |= (data[offset + 1] & 0x7f) << 14;
-  size |= (data[offset + 2] & 0x7f) << 7;
-  size |= data[offset + 3] & 0x7f;
-  return size;
-};
-const canParse$2 = (data, offset) => {
-  return isHeader$2(data, offset) && readSize(data, offset + 6) + 10 <= data.length - offset;
-};
+  return out;
+}
 
 /**
- * Searches for the Elementary Stream timestamp found in the ID3 data chunk
- * @param data - Block of data containing one or more ID3 tags
+ *  hex dump helper class
  */
-const getTimeStamp = data => {
-  const frames = getID3Frames(data);
-  for (let i = 0; i < frames.length; i++) {
-    const frame = frames[i];
-    if (isTimeStampFrame(frame)) {
-      return readTimeStamp(frame);
+
+const Hex = {
+  hexDump: function (array) {
+    let str = '';
+    for (let i = 0; i < array.length; i++) {
+      let h = array[i].toString(16);
+      if (h.length < 2) {
+        h = '0' + h;
+      }
+      str += h;
     }
-  }
-  return undefined;
-};
-
-/**
- * Returns true if the ID3 frame is an Elementary Stream timestamp frame
- */
-const isTimeStampFrame = frame => {
-  return frame && frame.key === 'PRIV' && frame.info === 'com.apple.streaming.transportStreamTimestamp';
-};
-const getFrameData = data => {
-  /*
-  Frame ID       $xx xx xx xx (four characters)
-  Size           $xx xx xx xx
-  Flags          $xx xx
-  */
-  const type = String.fromCharCode(data[0], data[1], data[2], data[3]);
-  const size = readSize(data, 4);
-
-  // skip frame id, size, and flags
-  const offset = 10;
-  return {
-    type,
-    size,
-    data: data.subarray(offset, offset + size)
-  };
-};
-
-/**
- * Returns an array of ID3 frames found in all the ID3 tags in the id3Data
- * @param id3Data - The ID3 data containing one or more ID3 tags
- */
-const getID3Frames = id3Data => {
-  let offset = 0;
-  const frames = [];
-  while (isHeader$2(id3Data, offset)) {
-    const size = readSize(id3Data, offset + 6);
-    // skip past ID3 header
-    offset += 10;
-    const end = offset + size;
-    // loop through frames in the ID3 tag
-    while (offset + 8 < end) {
-      const frameData = getFrameData(id3Data.subarray(offset));
-      const frame = decodeFrame(frameData);
-      if (frame) {
-        frames.push(frame);
-      }
-
-      // skip frame header and frame data
-      offset += frameData.size + 10;
-    }
-    if (isFooter(id3Data, offset)) {
-      offset += 10;
-    }
-  }
-  return frames;
-};
-const decodeFrame = frame => {
-  if (frame.type === 'PRIV') {
-    return decodePrivFrame(frame);
-  } else if (frame.type[0] === 'W') {
-    return decodeURLFrame(frame);
-  }
-  return decodeTextFrame(frame);
-};
-const decodePrivFrame = frame => {
-  /*
-  Format: <text string>\0<binary data>
-  */
-  if (frame.size < 2) {
-    return undefined;
-  }
-  const owner = utf8ArrayToStr(frame.data, true);
-  const privateData = new Uint8Array(frame.data.subarray(owner.length + 1));
-  return {
-    key: frame.type,
-    info: owner,
-    data: privateData.buffer
-  };
-};
-const decodeTextFrame = frame => {
-  if (frame.size < 2) {
-    return undefined;
-  }
-  if (frame.type === 'TXXX') {
-    /*
-    Format:
-    [0]   = {Text Encoding}
-    [1-?] = {Description}\0{Value}
-    */
-    let index = 1;
-    const description = utf8ArrayToStr(frame.data.subarray(index), true);
-    index += description.length + 1;
-    const value = utf8ArrayToStr(frame.data.subarray(index));
-    return {
-      key: frame.type,
-      info: description,
-      data: value
-    };
-  }
-  /*
-  Format:
-  [0]   = {Text Encoding}
-  [1-?] = {Value}
-  */
-  const text = utf8ArrayToStr(frame.data.subarray(1));
-  return {
-    key: frame.type,
-    data: text
-  };
-};
-const decodeURLFrame = frame => {
-  if (frame.type === 'WXXX') {
-    /*
-    Format:
-    [0]   = {Text Encoding}
-    [1-?] = {Description}\0{URL}
-    */
-    if (frame.size < 2) {
-      return undefined;
-    }
-    let index = 1;
-    const description = utf8ArrayToStr(frame.data.subarray(index), true);
-    index += description.length + 1;
-    const value = utf8ArrayToStr(frame.data.subarray(index));
-    return {
-      key: frame.type,
-      info: description,
-      data: value
-    };
-  }
-  /*
-  Format:
-  [0-?] = {URL}
-  */
-  const url = utf8ArrayToStr(frame.data);
-  return {
-    key: frame.type,
-    data: url
-  };
-};
-const readTimeStamp = timeStampFrame => {
-  if (timeStampFrame.data.byteLength === 8) {
-    const data = new Uint8Array(timeStampFrame.data);
-    // timestamp is 33 bit expressed as a big-endian eight-octet number,
-    // with the upper 31 bits set to zero.
-    const pts33Bit = data[3] & 0x1;
-    let timestamp = (data[4] << 23) + (data[5] << 15) + (data[6] << 7) + data[7];
-    timestamp /= 45;
-    if (pts33Bit) {
-      timestamp += 47721858.84;
-    } // 2^32 / 90
-
-    return Math.round(timestamp);
-  }
-  return undefined;
-};
-
-// http://stackoverflow.com/questions/8936984/uint8array-to-string-in-javascript/22373197
-// http://www.onicos.com/staff/iz/amuse/javascript/expert/utf.txt
-/* utf.js - UTF-8 <=> UTF-16 convertion
- *
- * Copyright (C) 1999 Masanao Izumo <iz@onicos.co.jp>
- * Version: 1.0
- * LastModified: Dec 25 1999
- * This library is free.  You can redistribute it and/or modify it.
- */
-const utf8ArrayToStr = (array, exitOnNull = false) => {
-  const decoder = getTextDecoder();
-  if (decoder) {
-    const decoded = decoder.decode(array);
-    if (exitOnNull) {
-      // grab up to the first null
-      const idx = decoded.indexOf('\0');
-      return idx !== -1 ? decoded.substring(0, idx) : decoded;
-    }
-
-    // remove any null characters
-    return decoded.replace(/\0/g, '');
-  }
-  const len = array.length;
-  let c;
-  let char2;
-  let char3;
-  let out = '';
-  let i = 0;
-  while (i < len) {
-    c = array[i++];
-    if (c === 0x00 && exitOnNull) {
-      return out;
-    } else if (c === 0x00 || c === 0x03) {
-      // If the character is 3 (END_OF_TEXT) or 0 (NULL) then skip it
-      continue;
-    }
-    switch (c >> 4) {
-      case 0:
-      case 1:
-      case 2:
-      case 3:
-      case 4:
-      case 5:
-      case 6:
-      case 7:
-        // 0xxxxxxx
-        out += String.fromCharCode(c);
-        break;
-      case 12:
-      case 13:
-        // 110x xxxx   10xx xxxx
-        char2 = array[i++];
-        out += String.fromCharCode((c & 0x1f) << 6 | char2 & 0x3f);
-        break;
-      case 14:
-        // 1110 xxxx  10xx xxxx  10xx xxxx
-        char2 = array[i++];
-        char3 = array[i++];
-        out += String.fromCharCode((c & 0x0f) << 12 | (char2 & 0x3f) << 6 | (char3 & 0x3f) << 0);
-        break;
-    }
-  }
-  return out;
-};
-let decoder;
-function getTextDecoder() {
-  // On Play Station 4, TextDecoder is defined but partially implemented.
-  // Manual decoding option is preferable
-  if (navigator.userAgent.includes('PlayStation 4')) {
-    return;
-  }
-  if (!decoder && typeof self.TextDecoder !== 'undefined') {
-    decoder = new self.TextDecoder('utf-8');
-  }
-  return decoder;
-}
-
-/**
- *  hex dump helper class
- */
-
-const Hex = {
-  hexDump: function (array) {
-    let str = '';
-    for (let i = 0; i < array.length; i++) {
-      let h = array[i].toString(16);
-      if (h.length < 2) {
-        h = '0' + h;
-      }
-      str += h;
-    }
-    return str;
+    return str;
   }
 };
 
@@ -1626,7 +1395,7 @@ function parseStsd(stsd) {
       {
         const codecBox = findBox(sampleEntries, [fourCC])[0];
         const esdsBox = findBox(codecBox.subarray(28), ['esds'])[0];
-        if (esdsBox && esdsBox.length > 12) {
+        if (esdsBox && esdsBox.length > 7) {
           let i = 4;
           // ES Descriptor tag
           if (esdsBox[i++] !== 0x03) {
@@ -1741,7 +1510,9 @@ function parseStsd(stsd) {
 }
 function skipBERInteger(bytes, i) {
   const limit = i + 5;
-  while (bytes[i++] & 0x80 && i < limit) {}
+  while (bytes[i++] & 0x80 && i < limit) {
+    /* do nothing */
+  }
   return i;
 }
 function toHex(x) {
@@ -2433,12 +2204,12 @@ class LevelKey {
     this.keyFormatVersions = formatversions;
     this.iv = iv;
     this.encrypted = method ? method !== 'NONE' : false;
-    this.isCommonEncryption = this.encrypted && method !== 'AES-128';
+    this.isCommonEncryption = this.encrypted && !isFullSegmentEncryption(method);
   }
   isSupported() {
     // If it's Segment encryption or No encryption, just select that key system
     if (this.method) {
-      if (this.method === 'AES-128' || this.method === 'NONE') {
+      if (isFullSegmentEncryption(this.method) || this.method === 'NONE') {
         return true;
       }
       if (this.keyFormat === 'identity') {
@@ -2452,14 +2223,13 @@ class LevelKey {
     if (!this.encrypted || !this.uri) {
       return null;
     }
-    if (this.method === 'AES-128' && this.uri && !this.iv) {
+    if (isFullSegmentEncryption(this.method) && this.uri && !this.iv) {
       if (typeof sn !== 'number') {
         // We are fetching decryption data for a initialization segment
-        // If the segment was encrypted with AES-128
+        // If the segment was encrypted with AES-128/256
         // It must have an IV defined. We cannot substitute the Segment Number in.
-        if (this.method === 'AES-128' && !this.iv) {
-          logger.warn(`missing IV for initialization segment with method="${this.method}" - compliance issue`);
-        }
+        logger.warn(`missing IV for initialization segment with method="${this.method}" - compliance issue`);
+
         // Explicitly set sn to resulting value from implicit conversions 'initSegment' values for IV generation.
         sn = 0;
       }
@@ -2609,23 +2379,28 @@ function getCodecCompatibleNameLower(lowerCaseCodec, preferManagedMediaSource =
   if (CODEC_COMPATIBLE_NAMES[lowerCaseCodec]) {
     return CODEC_COMPATIBLE_NAMES[lowerCaseCodec];
   }
-
-  // Idealy fLaC and Opus would be first (spec-compliant) but
-  // some browsers will report that fLaC is supported then fail.
-  // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
   const codecsToCheck = {
+    // Idealy fLaC and Opus would be first (spec-compliant) but
+    // some browsers will report that fLaC is supported then fail.
+    // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
     flac: ['flac', 'fLaC', 'FLAC'],
-    opus: ['opus', 'Opus']
+    opus: ['opus', 'Opus'],
+    // Replace audio codec info if browser does not support mp4a.40.34,
+    // and demuxer can fallback to 'audio/mpeg' or 'audio/mp4;codecs="mp3"'
+    'mp4a.40.34': ['mp3']
   }[lowerCaseCodec];
   for (let i = 0; i < codecsToCheck.length; i++) {
+    var _getMediaSource;
     if (isCodecMediaSourceSupported(codecsToCheck[i], 'audio', preferManagedMediaSource)) {
       CODEC_COMPATIBLE_NAMES[lowerCaseCodec] = codecsToCheck[i];
       return codecsToCheck[i];
+    } else if (codecsToCheck[i] === 'mp3' && (_getMediaSource = getMediaSource(preferManagedMediaSource)) != null && _getMediaSource.isTypeSupported('audio/mpeg')) {
+      return '';
     }
   }
   return lowerCaseCodec;
 }
-const AUDIO_CODEC_REGEXP = /flac|opus/i;
+const AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
 function getCodecCompatibleName(codec, preferManagedMediaSource = true) {
   return codec.replace(AUDIO_CODEC_REGEXP, m => getCodecCompatibleNameLower(m.toLowerCase(), preferManagedMediaSource));
 }
@@ -2648,6 +2423,16 @@ function convertAVC1ToAVCOTI(codec) {
   }
   return codec;
 }
+function getM2TSSupportedAudioTypes(preferManagedMediaSource) {
+  const MediaSource = getMediaSource(preferManagedMediaSource) || {
+    isTypeSupported: () => false
+  };
+  return {
+    mpeg: MediaSource.isTypeSupported('audio/mpeg'),
+    mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
+    ac3: false
+  };
+}
 
 const MASTER_PLAYLIST_REGEX = /#EXT-X-STREAM-INF:([^\r\n]*)(?:[\r\n](?:#[^\r\n]*)?)*([^\r\n]+)|#EXT-X-(SESSION-DATA|SESSION-KEY|DEFINE|CONTENT-STEERING|START):([^\r\n]*)[\r\n]+/g;
 const MASTER_PLAYLIST_MEDIA_REGEX = /#EXT-X-MEDIA:(.*)/g;
@@ -3448,10 +3233,10 @@ class PlaylistLoader {
       const loaderContext = loader.context;
       if (loaderContext && loaderContext.url === context.url && loaderContext.level === context.level) {
         // same URL can't overlap
-        logger.trace('[playlist-loader]: playlist request ongoing');
+        this.hls.logger.trace('[playlist-loader]: playlist request ongoing');
         return;
       }
-      logger.log(`[playlist-loader]: aborting previous loader for type: ${context.type}`);
+      this.hls.logger.log(`[playlist-loader]: aborting previous loader for type: ${context.type}`);
       loader.abort();
     }
 
@@ -3561,7 +3346,7 @@ class PlaylistLoader {
       // alt audio rendition in which quality levels (main)
       // contains both audio+video. but with mixed audio track not signaled
       if (!embeddedAudioFound && levels[0].audioCodec && !levels[0].attrs.AUDIO) {
-        logger.log('[playlist-loader]: audio codec signaled in quality level, but no embedded audio track signaled, create one');
+        this.hls.logger.log('[playlist-loader]: audio codec signaled in quality level, but no embedded audio track signaled, create one');
         audioTracks.unshift({
           type: 'main',
           name: 'main',
@@ -3660,7 +3445,7 @@ class PlaylistLoader {
       message += ` id: ${context.id} group-id: "${context.groupId}"`;
     }
     const error = new Error(message);
-    logger.warn(`[playlist-loader]: ${message}`);
+    this.hls.logger.warn(`[playlist-loader]: ${message}`);
     let details = ErrorDetails.UNKNOWN;
     let fatal = false;
     const loader = this.getInternalLoader(context);
@@ -3898,28 +3683,427 @@ var MetadataSchema = {
   emsg: "https://aomedia.org/emsg/ID3"
 };
 
-const MIN_CUE_DURATION = 0.25;
-function getCueClass() {
-  if (typeof self === 'undefined') return undefined;
-  return self.VTTCue || self.TextTrackCue;
-}
-function createCueWithDataFields(Cue, startTime, endTime, data, type) {
-  let cue = new Cue(startTime, endTime, '');
-  try {
-    cue.value = data;
-    if (type) {
-      cue.type = type;
-    }
-  } catch (e) {
-    cue = new Cue(startTime, endTime, JSON.stringify(type ? _objectSpread2({
-      type
-    }, data) : data));
+/**
+ * Decode an ID3 PRIV frame.
+ *
+ * @param frame - the ID3 PRIV frame
+ *
+ * @returns The decoded ID3 PRIV frame
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function decodeId3PrivFrame(frame) {
+  /*
+  Format: <text string>\0<binary data>
+  */
+  if (frame.size < 2) {
+    return undefined;
   }
-  return cue;
-}
-
-// VTTCue latest draft allows an infinite duration, fallback
-// to MAX_VALUE if necessary
+  const owner = utf8ArrayToStr(frame.data, true);
+  const privateData = new Uint8Array(frame.data.subarray(owner.length + 1));
+  return {
+    key: frame.type,
+    info: owner,
+    data: privateData.buffer
+  };
+}
+
+/**
+ * Decodes an ID3 text frame
+ *
+ * @param frame - the ID3 text frame
+ *
+ * @returns The decoded ID3 text frame
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function decodeId3TextFrame(frame) {
+  if (frame.size < 2) {
+    return undefined;
+  }
+  if (frame.type === 'TXXX') {
+    /*
+    Format:
+    [0]   = {Text Encoding}
+    [1-?] = {Description}\0{Value}
+    */
+    let index = 1;
+    const description = utf8ArrayToStr(frame.data.subarray(index), true);
+    index += description.length + 1;
+    const value = utf8ArrayToStr(frame.data.subarray(index));
+    return {
+      key: frame.type,
+      info: description,
+      data: value
+    };
+  }
+  /*
+  Format:
+  [0]   = {Text Encoding}
+  [1-?] = {Value}
+  */
+  const text = utf8ArrayToStr(frame.data.subarray(1));
+  return {
+    key: frame.type,
+    info: '',
+    data: text
+  };
+}
+
+/**
+ * Decode a URL frame
+ *
+ * @param frame - the ID3 URL frame
+ *
+ * @returns The decoded ID3 URL frame
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function decodeId3UrlFrame(frame) {
+  if (frame.type === 'WXXX') {
+    /*
+    Format:
+    [0]   = {Text Encoding}
+    [1-?] = {Description}\0{URL}
+    */
+    if (frame.size < 2) {
+      return undefined;
+    }
+    let index = 1;
+    const description = utf8ArrayToStr(frame.data.subarray(index), true);
+    index += description.length + 1;
+    const value = utf8ArrayToStr(frame.data.subarray(index));
+    return {
+      key: frame.type,
+      info: description,
+      data: value
+    };
+  }
+  /*
+  Format:
+  [0-?] = {URL}
+  */
+  const url = utf8ArrayToStr(frame.data);
+  return {
+    key: frame.type,
+    info: '',
+    data: url
+  };
+}
+
+function toUint8(data, offset = 0, length = Infinity) {
+  return view(data, offset, length, Uint8Array);
+}
+function view(data, offset, length, Type) {
+  const buffer = unsafeGetArrayBuffer(data);
+  let bytesPerElement = 1;
+  if ('BYTES_PER_ELEMENT' in Type) {
+    bytesPerElement = Type.BYTES_PER_ELEMENT;
+  }
+  // Absolute end of the |data| view within |buffer|.
+  const dataOffset = isArrayBufferView(data) ? data.byteOffset : 0;
+  const dataEnd = (dataOffset + data.byteLength) / bytesPerElement;
+  // Absolute start of the result within |buffer|.
+  const rawStart = (dataOffset + offset) / bytesPerElement;
+  const start = Math.floor(Math.max(0, Math.min(rawStart, dataEnd)));
+  // Absolute end of the result within |buffer|.
+  const end = Math.floor(Math.min(start + Math.max(length, 0), dataEnd));
+  return new Type(buffer, start, end - start);
+}
+function unsafeGetArrayBuffer(view) {
+  if (view instanceof ArrayBuffer) {
+    return view;
+  } else {
+    return view.buffer;
+  }
+}
+function isArrayBufferView(obj) {
+  return obj && obj.buffer instanceof ArrayBuffer && obj.byteLength !== undefined && obj.byteOffset !== undefined;
+}
+
+function toArrayBuffer(view) {
+  if (view instanceof ArrayBuffer) {
+    return view;
+  } else {
+    if (view.byteOffset == 0 && view.byteLength == view.buffer.byteLength) {
+      // This is a TypedArray over the whole buffer.
+      return view.buffer;
+    }
+    // This is a 'view' on the buffer.  Create a new buffer that only contains
+    // the data.  Note that since this isn't an ArrayBuffer, the 'new' call
+    // will allocate a new buffer to hold the copy.
+    return new Uint8Array(view).buffer;
+  }
+}
+
+function decodeId3ImageFrame(frame) {
+  const metadataFrame = {
+    key: frame.type,
+    description: '',
+    data: '',
+    mimeType: null,
+    pictureType: null
+  };
+  const utf8Encoding = 0x03;
+  if (frame.size < 2) {
+    return undefined;
+  }
+  if (frame.data[0] !== utf8Encoding) {
+    console.log('Ignore frame with unrecognized character ' + 'encoding');
+    return undefined;
+  }
+  const mimeTypeEndIndex = frame.data.subarray(1).indexOf(0);
+  if (mimeTypeEndIndex === -1) {
+    return undefined;
+  }
+  const mimeType = utf8ArrayToStr(toUint8(frame.data, 1, mimeTypeEndIndex));
+  const pictureType = frame.data[2 + mimeTypeEndIndex];
+  const descriptionEndIndex = frame.data.subarray(3 + mimeTypeEndIndex).indexOf(0);
+  if (descriptionEndIndex === -1) {
+    return undefined;
+  }
+  const description = utf8ArrayToStr(toUint8(frame.data, 3 + mimeTypeEndIndex, descriptionEndIndex));
+  let data;
+  if (mimeType === '-->') {
+    data = utf8ArrayToStr(toUint8(frame.data, 4 + mimeTypeEndIndex + descriptionEndIndex));
+  } else {
+    data = toArrayBuffer(frame.data.subarray(4 + mimeTypeEndIndex + descriptionEndIndex));
+  }
+  metadataFrame.mimeType = mimeType;
+  metadataFrame.pictureType = pictureType;
+  metadataFrame.description = description;
+  metadataFrame.data = data;
+  return metadataFrame;
+}
+
+/**
+ * Decode an ID3 frame.
+ *
+ * @param frame - the ID3 frame
+ *
+ * @returns The decoded ID3 frame
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function decodeId3Frame(frame) {
+  if (frame.type === 'PRIV') {
+    return decodeId3PrivFrame(frame);
+  } else if (frame.type[0] === 'W') {
+    return decodeId3UrlFrame(frame);
+  } else if (frame.type === 'APIC') {
+    return decodeId3ImageFrame(frame);
+  }
+  return decodeId3TextFrame(frame);
+}
+
+/**
+ * Read ID3 size
+ *
+ * @param data - The data to read from
+ * @param offset - The offset at which to start reading
+ *
+ * @returns The size
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function readId3Size(data, offset) {
+  let size = 0;
+  size = (data[offset] & 0x7f) << 21;
+  size |= (data[offset + 1] & 0x7f) << 14;
+  size |= (data[offset + 2] & 0x7f) << 7;
+  size |= data[offset + 3] & 0x7f;
+  return size;
+}
+
+/**
+ * Returns the data of an ID3 frame.
+ *
+ * @param data - The data to read from
+ *
+ * @returns The data of the ID3 frame
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function getId3FrameData(data) {
+  /*
+  Frame ID       $xx xx xx xx (four characters)
+  Size           $xx xx xx xx
+  Flags          $xx xx
+  */
+  const type = String.fromCharCode(data[0], data[1], data[2], data[3]);
+  const size = readId3Size(data, 4);
+  // skip frame id, size, and flags
+  const offset = 10;
+  return {
+    type,
+    size,
+    data: data.subarray(offset, offset + size)
+  };
+}
+
+/**
+ * Returns true if an ID3 footer can be found at offset in data
+ *
+ * @param data - The data to search in
+ * @param offset - The offset at which to start searching
+ *
+ * @returns `true` if an ID3 footer is found
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function isId3Footer(data, offset) {
+  /*
+   * The footer is a copy of the header, but with a different identifier
+   */
+  if (offset + 10 <= data.length) {
+    // look for '3DI' identifier
+    if (data[offset] === 0x33 && data[offset + 1] === 0x44 && data[offset + 2] === 0x49) {
+      // check version is within range
+      if (data[offset + 3] < 0xff && data[offset + 4] < 0xff) {
+        // check size is within range
+        if (data[offset + 6] < 0x80 && data[offset + 7] < 0x80 && data[offset + 8] < 0x80 && data[offset + 9] < 0x80) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Returns true if an ID3 header can be found at offset in data
+ *
+ * @param data - The data to search in
+ * @param offset - The offset at which to start searching
+ *
+ * @returns `true` if an ID3 header is found
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function isId3Header(data, offset) {
+  /*
+   * http://id3.org/id3v2.3.0
+   * [0]     = 'I'
+   * [1]     = 'D'
+   * [2]     = '3'
+   * [3,4]   = {Version}
+   * [5]     = {Flags}
+   * [6-9]   = {ID3 Size}
+   *
+   * An ID3v2 tag can be detected with the following pattern:
+   *  $49 44 33 yy yy xx zz zz zz zz
+   * Where yy is less than $FF, xx is the 'flags' byte and zz is less than $80
+   */
+  if (offset + 10 <= data.length) {
+    // look for 'ID3' identifier
+    if (data[offset] === 0x49 && data[offset + 1] === 0x44 && data[offset + 2] === 0x33) {
+      // check version is within range
+      if (data[offset + 3] < 0xff && data[offset + 4] < 0xff) {
+        // check size is within range
+        if (data[offset + 6] < 0x80 && data[offset + 7] < 0x80 && data[offset + 8] < 0x80 && data[offset + 9] < 0x80) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+const HEADER_FOOTER_SIZE = 10;
+const FRAME_SIZE = 10;
+/**
+ * Returns an array of ID3 frames found in all the ID3 tags in the id3Data
+ *
+ * @param id3Data - The ID3 data containing one or more ID3 tags
+ *
+ * @returns Array of ID3 frame objects
+ *
+ * @group ID3
+ *
+ * @beta
+ */
+function getId3Frames(id3Data) {
+  let offset = 0;
+  const frames = [];
+  while (isId3Header(id3Data, offset)) {
+    const size = readId3Size(id3Data, offset + 6);
+    if (id3Data[offset + 5] >> 6 & 1) {
+      // skip extended header
+      offset += HEADER_FOOTER_SIZE;
+    }
+    // skip past ID3 header
+    offset += HEADER_FOOTER_SIZE;
+    const end = offset + size;
+    // loop through frames in the ID3 tag
+    while (offset + FRAME_SIZE < end) {
+      const frameData = getId3FrameData(id3Data.subarray(offset));
+      const frame = decodeId3Frame(frameData);
+      if (frame) {
+        frames.push(frame);
+      }
+      // skip frame header and frame data
+      offset += frameData.size + HEADER_FOOTER_SIZE;
+    }
+    if (isId3Footer(id3Data, offset)) {
+      offset += HEADER_FOOTER_SIZE;
+    }
+  }
+  return frames;
+}
+
+/**
+ * Returns true if the ID3 frame is an Elementary Stream timestamp frame
+ *
+ * @param frame - the ID3 frame
+ *
+ * @returns `true` if the ID3 frame is an Elementary Stream timestamp frame
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function isId3TimestampFrame(frame) {
+  return frame && frame.key === 'PRIV' && frame.info === 'com.apple.streaming.transportStreamTimestamp';
+}
+
+const MIN_CUE_DURATION = 0.25;
+function getCueClass() {
+  if (typeof self === 'undefined') return undefined;
+  return self.VTTCue || self.TextTrackCue;
+}
+function createCueWithDataFields(Cue, startTime, endTime, data, type) {
+  let cue = new Cue(startTime, endTime, '');
+  try {
+    cue.value = data;
+    if (type) {
+      cue.type = type;
+    }
+  } catch (e) {
+    cue = new Cue(startTime, endTime, JSON.stringify(type ? _objectSpread2({
+      type
+    }, data) : data));
+  }
+  return cue;
+}
+
+// VTTCue latest draft allows an infinite duration, fallback
+// to MAX_VALUE if necessary
 const MAX_CUE_ENDTIME = (() => {
   const Cue = getCueClass();
   try {
@@ -3980,11 +4164,10 @@ class ID3TrackController {
     this.media = data.media;
   }
   onMediaDetaching() {
-    if (!this.id3Track) {
-      return;
+    if (this.id3Track) {
+      clearCurrentCues(this.id3Track);
+      this.id3Track = null;
     }
-    clearCurrentCues(this.id3Track);
-    this.id3Track = null;
     this.media = null;
     this.dateRangeCuesAppended = {};
   }
@@ -4043,7 +4226,7 @@ class ID3TrackController {
       if (type === MetadataSchema.emsg && !enableEmsgMetadataCues || !enableID3MetadataCues) {
         continue;
       }
-      const frames = getID3Frames(samples[i].data);
+      const frames = getId3Frames(samples[i].data);
       if (frames) {
         const startTime = samples[i].pts;
         let endTime = startTime + samples[i].duration;
@@ -4057,7 +4240,7 @@ class ID3TrackController {
         for (let j = 0; j < frames.length; j++) {
           const frame = frames[j];
           // Safari doesn't put the timestamp frame in the TextTrack
-          if (!isTimeStampFrame(frame)) {
+          if (!isId3TimestampFrame(frame)) {
             // add a bounds to any unbounded cues
             this.updateId3CueEnds(startTime, type);
             const cue = createCueWithDataFields(Cue, startTime, endTime, frame, type);
@@ -4225,7 +4408,47 @@ class LatencyController {
     this.currentTime = 0;
     this.stallCount = 0;
     this._latency = null;
-    this.timeupdateHandler = () => this.timeupdate();
+    this.onTimeupdate = () => {
+      const {
+        media,
+        levelDetails
+      } = this;
+      if (!media || !levelDetails) {
+        return;
+      }
+      this.currentTime = media.currentTime;
+      const latency = this.computeLatency();
+      if (latency === null) {
+        return;
+      }
+      this._latency = latency;
+
+      // Adapt playbackRate to meet target latency in low-latency mode
+      const {
+        lowLatencyMode,
+        maxLiveSyncPlaybackRate
+      } = this.config;
+      if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
+        return;
+      }
+      const targetLatency = this.targetLatency;
+      if (targetLatency === null) {
+        return;
+      }
+      const distanceFromTarget = latency - targetLatency;
+      // Only adjust playbackRate when within one target duration of targetLatency
+      // and more than one second from under-buffering.
+      // Playback further than one target duration from target can be considered DVR playback.
+      const liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
+      const inLiveRange = distanceFromTarget < liveMinLatencyDuration;
+      if (inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
+        const max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
+        const rate = Math.round(2 / (1 + Math.exp(-0.75 * distanceFromTarget - this.edgeStalled)) * 20) / 20;
+        media.playbackRate = Math.min(max, Math.max(1, rate));
+      } else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
+        media.playbackRate = 1;
+      }
+    };
     this.hls = hls;
     this.config = hls.config;
     this.registerListeners();
@@ -4317,7 +4540,7 @@ class LatencyController {
     this.onMediaDetaching();
     this.levelDetails = null;
     // @ts-ignore
-    this.hls = this.timeupdateHandler = null;
+    this.hls = null;
   }
   registerListeners() {
     this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
@@ -4335,11 +4558,11 @@ class LatencyController {
   }
   onMediaAttached(event, data) {
     this.media = data.media;
-    this.media.addEventListener('timeupdate', this.timeupdateHandler);
+    this.media.addEventListener('timeupdate', this.onTimeupdate);
   }
   onMediaDetaching() {
     if (this.media) {
-      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
+      this.media.removeEventListener('timeupdate', this.onTimeupdate);
       this.media = null;
     }
   }
@@ -4353,10 +4576,10 @@ class LatencyController {
   }) {
     this.levelDetails = details;
     if (details.advanced) {
-      this.timeupdate();
+      this.onTimeupdate();
     }
     if (!details.live && this.media) {
-      this.media.removeEventListener('timeupdate', this.timeupdateHandler);
+      this.media.removeEventListener('timeupdate', this.onTimeupdate);
     }
   }
   onError(event, data) {
@@ -4366,48 +4589,7 @@ class LatencyController {
     }
     this.stallCount++;
     if ((_this$levelDetails = this.levelDetails) != null && _this$levelDetails.live) {
-      logger.warn('[playback-rate-controller]: Stall detected, adjusting target latency');
-    }
-  }
-  timeupdate() {
-    const {
-      media,
-      levelDetails
-    } = this;
-    if (!media || !levelDetails) {
-      return;
-    }
-    this.currentTime = media.currentTime;
-    const latency = this.computeLatency();
-    if (latency === null) {
-      return;
-    }
-    this._latency = latency;
-
-    // Adapt playbackRate to meet target latency in low-latency mode
-    const {
-      lowLatencyMode,
-      maxLiveSyncPlaybackRate
-    } = this.config;
-    if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
-      return;
-    }
-    const targetLatency = this.targetLatency;
-    if (targetLatency === null) {
-      return;
-    }
-    const distanceFromTarget = latency - targetLatency;
-    // Only adjust playbackRate when within one target duration of targetLatency
-    // and more than one second from under-buffering.
-    // Playback further than one target duration from target can be considered DVR playback.
-    const liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
-    const inLiveRange = distanceFromTarget < liveMinLatencyDuration;
-    if (inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
-      const max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
-      const rate = Math.round(2 / (1 + Math.exp(-0.75 * distanceFromTarget - this.edgeStalled)) * 20) / 20;
-      media.playbackRate = Math.min(max, Math.max(1, rate));
-    } else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
-      media.playbackRate = 1;
+      this.hls.logger.warn('[latency-controller]: Stall detected, adjusting target latency');
     }
   }
   estimateLiveEdge() {
@@ -5182,18 +5364,13 @@ var ErrorActionFlags = {
   MoveAllAlternatesMatchingHDCP: 2,
   SwitchToSDR: 4
 }; // Reserved for future use
-class ErrorController {
+class ErrorController extends Logger {
   constructor(hls) {
+    super('error-controller', hls.logger);
     this.hls = void 0;
     this.playlistError = 0;
     this.penalizedRenditions = {};
-    this.log = void 0;
-    this.warn = void 0;
-    this.error = void 0;
     this.hls = hls;
-    this.log = logger.log.bind(logger, `[info]:`);
-    this.warn = logger.warn.bind(logger, `[warning]:`);
-    this.error = logger.error.bind(logger, `[error]:`);
     this.registerListeners();
   }
   registerListeners() {
@@ -5545,16 +5722,13 @@ class ErrorController {
   }
 }
 
-class BasePlaylistController {
+class BasePlaylistController extends Logger {
   constructor(hls, logPrefix) {
+    super(logPrefix, hls.logger);
     this.hls = void 0;
     this.timer = -1;
     this.requestScheduled = -1;
     this.canLoad = false;
-    this.log = void 0;
-    this.warn = void 0;
-    this.log = logger.log.bind(logger, `${logPrefix}:`);
-    this.warn = logger.warn.bind(logger, `${logPrefix}:`);
     this.hls = hls;
   }
   destroy() {
@@ -5587,7 +5761,7 @@ class BasePlaylistController {
         try {
           uri = new self.URL(attr.URI, previous.url).href;
         } catch (error) {
-          logger.warn(`Could not construct new URL for Rendition Report: ${error}`);
+          this.warn(`Could not construct new URL for Rendition Report: ${error}`);
           uri = attr.URI || '';
         }
         // Use exact match. Otherwise, the last partial match, if any, will be used
@@ -5675,7 +5849,12 @@ class BasePlaylistController {
         const cdnAge = lastAdvanced + details.ageHeader;
         let currentGoal = Math.min(cdnAge - details.partTarget, details.targetduration * 1.5);
         if (currentGoal > 0) {
-          if (previousDetails && currentGoal > previousDetails.tuneInGoal) {
+          if (cdnAge > details.targetduration * 3) {
+            // Omit segment and part directives when the last response was more than 3 target durations ago,
+            this.log(`Playlist last advanced ${lastAdvanced.toFixed(2)}s ago. Omitting segment and part directives.`);
+            msn = undefined;
+            part = undefined;
+          } else if (previousDetails != null && previousDetails.tuneInGoal && cdnAge - details.partTarget > previousDetails.tuneInGoal) {
             // If we attempted to get the next or latest playlist update, but currentGoal increased,
             // then we either can't catchup, or the "age" header cannot be trusted.
             this.warn(`CDN Tune-in goal increased from: ${previousDetails.tuneInGoal} to: ${currentGoal} with playlist age: ${details.age}`);
@@ -6121,8 +6300,9 @@ function getCodecTiers(levels, audioTracksByGroup, minAutoLevel, maxAutoLevel) {
   }, {});
 }
 
-class AbrController {
+class AbrController extends Logger {
   constructor(_hls) {
+    super('abr', _hls.logger);
     this.hls = void 0;
     this.lastLevelLoadSec = 0;
     this.lastLoadedFragLevel = -1;
@@ -6236,7 +6416,7 @@ class AbrController {
         this.resetEstimator(nextLoadLevelBitrate);
       }
       this.clearTimer();
-      logger.warn(`[abr] Fragment ${frag.sn}${part ? ' part ' + part.index : ''} of level ${frag.level} is loading too slowly;
+      this.warn(`Fragment ${frag.sn}${part ? ' part ' + part.index : ''} of level ${frag.level} is loading too slowly;
       Time to underbuffer: ${bufferStarvationDelay.toFixed(3)} s
       Estimated load time for current fragment: ${fragLoadedDelay.toFixed(3)} s
       Estimated load time for down switch fragment: ${fragLevelNextLoadedDelay.toFixed(3)} s
@@ -6256,7 +6436,7 @@ class AbrController {
   }
   resetEstimator(abrEwmaDefaultEstimate) {
     if (abrEwmaDefaultEstimate) {
-      logger.log(`setting initial bwe to ${abrEwmaDefaultEstimate}`);
+      this.log(`setting initial bwe to ${abrEwmaDefaultEstimate}`);
       this.hls.config.abrEwmaDefaultEstimate = abrEwmaDefaultEstimate;
     }
     this.firstSelection = -1;
@@ -6488,7 +6668,7 @@ class AbrController {
     }
     const firstLevel = this.hls.firstLevel;
     const clamped = Math.min(Math.max(firstLevel, minAutoLevel), maxAutoLevel);
-    logger.warn(`[abr] Could not find best starting auto level. Defaulting to first in playlist ${firstLevel} clamped to ${clamped}`);
+    this.warn(`Could not find best starting auto level. Defaulting to first in playlist ${firstLevel} clamped to ${clamped}`);
     return clamped;
   }
   get forcedAutoLevel() {
@@ -6534,6 +6714,9 @@ class AbrController {
       partCurrent,
       hls
     } = this;
+    if (hls.levels.length <= 1) {
+      return hls.loadLevel;
+    }
     const {
       maxAutoLevel,
       config,
@@ -6566,13 +6749,13 @@ class AbrController {
         // cap maxLoadingDelay and ensure it is not bigger 'than bitrate test' frag duration
         const maxLoadingDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxLoadingDelay) : config.maxLoadingDelay;
         maxStarvationDelay = maxLoadingDelay - bitrateTestDelay;
-        logger.info(`[abr] bitrate test took ${Math.round(1000 * bitrateTestDelay)}ms, set first fragment max fetchDuration to ${Math.round(1000 * maxStarvationDelay)} ms`);
+        this.info(`bitrate test took ${Math.round(1000 * bitrateTestDelay)}ms, set first fragment max fetchDuration to ${Math.round(1000 * maxStarvationDelay)} ms`);
         // don't use conservative factor on bitrate test
         bwFactor = bwUpFactor = 1;
       }
     }
     const bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, maxStarvationDelay, bwFactor, bwUpFactor);
-    logger.info(`[abr] ${bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty'}, optimal quality level ${bestLevel}`);
+    this.info(`${bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty'}, optimal quality level ${bestLevel}`);
     if (bestLevel > -1) {
       return bestLevel;
     }
@@ -6646,7 +6829,7 @@ class AbrController {
       currentVideoRange = preferHDR ? videoRanges[videoRanges.length - 1] : videoRanges[0];
       currentFrameRate = minFramerate;
       currentBw = Math.max(currentBw, minBitrate);
-      logger.log(`[abr] picked start tier ${JSON.stringify(startTier)}`);
+      this.log(`picked start tier ${JSON.stringify(startTier)}`);
     } else {
       currentCodecSet = level == null ? void 0 : level.codecSet;
       currentVideoRange = level == null ? void 0 : level.videoRange;
@@ -6699,9 +6882,9 @@ class AbrController {
         const forcedAutoLevel = this.forcedAutoLevel;
         if (i !== loadLevel && (forcedAutoLevel === -1 || forcedAutoLevel !== loadLevel)) {
           if (levelsSkipped.length) {
-            logger.trace(`[abr] Skipped level(s) ${levelsSkipped.join(',')} of ${maxAutoLevel} max with CODECS and VIDEO-RANGE:"${levels[levelsSkipped[0]].codecs}" ${levels[levelsSkipped[0]].videoRange}; not compatible with "${level.codecs}" ${currentVideoRange}`);
+            this.trace(`Skipped level(s) ${levelsSkipped.join(',')} of ${maxAutoLevel} max with CODECS and VIDEO-RANGE:"${levels[levelsSkipped[0]].codecs}" ${levels[levelsSkipped[0]].videoRange}; not compatible with "${level.codecs}" ${currentVideoRange}`);
           }
-          logger.info(`[abr] switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${currentCodecSet} videoRange:${currentVideoRange} hls.loadLevel:${loadLevel}`);
+          this.info(`switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${currentCodecSet} videoRange:${currentVideoRange} hls.loadLevel:${loadLevel}`);
         }
         if (firstSelection) {
           this.firstSelection = i;
@@ -6744,40 +6927,29 @@ class BufferHelper {
    * Return true if `media`'s buffered include `position`
    */
   static isBuffered(media, position) {
-    try {
-      if (media) {
-        const buffered = BufferHelper.getBuffered(media);
-        for (let i = 0; i < buffered.length; i++) {
-          if (position >= buffered.start(i) && position <= buffered.end(i)) {
-            return true;
-          }
+    if (media) {
+      const buffered = BufferHelper.getBuffered(media);
+      for (let i = buffered.length; i--;) {
+        if (position >= buffered.start(i) && position <= buffered.end(i)) {
+          return true;
         }
       }
-    } catch (error) {
-      // this is to catch
-      // InvalidStateError: Failed to read the 'buffered' property from 'SourceBuffer':
-      // This SourceBuffer has been removed from the parent media source
     }
     return false;
   }
   static bufferInfo(media, pos, maxHoleDuration) {
-    try {
-      if (media) {
-        const vbuffered = BufferHelper.getBuffered(media);
+    if (media) {
+      const vbuffered = BufferHelper.getBuffered(media);
+      if (vbuffered.length) {
         const buffered = [];
-        let i;
-        for (i = 0; i < vbuffered.length; i++) {
+        for (let i = 0; i < vbuffered.length; i++) {
           buffered.push({
             start: vbuffered.start(i),
             end: vbuffered.end(i)
           });
         }
-        return this.bufferedInfo(buffered, pos, maxHoleDuration);
+        return BufferHelper.bufferedInfo(buffered, pos, maxHoleDuration);
       }
-    } catch (error) {
-      // this is to catch
-      // InvalidStateError: Failed to read the 'buffered' property from 'SourceBuffer':
-      // This SourceBuffer has been removed from the parent media source
     }
     return {
       len: 0,
@@ -6789,14 +6961,7 @@ class BufferHelper {
   static bufferedInfo(buffered, pos, maxHoleDuration) {
     pos = Math.max(0, pos);
     // sort on buffer.start/smaller end (IE does not always return sorted buffered range)
-    buffered.sort(function (a, b) {
-      const diff = a.start - b.start;
-      if (diff) {
-        return diff;
-      } else {
-        return b.end - a.end;
-      }
-    });
+    buffered.sort((a, b) => a.start - b.start || b.end - a.end);
     let buffered2 = [];
     if (maxHoleDuration) {
       // there might be some small holes between buffer time range
@@ -6863,7 +7028,7 @@ class BufferHelper {
    */
   static getBuffered(media) {
     try {
-      return media.buffered;
+      return media.buffered || noopBuffered;
     } catch (e) {
       logger.log('failed to get media.buffered', e);
       return noopBuffered;
@@ -6888,24 +7053,22 @@ class BufferOperationQueue {
       this.executeNext(type);
     }
   }
-  insertAbort(operation, type) {
-    const queue = this.queues[type];
-    queue.unshift(operation);
-    this.executeNext(type);
-  }
   appendBlocker(type) {
-    let execute;
-    const promise = new Promise(resolve => {
-      execute = resolve;
+    return new Promise(resolve => {
+      const operation = {
+        execute: resolve,
+        onStart: () => {},
+        onComplete: () => {},
+        onError: () => {}
+      };
+      this.append(operation, type);
     });
-    const operation = {
-      execute,
-      onStart: () => {},
-      onComplete: () => {},
-      onError: () => {}
-    };
-    this.append(operation, type);
-    return promise;
+  }
+  unblockAudio(op) {
+    const queue = this.queues.audio;
+    if (queue[0] === op) {
+      this.shiftAndExecuteNext('audio');
+    }
   }
   executeNext(type) {
     const queue = this.queues[type];
@@ -6937,8 +7100,9 @@ class BufferOperationQueue {
 }
 
 const VIDEO_CODEC_PROFILE_REPLACE = /(avc[1234]|hvc1|hev1|dvh[1e]|vp09|av01)(?:\.[^.,]+)+/;
-class BufferController {
-  constructor(hls) {
+class BufferController extends Logger {
+  constructor(hls, fragmentTracker) {
+    super('buffer-controller', hls.logger);
     // The level details used to determine duration, target-duration and live
     this.details = null;
     // cache the self generated object url to detect hijack of video tag
@@ -6948,6 +7112,7 @@ class BufferController {
     // 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.fragmentTracker = void 0;
     // The number of BUFFER_CODEC events received before any sourceBuffers are created
     this.bufferCodecEventsExpected = 0;
     // The total number of BUFFER_CODEC events received
@@ -6958,6 +7123,10 @@ class BufferController {
     this.mediaSource = null;
     // Last MP3 audio chunk appended
     this.lastMpegAudioChunk = null;
+    // Audio fragment blocked from appending until corresponding video appends or context changes
+    this.blockedAudioAppend = null;
+    // Keep track of video append position for unblocking audio
+    this.lastVideoAppendEnd = 0;
     this.appendSource = void 0;
     // counters
     this.appendErrors = {
@@ -6968,9 +7137,6 @@ class BufferController {
     this.tracks = {};
     this.pendingTracks = {};
     this.sourceBuffer = void 0;
-    this.log = void 0;
-    this.warn = void 0;
-    this.error = void 0;
     this._onEndStreaming = event => {
       if (!this.hls) {
         return;
@@ -6992,7 +7158,10 @@ class BufferController {
       this.log('Media source opened');
       if (media) {
         media.removeEventListener('emptied', this._onMediaEmptied);
-        this.updateMediaElementDuration();
+        const durationAndRange = this.getDurationAndRange();
+        if (durationAndRange) {
+          this.updateMediaSource(durationAndRange);
+        }
         this.hls.trigger(Events.MEDIA_ATTACHED, {
           media,
           mediaSource: mediaSource
@@ -7016,15 +7185,12 @@ class BufferController {
         _objectUrl
       } = this;
       if (mediaSrc !== _objectUrl) {
-        logger.error(`Media element src was set while attaching MediaSource (${_objectUrl} > ${mediaSrc})`);
+        this.error(`Media element src was set while attaching MediaSource (${_objectUrl} > ${mediaSrc})`);
       }
     };
     this.hls = hls;
-    const logPrefix = '[buffer-controller]';
+    this.fragmentTracker = fragmentTracker;
     this.appendSource = isManagedMediaSource(getMediaSource(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();
   }
@@ -7036,7 +7202,13 @@ class BufferController {
     this.details = null;
     this.lastMpegAudioChunk = null;
     // @ts-ignore
-    this.hls = null;
+    this.hls = this.fragmentTracker = null;
+    // @ts-ignore
+    this._onMediaSourceOpen = this._onMediaSourceClose = null;
+    // @ts-ignore
+    this._onMediaSourceEnded = null;
+    // @ts-ignore
+    this._onStartStreaming = this._onEndStreaming = null;
   }
   registerListeners() {
     const {
@@ -7086,6 +7258,8 @@ class BufferController {
       audiovideo: 0
     };
     this.lastMpegAudioChunk = null;
+    this.blockedAudioAppend = null;
+    this.lastVideoAppendEnd = 0;
   }
   onManifestLoading() {
     this.bufferCodecEventsExpected = this._bufferCodecEventsTotal = 0;
@@ -7168,34 +7342,34 @@ class BufferController {
         mediaSource.removeEventListener('startstreaming', this._onStartStreaming);
         mediaSource.removeEventListener('endstreaming', this._onEndStreaming);
       }
+      this.mediaSource = null;
+      this._objectUrl = null;
+    }
 
-      // Detach properly the MediaSource from the HTMLMediaElement as
-      // suggested in https://github.com/w3c/media-source/issues/53.
-      if (media) {
-        media.removeEventListener('emptied', this._onMediaEmptied);
-        if (_objectUrl) {
-          self.URL.revokeObjectURL(_objectUrl);
-        }
+    // Detach properly the MediaSource from the HTMLMediaElement as
+    // suggested in https://github.com/w3c/media-source/issues/53.
+    if (media) {
+      media.removeEventListener('emptied', this._onMediaEmptied);
+      if (_objectUrl) {
+        self.URL.revokeObjectURL(_objectUrl);
+      }
 
-        // clean up video tag src only if it's our own url. some external libraries might
-        // hijack the video tag and change its 'src' without destroying the Hls instance first
-        if (this.mediaSrc === _objectUrl) {
-          media.removeAttribute('src');
-          if (this.appendSource) {
-            removeSourceChildren(media);
-          }
-          media.load();
-        } else {
-          this.warn('media|source.src was changed by a third party - skip cleanup');
+      // clean up video tag src only if it's our own url. some external libraries might
+      // hijack the video tag and change its 'src' without destroying the Hls instance first
+      if (this.mediaSrc === _objectUrl) {
+        media.removeAttribute('src');
+        if (this.appendSource) {
+          removeSourceChildren(media);
         }
+        media.load();
+      } else {
+        this.warn('media|source.src was changed by a third party - skip cleanup');
       }
-      this.mediaSource = null;
       this.media = null;
-      this._objectUrl = null;
-      this.bufferCodecEventsExpected = this._bufferCodecEventsTotal;
-      this.pendingTracks = {};
-      this.tracks = {};
     }
+    this.bufferCodecEventsExpected = this._bufferCodecEventsTotal;
+    this.pendingTracks = {};
+    this.tracks = {};
     this.hls.trigger(Events.MEDIA_DETACHED, undefined);
   }
   onBufferReset() {
@@ -7203,6 +7377,7 @@ class BufferController {
       this.resetBuffer(type);
     });
     this._initSourceBuffer();
+    this.hls.resumeBuffering();
   }
   resetBuffer(type) {
     const sb = this.sourceBuffer[type];
@@ -7226,9 +7401,10 @@ class BufferController {
     const trackNames = Object.keys(data);
     trackNames.forEach(trackName => {
       if (sourceBufferCount) {
+        var _track$buffer;
         // check if SourceBuffer codec needs to change
         const track = this.tracks[trackName];
-        if (track && typeof track.buffer.changeType === 'function') {
+        if (track && typeof ((_track$buffer = track.buffer) == null ? void 0 : _track$buffer.changeType) === 'function') {
           var _trackCodec;
           const {
             id,
@@ -7298,20 +7474,54 @@ class BufferController {
     };
     operationQueue.append(operation, type, !!this.pendingTracks[type]);
   }
+  blockAudio(partOrFrag) {
+    var _this$fragmentTracker;
+    const pStart = partOrFrag.start;
+    const pTime = pStart + partOrFrag.duration * 0.05;
+    const atGap = ((_this$fragmentTracker = this.fragmentTracker.getAppendedFrag(pStart, PlaylistLevelType.MAIN)) == null ? void 0 : _this$fragmentTracker.gap) === true;
+    if (atGap) {
+      return;
+    }
+    const op = {
+      execute: () => {
+        var _this$fragmentTracker2;
+        if (this.lastVideoAppendEnd > pTime || this.sourceBuffer.video && BufferHelper.isBuffered(this.sourceBuffer.video, pTime) || ((_this$fragmentTracker2 = this.fragmentTracker.getAppendedFrag(pTime, PlaylistLevelType.MAIN)) == null ? void 0 : _this$fragmentTracker2.gap) === true) {
+          this.blockedAudioAppend = null;
+          this.operationQueue.shiftAndExecuteNext('audio');
+        }
+      },
+      onStart: () => {},
+      onComplete: () => {},
+      onError: () => {}
+    };
+    this.blockedAudioAppend = {
+      op,
+      frag: partOrFrag
+    };
+    this.operationQueue.append(op, 'audio', true);
+  }
+  unblockAudio() {
+    const blockedAudioAppend = this.blockedAudioAppend;
+    if (blockedAudioAppend) {
+      this.blockedAudioAppend = null;
+      this.operationQueue.unblockAudio(blockedAudioAppend.op);
+    }
+  }
   onBufferAppending(event, eventData) {
     const {
-      hls,
       operationQueue,
       tracks
     } = this;
     const {
       data,
       type,
+      parent,
       frag,
       part,
       chunkMeta
     } = eventData;
     const chunkStats = chunkMeta.buffering[type];
+    const sn = frag.sn;
     const bufferAppendingStart = self.performance.now();
     chunkStats.start = bufferAppendingStart;
     const fragBuffering = frag.stats.buffering;
@@ -7334,7 +7544,36 @@ class BufferController {
       checkTimestampOffset = !this.lastMpegAudioChunk || chunkMeta.id === 1 || this.lastMpegAudioChunk.sn !== chunkMeta.sn;
       this.lastMpegAudioChunk = chunkMeta;
     }
-    const fragStart = frag.start;
+
+    // Block audio append until overlapping video append
+    const videoSb = this.sourceBuffer.video;
+    if (videoSb && sn !== 'initSegment') {
+      const partOrFrag = part || frag;
+      const blockedAudioAppend = this.blockedAudioAppend;
+      if (type === 'audio' && parent !== 'main' && !this.blockedAudioAppend) {
+        const pStart = partOrFrag.start;
+        const pTime = pStart + partOrFrag.duration * 0.05;
+        const vbuffered = videoSb.buffered;
+        const vappending = this.operationQueue.current('video');
+        if (!vbuffered.length && !vappending) {
+          // wait for video before appending audio
+          this.blockAudio(partOrFrag);
+        } else if (!vappending && !BufferHelper.isBuffered(videoSb, pTime) && this.lastVideoAppendEnd < pTime) {
+          // audio is ahead of video
+          this.blockAudio(partOrFrag);
+        }
+      } else if (type === 'video') {
+        const videoAppendEnd = partOrFrag.end;
+        if (blockedAudioAppend) {
+          const audioStart = blockedAudioAppend.frag.start;
+          if (videoAppendEnd > audioStart || videoAppendEnd < this.lastVideoAppendEnd || BufferHelper.isBuffered(videoSb, audioStart)) {
+            this.unblockAudio();
+          }
+        }
+        this.lastVideoAppendEnd = videoAppendEnd;
+      }
+    }
+    const fragStart = (part || frag).start;
     const operation = {
       execute: () => {
         chunkStats.executeStart = self.performance.now();
@@ -7343,7 +7582,7 @@ class BufferController {
           if (sb) {
             const delta = fragStart - sb.timestampOffset;
             if (Math.abs(delta) >= 0.1) {
-              this.log(`Updating audio SourceBuffer timestampOffset to ${fragStart} (delta: ${delta}) sn: ${frag.sn})`);
+              this.log(`Updating audio SourceBuffer timestampOffset to ${fragStart} (delta: ${delta}) sn: ${sn})`);
               sb.timestampOffset = fragStart;
             }
           }
@@ -7410,22 +7649,21 @@ class BufferController {
           /* with UHD content, we could get loop of quota exceeded error until
             browser is able to evict some data from sourcebuffer. Retrying can help recover.
           */
-          this.warn(`Failed ${appendErrorCount}/${hls.config.appendErrorMaxRetry} times to append segment in "${type}" sourceBuffer`);
-          if (appendErrorCount >= hls.config.appendErrorMaxRetry) {
+          this.warn(`Failed ${appendErrorCount}/${this.hls.config.appendErrorMaxRetry} times to append segment in "${type}" sourceBuffer`);
+          if (appendErrorCount >= this.hls.config.appendErrorMaxRetry) {
             event.fatal = true;
           }
         }
-        hls.trigger(Events.ERROR, event);
+        this.hls.trigger(Events.ERROR, event);
       }
     };
     operationQueue.append(operation, type, !!this.pendingTracks[type]);
   }
-  onBufferFlushing(event, data) {
-    const {
-      operationQueue
-    } = this;
-    const flushOperation = type => ({
-      execute: this.removeExecutor.bind(this, type, data.startOffset, data.endOffset),
+  getFlushOp(type, start, end) {
+    return {
+      execute: () => {
+        this.removeExecutor(type, start, end);
+      },
       onStart: () => {
         // logger.debug(`[buffer-controller]: Started flushing ${data.startOffset} -> ${data.endOffset} for ${type} Source Buffer`);
       },
@@ -7438,12 +7676,22 @@ class BufferController {
       onError: error => {
         this.warn(`Failed to remove from ${type} SourceBuffer`, error);
       }
-    });
-    if (data.type) {
-      operationQueue.append(flushOperation(data.type), data.type);
+    };
+  }
+  onBufferFlushing(event, data) {
+    const {
+      operationQueue
+    } = this;
+    const {
+      type,
+      startOffset,
+      endOffset
+    } = data;
+    if (type) {
+      operationQueue.append(this.getFlushOp(type, startOffset, endOffset), type);
     } else {
-      this.getSourceBufferTypes().forEach(type => {
-        operationQueue.append(flushOperation(type), type);
+      this.getSourceBufferTypes().forEach(sbType => {
+        operationQueue.append(this.getFlushOp(sbType, startOffset, endOffset), sbType);
       });
     }
   }
@@ -7490,6 +7738,9 @@ class BufferController {
   // on BUFFER_EOS mark matching sourcebuffer(s) as ended and trigger checkEos()
   // an undefined data.type will mark all buffers as EOS.
   onBufferEos(event, data) {
+    if (data.type === 'video') {
+      this.unblockAudio();
+    }
     const ended = this.getSourceBufferTypes().reduce((acc, type) => {
       const sb = this.sourceBuffer[type];
       if (sb && (!data.type || data.type === type)) {
@@ -7532,10 +7783,14 @@ class BufferController {
       return;
     }
     this.details = details;
+    const durationAndRange = this.getDurationAndRange();
+    if (!durationAndRange) {
+      return;
+    }
     if (this.getSourceBufferTypes().length) {
-      this.blockBuffers(this.updateMediaElementDuration.bind(this));
+      this.blockBuffers(() => this.updateMediaSource(durationAndRange));
     } else {
-      this.updateMediaElementDuration();
+      this.updateMediaSource(durationAndRange);
     }
   }
   trimBuffers() {
@@ -7640,9 +7895,9 @@ class BufferController {
    * 'liveDurationInfinity` is set to `true`
    * More details: https://github.com/video-dev/hls.js/issues/355
    */
-  updateMediaElementDuration() {
+  getDurationAndRange() {
     if (!this.details || !this.media || !this.mediaSource || this.mediaSource.readyState !== 'open') {
-      return;
+      return null;
     }
     const {
       details,
@@ -7656,25 +7911,41 @@ class BufferController {
     if (details.live && hls.config.liveDurationInfinity) {
       // Override duration to Infinity
       mediaSource.duration = Infinity;
-      this.updateSeekableRange(details);
+      const len = details.fragments.length;
+      if (len && details.live && !!mediaSource.setLiveSeekableRange) {
+        const start = Math.max(0, details.fragments[0].start);
+        const end = Math.max(start, start + details.totalduration);
+        return {
+          duration: Infinity,
+          start,
+          end
+        };
+      }
+      return {
+        duration: Infinity
+      };
     } else if (levelDuration > msDuration && levelDuration > mediaDuration || !isFiniteNumber(mediaDuration)) {
-      // levelDuration was the last value we set.
-      // not using mediaSource.duration as the browser may tweak this value
-      // only update Media Source duration if its value increase, this is to avoid
-      // flushing already buffered portion when switching between quality level
-      this.log(`Updating Media Source duration to ${levelDuration.toFixed(3)}`);
-      mediaSource.duration = levelDuration;
+      return {
+        duration: levelDuration
+      };
     }
+    return null;
   }
-  updateSeekableRange(levelDetails) {
-    const mediaSource = this.mediaSource;
-    const fragments = levelDetails.fragments;
-    const len = fragments.length;
-    if (len && levelDetails.live && mediaSource != null && mediaSource.setLiveSeekableRange) {
-      const start = Math.max(0, fragments[0].start);
-      const end = Math.max(start, start + levelDetails.totalduration);
-      this.log(`Media Source duration is set to ${mediaSource.duration}. Setting seekable range to ${start}-${end}.`);
-      mediaSource.setLiveSeekableRange(start, end);
+  updateMediaSource({
+    duration,
+    start,
+    end
+  }) {
+    if (!this.media || !this.mediaSource || this.mediaSource.readyState !== 'open') {
+      return;
+    }
+    if (isFiniteNumber(duration)) {
+      this.log(`Updating Media Source duration to ${duration.toFixed(3)}`);
+    }
+    this.mediaSource.duration = duration;
+    if (start !== undefined && end !== undefined) {
+      this.log(`Media Source duration is set to ${this.mediaSource.duration}. Setting seekable range to ${start}-${end}.`);
+      this.mediaSource.setLiveSeekableRange(start, end);
     }
   }
   checkPendingTracks() {
@@ -7860,6 +8131,7 @@ class BufferController {
       }
       return;
     }
+    sb.ending = false;
     sb.ended = false;
     sb.appendBuffer(data);
   }
@@ -7879,10 +8151,14 @@ class BufferController {
 
     // logger.debug(`[buffer-controller]: Blocking ${buffers} SourceBuffer`);
     const blockingOperations = buffers.map(type => operationQueue.appendBlocker(type));
-    Promise.all(blockingOperations).then(() => {
+    const audioBlocked = buffers.length > 1 && !!this.blockedAudioAppend;
+    if (audioBlocked) {
+      this.unblockAudio();
+    }
+    Promise.all(blockingOperations).then(result => {
       // logger.debug(`[buffer-controller]: Blocking operation resolved; unblocking ${buffers} SourceBuffer`);
       onUnblocked();
-      buffers.forEach(type => {
+      buffers.forEach((type, i) => {
         const sb = this.sourceBuffer[type];
         // Only cycle the queue if the SB is not updating. There's a bug in Chrome which sets the SB updating flag to
         // true when changing the MediaSource duration (https://bugs.chromium.org/p/chromium/issues/detail?id=959359&can=2&q=mediasource%20duration)
@@ -8031,6 +8307,7 @@ class CapLevelController {
   }
   onMediaDetaching() {
     this.stopCapping();
+    this.media = null;
   }
   detectPlayerSize() {
     if (this.media) {
@@ -8043,10 +8320,10 @@ class CapLevelController {
         const hls = this.hls;
         const maxLevel = this.getMaxLevel(levels.length - 1);
         if (maxLevel !== this.autoLevelCapping) {
-          logger.log(`Setting autoLevelCapping to ${maxLevel}: ${levels[maxLevel].height}p@${levels[maxLevel].bitrate} for media ${this.mediaWidth}x${this.mediaHeight}`);
+          hls.logger.log(`Setting autoLevelCapping to ${maxLevel}: ${levels[maxLevel].height}p@${levels[maxLevel].bitrate} for media ${this.mediaWidth}x${this.mediaHeight}`);
         }
         hls.autoLevelCapping = maxLevel;
-        if (hls.autoLevelCapping > this.autoLevelCapping && this.streamController) {
+        if (hls.autoLevelEnabled && hls.autoLevelCapping > this.autoLevelCapping && this.streamController) {
           // if auto level capping has a higher value for the previous one, flush the buffer using nextLevelSwitch
           // usually happen when the user go to the fullscreen mode.
           this.streamController.nextLevelSwitch();
@@ -8182,9 +8459,11 @@ class FPSController {
   }
   registerListeners() {
     this.hls.on(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
+    this.hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
   }
   unregisterListeners() {
     this.hls.off(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
+    this.hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
   }
   destroy() {
     if (this.timer) {
@@ -8206,6 +8485,9 @@ class FPSController {
       this.timer = self.setInterval(this.checkFPSInterval.bind(this), config.fpsDroppedMonitoringPeriod);
     }
   }
+  onMediaDetaching() {
+    this.media = null;
+  }
   checkFPS(video, decodedFrames, droppedFrames) {
     const currentTime = performance.now();
     if (decodedFrames) {
@@ -8221,10 +8503,10 @@ class FPSController {
           totalDroppedFrames: droppedFrames
         });
         if (droppedFPS > 0) {
-          // logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
+          // hls.logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
           if (currentDropped > hls.config.fpsDroppedMonitoringThreshold * currentDecoded) {
             let currentLevel = hls.currentLevel;
-            logger.warn('drop FPS ratio greater than max allowed value for currentLevel: ' + currentLevel);
+            hls.logger.warn('drop FPS ratio greater than max allowed value for currentLevel: ' + currentLevel);
             if (currentLevel > 0 && (hls.autoLevelCapping === -1 || hls.autoLevelCapping >= currentLevel)) {
               currentLevel = currentLevel - 1;
               hls.trigger(Events.FPS_DROP_LEVEL_CAPPING, {
@@ -8257,14 +8539,14 @@ class FPSController {
 }
 
 const PATHWAY_PENALTY_DURATION_MS = 300000;
-class ContentSteeringController {
+class ContentSteeringController extends Logger {
   constructor(hls) {
+    super('content-steering', hls.logger);
     this.hls = void 0;
-    this.log = void 0;
     this.loader = null;
     this.uri = null;
     this.pathwayId = '.';
-    this.pathwayPriority = null;
+    this._pathwayPriority = null;
     this.timeToLoad = 300;
     this.reloadTimer = -1;
     this.updated = 0;
@@ -8275,7 +8557,6 @@ class ContentSteeringController {
     this.subtitleTracks = null;
     this.penalizedPathways = {};
     this.hls = hls;
-    this.log = logger.log.bind(logger, `[content-steering]:`);
     this.registerListeners();
   }
   registerListeners() {
@@ -8295,6 +8576,20 @@ class ContentSteeringController {
     hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
     hls.off(Events.ERROR, this.onError, this);
   }
+  pathways() {
+    return (this.levels || []).reduce((pathways, level) => {
+      if (pathways.indexOf(level.pathwayId) === -1) {
+        pathways.push(level.pathwayId);
+      }
+      return pathways;
+    }, []);
+  }
+  get pathwayPriority() {
+    return this._pathwayPriority;
+  }
+  set pathwayPriority(pathwayPriority) {
+    this.updatePathwayPriority(pathwayPriority);
+  }
   startLoad() {
     this.started = true;
     this.clearTimeout();
@@ -8368,7 +8663,7 @@ class ContentSteeringController {
     } = data;
     if ((errorAction == null ? void 0 : errorAction.action) === NetworkErrorAction.SendAlternateToPenaltyBox && errorAction.flags === ErrorActionFlags.MoveAllAlternatesMatchingHost) {
       const levels = this.levels;
-      let pathwayPriority = this.pathwayPriority;
+      let pathwayPriority = this._pathwayPriority;
       let errorPathway = this.pathwayId;
       if (data.context) {
         const {
@@ -8387,19 +8682,14 @@ class ContentSteeringController {
       }
       if (!pathwayPriority && levels) {
         // If PATHWAY-PRIORITY was not provided, list pathways for error handling
-        pathwayPriority = levels.reduce((pathways, level) => {
-          if (pathways.indexOf(level.pathwayId) === -1) {
-            pathways.push(level.pathwayId);
-          }
-          return pathways;
-        }, []);
+        pathwayPriority = this.pathways();
       }
       if (pathwayPriority && pathwayPriority.length > 1) {
         this.updatePathwayPriority(pathwayPriority);
         errorAction.resolved = this.pathwayId !== errorPathway;
       }
       if (!errorAction.resolved) {
-        logger.warn(`Could not resolve ${data.details} ("${data.error.message}") with content-steering for Pathway: ${errorPathway} levels: ${levels ? levels.length : levels} priorities: ${JSON.stringify(pathwayPriority)} penalized: ${JSON.stringify(this.penalizedPathways)}`);
+        this.warn(`Could not resolve ${data.details} ("${data.error.message}") with content-steering for Pathway: ${errorPathway} levels: ${levels ? levels.length : levels} priorities: ${JSON.stringify(pathwayPriority)} penalized: ${JSON.stringify(this.penalizedPathways)}`);
       }
     }
   }
@@ -8426,7 +8716,7 @@ class ContentSteeringController {
     return this.levels.filter(level => pathwayId === level.pathwayId);
   }
   updatePathwayPriority(pathwayPriority) {
-    this.pathwayPriority = pathwayPriority;
+    this._pathwayPriority = pathwayPriority;
     let levels;
 
     // Evaluate if we should remove the pathway from the penalized list
@@ -8570,7 +8860,7 @@ class ContentSteeringController {
       onSuccess: (response, stats, context, networkDetails) => {
         this.log(`Loaded steering manifest: "${url}"`);
         const steeringData = response.data;
-        if (steeringData.VERSION !== 1) {
+        if ((steeringData == null ? void 0 : steeringData.VERSION) !== 1) {
           this.log(`Steering VERSION ${steeringData.VERSION} not supported!`);
           return;
         }
@@ -9478,7 +9768,7 @@ const hlsDefaultConfig = _objectSpread2(_objectSpread2({
 });
 function timelineConfig() {
   return {
-    cueHandler: Cues,
+    cueHandler: HevcVideoParser,
     // used by timeline-controller
     enableWebVTT: false,
     // used by timeline-controller
@@ -9509,7 +9799,7 @@ function timelineConfig() {
 /**
  * @ignore
  */
-function mergeConfig(defaultConfig, userConfig) {
+function mergeConfig(defaultConfig, userConfig, logger) {
   if ((userConfig.liveSyncDurationCount || userConfig.liveMaxLatencyDurationCount) && (userConfig.liveSyncDuration || userConfig.liveMaxLatencyDuration)) {
     throw new Error("Illegal hls.js config: don't mix up liveSyncDurationCount/liveMaxLatencyDurationCount and liveSyncDuration/liveMaxLatencyDuration");
   }
@@ -9579,7 +9869,7 @@ function deepCpy(obj) {
 /**
  * @ignore
  */
-function enableStreamingMode(config) {
+function enableStreamingMode(config, logger) {
   const currentLoader = config.loader;
   if (currentLoader !== FetchLoader && currentLoader !== XhrLoader) {
     // If a developer has configured their own loader, respect that choice
@@ -9596,10 +9886,9 @@ function enableStreamingMode(config) {
   }
 }
 
-let chromeOrFirefox;
 class LevelController extends BasePlaylistController {
   constructor(hls, contentSteeringController) {
-    super(hls, '[level-controller]');
+    super(hls, 'level-controller');
     this._levels = [];
     this._firstLevel = -1;
     this._maxAutoLevel = -1;
@@ -9670,23 +9959,15 @@ class LevelController extends BasePlaylistController {
     let videoCodecFound = false;
     let audioCodecFound = false;
     data.levels.forEach(levelParsed => {
-      var _audioCodec, _videoCodec;
+      var _videoCodec;
       const attributes = levelParsed.attrs;
-
-      // erase audio codec info if browser does not support mp4a.40.34.
-      // demuxer will autodetect codec and fallback to mpeg/audio
       let {
         audioCodec,
         videoCodec
       } = levelParsed;
-      if (((_audioCodec = audioCodec) == null ? void 0 : _audioCodec.indexOf('mp4a.40.34')) !== -1) {
-        chromeOrFirefox || (chromeOrFirefox = /chrome|firefox/i.test(navigator.userAgent));
-        if (chromeOrFirefox) {
-          levelParsed.audioCodec = audioCodec = undefined;
-        }
-      }
       if (audioCodec) {
-        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource);
+        // Returns empty and set to undefined for 'mp4a.40.34' with fallback to 'audio/mpeg' SourceBuffer
+        levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource) || undefined;
       }
       if (((_videoCodec = videoCodec) == null ? void 0 : _videoCodec.indexOf('avc1')) === 0) {
         videoCodec = levelParsed.videoCodec = convertAVC1ToAVCOTI(videoCodec);
@@ -9981,6 +10262,25 @@ class LevelController extends BasePlaylistController {
   set startLevel(newLevel) {
     this._startLevel = newLevel;
   }
+  get pathwayPriority() {
+    if (this.steering) {
+      return this.steering.pathwayPriority;
+    }
+    return null;
+  }
+  set pathwayPriority(pathwayPriority) {
+    if (this.steering) {
+      const pathwaysList = this.steering.pathways();
+      const filteredPathwayPriority = pathwayPriority.filter(pathwayId => {
+        return pathwaysList.indexOf(pathwayId) !== -1;
+      });
+      if (pathwayPriority.length < 1) {
+        this.warn(`pathwayPriority ${pathwayPriority} should contain at least one pathway from list: ${pathwaysList}`);
+        return;
+      }
+      this.steering.pathwayPriority = filteredPathwayPriority;
+    }
+  }
   onError(event, data) {
     if (data.fatal || !data.context) {
       return;
@@ -10028,7 +10328,12 @@ class LevelController extends BasePlaylistController {
       if (curLevel.fragmentError === 0) {
         curLevel.loadError = 0;
       }
-      this.playlistLoaded(level, data, curLevel.details);
+      // Ignore matching details populated by loading a Media Playlist directly
+      let previousDetails = curLevel.details;
+      if (previousDetails === data.details && previousDetails.advanced) {
+        previousDetails = undefined;
+      }
+      this.playlistLoaded(level, data, previousDetails);
     } else if ((_data$deliveryDirecti2 = data.deliveryDirectives) != null && _data$deliveryDirecti2.skip) {
       // received a delta playlist update that cannot be merged
       details.deltaUpdateFailed = true;
@@ -10206,13 +10511,16 @@ class FragmentTracker {
    * If not found any Fragment, return null
    */
   getBufferedFrag(position, levelType) {
+    return this.getFragAtPos(position, levelType, true);
+  }
+  getFragAtPos(position, levelType, buffered) {
     const {
       fragments
     } = this;
     const keys = Object.keys(fragments);
     for (let i = keys.length; i--;) {
       const fragmentEntity = fragments[keys[i]];
-      if ((fragmentEntity == null ? void 0 : fragmentEntity.body.type) === levelType && fragmentEntity.buffered) {
+      if ((fragmentEntity == null ? void 0 : fragmentEntity.body.type) === levelType && (!buffered || fragmentEntity.buffered)) {
         const frag = fragmentEntity.body;
         if (frag.start <= position && position <= frag.end) {
           return frag;
@@ -10467,7 +10775,8 @@ class FragmentTracker {
     const {
       frag,
       part,
-      timeRanges
+      timeRanges,
+      type
     } = data;
     if (frag.sn === 'initSegment') {
       return;
@@ -10482,10 +10791,8 @@ class FragmentTracker {
     }
     // Store the latest timeRanges loaded in the buffer
     this.timeRanges = timeRanges;
-    Object.keys(timeRanges).forEach(elementaryStream => {
-      const timeRange = timeRanges[elementaryStream];
-      this.detectEvictedFragments(elementaryStream, timeRange, playlistType, part);
-    });
+    const timeRange = timeRanges[type];
+    this.detectEvictedFragments(type, timeRange, playlistType, part);
   }
   onFragBuffered(event, data) {
     this.detectPartialFragments(data);
@@ -10814,8 +11121,8 @@ function createLoaderContext(frag, part = null) {
     var _frag$decryptdata;
     let byteRangeStart = start;
     let byteRangeEnd = end;
-    if (frag.sn === 'initSegment' && ((_frag$decryptdata = frag.decryptdata) == null ? void 0 : _frag$decryptdata.method) === 'AES-128') {
-      // MAP segment encrypted with method 'AES-128', when served with HTTP Range,
+    if (frag.sn === 'initSegment' && isMethodFullSegmentAesCbc((_frag$decryptdata = frag.decryptdata) == null ? void 0 : _frag$decryptdata.method)) {
+      // MAP segment encrypted with method 'AES-128' or 'AES-256' (cbc), when served with HTTP Range,
       // has the unencrypted size specified in the range.
       // Ref: https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-6.3.6
       const fragmentLen = end - start;
@@ -10848,6 +11155,9 @@ function createGapLoadError(frag, part) {
   (part ? part : frag).stats.aborted = true;
   return new LoadError(errorData);
 }
+function isMethodFullSegmentAesCbc(method) {
+  return method === 'AES-128' || method === 'AES-256';
+}
 class LoadError extends Error {
   constructor(data) {
     super(data.error.message);
@@ -10993,6 +11303,8 @@ class KeyLoader {
         }
         return this.loadKeyEME(keyInfo, frag);
       case 'AES-128':
+      case 'AES-256':
+      case 'AES-256-CTR':
         return this.loadKeyHTTP(keyInfo, frag);
       default:
         return Promise.reject(this.createKeyLoadError(frag, ErrorDetails.KEY_LOAD_ERROR, new Error(`Key supplied with unsupported METHOD: "${decryptdata.method}"`)));
@@ -11128,8 +11440,9 @@ class KeyLoader {
  * we are limiting the task execution per call stack to exactly one, but scheduling/post-poning further
  * task processing on the next main loop iteration (also known as "next tick" in the Node/JS runtime lingo).
  */
-class TaskLoop {
-  constructor() {
+class TaskLoop extends Logger {
+  constructor(label, logger) {
+    super(label, logger);
     this._boundTick = void 0;
     this._tickTimer = null;
     this._tickInterval = null;
@@ -11397,33 +11710,61 @@ function alignMediaPlaylistByPDT(details, refDetails) {
 }
 
 class AESCrypto {
-  constructor(subtle, iv) {
+  constructor(subtle, iv, aesMode) {
     this.subtle = void 0;
     this.aesIV = void 0;
+    this.aesMode = void 0;
     this.subtle = subtle;
     this.aesIV = iv;
+    this.aesMode = aesMode;
   }
   decrypt(data, key) {
-    return this.subtle.decrypt({
-      name: 'AES-CBC',
-      iv: this.aesIV
-    }, key, data);
+    switch (this.aesMode) {
+      case DecrypterAesMode.cbc:
+        return this.subtle.decrypt({
+          name: 'AES-CBC',
+          iv: this.aesIV
+        }, key, data);
+      case DecrypterAesMode.ctr:
+        return this.subtle.decrypt({
+          name: 'AES-CTR',
+          counter: this.aesIV,
+          length: 64
+        },
+        //64 : NIST SP800-38A standard suggests that the counter should occupy half of the counter block
+        key, data);
+      default:
+        throw new Error(`[AESCrypto] invalid aes mode ${this.aesMode}`);
+    }
   }
 }
 
 class FastAESKey {
-  constructor(subtle, key) {
+  constructor(subtle, key, aesMode) {
     this.subtle = void 0;
     this.key = void 0;
+    this.aesMode = void 0;
     this.subtle = subtle;
     this.key = key;
+    this.aesMode = aesMode;
   }
   expandKey() {
+    const subtleAlgoName = getSubtleAlgoName(this.aesMode);
     return this.subtle.importKey('raw', this.key, {
-      name: 'AES-CBC'
+      name: subtleAlgoName
     }, false, ['encrypt', 'decrypt']);
   }
 }
+function getSubtleAlgoName(aesMode) {
+  switch (aesMode) {
+    case DecrypterAesMode.cbc:
+      return 'AES-CBC';
+    case DecrypterAesMode.ctr:
+      return 'AES-CTR';
+    default:
+      throw new Error(`[FastAESKey] invalid aes mode ${aesMode}`);
+  }
+}
 
 // PKCS7
 function removePadding(array) {
@@ -11673,7 +12014,8 @@ class Decrypter {
     this.currentIV = null;
     this.currentResult = null;
     this.useSoftware = void 0;
-    this.useSoftware = config.enableSoftwareAES;
+    this.enableSoftwareAES = void 0;
+    this.enableSoftwareAES = config.enableSoftwareAES;
     this.removePKCS7Padding = removePKCS7Padding;
     // built in decryptor expects PKCS7 padding
     if (removePKCS7Padding) {
@@ -11724,10 +12066,10 @@ class Decrypter {
       this.softwareDecrypter = null;
     }
   }
-  decrypt(data, key, iv) {
+  decrypt(data, key, iv, aesMode) {
     if (this.useSoftware) {
       return new Promise((resolve, reject) => {
-        this.softwareDecrypt(new Uint8Array(data), key, iv);
+        this.softwareDecrypt(new Uint8Array(data), key, iv, aesMode);
         const decryptResult = this.flush();
         if (decryptResult) {
           resolve(decryptResult.buffer);
@@ -11736,17 +12078,21 @@ class Decrypter {
         }
       });
     }
-    return this.webCryptoDecrypt(new Uint8Array(data), key, iv);
+    return this.webCryptoDecrypt(new Uint8Array(data), key, iv, aesMode);
   }
 
   // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
   // data is handled in the flush() call
-  softwareDecrypt(data, key, iv) {
+  softwareDecrypt(data, key, iv, aesMode) {
     const {
       currentIV,
       currentResult,
       remainderData
     } = this;
+    if (aesMode !== DecrypterAesMode.cbc || key.byteLength !== 16) {
+      logger.warn('SoftwareDecrypt: can only handle AES-128-CBC');
+      return null;
+    }
     this.logOnce('JS AES decrypt');
     // The output is staggered during progressive parsing - the current result is cached, and emitted on the next call
     // This is done in order to strip PKCS7 padding, which is found at the end of each segment. We only know we've reached
@@ -11779,13 +12125,13 @@ class Decrypter {
     }
     return result;
   }
-  webCryptoDecrypt(data, key, iv) {
+  webCryptoDecrypt(data, key, iv, aesMode) {
     if (this.key !== key || !this.fastAesKey) {
       if (!this.subtle) {
-        return Promise.resolve(this.onWebCryptoError(data, key, iv));
+        return Promise.resolve(this.onWebCryptoError(data, key, iv, aesMode));
       }
       this.key = key;
-      this.fastAesKey = new FastAESKey(this.subtle, key);
+      this.fastAesKey = new FastAESKey(this.subtle, key, aesMode);
     }
     return this.fastAesKey.expandKey().then(aesKey => {
       // decrypt using web crypto
@@ -11793,22 +12139,25 @@ class Decrypter {
         return Promise.reject(new Error('web crypto not initialized'));
       }
       this.logOnce('WebCrypto AES decrypt');
-      const crypto = new AESCrypto(this.subtle, new Uint8Array(iv));
+      const crypto = new AESCrypto(this.subtle, new Uint8Array(iv), aesMode);
       return crypto.decrypt(data.buffer, aesKey);
     }).catch(err => {
       logger.warn(`[decrypter]: WebCrypto Error, disable WebCrypto API, ${err.name}: ${err.message}`);
-      return this.onWebCryptoError(data, key, iv);
+      return this.onWebCryptoError(data, key, iv, aesMode);
     });
   }
-  onWebCryptoError(data, key, iv) {
-    this.useSoftware = true;
-    this.logEnabled = true;
-    this.softwareDecrypt(data, key, iv);
-    const decryptResult = this.flush();
-    if (decryptResult) {
-      return decryptResult.buffer;
+  onWebCryptoError(data, key, iv, aesMode) {
+    const enableSoftwareAES = this.enableSoftwareAES;
+    if (enableSoftwareAES) {
+      this.useSoftware = true;
+      this.logEnabled = true;
+      this.softwareDecrypt(data, key, iv, aesMode);
+      const decryptResult = this.flush();
+      if (decryptResult) {
+        return decryptResult.buffer;
+      }
     }
-    throw new Error('WebCrypto and softwareDecrypt: failed to decrypt data');
+    throw new Error('WebCrypto' + (enableSoftwareAES ? ' and softwareDecrypt' : '') + ': failed to decrypt data');
   }
   getValidChunk(data) {
     let currentChunk = data;
@@ -11859,7 +12208,7 @@ const State = {
 };
 class BaseStreamController extends TaskLoop {
   constructor(hls, fragmentTracker, keyLoader, logPrefix, playlistType) {
-    super();
+    super(logPrefix, hls.logger);
     this.hls = void 0;
     this.fragPrevious = null;
     this.fragCurrent = null;
@@ -11884,22 +12233,98 @@ class BaseStreamController extends TaskLoop {
     this.startFragRequested = false;
     this.decrypter = void 0;
     this.initPTS = [];
-    this.onvseeking = null;
-    this.onvended = null;
-    this.logPrefix = '';
-    this.log = void 0;
-    this.warn = void 0;
+    this.buffering = true;
+    this.loadingParts = false;
+    this.onMediaSeeking = () => {
+      const {
+        config,
+        fragCurrent,
+        media,
+        mediaBuffer,
+        state
+      } = this;
+      const currentTime = media ? media.currentTime : 0;
+      const bufferInfo = BufferHelper.bufferInfo(mediaBuffer ? mediaBuffer : media, currentTime, config.maxBufferHole);
+      this.log(`media seeking to ${isFiniteNumber(currentTime) ? currentTime.toFixed(3) : currentTime}, state: ${state}`);
+      if (this.state === State.ENDED) {
+        this.resetLoadingState();
+      } else if (fragCurrent) {
+        // Seeking while frag load is in progress
+        const tolerance = config.maxFragLookUpTolerance;
+        const fragStartOffset = fragCurrent.start - tolerance;
+        const fragEndOffset = fragCurrent.start + fragCurrent.duration + tolerance;
+        // if seeking out of buffered range or into new one
+        if (!bufferInfo.len || fragEndOffset < bufferInfo.start || fragStartOffset > bufferInfo.end) {
+          const pastFragment = currentTime > fragEndOffset;
+          // if the seek position is outside the current fragment range
+          if (currentTime < fragStartOffset || pastFragment) {
+            if (pastFragment && fragCurrent.loader) {
+              this.log('seeking outside of buffer while fragment load in progress, cancel fragment load');
+              fragCurrent.abortRequests();
+              this.resetLoadingState();
+            }
+            this.fragPrevious = null;
+          }
+        }
+      }
+      if (media) {
+        // Remove gap fragments
+        this.fragmentTracker.removeFragmentsInRange(currentTime, Infinity, this.playlistType, true);
+        this.lastCurrentTime = currentTime;
+        if (!this.loadingParts) {
+          const bufferEnd = Math.max(bufferInfo.end, currentTime);
+          const shouldLoadParts = this.shouldLoadParts(this.getLevelDetails(), bufferEnd);
+          if (shouldLoadParts) {
+            this.log(`LL-Part loading ON after seeking to ${currentTime.toFixed(2)} with buffer @${bufferEnd.toFixed(2)}`);
+            this.loadingParts = shouldLoadParts;
+          }
+        }
+      }
+
+      // in case seeking occurs although no media buffered, adjust startPosition and nextLoadPosition to seek target
+      if (!this.loadedmetadata && !bufferInfo.len) {
+        this.nextLoadPosition = this.startPosition = currentTime;
+      }
+
+      // Async tick to speed up processing
+      this.tickImmediate();
+    };
+    this.onMediaEnded = () => {
+      // reset startPosition and lastCurrentTime to restart playback @ stream beginning
+      this.startPosition = this.lastCurrentTime = 0;
+      if (this.playlistType === PlaylistLevelType.MAIN) {
+        this.hls.trigger(Events.MEDIA_ENDED, {
+          stalled: false
+        });
+      }
+    };
     this.playlistType = playlistType;
-    this.logPrefix = logPrefix;
-    this.log = logger.log.bind(logger, `${logPrefix}:`);
-    this.warn = logger.warn.bind(logger, `${logPrefix}:`);
     this.hls = hls;
     this.fragmentLoader = new FragmentLoader(hls.config);
     this.keyLoader = keyLoader;
     this.fragmentTracker = fragmentTracker;
     this.config = hls.config;
     this.decrypter = new Decrypter(hls.config);
+  }
+  registerListeners() {
+    const {
+      hls
+    } = this;
+    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
+    hls.on(Events.ERROR, this.onError, this);
+  }
+  unregisterListeners() {
+    const {
+      hls
+    } = this;
+    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
+    hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
+    hls.off(Events.ERROR, this.onError, this);
   }
   doTick() {
     this.onTickEnd();
@@ -11923,6 +12348,12 @@ class BaseStreamController extends TaskLoop {
     this.clearNextTick();
     this.state = State.STOPPED;
   }
+  pauseBuffering() {
+    this.buffering = false;
+  }
+  resumeBuffering() {
+    this.buffering = true;
+  }
   _streamEnded(bufferInfo, levelDetails) {
     // If playlist is live, there is another buffered range after the current range, nothing buffered, media is detached,
     // of nothing loading/loaded return false
@@ -11953,10 +12384,8 @@ class BaseStreamController extends TaskLoop {
   }
   onMediaAttached(event, data) {
     const media = this.media = this.mediaBuffer = data.media;
-    this.onvseeking = this.onMediaSeeking.bind(this);
-    this.onvended = this.onMediaEnded.bind(this);
-    media.addEventListener('seeking', this.onvseeking);
-    media.addEventListener('ended', this.onvended);
+    media.addEventListener('seeking', this.onMediaSeeking);
+    media.addEventListener('ended', this.onMediaEnded);
     const config = this.config;
     if (this.levels && config.autoStartLoad && this.state === State.STOPPED) {
       this.startLoad(config.startPosition);
@@ -11970,10 +12399,9 @@ class BaseStreamController extends TaskLoop {
     }
 
     // remove video listeners
-    if (media && this.onvseeking && this.onvended) {
-      media.removeEventListener('seeking', this.onvseeking);
-      media.removeEventListener('ended', this.onvended);
-      this.onvseeking = this.onvended = null;
+    if (media) {
+      media.removeEventListener('seeking', this.onMediaSeeking);
+      media.removeEventListener('ended', this.onMediaEnded);
     }
     if (this.keyLoader) {
       this.keyLoader.detach();
@@ -11983,66 +12411,17 @@ class BaseStreamController extends TaskLoop {
     this.fragmentTracker.removeAllFragments();
     this.stopLoad();
   }
-  onMediaSeeking() {
-    const {
-      config,
-      fragCurrent,
-      media,
-      mediaBuffer,
-      state
-    } = this;
-    const currentTime = media ? media.currentTime : 0;
-    const bufferInfo = BufferHelper.bufferInfo(mediaBuffer ? mediaBuffer : media, currentTime, config.maxBufferHole);
-    this.log(`media seeking to ${isFiniteNumber(currentTime) ? currentTime.toFixed(3) : currentTime}, state: ${state}`);
-    if (this.state === State.ENDED) {
-      this.resetLoadingState();
-    } else if (fragCurrent) {
-      // Seeking while frag load is in progress
-      const tolerance = config.maxFragLookUpTolerance;
-      const fragStartOffset = fragCurrent.start - tolerance;
-      const fragEndOffset = fragCurrent.start + fragCurrent.duration + tolerance;
-      // if seeking out of buffered range or into new one
-      if (!bufferInfo.len || fragEndOffset < bufferInfo.start || fragStartOffset > bufferInfo.end) {
-        const pastFragment = currentTime > fragEndOffset;
-        // if the seek position is outside the current fragment range
-        if (currentTime < fragStartOffset || pastFragment) {
-          if (pastFragment && fragCurrent.loader) {
-            this.log('seeking outside of buffer while fragment load in progress, cancel fragment load');
-            fragCurrent.abortRequests();
-            this.resetLoadingState();
-          }
-          this.fragPrevious = null;
-        }
-      }
-    }
-    if (media) {
-      // Remove gap fragments
-      this.fragmentTracker.removeFragmentsInRange(currentTime, Infinity, this.playlistType, true);
-      this.lastCurrentTime = currentTime;
-    }
-
-    // in case seeking occurs although no media buffered, adjust startPosition and nextLoadPosition to seek target
-    if (!this.loadedmetadata && !bufferInfo.len) {
-      this.nextLoadPosition = this.startPosition = currentTime;
-    }
-
-    // Async tick to speed up processing
-    this.tickImmediate();
-  }
-  onMediaEnded() {
-    // reset startPosition and lastCurrentTime to restart playback @ stream beginning
-    this.startPosition = this.lastCurrentTime = 0;
-  }
+  onManifestLoading() {}
+  onError(event, data) {}
   onManifestLoaded(event, data) {
     this.startTimeOffset = data.startTimeOffset;
     this.initPTS = [];
   }
   onHandlerDestroying() {
-    this.hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
     this.stopLoad();
     super.onHandlerDestroying();
     // @ts-ignore
-    this.hls = null;
+    this.hls = this.onMediaSeeking = this.onMediaEnded = null;
   }
   onHandlerDestroyed() {
     this.state = State.STOPPED;
@@ -12176,10 +12555,10 @@ class BaseStreamController extends TaskLoop {
       const decryptData = frag.decryptdata;
 
       // check to see if the payload needs to be decrypted
-      if (payload && payload.byteLength > 0 && decryptData != null && decryptData.key && decryptData.iv && decryptData.method === 'AES-128') {
+      if (payload && payload.byteLength > 0 && decryptData != null && decryptData.key && decryptData.iv && isFullSegmentEncryption(decryptData.method)) {
         const startTime = self.performance.now();
         // decrypt init segment data
-        return this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer).catch(err => {
+        return this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer, getAesModeFromFullSegmentMethod(decryptData.method)).catch(err => {
           hls.trigger(Events.ERROR, {
             type: ErrorTypes.MEDIA_ERROR,
             details: ErrorDetails.FRAG_DECRYPT_ERROR,
@@ -12220,7 +12599,9 @@ class BaseStreamController extends TaskLoop {
       throw new Error('init load aborted, missing levels');
     }
     const stats = data.frag.stats;
-    this.state = State.IDLE;
+    if (this.state !== State.STOPPED) {
+      this.state = State.IDLE;
+    }
     data.frag.data = new Uint8Array(data.payload);
     stats.parsing.start = stats.buffering.start = self.performance.now();
     stats.parsing.end = stats.buffering.end = self.performance.now();
@@ -12291,7 +12672,7 @@ class BaseStreamController extends TaskLoop {
     }
     let keyLoadingPromise = null;
     if (frag.encrypted && !((_frag$decryptdata = frag.decryptdata) != null && _frag$decryptdata.key)) {
-      this.log(`Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${this.logPrefix === '[stream-controller]' ? 'level' : 'track'} ${frag.level}`);
+      this.log(`Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'} ${frag.level}`);
       this.state = State.KEY_LOADING;
       this.fragCurrent = frag;
       keyLoadingPromise = this.keyLoader.load(frag).then(keyLoadedData => {
@@ -12312,8 +12693,16 @@ class BaseStreamController extends TaskLoop {
     } else if (!frag.encrypted && details.encryptedFragments.length) {
       this.keyLoader.loadClear(frag, details.encryptedFragments);
     }
+    const fragPrevious = this.fragPrevious;
+    if (frag.sn !== 'initSegment' && (!fragPrevious || frag.sn !== fragPrevious.sn)) {
+      const shouldLoadParts = this.shouldLoadParts(level.details, frag.end);
+      if (shouldLoadParts !== this.loadingParts) {
+        this.log(`LL-Part loading ${shouldLoadParts ? 'ON' : 'OFF'} loading sn ${fragPrevious == null ? void 0 : fragPrevious.sn}->${frag.sn}`);
+        this.loadingParts = shouldLoadParts;
+      }
+    }
     targetBufferTime = Math.max(frag.start, targetBufferTime || 0);
-    if (this.config.lowLatencyMode && frag.sn !== 'initSegment') {
+    if (this.loadingParts && frag.sn !== 'initSegment') {
       const partList = details.partList;
       if (partList && progressCallback) {
         if (targetBufferTime > frag.end && details.fragmentHint) {
@@ -12322,7 +12711,7 @@ class BaseStreamController extends TaskLoop {
         const partIndex = this.getNextPart(partList, frag, targetBufferTime);
         if (partIndex > -1) {
           const part = partList[partIndex];
-          this.log(`Loading part sn: ${frag.sn} p: ${part.index} cc: ${frag.cc} of playlist [${details.startSN}-${details.endSN}] parts [0-${partIndex}-${partList.length - 1}] ${this.logPrefix === '[stream-controller]' ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
+          this.log(`Loading part sn: ${frag.sn} p: ${part.index} cc: ${frag.cc} of playlist [${details.startSN}-${details.endSN}] parts [0-${partIndex}-${partList.length - 1}] ${this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
           this.nextLoadPosition = part.start + part.duration;
           this.state = State.FRAG_LOADING;
           let _result;
@@ -12351,7 +12740,14 @@ class BaseStreamController extends TaskLoop {
         }
       }
     }
-    this.log(`Loading fragment ${frag.sn} cc: ${frag.cc} ${details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : ''}${this.logPrefix === '[stream-controller]' ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
+    if (frag.sn !== 'initSegment' && this.loadingParts) {
+      this.log(`LL-Part loading OFF after next part miss @${targetBufferTime.toFixed(2)}`);
+      this.loadingParts = false;
+    } else if (!frag.url) {
+      // Selected fragment hint for part but not loading parts
+      return Promise.resolve(null);
+    }
+    this.log(`Loading fragment ${frag.sn} cc: ${frag.cc} ${details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : ''}${this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'}: ${frag.level}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
     // Don't update nextLoadPosition for fragments which are not buffered
     if (isFiniteNumber(frag.sn) && !this.bitrateTest) {
       this.nextLoadPosition = frag.start + frag.duration;
@@ -12449,8 +12845,36 @@ class BaseStreamController extends TaskLoop {
     if (part) {
       part.stats.parsing.end = now;
     }
+    // See if part loading should be disabled/enabled based on buffer and playback position.
+    if (frag.sn !== 'initSegment') {
+      const levelDetails = this.getLevelDetails();
+      const loadingPartsAtEdge = levelDetails && frag.sn > levelDetails.endSN;
+      const shouldLoadParts = loadingPartsAtEdge || this.shouldLoadParts(levelDetails, frag.end);
+      if (shouldLoadParts !== this.loadingParts) {
+        this.log(`LL-Part loading ${shouldLoadParts ? 'ON' : 'OFF'} after parsing segment ending @${frag.end.toFixed(2)}`);
+        this.loadingParts = shouldLoadParts;
+      }
+    }
     this.updateLevelTiming(frag, part, level, chunkMeta.partial);
   }
+  shouldLoadParts(details, bufferEnd) {
+    if (this.config.lowLatencyMode) {
+      if (!details) {
+        return this.loadingParts;
+      }
+      if (details != null && details.partList) {
+        var _details$fragmentHint;
+        // Buffer must be ahead of first part + duration of parts after last segment
+        // and playback must be at or past segment adjacent to part list
+        const firstPart = details.partList[0];
+        const safePartStart = firstPart.end + (((_details$fragmentHint = details.fragmentHint) == null ? void 0 : _details$fragmentHint.duration) || 0);
+        if (bufferEnd >= safePartStart && this.lastCurrentTime > firstPart.start - firstPart.fragment.duration) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
   getCurrentContext(chunkMeta) {
     const {
       levels,
@@ -12551,7 +12975,7 @@ class BaseStreamController extends TaskLoop {
     // Workaround flaw in getting forward buffer when maxBufferHole is smaller than gap at current pos
     if (bufferInfo.len === 0 && bufferInfo.nextStart !== undefined) {
       const bufferedFragAtPos = this.fragmentTracker.getBufferedFrag(pos, type);
-      if (bufferedFragAtPos && bufferInfo.nextStart < bufferedFragAtPos.end) {
+      if (bufferedFragAtPos && (bufferInfo.nextStart <= bufferedFragAtPos.end || bufferedFragAtPos.gap)) {
         return BufferHelper.bufferInfo(bufferable, pos, Math.max(bufferInfo.nextStart, maxBufferHole));
       }
     }
@@ -12600,7 +13024,8 @@ class BaseStreamController extends TaskLoop {
       config
     } = this;
     const start = fragments[0].start;
-    let frag;
+    const canLoadParts = config.lowLatencyMode && !!levelDetails.partList;
+    let frag = null;
     if (levelDetails.live) {
       const initialLiveManifestSize = config.initialLiveManifestSize;
       if (fragLen < initialLiveManifestSize) {
@@ -12612,6 +13037,10 @@ class BaseStreamController extends TaskLoop {
       // Do not load using live logic if the starting frag is requested - we want to use getFragmentAtPosition() so that
       // we get the fragment matching that start time
       if (!levelDetails.PTSKnown && !this.startFragRequested && this.startPosition === -1 || pos < start) {
+        if (canLoadParts && !this.loadingParts) {
+          this.log(`LL-Part loading ON for initial live fragment`);
+          this.loadingParts = true;
+        }
         frag = this.getInitialLiveFragment(levelDetails, fragments);
         this.startPosition = this.nextLoadPosition = frag ? this.hls.liveSyncPosition || frag.start : pos;
       }
@@ -12622,7 +13051,7 @@ class BaseStreamController extends TaskLoop {
 
     // If we haven't run into any special cases already, just load the fragment most closely matching the requested position
     if (!frag) {
-      const end = config.lowLatencyMode ? levelDetails.partEnd : levelDetails.fragmentEnd;
+      const end = this.loadingParts ? levelDetails.partEnd : levelDetails.fragmentEnd;
       frag = this.getFragmentAtPosition(pos, end, levelDetails);
     }
     return this.mapToInitFragWhenRequired(frag);
@@ -12744,7 +13173,7 @@ class BaseStreamController extends TaskLoop {
     } = levelDetails;
     const tolerance = config.maxFragLookUpTolerance;
     const partList = levelDetails.partList;
-    const loadingParts = !!(config.lowLatencyMode && partList != null && partList.length && fragmentHint);
+    const loadingParts = !!(this.loadingParts && partList != null && partList.length && fragmentHint);
     if (loadingParts && fragmentHint && !this.bitrateTest) {
       // Include incomplete fragment with parts at end
       fragments = fragments.concat(fragmentHint);
@@ -12937,7 +13366,7 @@ class BaseStreamController extends TaskLoop {
           errorAction.resolved = true;
         }
       } else {
-        logger.warn(`${data.details} reached or exceeded max retry (${retryCount})`);
+        this.warn(`${data.details} reached or exceeded max retry (${retryCount})`);
         return;
       }
     } else if ((errorAction == null ? void 0 : errorAction.action) === NetworkErrorAction.SendAlternateToPenaltyBox) {
@@ -13005,7 +13434,9 @@ class BaseStreamController extends TaskLoop {
     this.log('Reset loading state');
     this.fragCurrent = null;
     this.fragPrevious = null;
-    this.state = State.IDLE;
+    if (this.state !== State.STOPPED) {
+      this.state = State.IDLE;
+    }
   }
   resetStartWhenNotLoaded(level) {
     // if loadedmetadata is not set, it means that first frag request failed
@@ -13184,6 +13615,104 @@ function dummyTrack(type = '', inputTimeScale = 90000) {
   };
 }
 
+/**
+ * Returns any adjacent ID3 tags found in data starting at offset, as one block of data
+ *
+ * @param data - The data to search in
+ * @param offset - The offset at which to start searching
+ *
+ * @returns The block of data containing any ID3 tags found
+ * or `undefined` if no header is found at the starting offset
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function getId3Data(data, offset) {
+  const front = offset;
+  let length = 0;
+  while (isId3Header(data, offset)) {
+    // ID3 header is 10 bytes
+    length += 10;
+    const size = readId3Size(data, offset + 6);
+    length += size;
+    if (isId3Footer(data, offset + 10)) {
+      // ID3 footer is 10 bytes
+      length += 10;
+    }
+    offset += length;
+  }
+  if (length > 0) {
+    return data.subarray(front, front + length);
+  }
+  return undefined;
+}
+
+/**
+ * Read a 33 bit timestamp from an ID3 frame.
+ *
+ * @param timeStampFrame - the ID3 frame
+ *
+ * @returns The timestamp
+ *
+ * @internal
+ *
+ * @group ID3
+ */
+function readId3Timestamp(timeStampFrame) {
+  if (timeStampFrame.data.byteLength === 8) {
+    const data = new Uint8Array(timeStampFrame.data);
+    // timestamp is 33 bit expressed as a big-endian eight-octet number,
+    // with the upper 31 bits set to zero.
+    const pts33Bit = data[3] & 0x1;
+    let timestamp = (data[4] << 23) + (data[5] << 15) + (data[6] << 7) + data[7];
+    timestamp /= 45;
+    if (pts33Bit) {
+      timestamp += 47721858.84;
+    } // 2^32 / 90
+    return Math.round(timestamp);
+  }
+  return undefined;
+}
+
+/**
+ * Searches for the Elementary Stream timestamp found in the ID3 data chunk
+ *
+ * @param data - Block of data containing one or more ID3 tags
+ *
+ * @returns The timestamp
+ *
+ * @group ID3
+ *
+ * @beta
+ */
+function getId3Timestamp(data) {
+  const frames = getId3Frames(data);
+  for (let i = 0; i < frames.length; i++) {
+    const frame = frames[i];
+    if (isId3TimestampFrame(frame)) {
+      return readId3Timestamp(frame);
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Checks if the given data contains an ID3 tag.
+ *
+ * @param data - The data to check
+ * @param offset - The offset at which to start checking
+ *
+ * @returns `true` if an ID3 tag is found
+ *
+ * @group ID3
+ *
+ * @beta
+ */
+function canParseId3(data, offset) {
+  return isId3Header(data, offset) && readId3Size(data, offset + 6) + 10 <= data.length - offset;
+}
+
 class BaseAudioDemuxer {
   constructor() {
     this._audioTrack = void 0;
@@ -13225,12 +13754,12 @@ class BaseAudioDemuxer {
       data = appendUint8Array(this.cachedData, data);
       this.cachedData = null;
     }
-    let id3Data = getID3Data(data, 0);
+    let id3Data = getId3Data(data, 0);
     let offset = id3Data ? id3Data.length : 0;
     let lastDataIndex;
     const track = this._audioTrack;
     const id3Track = this._id3Track;
-    const timestamp = id3Data ? getTimeStamp(id3Data) : undefined;
+    const timestamp = id3Data ? getId3Timestamp(id3Data) : undefined;
     const length = data.length;
     if (this.basePTS === null || this.frameIndex === 0 && isFiniteNumber(timestamp)) {
       this.basePTS = initPTSFn(timestamp, timeOffset, this.initPTS);
@@ -13261,9 +13790,9 @@ class BaseAudioDemuxer {
         } else {
           offset = length;
         }
-      } else if (canParse$2(data, offset)) {
-        // after a ID3.canParse, a call to ID3.getID3Data *should* always returns some data
-        id3Data = getID3Data(data, offset);
+      } else if (canParseId3(data, offset)) {
+        // after a canParse, a call to getId3Data *should* always returns some data
+        id3Data = getId3Data(data, offset);
         id3Track.samples.push({
           pts: this.lastPTS,
           dts: this.lastPTS,
@@ -13332,6 +13861,7 @@ const initPTSFn = (timestamp, timeOffset, initPTS) => {
  */
 function getAudioConfig(observer, data, offset, audioCodec) {
   let adtsObjectType;
+  let originalAdtsObjectType;
   let adtsExtensionSamplingIndex;
   let adtsChannelConfig;
   let config;
@@ -13339,7 +13869,7 @@ function getAudioConfig(observer, data, offset, audioCodec) {
   const manifestCodec = audioCodec;
   const adtsSamplingRates = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
   // byte 2
-  adtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
+  adtsObjectType = originalAdtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
   const adtsSamplingIndex = (data[offset + 2] & 0x3c) >>> 2;
   if (adtsSamplingIndex > adtsSamplingRates.length - 1) {
     const error = new Error(`invalid ADTS sampling index:${adtsSamplingIndex}`);
@@ -13356,8 +13886,8 @@ function getAudioConfig(observer, data, offset, audioCodec) {
   // byte 3
   adtsChannelConfig |= (data[offset + 3] & 0xc0) >>> 6;
   logger.log(`manifest codec:${audioCodec}, ADTS type:${adtsObjectType}, samplingIndex:${adtsSamplingIndex}`);
-  // firefox: freq less than 24kHz = AAC SBR (HE-AAC)
-  if (/firefox/i.test(userAgent)) {
+  // Firefox and Pale Moon: freq less than 24kHz = AAC SBR (HE-AAC)
+  if (/firefox|palemoon/i.test(userAgent)) {
     if (adtsSamplingIndex >= 6) {
       adtsObjectType = 5;
       config = new Array(4);
@@ -13451,6 +13981,7 @@ function getAudioConfig(observer, data, offset, audioCodec) {
     samplerate: adtsSamplingRates[adtsSamplingIndex],
     channelCount: adtsChannelConfig,
     codec: 'mp4a.40.' + adtsObjectType,
+    parsedCodec: 'mp4a.40.' + originalAdtsObjectType,
     manifestCodec
   };
 }
@@ -13505,7 +14036,8 @@ function initTrackConfig(track, observer, data, offset, audioCodec) {
     track.channelCount = config.channelCount;
     track.codec = config.codec;
     track.manifestCodec = config.manifestCodec;
-    logger.log(`parsed codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`);
+    track.parsedCodec = config.parsedCodec;
+    logger.log(`parsed codec:${track.parsedCodec}, codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`);
   }
 }
 function getFrameDuration(samplerate) {
@@ -13754,7 +14286,7 @@ class AACDemuxer extends BaseAudioDemuxer {
     // Look for ADTS header | 1111 1111 | 1111 X00X | where X can be either 0 or 1
     // Layer bits (position 14 and 15) in header should be always 0 for ADTS
     // More info https://wiki.multimedia.cx/index.php?title=ADTS
-    const id3Data = getID3Data(data, 0);
+    const id3Data = getId3Data(data, 0);
     let offset = (id3Data == null ? void 0 : id3Data.length) || 0;
     if (probe(data, offset)) {
       return false;
@@ -13945,21 +14477,7 @@ class BaseVideoParser {
       units: [],
       debug,
       length: 0
-    };
-  }
-  getLastNalUnit(samples) {
-    var _VideoSample;
-    let VideoSample = this.VideoSample;
-    let lastUnit;
-    // try to fallback to previous sample if current one is empty
-    if (!VideoSample || VideoSample.units.length === 0) {
-      VideoSample = samples[samples.length - 1];
-    }
-    if ((_VideoSample = VideoSample) != null && _VideoSample.units) {
-      const units = VideoSample.units;
-      lastUnit = units[units.length - 1];
-    }
-    return lastUnit;
+    };
   }
   pushAccessUnit(VideoSample, videoTrack) {
     if (VideoSample.units.length && VideoSample.frame) {
@@ -13983,6 +14501,122 @@ class BaseVideoParser {
       logger.log(VideoSample.pts + '/' + VideoSample.dts + ':' + VideoSample.debug);
     }
   }
+  parseNALu(track, array, last) {
+    const len = array.byteLength;
+    let state = track.naluState || 0;
+    const lastState = state;
+    const units = [];
+    let i = 0;
+    let value;
+    let overflow;
+    let unitType;
+    let lastUnitStart = -1;
+    let lastUnitType = 0;
+    // logger.log('PES:' + Hex.hexDump(array));
+
+    if (state === -1) {
+      // special use case where we found 3 or 4-byte start codes exactly at the end of previous PES packet
+      lastUnitStart = 0;
+      // NALu type is value read from offset 0
+      lastUnitType = this.getNALuType(array, 0);
+      state = 0;
+      i = 1;
+    }
+    while (i < len) {
+      value = array[i++];
+      // optimization. state 0 and 1 are the predominant case. let's handle them outside of the switch/case
+      if (!state) {
+        state = value ? 0 : 1;
+        continue;
+      }
+      if (state === 1) {
+        state = value ? 0 : 2;
+        continue;
+      }
+      // here we have state either equal to 2 or 3
+      if (!value) {
+        state = 3;
+      } else if (value === 1) {
+        overflow = i - state - 1;
+        if (lastUnitStart >= 0) {
+          const unit = {
+            data: array.subarray(lastUnitStart, overflow),
+            type: lastUnitType
+          };
+          if (track.lastNalu) {
+            units.push(track.lastNalu);
+            track.lastNalu = null;
+          }
+          // logger.log('pushing NALU, type/size:' + unit.type + '/' + unit.data.byteLength);
+          units.push(unit);
+        } else {
+          // lastUnitStart is undefined => this is the first start code found in this PES packet
+          // first check if start code delimiter is overlapping between 2 PES packets,
+          // ie it started in last packet (lastState not zero)
+          // and ended at the beginning of this PES packet (i <= 4 - lastState)
+          const lastUnit = track.lastNalu;
+          if (lastUnit) {
+            if (lastState && i <= 4 - lastState) {
+              // start delimiter overlapping between PES packets
+              // strip start delimiter bytes from the end of last NAL unit
+              // check if lastUnit had a state different from zero
+              if (lastUnit.state) {
+                // strip last bytes
+                lastUnit.data = lastUnit.data.subarray(0, lastUnit.data.byteLength - lastState);
+              }
+            }
+            // If NAL units are not starting right at the beginning of the PES packet, push preceding data into previous NAL unit.
+
+            if (overflow > 0) {
+              // logger.log('first NALU found with overflow:' + overflow);
+              lastUnit.data = appendUint8Array(lastUnit.data, array.subarray(0, overflow));
+              lastUnit.state = 0;
+              units.push(lastUnit);
+              track.lastNalu = null;
+            }
+          }
+        }
+        // check if we can read unit type
+        if (i < len) {
+          unitType = this.getNALuType(array, i);
+          // logger.log('find NALU @ offset:' + i + ',type:' + unitType);
+          lastUnitStart = i;
+          lastUnitType = unitType;
+          state = 0;
+        } else {
+          // not enough byte to read unit type. let's read it on next PES parsing
+          state = -1;
+        }
+      } else {
+        state = 0;
+      }
+    }
+    if (lastUnitStart >= 0 && state >= 0) {
+      const unit = {
+        data: array.subarray(lastUnitStart, len),
+        type: lastUnitType,
+        state: state
+      };
+      if (!last) {
+        track.lastNalu = unit;
+        // logger.log('store NALu to push it on next PES');
+      } else {
+        units.push(unit);
+        // logger.log('pushing NALU, type/size/state:' + unit.type + '/' + unit.data.byteLength + '/' + state);
+      }
+    } else if (units.length === 0) {
+      // no NALu found
+      // append pes.data to previous NAL unit
+      const lastUnit = track.lastNalu;
+      if (lastUnit) {
+        lastUnit.data = appendUint8Array(lastUnit.data, array);
+        units.push(lastUnit);
+        track.lastNalu = null;
+      }
+    }
+    track.naluState = state;
+    return units;
+  }
 }
 
 /**
@@ -14060,259 +14694,76 @@ class ExpGolomb {
     } else {
       return valu;
     }
-  }
-
-  // ():uint
-  skipLZ() {
-    let leadingZeroCount; // :uint
-    for (leadingZeroCount = 0; leadingZeroCount < this.bitsAvailable; ++leadingZeroCount) {
-      if ((this.word & 0x80000000 >>> leadingZeroCount) !== 0) {
-        // the first bit of working word is 1
-        this.word <<= leadingZeroCount;
-        this.bitsAvailable -= leadingZeroCount;
-        return leadingZeroCount;
-      }
-    }
-    // we exhausted word and still have not found a 1
-    this.loadWord();
-    return leadingZeroCount + this.skipLZ();
-  }
-
-  // ():void
-  skipUEG() {
-    this.skipBits(1 + this.skipLZ());
-  }
-
-  // ():void
-  skipEG() {
-    this.skipBits(1 + this.skipLZ());
-  }
-
-  // ():uint
-  readUEG() {
-    const clz = this.skipLZ(); // :uint
-    return this.readBits(clz + 1) - 1;
-  }
-
-  // ():int
-  readEG() {
-    const valu = this.readUEG(); // :int
-    if (0x01 & valu) {
-      // the number is odd if the low order bit is set
-      return 1 + valu >>> 1; // add 1 to make it even, and divide by 2
-    } else {
-      return -1 * (valu >>> 1); // divide by two then make it negative
-    }
-  }
-
-  // Some convenience functions
-  // :Boolean
-  readBoolean() {
-    return this.readBits(1) === 1;
-  }
-
-  // ():int
-  readUByte() {
-    return this.readBits(8);
-  }
-
-  // ():int
-  readUShort() {
-    return this.readBits(16);
-  }
-
-  // ():int
-  readUInt() {
-    return this.readBits(32);
-  }
-
-  /**
-   * Advance the ExpGolomb decoder past a scaling list. The scaling
-   * list is optionally transmitted as part of a sequence parameter
-   * set and is not relevant to transmuxing.
-   * @param count the number of entries in this scaling list
-   * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
-   */
-  skipScalingList(count) {
-    let lastScale = 8;
-    let nextScale = 8;
-    let deltaScale;
-    for (let j = 0; j < count; j++) {
-      if (nextScale !== 0) {
-        deltaScale = this.readEG();
-        nextScale = (lastScale + deltaScale + 256) % 256;
-      }
-      lastScale = nextScale === 0 ? lastScale : nextScale;
-    }
-  }
-
-  /**
-   * Read a sequence parameter set and return some interesting video
-   * properties. A sequence parameter set is the H264 metadata that
-   * describes the properties of upcoming video frames.
-   * @returns an object with configuration parsed from the
-   * sequence parameter set, including the dimensions of the
-   * associated video frames.
-   */
-  readSPS() {
-    let frameCropLeftOffset = 0;
-    let frameCropRightOffset = 0;
-    let frameCropTopOffset = 0;
-    let frameCropBottomOffset = 0;
-    let numRefFramesInPicOrderCntCycle;
-    let scalingListCount;
-    let i;
-    const readUByte = this.readUByte.bind(this);
-    const readBits = this.readBits.bind(this);
-    const readUEG = this.readUEG.bind(this);
-    const readBoolean = this.readBoolean.bind(this);
-    const skipBits = this.skipBits.bind(this);
-    const skipEG = this.skipEG.bind(this);
-    const skipUEG = this.skipUEG.bind(this);
-    const skipScalingList = this.skipScalingList.bind(this);
-    readUByte();
-    const profileIdc = readUByte(); // profile_idc
-    readBits(5); // profileCompat constraint_set[0-4]_flag, u(5)
-    skipBits(3); // reserved_zero_3bits u(3),
-    readUByte(); // level_idc u(8)
-    skipUEG(); // seq_parameter_set_id
-    // some profiles have more optional data we don't need
-    if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
-      const chromaFormatIdc = readUEG();
-      if (chromaFormatIdc === 3) {
-        skipBits(1);
-      } // separate_colour_plane_flag
-
-      skipUEG(); // bit_depth_luma_minus8
-      skipUEG(); // bit_depth_chroma_minus8
-      skipBits(1); // qpprime_y_zero_transform_bypass_flag
-      if (readBoolean()) {
-        // seq_scaling_matrix_present_flag
-        scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
-        for (i = 0; i < scalingListCount; i++) {
-          if (readBoolean()) {
-            // seq_scaling_list_present_flag[ i ]
-            if (i < 6) {
-              skipScalingList(16);
-            } else {
-              skipScalingList(64);
-            }
-          }
-        }
-      }
-    }
-    skipUEG(); // log2_max_frame_num_minus4
-    const picOrderCntType = readUEG();
-    if (picOrderCntType === 0) {
-      readUEG(); // log2_max_pic_order_cnt_lsb_minus4
-    } else if (picOrderCntType === 1) {
-      skipBits(1); // delta_pic_order_always_zero_flag
-      skipEG(); // offset_for_non_ref_pic
-      skipEG(); // offset_for_top_to_bottom_field
-      numRefFramesInPicOrderCntCycle = readUEG();
-      for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
-        skipEG();
-      } // offset_for_ref_frame[ i ]
-    }
-    skipUEG(); // max_num_ref_frames
-    skipBits(1); // gaps_in_frame_num_value_allowed_flag
-    const picWidthInMbsMinus1 = readUEG();
-    const picHeightInMapUnitsMinus1 = readUEG();
-    const frameMbsOnlyFlag = readBits(1);
-    if (frameMbsOnlyFlag === 0) {
-      skipBits(1);
-    } // mb_adaptive_frame_field_flag
-
-    skipBits(1); // direct_8x8_inference_flag
-    if (readBoolean()) {
-      // frame_cropping_flag
-      frameCropLeftOffset = readUEG();
-      frameCropRightOffset = readUEG();
-      frameCropTopOffset = readUEG();
-      frameCropBottomOffset = readUEG();
-    }
-    let pixelRatio = [1, 1];
-    if (readBoolean()) {
-      // vui_parameters_present_flag
-      if (readBoolean()) {
-        // aspect_ratio_info_present_flag
-        const aspectRatioIdc = readUByte();
-        switch (aspectRatioIdc) {
-          case 1:
-            pixelRatio = [1, 1];
-            break;
-          case 2:
-            pixelRatio = [12, 11];
-            break;
-          case 3:
-            pixelRatio = [10, 11];
-            break;
-          case 4:
-            pixelRatio = [16, 11];
-            break;
-          case 5:
-            pixelRatio = [40, 33];
-            break;
-          case 6:
-            pixelRatio = [24, 11];
-            break;
-          case 7:
-            pixelRatio = [20, 11];
-            break;
-          case 8:
-            pixelRatio = [32, 11];
-            break;
-          case 9:
-            pixelRatio = [80, 33];
-            break;
-          case 10:
-            pixelRatio = [18, 11];
-            break;
-          case 11:
-            pixelRatio = [15, 11];
-            break;
-          case 12:
-            pixelRatio = [64, 33];
-            break;
-          case 13:
-            pixelRatio = [160, 99];
-            break;
-          case 14:
-            pixelRatio = [4, 3];
-            break;
-          case 15:
-            pixelRatio = [3, 2];
-            break;
-          case 16:
-            pixelRatio = [2, 1];
-            break;
-          case 255:
-            {
-              pixelRatio = [readUByte() << 8 | readUByte(), readUByte() << 8 | readUByte()];
-              break;
-            }
-        }
+  }
+
+  // ():uint
+  skipLZ() {
+    let leadingZeroCount; // :uint
+    for (leadingZeroCount = 0; leadingZeroCount < this.bitsAvailable; ++leadingZeroCount) {
+      if ((this.word & 0x80000000 >>> leadingZeroCount) !== 0) {
+        // the first bit of working word is 1
+        this.word <<= leadingZeroCount;
+        this.bitsAvailable -= leadingZeroCount;
+        return leadingZeroCount;
       }
     }
-    return {
-      width: Math.ceil((picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2),
-      height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset),
-      pixelRatio: pixelRatio
-    };
+    // we exhausted word and still have not found a 1
+    this.loadWord();
+    return leadingZeroCount + this.skipLZ();
   }
-  readSliceType() {
-    // skip NALu type
-    this.readUByte();
-    // discard first_mb_in_slice
-    this.readUEG();
-    // return slice_type
-    return this.readUEG();
+
+  // ():void
+  skipUEG() {
+    this.skipBits(1 + this.skipLZ());
+  }
+
+  // ():void
+  skipEG() {
+    this.skipBits(1 + this.skipLZ());
+  }
+
+  // ():uint
+  readUEG() {
+    const clz = this.skipLZ(); // :uint
+    return this.readBits(clz + 1) - 1;
+  }
+
+  // ():int
+  readEG() {
+    const valu = this.readUEG(); // :int
+    if (0x01 & valu) {
+      // the number is odd if the low order bit is set
+      return 1 + valu >>> 1; // add 1 to make it even, and divide by 2
+    } else {
+      return -1 * (valu >>> 1); // divide by two then make it negative
+    }
+  }
+
+  // Some convenience functions
+  // :Boolean
+  readBoolean() {
+    return this.readBits(1) === 1;
+  }
+
+  // ():int
+  readUByte() {
+    return this.readBits(8);
+  }
+
+  // ():int
+  readUShort() {
+    return this.readBits(16);
+  }
+
+  // ():int
+  readUInt() {
+    return this.readBits(32);
   }
 }
 
 class AvcVideoParser extends BaseVideoParser {
-  parseAVCPES(track, textTrack, pes, last, duration) {
-    const units = this.parseAVCNALu(track, pes.data);
+  parsePES(track, textTrack, pes, last, duration) {
+    const units = this.parseNALu(track, pes.data, last);
     let VideoSample = this.VideoSample;
     let push;
     let spsfound = false;
@@ -14337,7 +14788,7 @@ class AvcVideoParser extends BaseVideoParser {
             // only check slice type to detect KF in case SPS found in same packet (any keyframe is preceded by SPS ...)
             if (spsfound && data.length > 4) {
               // retrieve slice type by parsing beginning of NAL unit (follow H264 spec, slice_header definition) to detect keyframe embedded in NDR
-              const sliceType = new ExpGolomb(data).readSliceType();
+              const sliceType = this.readSliceType(data);
               // 2 : I slice, 4 : SI slice, 7 : I slice, 9: SI slice
               // SI slice : A slice that is coded using intra prediction only and using quantisation of the prediction samples.
               // An SI slice can be coded such that its decoded samples can be constructed identically to an SP slice.
@@ -14391,8 +14842,7 @@ class AvcVideoParser extends BaseVideoParser {
             push = true;
             spsfound = true;
             const sps = unit.data;
-            const expGolombDecoder = new ExpGolomb(sps);
-            const config = expGolombDecoder.readSPS();
+            const config = this.readSPS(sps);
             if (!track.sps || track.width !== config.width || track.height !== config.height || ((_track$pixelRatio = track.pixelRatio) == null ? void 0 : _track$pixelRatio[0]) !== config.pixelRatio[0] || ((_track$pixelRatio2 = track.pixelRatio) == null ? void 0 : _track$pixelRatio2[1]) !== config.pixelRatio[1]) {
               track.width = config.width;
               track.height = config.height;
@@ -14448,109 +14898,192 @@ class AvcVideoParser extends BaseVideoParser {
       this.VideoSample = null;
     }
   }
-  parseAVCNALu(track, array) {
-    const len = array.byteLength;
-    let state = track.naluState || 0;
-    const lastState = state;
-    const units = [];
-    let i = 0;
-    let value;
-    let overflow;
-    let unitType;
-    let lastUnitStart = -1;
-    let lastUnitType = 0;
-    // logger.log('PES:' + Hex.hexDump(array));
+  getNALuType(data, offset) {
+    return data[offset] & 0x1f;
+  }
+  readSliceType(data) {
+    const eg = new ExpGolomb(data);
+    // skip NALu type
+    eg.readUByte();
+    // discard first_mb_in_slice
+    eg.readUEG();
+    // return slice_type
+    return eg.readUEG();
+  }
 
-    if (state === -1) {
-      // special use case where we found 3 or 4-byte start codes exactly at the end of previous PES packet
-      lastUnitStart = 0;
-      // NALu type is value read from offset 0
-      lastUnitType = array[0] & 0x1f;
-      state = 0;
-      i = 1;
-    }
-    while (i < len) {
-      value = array[i++];
-      // optimization. state 0 and 1 are the predominant case. let's handle them outside of the switch/case
-      if (!state) {
-        state = value ? 0 : 1;
-        continue;
-      }
-      if (state === 1) {
-        state = value ? 0 : 2;
-        continue;
+  /**
+   * The scaling list is optionally transmitted as part of a sequence parameter
+   * set and is not relevant to transmuxing.
+   * @param count the number of entries in this scaling list
+   * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
+   */
+  skipScalingList(count, reader) {
+    let lastScale = 8;
+    let nextScale = 8;
+    let deltaScale;
+    for (let j = 0; j < count; j++) {
+      if (nextScale !== 0) {
+        deltaScale = reader.readEG();
+        nextScale = (lastScale + deltaScale + 256) % 256;
       }
-      // here we have state either equal to 2 or 3
-      if (!value) {
-        state = 3;
-      } else if (value === 1) {
-        overflow = i - state - 1;
-        if (lastUnitStart >= 0) {
-          const unit = {
-            data: array.subarray(lastUnitStart, overflow),
-            type: lastUnitType
-          };
-          // logger.log('pushing NALU, type/size:' + unit.type + '/' + unit.data.byteLength);
-          units.push(unit);
-        } else {
-          // lastUnitStart is undefined => this is the first start code found in this PES packet
-          // first check if start code delimiter is overlapping between 2 PES packets,
-          // ie it started in last packet (lastState not zero)
-          // and ended at the beginning of this PES packet (i <= 4 - lastState)
-          const lastUnit = this.getLastNalUnit(track.samples);
-          if (lastUnit) {
-            if (lastState && i <= 4 - lastState) {
-              // start delimiter overlapping between PES packets
-              // strip start delimiter bytes from the end of last NAL unit
-              // check if lastUnit had a state different from zero
-              if (lastUnit.state) {
-                // strip last bytes
-                lastUnit.data = lastUnit.data.subarray(0, lastUnit.data.byteLength - lastState);
-              }
-            }
-            // If NAL units are not starting right at the beginning of the PES packet, push preceding data into previous NAL unit.
+      lastScale = nextScale === 0 ? lastScale : nextScale;
+    }
+  }
 
-            if (overflow > 0) {
-              // logger.log('first NALU found with overflow:' + overflow);
-              lastUnit.data = appendUint8Array(lastUnit.data, array.subarray(0, overflow));
-              lastUnit.state = 0;
-            }
-          }
-        }
-        // check if we can read unit type
-        if (i < len) {
-          unitType = array[i] & 0x1f;
-          // logger.log('find NALU @ offset:' + i + ',type:' + unitType);
-          lastUnitStart = i;
-          lastUnitType = unitType;
-          state = 0;
-        } else {
-          // not enough byte to read unit type. let's read it on next PES parsing
-          state = -1;
+  /**
+   * Read a sequence parameter set and return some interesting video
+   * properties. A sequence parameter set is the H264 metadata that
+   * describes the properties of upcoming video frames.
+   * @returns an object with configuration parsed from the
+   * sequence parameter set, including the dimensions of the
+   * associated video frames.
+   */
+  readSPS(sps) {
+    const eg = new ExpGolomb(sps);
+    let frameCropLeftOffset = 0;
+    let frameCropRightOffset = 0;
+    let frameCropTopOffset = 0;
+    let frameCropBottomOffset = 0;
+    let numRefFramesInPicOrderCntCycle;
+    let scalingListCount;
+    let i;
+    const readUByte = eg.readUByte.bind(eg);
+    const readBits = eg.readBits.bind(eg);
+    const readUEG = eg.readUEG.bind(eg);
+    const readBoolean = eg.readBoolean.bind(eg);
+    const skipBits = eg.skipBits.bind(eg);
+    const skipEG = eg.skipEG.bind(eg);
+    const skipUEG = eg.skipUEG.bind(eg);
+    const skipScalingList = this.skipScalingList.bind(this);
+    readUByte();
+    const profileIdc = readUByte(); // profile_idc
+    readBits(5); // profileCompat constraint_set[0-4]_flag, u(5)
+    skipBits(3); // reserved_zero_3bits u(3),
+    readUByte(); // level_idc u(8)
+    skipUEG(); // seq_parameter_set_id
+    // some profiles have more optional data we don't need
+    if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
+      const chromaFormatIdc = readUEG();
+      if (chromaFormatIdc === 3) {
+        skipBits(1);
+      } // separate_colour_plane_flag
+
+      skipUEG(); // bit_depth_luma_minus8
+      skipUEG(); // bit_depth_chroma_minus8
+      skipBits(1); // qpprime_y_zero_transform_bypass_flag
+      if (readBoolean()) {
+        // seq_scaling_matrix_present_flag
+        scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
+        for (i = 0; i < scalingListCount; i++) {
+          if (readBoolean()) {
+            // seq_scaling_list_present_flag[ i ]
+            if (i < 6) {
+              skipScalingList(16, eg);
+            } else {
+              skipScalingList(64, eg);
+            }
+          }
         }
-      } else {
-        state = 0;
       }
     }
-    if (lastUnitStart >= 0 && state >= 0) {
-      const unit = {
-        data: array.subarray(lastUnitStart, len),
-        type: lastUnitType,
-        state: state
-      };
-      units.push(unit);
-      // logger.log('pushing NALU, type/size/state:' + unit.type + '/' + unit.data.byteLength + '/' + state);
+    skipUEG(); // log2_max_frame_num_minus4
+    const picOrderCntType = readUEG();
+    if (picOrderCntType === 0) {
+      readUEG(); // log2_max_pic_order_cnt_lsb_minus4
+    } else if (picOrderCntType === 1) {
+      skipBits(1); // delta_pic_order_always_zero_flag
+      skipEG(); // offset_for_non_ref_pic
+      skipEG(); // offset_for_top_to_bottom_field
+      numRefFramesInPicOrderCntCycle = readUEG();
+      for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
+        skipEG();
+      } // offset_for_ref_frame[ i ]
     }
-    // no NALu found
-    if (units.length === 0) {
-      // append pes.data to previous NAL unit
-      const lastUnit = this.getLastNalUnit(track.samples);
-      if (lastUnit) {
-        lastUnit.data = appendUint8Array(lastUnit.data, array);
+    skipUEG(); // max_num_ref_frames
+    skipBits(1); // gaps_in_frame_num_value_allowed_flag
+    const picWidthInMbsMinus1 = readUEG();
+    const picHeightInMapUnitsMinus1 = readUEG();
+    const frameMbsOnlyFlag = readBits(1);
+    if (frameMbsOnlyFlag === 0) {
+      skipBits(1);
+    } // mb_adaptive_frame_field_flag
+
+    skipBits(1); // direct_8x8_inference_flag
+    if (readBoolean()) {
+      // frame_cropping_flag
+      frameCropLeftOffset = readUEG();
+      frameCropRightOffset = readUEG();
+      frameCropTopOffset = readUEG();
+      frameCropBottomOffset = readUEG();
+    }
+    let pixelRatio = [1, 1];
+    if (readBoolean()) {
+      // vui_parameters_present_flag
+      if (readBoolean()) {
+        // aspect_ratio_info_present_flag
+        const aspectRatioIdc = readUByte();
+        switch (aspectRatioIdc) {
+          case 1:
+            pixelRatio = [1, 1];
+            break;
+          case 2:
+            pixelRatio = [12, 11];
+            break;
+          case 3:
+            pixelRatio = [10, 11];
+            break;
+          case 4:
+            pixelRatio = [16, 11];
+            break;
+          case 5:
+            pixelRatio = [40, 33];
+            break;
+          case 6:
+            pixelRatio = [24, 11];
+            break;
+          case 7:
+            pixelRatio = [20, 11];
+            break;
+          case 8:
+            pixelRatio = [32, 11];
+            break;
+          case 9:
+            pixelRatio = [80, 33];
+            break;
+          case 10:
+            pixelRatio = [18, 11];
+            break;
+          case 11:
+            pixelRatio = [15, 11];
+            break;
+          case 12:
+            pixelRatio = [64, 33];
+            break;
+          case 13:
+            pixelRatio = [160, 99];
+            break;
+          case 14:
+            pixelRatio = [4, 3];
+            break;
+          case 15:
+            pixelRatio = [3, 2];
+            break;
+          case 16:
+            pixelRatio = [2, 1];
+            break;
+          case 255:
+            {
+              pixelRatio = [readUByte() << 8 | readUByte(), readUByte() << 8 | readUByte()];
+              break;
+            }
+        }
       }
     }
-    track.naluState = state;
-    return units;
+    return {
+      width: Math.ceil((picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2),
+      height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset),
+      pixelRatio: pixelRatio
+    };
   }
 }
 
@@ -14568,7 +15101,7 @@ class SampleAesDecrypter {
     });
   }
   decryptBuffer(encryptedData) {
-    return this.decrypter.decrypt(encryptedData, this.keyData.key.buffer, this.keyData.iv.buffer);
+    return this.decrypter.decrypt(encryptedData, this.keyData.key.buffer, this.keyData.iv.buffer, DecrypterAesMode.cbc);
   }
 
   // AAC - encrypt all full 16 bytes blocks starting from offset 16
@@ -14682,7 +15215,7 @@ class TSDemuxer {
     this.observer = observer;
     this.config = config;
     this.typeSupported = typeSupported;
-    this.videoParser = new AvcVideoParser();
+    this.videoParser = null;
   }
   static probe(data) {
     const syncOffset = TSDemuxer.syncOffset(data);
@@ -14847,7 +15380,16 @@ class TSDemuxer {
           case videoPid:
             if (stt) {
               if (videoData && (pes = parsePES(videoData))) {
-                this.videoParser.parseAVCPES(videoTrack, textTrack, pes, false, this._duration);
+                if (this.videoParser === null) {
+                  switch (videoTrack.segmentCodec) {
+                    case 'avc':
+                      this.videoParser = new AvcVideoParser();
+                      break;
+                  }
+                }
+                if (this.videoParser !== null) {
+                  this.videoParser.parsePES(videoTrack, textTrack, pes, false, this._duration);
+                }
               }
               videoData = {
                 data: [],
@@ -15009,8 +15551,17 @@ class TSDemuxer {
     // try to parse last PES packets
     let pes;
     if (videoData && (pes = parsePES(videoData))) {
-      this.videoParser.parseAVCPES(videoTrack, textTrack, pes, true, this._duration);
-      videoTrack.pesData = null;
+      if (this.videoParser === null) {
+        switch (videoTrack.segmentCodec) {
+          case 'avc':
+            this.videoParser = new AvcVideoParser();
+            break;
+        }
+      }
+      if (this.videoParser !== null) {
+        this.videoParser.parsePES(videoTrack, textTrack, pes, true, this._duration);
+        videoTrack.pesData = null;
+      }
     } else {
       // either avcData null or PES truncated, keep it for next frag parsing
       videoTrack.pesData = videoData;
@@ -15312,7 +15863,10 @@ function parsePMT(data, offset, typeSupported, isSampleAes) {
       case 0x87:
         throw new Error('Unsupported EC-3 in M2TS found');
       case 0x24:
-        throw new Error('Unsupported HEVC in M2TS found');
+        // ITU-T Rec. H.265 and ISO/IEC 23008-2 (HEVC)
+        {
+          throw new Error('Unsupported HEVC in M2TS found');
+        }
     }
     // move to the next table entry
     // skip past the elementary stream descriptors, if present
@@ -15455,11 +16009,11 @@ class MP3Demuxer extends BaseAudioDemuxer {
     // Look for MPEG header | 1111 1111 | 111X XYZX | where X can be either 0 or 1 and Y or Z should be 1
     // Layer bits (position 14 and 15) in header should be always different from 0 (Layer I or Layer II or Layer III)
     // More info http://www.mp3-tech.org/programmer/frame_header.html
-    const id3Data = getID3Data(data, 0);
+    const id3Data = getId3Data(data, 0);
     let offset = (id3Data == null ? void 0 : id3Data.length) || 0;
 
     // Check for ac-3|ec-3 sync bytes and return false if present
-    if (id3Data && data[offset] === 0x0b && data[offset + 1] === 0x77 && getTimeStamp(id3Data) !== undefined &&
+    if (id3Data && data[offset] === 0x0b && data[offset + 1] === 0x77 && getId3Timestamp(id3Data) !== undefined &&
     // check the bsid to confirm ac-3 or ec-3 (not mp3)
     getAudioBSID(data, offset) <= 16) {
       return false;
@@ -15534,6 +16088,8 @@ class MP4 {
       avc1: [],
       // codingname
       avcC: [],
+      hvc1: [],
+      hvcC: [],
       btrt: [],
       dinf: [],
       dref: [],
@@ -15958,8 +16514,10 @@ class MP4 {
         return MP4.box(MP4.types.stsd, MP4.STSD, MP4.ac3(track));
       }
       return MP4.box(MP4.types.stsd, MP4.STSD, MP4.mp4a(track));
-    } else {
+    } else if (track.segmentCodec === 'avc') {
       return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
+    } else {
+      return MP4.box(MP4.types.stsd, MP4.STSD, MP4.hvc1(track));
     }
   }
   static tkhd(track) {
@@ -16097,6 +16655,84 @@ class MP4 {
     const result = appendUint8Array(MP4.FTYP, movie);
     return result;
   }
+  static hvc1(track) {
+    const ps = track.params;
+    const units = [track.vps, track.sps, track.pps];
+    const NALuLengthSize = 4;
+    const config = new Uint8Array([0x01, ps.general_profile_space << 6 | (ps.general_tier_flag ? 32 : 0) | ps.general_profile_idc, ps.general_profile_compatibility_flags[0], ps.general_profile_compatibility_flags[1], ps.general_profile_compatibility_flags[2], ps.general_profile_compatibility_flags[3], ps.general_constraint_indicator_flags[0], ps.general_constraint_indicator_flags[1], ps.general_constraint_indicator_flags[2], ps.general_constraint_indicator_flags[3], ps.general_constraint_indicator_flags[4], ps.general_constraint_indicator_flags[5], ps.general_level_idc, 240 | ps.min_spatial_segmentation_idc >> 8, 255 & ps.min_spatial_segmentation_idc, 252 | ps.parallelismType, 252 | ps.chroma_format_idc, 248 | ps.bit_depth_luma_minus8, 248 | ps.bit_depth_chroma_minus8, 0x00, parseInt(ps.frame_rate.fps), NALuLengthSize - 1 | ps.temporal_id_nested << 2 | ps.num_temporal_layers << 3 | (ps.frame_rate.fixed ? 64 : 0), units.length]);
+
+    // compute hvcC size in bytes
+    let length = config.length;
+    for (let i = 0; i < units.length; i += 1) {
+      length += 3;
+      for (let j = 0; j < units[i].length; j += 1) {
+        length += 2 + units[i][j].length;
+      }
+    }
+    const hvcC = new Uint8Array(length);
+    hvcC.set(config, 0);
+    length = config.length;
+    // append parameter set units: one vps, one or more sps and pps
+    const iMax = units.length - 1;
+    for (let i = 0; i < units.length; i += 1) {
+      hvcC.set(new Uint8Array([32 + i | (i === iMax ? 128 : 0), 0x00, units[i].length]), length);
+      length += 3;
+      for (let j = 0; j < units[i].length; j += 1) {
+        hvcC.set(new Uint8Array([units[i][j].length >> 8, units[i][j].length & 255]), length);
+        length += 2;
+        hvcC.set(units[i][j], length);
+        length += units[i][j].length;
+      }
+    }
+    const hvcc = MP4.box(MP4.types.hvcC, hvcC);
+    const width = track.width;
+    const height = track.height;
+    const hSpacing = track.pixelRatio[0];
+    const vSpacing = track.pixelRatio[1];
+    return MP4.box(MP4.types.hvc1, new Uint8Array([0x00, 0x00, 0x00,
+    // reserved
+    0x00, 0x00, 0x00,
+    // reserved
+    0x00, 0x01,
+    // data_reference_index
+    0x00, 0x00,
+    // pre_defined
+    0x00, 0x00,
+    // reserved
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    // pre_defined
+    width >> 8 & 0xff, width & 0xff,
+    // width
+    height >> 8 & 0xff, height & 0xff,
+    // height
+    0x00, 0x48, 0x00, 0x00,
+    // horizresolution
+    0x00, 0x48, 0x00, 0x00,
+    // vertresolution
+    0x00, 0x00, 0x00, 0x00,
+    // reserved
+    0x00, 0x01,
+    // frame_count
+    0x12, 0x64, 0x61, 0x69, 0x6c,
+    // dailymotion/hls.js
+    0x79, 0x6d, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x68, 0x6c, 0x73, 0x2e, 0x6a, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    // compressorname
+    0x00, 0x18,
+    // depth = 24
+    0x11, 0x11]),
+    // pre_defined = -1
+    hvcc, MP4.box(MP4.types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80,
+    // bufferSizeDB
+    0x00, 0x2d, 0xc6, 0xc0,
+    // maxBitrate
+    0x00, 0x2d, 0xc6, 0xc0])),
+    // avgBitrate
+    MP4.box(MP4.types.pasp, new Uint8Array([hSpacing >> 24,
+    // hSpacing
+    hSpacing >> 16 & 0xff, hSpacing >> 8 & 0xff, hSpacing & 0xff, vSpacing >> 24,
+    // vSpacing
+    vSpacing >> 16 & 0xff, vSpacing >> 8 & 0xff, vSpacing & 0xff])));
+  }
 }
 MP4.types = void 0;
 MP4.HDLR_TYPES = void 0;
@@ -16472,9 +17108,9 @@ class MP4Remuxer {
       const foundOverlap = delta < -1;
       if (foundHole || foundOverlap) {
         if (foundHole) {
-          logger.warn(`AVC: ${toMsFromMpegTsClock(delta, true)} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(3)}`);
+          logger.warn(`${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(delta, true)} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(3)}`);
         } else {
-          logger.warn(`AVC: ${toMsFromMpegTsClock(-delta, true)} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(3)}`);
+          logger.warn(`${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(-delta, true)} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(3)}`);
         }
         if (!foundOverlap || nextAvcDts >= inputSamples[0].pts || chromeVersion) {
           firstDTS = nextAvcDts;
@@ -16483,12 +17119,24 @@ class MP4Remuxer {
             inputSamples[0].dts = firstDTS;
             inputSamples[0].pts = firstPTS;
           } else {
+            let isPTSOrderRetained = true;
             for (let i = 0; i < inputSamples.length; i++) {
-              if (inputSamples[i].dts > firstPTS) {
+              if (inputSamples[i].dts > firstPTS && isPTSOrderRetained) {
                 break;
               }
+              const prevPTS = inputSamples[i].pts;
               inputSamples[i].dts -= delta;
               inputSamples[i].pts -= delta;
+
+              // check to see if this sample's PTS order has changed
+              // relative to the next one
+              if (i < inputSamples.length - 1) {
+                const nextSamplePTS = inputSamples[i + 1].pts;
+                const currentSamplePTS = inputSamples[i].pts;
+                const currentOrder = nextSamplePTS <= currentSamplePTS;
+                const prevOrder = nextSamplePTS <= prevPTS;
+                isPTSOrderRetained = currentOrder == prevOrder;
+              }
             }
           }
           logger.log(`Video: Initial PTS/DTS adjusted: ${toMsFromMpegTsClock(firstPTS, true)}/${toMsFromMpegTsClock(firstDTS, true)}, delta: ${toMsFromMpegTsClock(delta, true)} ms`);
@@ -16636,7 +17284,7 @@ class MP4Remuxer {
         }
       }
     }
-    // next AVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
+    // next AVC/HEVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
     mp4SampleDuration = stretchedLastFrame || !mp4SampleDuration ? averageSampleDuration : mp4SampleDuration;
     this.nextAvcDts = nextAvcDts = lastDTS + mp4SampleDuration;
     this.videoSampleDuration = mp4SampleDuration;
@@ -16769,7 +17417,7 @@ class MP4Remuxer {
           logger.warn(`[mp4-remuxer]: Injecting ${missing} audio frame @ ${(nextPts / inputTimeScale).toFixed(3)}s due to ${Math.round(1000 * delta / inputTimeScale)} ms gap.`);
           for (let j = 0; j < missing; j++) {
             const newStamp = Math.max(nextPts, 0);
-            let fillFrame = AAC.getSilentFrame(track.manifestCodec || track.codec, track.channelCount);
+            let fillFrame = AAC.getSilentFrame(track.parsedCodec || track.manifestCodec || track.codec, track.channelCount);
             if (!fillFrame) {
               logger.log('[mp4-remuxer]: Unable to get silent frame for given audio codec; duplicating last frame instead.');
               fillFrame = sample.unit.subarray();
@@ -16897,7 +17545,7 @@ class MP4Remuxer {
     // samples count of this segment's duration
     const nbSamples = Math.ceil((endDTS - startDTS) / frameDuration);
     // silent frame
-    const silentFrame = AAC.getSilentFrame(track.manifestCodec || track.codec, track.channelCount);
+    const silentFrame = AAC.getSilentFrame(track.parsedCodec || track.manifestCodec || track.codec, track.channelCount);
     logger.warn('[mp4-remuxer]: remux empty Audio');
     // Can't remux if we can't generate a silent frame...
     if (!silentFrame) {
@@ -17288,13 +17936,15 @@ class Transmuxer {
       initSegmentData
     } = transmuxConfig;
     const keyData = getEncryptionType(uintData, decryptdata);
-    if (keyData && keyData.method === 'AES-128') {
+    if (keyData && isFullSegmentEncryption(keyData.method)) {
       const decrypter = this.getDecrypter();
+      const aesMode = getAesModeFromFullSegmentMethod(keyData.method);
+
       // Software decryption is synchronous; webCrypto is not
       if (decrypter.isSync()) {
         // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
         // data is handled in the flush() call
-        let decryptedData = decrypter.softwareDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer);
+        let decryptedData = decrypter.softwareDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode);
         // For Low-Latency HLS Parts, decrypt in place, since part parsing is expected on push progress
         const loadingParts = chunkMeta.part > -1;
         if (loadingParts) {
@@ -17306,7 +17956,7 @@ class Transmuxer {
         }
         uintData = new Uint8Array(decryptedData);
       } else {
-        this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer).then(decryptedData => {
+        this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode).then(decryptedData => {
           // Calling push here is important; if flush() is called while this is still resolving, this ensures that
           // the decrypted data has been transmuxed
           const result = this.push(decryptedData, null, chunkMeta);
@@ -17960,14 +18610,7 @@ class TransmuxerInterface {
     this.observer = new EventEmitter();
     this.observer.on(Events.FRAG_DECRYPTED, forwardMessage);
     this.observer.on(Events.ERROR, forwardMessage);
-    const MediaSource = getMediaSource(config.preferManagedMediaSource) || {
-      isTypeSupported: () => false
-    };
-    const m2tsTypeSupported = {
-      mpeg: MediaSource.isTypeSupported('audio/mpeg'),
-      mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
-      ac3: false
-    };
+    const m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
 
     // navigator.vendor is not always available in Web Worker
     // refer to https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/navigator
@@ -18232,8 +18875,9 @@ const STALL_MINIMUM_DURATION_MS = 250;
 const MAX_START_GAP_JUMP = 2.0;
 const SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
 const SKIP_BUFFER_RANGE_START = 0.05;
-class GapController {
+class GapController extends Logger {
   constructor(config, media, fragmentTracker, hls) {
+    super('gap-controller', hls.logger);
     this.config = void 0;
     this.media = null;
     this.fragmentTracker = void 0;
@@ -18243,6 +18887,7 @@ class GapController {
     this.stalled = null;
     this.moved = false;
     this.seeking = false;
+    this.ended = 0;
     this.config = config;
     this.media = media;
     this.fragmentTracker = fragmentTracker;
@@ -18260,7 +18905,7 @@ class GapController {
    *
    * @param lastCurrentTime - Previously read playhead position
    */
-  poll(lastCurrentTime, activeFrag) {
+  poll(lastCurrentTime, activeFrag, levelDetails, state) {
     const {
       config,
       media,
@@ -18279,6 +18924,7 @@ class GapController {
 
     // The playhead is moving, no-op
     if (currentTime !== lastCurrentTime) {
+      this.ended = 0;
       this.moved = true;
       if (!seeking) {
         this.nudgeRetry = 0;
@@ -18287,7 +18933,7 @@ class GapController {
         // The playhead is now moving, but was previously stalled
         if (this.stallReported) {
           const _stalledDuration = self.performance.now() - stalled;
-          logger.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(_stalledDuration)}ms`);
+          this.warn(`playback not stuck anymore @${currentTime}, after ${Math.round(_stalledDuration)}ms`);
           this.stallReported = false;
         }
         this.stalled = null;
@@ -18323,7 +18969,6 @@ class GapController {
     // Skip start gaps if we haven't played, but the last poll detected the start of a stall
     // The addition poll gives the browser a chance to jump the gap for us
     if (!this.moved && this.stalled !== null) {
-      var _level$details;
       // There is no playable buffer (seeked, waiting for buffer)
       const isBuffered = bufferInfo.len > 0;
       if (!isBuffered && !nextStart) {
@@ -18335,9 +18980,8 @@ class GapController {
       // When joining a live stream with audio tracks, account for live playlist window sliding by allowing
       // a larger jump over start gaps caused by the audio-stream-controller buffering a start fragment
       // that begins over 1 target duration after the video start position.
-      const level = this.hls.levels ? this.hls.levels[this.hls.currentLevel] : null;
-      const isLive = level == null ? void 0 : (_level$details = level.details) == null ? void 0 : _level$details.live;
-      const maxStartGapJump = isLive ? level.details.targetduration * 2 : MAX_START_GAP_JUMP;
+      const isLive = !!(levelDetails != null && levelDetails.live);
+      const maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
       const partialOrGap = this.fragmentTracker.getPartialFragment(currentTime);
       if (startJump > 0 && (startJump <= maxStartGapJump || partialOrGap)) {
         if (!media.paused) {
@@ -18355,6 +18999,17 @@ class GapController {
     }
     const stalledDuration = tnow - stalled;
     if (!seeking && stalledDuration >= STALL_MINIMUM_DURATION_MS) {
+      // Dispatch MEDIA_ENDED when media.ended/ended event is not signalled at end of stream
+      if (state === State.ENDED && !(levelDetails != null && levelDetails.live) && Math.abs(currentTime - ((levelDetails == null ? void 0 : levelDetails.edge) || 0)) < 1) {
+        if (stalledDuration < 1000 || this.ended) {
+          return;
+        }
+        this.ended = currentTime;
+        this.hls.trigger(Events.MEDIA_ENDED, {
+          stalled: true
+        });
+        return;
+      }
       // Report stalling after trying to fix
       this._reportStall(bufferInfo);
       if (!this.media) {
@@ -18398,7 +19053,7 @@ class GapController {
     // needs to cross some sort of threshold covering all source-buffers content
     // to start playing properly.
     if ((bufferInfo.len > config.maxBufferHole || bufferInfo.nextStart && bufferInfo.nextStart - currentTime < config.maxBufferHole) && stalledDurationMs > config.highBufferWatchdogPeriod * 1000) {
-      logger.warn('Trying to nudge playhead over buffer-hole');
+      this.warn('Trying to nudge playhead over buffer-hole');
       // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
       // We only try to jump the hole if it's under the configured size
       // Reset stalled so to rearm watchdog timer
@@ -18422,7 +19077,7 @@ class GapController {
       // Report stalled error once
       this.stallReported = true;
       const error = new Error(`Playback stalling at @${media.currentTime} due to low buffer (${JSON.stringify(bufferInfo)})`);
-      logger.warn(error.message);
+      this.warn(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -18490,7 +19145,7 @@ class GapController {
           }
         }
         const targetTime = Math.max(startTime + SKIP_BUFFER_RANGE_START, currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS);
-        logger.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
+        this.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
         this.moved = true;
         this.stalled = null;
         media.currentTime = targetTime;
@@ -18531,7 +19186,7 @@ class GapController {
       const targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
       // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
       const error = new Error(`Nudging 'currentTime' from ${currentTime} to ${targetTime}`);
-      logger.warn(error.message);
+      this.warn(error.message);
       media.currentTime = targetTime;
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
@@ -18541,7 +19196,7 @@ class GapController {
       });
     } else {
       const error = new Error(`Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`);
-      logger.error(error.message);
+      this.error(error.message);
       hls.trigger(Events.ERROR, {
         type: ErrorTypes.MEDIA_ERROR,
         details: ErrorDetails.BUFFER_STALLED_ERROR,
@@ -18556,7 +19211,7 @@ const TICK_INTERVAL = 100; // how often to tick in ms
 
 class StreamController extends BaseStreamController {
   constructor(hls, fragmentTracker, keyLoader) {
-    super(hls, fragmentTracker, keyLoader, '[stream-controller]', PlaylistLevelType.MAIN);
+    super(hls, fragmentTracker, keyLoader, 'stream-controller', PlaylistLevelType.MAIN);
     this.audioCodecSwap = false;
     this.gapController = null;
     this.level = -1;
@@ -18564,27 +19219,43 @@ class StreamController extends BaseStreamController {
     this.altAudio = false;
     this.audioOnly = false;
     this.fragPlaying = null;
-    this.onvplaying = null;
-    this.onvseeked = null;
     this.fragLastKbps = 0;
     this.couldBacktrack = false;
     this.backtrackFragment = null;
     this.audioCodecSwitch = false;
     this.videoBuffer = null;
-    this._registerListeners();
+    this.onMediaPlaying = () => {
+      // tick to speed up FRAG_CHANGED triggering
+      this.tick();
+    };
+    this.onMediaSeeked = () => {
+      const media = this.media;
+      const currentTime = media ? media.currentTime : null;
+      if (isFiniteNumber(currentTime)) {
+        this.log(`Media seeked to ${currentTime.toFixed(3)}`);
+      }
+
+      // If seeked was issued before buffer was appended do not tick immediately
+      const bufferInfo = this.getMainFwdBufferInfo();
+      if (bufferInfo === null || bufferInfo.len === 0) {
+        this.warn(`Main forward buffer length on "seeked" event ${bufferInfo ? bufferInfo.len : 'empty'})`);
+        return;
+      }
+
+      // tick to speed up FRAG_CHANGED triggering
+      this.tick();
+    };
+    this.registerListeners();
   }
-  _registerListeners() {
+  registerListeners() {
+    super.registerListeners();
     const {
       hls
     } = this;
-    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.MANIFEST_PARSED, this.onManifestParsed, this);
     hls.on(Events.LEVEL_LOADING, this.onLevelLoading, this);
     hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.on(Events.FRAG_LOAD_EMERGENCY_ABORTED, this.onFragLoadEmergencyAborted, this);
-    hls.on(Events.ERROR, this.onError, this);
     hls.on(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.on(Events.AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
     hls.on(Events.BUFFER_CREATED, this.onBufferCreated, this);
@@ -18592,17 +19263,14 @@ class StreamController extends BaseStreamController {
     hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
-  _unregisterListeners() {
+  unregisterListeners() {
+    super.unregisterListeners();
     const {
       hls
     } = this;
-    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
     hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
     hls.off(Events.FRAG_LOAD_EMERGENCY_ABORTED, this.onFragLoadEmergencyAborted, this);
-    hls.off(Events.ERROR, this.onError, this);
     hls.off(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
     hls.off(Events.AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
     hls.off(Events.BUFFER_CREATED, this.onBufferCreated, this);
@@ -18611,7 +19279,9 @@ class StreamController extends BaseStreamController {
     hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
   onHandlerDestroying() {
-    this._unregisterListeners();
+    // @ts-ignore
+    this.onMediaPlaying = this.onMediaSeeked = null;
+    this.unregisterListeners();
     super.onHandlerDestroying();
   }
   startLoad(startPosition) {
@@ -18709,6 +19379,9 @@ class StreamController extends BaseStreamController {
     this.checkFragmentChanged();
   }
   doTickIdle() {
+    if (!this.buffering) {
+      return;
+    }
     const {
       hls,
       levelLastLoaded,
@@ -18936,22 +19609,19 @@ class StreamController extends BaseStreamController {
   onMediaAttached(event, data) {
     super.onMediaAttached(event, data);
     const media = data.media;
-    this.onvplaying = this.onMediaPlaying.bind(this);
-    this.onvseeked = this.onMediaSeeked.bind(this);
-    media.addEventListener('playing', this.onvplaying);
-    media.addEventListener('seeked', this.onvseeked);
+    media.addEventListener('playing', this.onMediaPlaying);
+    media.addEventListener('seeked', this.onMediaSeeked);
     this.gapController = new GapController(this.config, media, this.fragmentTracker, this.hls);
   }
   onMediaDetaching() {
     const {
       media
     } = this;
-    if (media && this.onvplaying && this.onvseeked) {
-      media.removeEventListener('playing', this.onvplaying);
-      media.removeEventListener('seeked', this.onvseeked);
-      this.onvplaying = this.onvseeked = null;
-      this.videoBuffer = null;
+    if (media) {
+      media.removeEventListener('playing', this.onMediaPlaying);
+      media.removeEventListener('seeked', this.onMediaSeeked);
     }
+    this.videoBuffer = null;
     this.fragPlaying = null;
     if (this.gapController) {
       this.gapController.destroy();
@@ -18959,27 +19629,6 @@ class StreamController extends BaseStreamController {
     }
     super.onMediaDetaching();
   }
-  onMediaPlaying() {
-    // tick to speed up FRAG_CHANGED triggering
-    this.tick();
-  }
-  onMediaSeeked() {
-    const media = this.media;
-    const currentTime = media ? media.currentTime : null;
-    if (isFiniteNumber(currentTime)) {
-      this.log(`Media seeked to ${currentTime.toFixed(3)}`);
-    }
-
-    // If seeked was issued before buffer was appended do not tick immediately
-    const bufferInfo = this.getMainFwdBufferInfo();
-    if (bufferInfo === null || bufferInfo.len === 0) {
-      this.warn(`Main forward buffer length on "seeked" event ${bufferInfo ? bufferInfo.len : 'empty'})`);
-      return;
-    }
-
-    // tick to speed up FRAG_CHANGED triggering
-    this.tick();
-  }
   onManifestLoading() {
     // reset buffer on manifest loading
     this.log('Trigger BUFFER_RESET');
@@ -19271,8 +19920,10 @@ class StreamController extends BaseStreamController {
     }
     if (this.loadedmetadata || !BufferHelper.getBuffered(media).length) {
       // Resolve gaps using the main buffer, whose ranges are the intersections of the A/V sourcebuffers
-      const activeFrag = this.state !== State.IDLE ? this.fragCurrent : null;
-      gapController.poll(this.lastCurrentTime, activeFrag);
+      const state = this.state;
+      const activeFrag = state !== State.IDLE ? this.fragCurrent : null;
+      const levelDetails = this.getLevelDetails();
+      gapController.poll(this.lastCurrentTime, activeFrag, levelDetails, state);
     }
     this.lastCurrentTime = media.currentTime;
   }
@@ -19605,6 +20256,17 @@ class StreamController extends BaseStreamController {
   getMainFwdBufferInfo() {
     return this.getFwdBufferInfo(this.mediaBuffer ? this.mediaBuffer : this.media, PlaylistLevelType.MAIN);
   }
+  get maxBufferLength() {
+    const {
+      levels,
+      level
+    } = this;
+    const levelInfo = levels == null ? void 0 : levels[level];
+    if (!levelInfo) {
+      return this.config.maxBufferLength;
+    }
+    return this.getMaxBufferLength(levelInfo.maxBitrate);
+  }
   backtrack(frag) {
     this.couldBacktrack = true;
     // Causes findFragments to backtrack through fragments to find the keyframe
@@ -19710,7 +20372,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.9";
+    return "1.5.10-0.canary.10320";
   }
 
   /**
@@ -19773,9 +20435,12 @@ class Hls {
      * The configuration object provided on player instantiation.
      */
     this.userConfig = void 0;
+    /**
+     * The logger functions used by this player instance, configured on player instantiation.
+     */
+    this.logger = void 0;
     this.coreComponents = void 0;
     this.networkControllers = void 0;
-    this.started = false;
     this._emitter = new EventEmitter();
     this._autoLevelCapping = -1;
     this._maxHdcpLevel = null;
@@ -19792,11 +20457,11 @@ class Hls {
     this._media = null;
     this.url = null;
     this.triggeringException = void 0;
-    enableLogs(userConfig.debug || false, 'Hls instance');
-    const config = this.config = mergeConfig(Hls.DefaultConfig, userConfig);
+    const logger = this.logger = enableLogs(userConfig.debug || false, 'Hls instance');
+    const config = this.config = mergeConfig(Hls.DefaultConfig, userConfig, logger);
     this.userConfig = userConfig;
     if (config.progressive) {
-      enableStreamingMode(config);
+      enableStreamingMode(config, logger);
     }
 
     // core controllers and network loaders
@@ -19809,17 +20474,17 @@ class Hls {
     } = config;
     const errorController = new ConfigErrorController(this);
     const abrController = this.abrController = new ConfigAbrController(this);
-    const bufferController = this.bufferController = new ConfigBufferController(this);
+    // FragmentTracker must be defined before StreamController because the order of event handling is important
+    const fragmentTracker = new FragmentTracker(this);
+    const bufferController = this.bufferController = new ConfigBufferController(this, fragmentTracker);
     const capLevelController = this.capLevelController = new ConfigCapLevelController(this);
     const fpsController = new ConfigFpsController(this);
     const playListLoader = new PlaylistLoader(this);
     const id3TrackController = new ID3TrackController(this);
     const ConfigContentSteeringController = config.contentSteeringController;
-    // ConentSteeringController is defined before LevelController to receive Multivariant Playlist events first
+    // ContentSteeringController is defined before LevelController to receive Multivariant Playlist events first
     const contentSteering = ConfigContentSteeringController ? new ConfigContentSteeringController(this) : null;
     const levelController = this.levelController = new LevelController(this, contentSteering);
-    // FragmentTracker must be defined before StreamController because the order of event handling is important
-    const fragmentTracker = new FragmentTracker(this);
     const keyLoader = new KeyLoader(this.config);
     const streamController = this.streamController = new StreamController(this, fragmentTracker, keyLoader);
 
@@ -19895,7 +20560,7 @@ class Hls {
       try {
         return this.emit(event, event, eventObject);
       } catch (error) {
-        logger.error('An internal error happened while handling event ' + event + '. Error message: "' + error.message + '". Here is a stacktrace:', error);
+        this.logger.error('An internal error happened while handling event ' + event + '. Error message: "' + error.message + '". Here is a stacktrace:', error);
         // Prevent recursion in error event handlers that throw #5497
         if (!this.triggeringException) {
           this.triggeringException = true;
@@ -19921,7 +20586,7 @@ class Hls {
    * Dispose of the instance
    */
   destroy() {
-    logger.log('destroy');
+    this.logger.log('destroy');
     this.trigger(Events.DESTROYING, undefined);
     this.detachMedia();
     this.removeAllListeners();
@@ -19942,7 +20607,7 @@ class Hls {
    * Attaches Hls.js to a media element
    */
   attachMedia(media) {
-    logger.log('attachMedia');
+    this.logger.log('attachMedia');
     this._media = media;
     this.trigger(Events.MEDIA_ATTACHING, {
       media: media
@@ -19953,7 +20618,7 @@ class Hls {
    * Detach Hls.js from the media
    */
   detachMedia() {
-    logger.log('detachMedia');
+    this.logger.log('detachMedia');
     this.trigger(Events.MEDIA_DETACHING, undefined);
     this._media = null;
   }
@@ -19970,7 +20635,7 @@ class Hls {
     });
     this._autoLevelCapping = -1;
     this._maxHdcpLevel = null;
-    logger.log(`loadSource:${loadingSource}`);
+    this.logger.log(`loadSource:${loadingSource}`);
     if (media && loadedSource && (loadedSource !== loadingSource || this.bufferController.hasSourceTypes())) {
       this.detachMedia();
       this.attachMedia(media);
@@ -19989,8 +20654,7 @@ class Hls {
    * Defaults to -1 (None: starts from earliest point)
    */
   startLoad(startPosition = -1) {
-    logger.log(`startLoad(${startPosition})`);
-    this.started = true;
+    this.logger.log(`startLoad(${startPosition})`);
     this.networkControllers.forEach(controller => {
       controller.startLoad(startPosition);
     });
@@ -20000,34 +20664,31 @@ class Hls {
    * Stop loading of any stream data.
    */
   stopLoad() {
-    logger.log('stopLoad');
-    this.started = false;
+    this.logger.log('stopLoad');
     this.networkControllers.forEach(controller => {
       controller.stopLoad();
     });
   }
 
   /**
-   * Resumes stream controller segment loading if previously started.
+   * Resumes stream controller segment loading after `pauseBuffering` has been called.
    */
   resumeBuffering() {
-    if (this.started) {
-      this.networkControllers.forEach(controller => {
-        if ('fragmentLoader' in controller) {
-          controller.startLoad(-1);
-        }
-      });
-    }
+    this.networkControllers.forEach(controller => {
+      if (controller.resumeBuffering) {
+        controller.resumeBuffering();
+      }
+    });
   }
 
   /**
-   * Stops stream controller segment loading without changing 'started' state like stopLoad().
+   * Prevents stream controller from loading new segments until `resumeBuffering` is called.
    * This allows for media buffering to be paused without interupting playlist loading.
    */
   pauseBuffering() {
     this.networkControllers.forEach(controller => {
-      if ('fragmentLoader' in controller) {
-        controller.stopLoad();
+      if (controller.pauseBuffering) {
+        controller.pauseBuffering();
       }
     });
   }
@@ -20036,7 +20697,7 @@ class Hls {
    * Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
    */
   swapAudioCodec() {
-    logger.log('swapAudioCodec');
+    this.logger.log('swapAudioCodec');
     this.streamController.swapAudioCodec();
   }
 
@@ -20047,7 +20708,7 @@ class Hls {
    * Automatic recovery of media-errors by this process is configurable.
    */
   recoverMediaError() {
-    logger.log('recoverMediaError');
+    this.logger.log('recoverMediaError');
     const media = this._media;
     this.detachMedia();
     if (media) {
@@ -20077,7 +20738,7 @@ class Hls {
    * Set quality level index immediately. This will flush the current buffer to replace the quality asap. That means playback will interrupt at least shortly to re-buffer and re-sync eventually. Set to -1 for automatic level selection.
    */
   set currentLevel(newLevel) {
-    logger.log(`set currentLevel:${newLevel}`);
+    this.logger.log(`set currentLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
     this.streamController.immediateLevelSwitch();
   }
@@ -20096,7 +20757,7 @@ class Hls {
    * @param newLevel - Pass -1 for automatic level selection
    */
   set nextLevel(newLevel) {
-    logger.log(`set nextLevel:${newLevel}`);
+    this.logger.log(`set nextLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
     this.streamController.nextLevelSwitch();
   }
@@ -20115,7 +20776,7 @@ class Hls {
    * @param newLevel - Pass -1 for automatic level selection
    */
   set loadLevel(newLevel) {
-    logger.log(`set loadLevel:${newLevel}`);
+    this.logger.log(`set loadLevel:${newLevel}`);
     this.levelController.manualLevel = newLevel;
   }
 
@@ -20146,7 +20807,7 @@ class Hls {
    * Sets "first-level", see getter.
    */
   set firstLevel(newLevel) {
-    logger.log(`set firstLevel:${newLevel}`);
+    this.logger.log(`set firstLevel:${newLevel}`);
     this.levelController.firstLevel = newLevel;
   }
 
@@ -20171,7 +20832,7 @@ class Hls {
    * (determined from download of first segment)
    */
   set startLevel(newLevel) {
-    logger.log(`set startLevel:${newLevel}`);
+    this.logger.log(`set startLevel:${newLevel}`);
     // if not in automatic start level detection, ensure startLevel is greater than minAutoLevel
     if (newLevel !== -1) {
       newLevel = Math.max(newLevel, this.minAutoLevel);
@@ -20246,7 +20907,7 @@ class Hls {
    */
   set autoLevelCapping(newLevel) {
     if (this._autoLevelCapping !== newLevel) {
-      logger.log(`set autoLevelCapping:${newLevel}`);
+      this.logger.log(`set autoLevelCapping:${newLevel}`);
       this._autoLevelCapping = newLevel;
       this.levelController.checkMaxAutoUpdated();
     }
@@ -20351,6 +21012,9 @@ class Hls {
   get mainForwardBufferInfo() {
     return this.streamController.getMainFwdBufferInfo();
   }
+  get maxBufferLength() {
+    return this.streamController.maxBufferLength;
+  }
 
   /**
    * Find and select the best matching audio track, making a level switch when a Group change is necessary.
@@ -20518,12 +21182,22 @@ class Hls {
   get forceStartLoad() {
     return this.streamController.forceStartLoad;
   }
+
+  /**
+   * ContentSteering pathwayPriority getter/setter
+   */
+  get pathwayPriority() {
+    return this.levelController.pathwayPriority;
+  }
+  set pathwayPriority(pathwayPriority) {
+    this.levelController.pathwayPriority = pathwayPriority;
+  }
 }
 Hls.defaultConfig = void 0;
 
-var KeySystemFormats = empty.KeySystemFormats;
-var KeySystems = empty.KeySystems;
-var SubtitleStreamController = empty.SubtitleStreamController;
-var TimelineController = empty.TimelineController;
-export { AbrController, AttrList, Cues as AudioStreamController, Cues as AudioTrackController, BasePlaylistController, BaseSegment, BaseStreamController, BufferController, Cues as CMCDController, CapLevelController, ChunkMetadata, ContentSteeringController, DateRange, Cues as EMEController, ErrorActionFlags, ErrorController, ErrorDetails, ErrorTypes, Events, FPSController, Fragment, Hls, HlsSkip, HlsUrlParameters, KeySystemFormats, KeySystems, Level, LevelDetails, LevelKey, LoadStats, MetadataSchema, NetworkErrorAction, Part, PlaylistLevelType, SubtitleStreamController, Cues as SubtitleTrackController, TimelineController, Hls as default, getMediaSource, isMSESupported, isSupported };
+var KeySystemFormats = emptyEs.KeySystemFormats;
+var KeySystems = emptyEs.KeySystems;
+var SubtitleStreamController = emptyEs.SubtitleStreamController;
+var TimelineController = emptyEs.TimelineController;
+export { AbrController, AttrList, HevcVideoParser as AudioStreamController, HevcVideoParser as AudioTrackController, BasePlaylistController, BaseSegment, BaseStreamController, BufferController, HevcVideoParser as CMCDController, CapLevelController, ChunkMetadata, ContentSteeringController, DateRange, HevcVideoParser as EMEController, ErrorActionFlags, ErrorController, ErrorDetails, ErrorTypes, Events, FPSController, Fragment, Hls, HlsSkip, HlsUrlParameters, KeySystemFormats, KeySystems, LevelDetails, LevelKey, LoadStats, MetadataSchema, NetworkErrorAction, Part, PlaylistLevelType, SubtitleStreamController, HevcVideoParser as SubtitleTrackController, TimelineController, Hls as default, getMediaSource, isMSESupported, isSupported };
 //# sourceMappingURL=hls.light.mjs.map