hls.js 1.5.8-0.canary.10153 → 1.5.8-0.canary.10155

package/dist/hls.js

@@ -637,7 +637,7 @@
       // 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.8-0.canary.10153");
+        newLogger.log("Debug logs enabled for \"" + context + "\" in hls.js version " + "1.5.8-0.canary.10155");
       } catch (e) {
         /* log fn threw an exception. All logger methods are no-ops. */
         return createLogger();
@@ -1209,6 +1209,24 @@
     });
   }
 
+  // breaking up those two types in order to clarify what is happening in the decoding path.
+
+  // 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.
+   */
+
+  function strToUtf8array(str) {
+    return Uint8Array.from(unescape(encodeURIComponent(str)), function (c) {
+      return c.charCodeAt(0);
+    });
+  }
+
   function getKeyIdBytes(str) {
     var keyIdbytes = strToUtf8array(str).subarray(0, 16);
     var paddedkeyIdbytes = new Uint8Array(16);
@@ -1246,11 +1264,6 @@
     }
     return keydata;
   }
-  function strToUtf8array(str) {
-    return Uint8Array.from(unescape(encodeURIComponent(str)), function (c) {
-      return c.charCodeAt(0);
-    });
-  }
 
   var DecrypterAesMode = {
     cbc: 0,
@@ -1400,387 +1413,118 @@
     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.
    */
-  var isHeader$2 = function isHeader(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
    */
-  var isFooter = function 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) {
+    if (exitOnNull === void 0) {
+      exitOnNull = false;
     }
-    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
-   */
-  var getID3Data = function getID3Data(data, offset) {
-    var front = offset;
-    var length = 0;
-    while (isHeader$2(data, offset)) {
-      // ID3 header is 10 bytes
-      length += 10;
-      var size = readSize(data, offset + 6);
-      length += size;
-      if (isFooter(data, offset + 10)) {
-        // ID3 footer is 10 bytes
-        length += 10;
+    if (typeof TextDecoder !== 'undefined') {
+      var decoder = new TextDecoder('utf-8');
+      var decoded = decoder.decode(array);
+      if (exitOnNull) {
+        // grab up to the first null
+        var idx = decoded.indexOf('\0');
+        return idx !== -1 ? decoded.substring(0, idx) : decoded;
       }
-      offset += length;
-    }
-    if (length > 0) {
-      return data.subarray(front, front + length);
+      // remove any null characters
+      return decoded.replace(/\0/g, '');
     }
-    return undefined;
-  };
-  var readSize = function readSize(data, offset) {
-    var 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;
-  };
-  var canParse$2 = function canParse(data, offset) {
-    return isHeader$2(data, offset) && readSize(data, offset + 6) + 10 <= data.length - offset;
-  };
-
-  /**
-   * Searches for the Elementary Stream timestamp found in the ID3 data chunk
-   * @param data - Block of data containing one or more ID3 tags
-   */
-  var getTimeStamp = function getTimeStamp(data) {
-    var frames = getID3Frames(data);
-    for (var i = 0; i < frames.length; i++) {
-      var frame = frames[i];
-      if (isTimeStampFrame(frame)) {
-        return readTimeStamp(frame);
+    var len = array.length;
+    var c;
+    var char2;
+    var char3;
+    var out = '';
+    var 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 undefined;
-  };
+    return out;
+  }
 
   /**
-   * Returns true if the ID3 frame is an Elementary Stream timestamp frame
+   *  hex dump helper class
    */
-  var isTimeStampFrame = function isTimeStampFrame(frame) {
-    return frame && frame.key === 'PRIV' && frame.info === 'com.apple.streaming.transportStreamTimestamp';
-  };
-  var getFrameData = function getFrameData(data) {
-    /*
-    Frame ID       $xx xx xx xx (four characters)
-    Size           $xx xx xx xx
-    Flags          $xx xx
-    */
-    var type = String.fromCharCode(data[0], data[1], data[2], data[3]);
-    var size = readSize(data, 4);
-
-    // skip frame id, size, and flags
-    var offset = 10;
-    return {
-      type: type,
-      size: 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
-   */
-  var getID3Frames = function getID3Frames(id3Data) {
-    var offset = 0;
-    var frames = [];
-    while (isHeader$2(id3Data, offset)) {
-      var size = readSize(id3Data, offset + 6);
-      // skip past ID3 header
-      offset += 10;
-      var end = offset + size;
-      // loop through frames in the ID3 tag
-      while (offset + 8 < end) {
-        var frameData = getFrameData(id3Data.subarray(offset));
-        var frame = decodeFrame(frameData);
-        if (frame) {
-          frames.push(frame);
+  var Hex = {
+    hexDump: function hexDump(array) {
+      var str = '';
+      for (var i = 0; i < array.length; i++) {
+        var h = array[i].toString(16);
+        if (h.length < 2) {
+          h = '0' + h;
         }
-
-        // skip frame header and frame data
-        offset += frameData.size + 10;
-      }
-      if (isFooter(id3Data, offset)) {
-        offset += 10;
+        str += h;
       }
+      return str;
     }
-    return frames;
-  };
-  var decodeFrame = function decodeFrame(frame) {
-    if (frame.type === 'PRIV') {
-      return decodePrivFrame(frame);
-    } else if (frame.type[0] === 'W') {
-      return decodeURLFrame(frame);
-    }
-    return decodeTextFrame(frame);
   };
-  var decodePrivFrame = function decodePrivFrame(frame) {
-    /*
-    Format: <text string>\0<binary data>
-    */
-    if (frame.size < 2) {
-      return undefined;
-    }
-    var owner = utf8ArrayToStr(frame.data, true);
-    var privateData = new Uint8Array(frame.data.subarray(owner.length + 1));
-    return {
-      key: frame.type,
-      info: owner,
-      data: privateData.buffer
-    };
-  };
-  var decodeTextFrame = function decodeTextFrame(frame) {
-    if (frame.size < 2) {
-      return undefined;
-    }
-    if (frame.type === 'TXXX') {
-      /*
-      Format:
-      [0]   = {Text Encoding}
-      [1-?] = {Description}\0{Value}
-      */
-      var index = 1;
-      var description = utf8ArrayToStr(frame.data.subarray(index), true);
-      index += description.length + 1;
-      var value = utf8ArrayToStr(frame.data.subarray(index));
-      return {
-        key: frame.type,
-        info: description,
-        data: value
-      };
-    }
-    /*
-    Format:
-    [0]   = {Text Encoding}
-    [1-?] = {Value}
-    */
-    var text = utf8ArrayToStr(frame.data.subarray(1));
-    return {
-      key: frame.type,
-      data: text
-    };
-  };
-  var decodeURLFrame = function decodeURLFrame(frame) {
-    if (frame.type === 'WXXX') {
-      /*
-      Format:
-      [0]   = {Text Encoding}
-      [1-?] = {Description}\0{URL}
-      */
-      if (frame.size < 2) {
-        return undefined;
-      }
-      var index = 1;
-      var description = utf8ArrayToStr(frame.data.subarray(index), true);
-      index += description.length + 1;
-      var value = utf8ArrayToStr(frame.data.subarray(index));
-      return {
-        key: frame.type,
-        info: description,
-        data: value
-      };
-    }
-    /*
-    Format:
-    [0-?] = {URL}
-    */
-    var url = utf8ArrayToStr(frame.data);
-    return {
-      key: frame.type,
-      data: url
-    };
-  };
-  var readTimeStamp = function readTimeStamp(timeStampFrame) {
-    if (timeStampFrame.data.byteLength === 8) {
-      var 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.
-      var pts33Bit = data[3] & 0x1;
-      var 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.
-   */
-  var utf8ArrayToStr = function utf8ArrayToStr(array, exitOnNull) {
-    if (exitOnNull === void 0) {
-      exitOnNull = false;
-    }
-    var decoder = getTextDecoder();
-    if (decoder) {
-      var decoded = decoder.decode(array);
-      if (exitOnNull) {
-        // grab up to the first null
-        var idx = decoded.indexOf('\0');
-        return idx !== -1 ? decoded.substring(0, idx) : decoded;
-      }
-
-      // remove any null characters
-      return decoded.replace(/\0/g, '');
-    }
-    var len = array.length;
-    var c;
-    var char2;
-    var char3;
-    var out = '';
-    var 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;
-  };
-  var 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
-   */
-
-  var Hex = {
-    hexDump: function hexDump(array) {
-      var str = '';
-      for (var i = 0; i < array.length; i++) {
-        var h = array[i].toString(16);
-        if (h.length < 2) {
-          h = '0' + h;
-        }
-        str += h;
-      }
-      return str;
-    }
-  };
-
-  var UINT32_MAX$1 = Math.pow(2, 32) - 1;
-  var push = [].push;
-
-  // We are using fixed track IDs for driving the MP4 remuxer
-  // instead of following the TS PIDs.
-  // There is no reason not to do this and some browsers/SourceBuffer-demuxers
-  // may not like if there are TrackID "switches"
-  // See https://github.com/video-dev/hls.js/issues/1331
-  // Here we are mapping our internal track types to constant MP4 track IDs
-  // With MSE currently one can only have one track of each, and we are muxing
-  // whatever video/audio rendition in them.
-  var RemuxerTrackIdConfig = {
-    video: 1,
-    audio: 2,
-    id3: 3,
-    text: 4
+
+  var UINT32_MAX$1 = Math.pow(2, 32) - 1;
+  var push = [].push;
+
+  // We are using fixed track IDs for driving the MP4 remuxer
+  // instead of following the TS PIDs.
+  // There is no reason not to do this and some browsers/SourceBuffer-demuxers
+  // may not like if there are TrackID "switches"
+  // See https://github.com/video-dev/hls.js/issues/1331
+  // Here we are mapping our internal track types to constant MP4 track IDs
+  // With MSE currently one can only have one track of each, and we are muxing
+  // whatever video/audio rendition in them.
+  var RemuxerTrackIdConfig = {
+    video: 1,
+    audio: 2,
+    id3: 3,
+    text: 4
   };
   function bin2str(data) {
     return String.fromCharCode.apply(null, data);
@@ -4637,42 +4381,551 @@
         return mid;
       }
     }
-    // At this point, left and right have swapped.
-    // No direct match was found, left or right element must be the closest. Check which one has the smallest diff.
-    return cues[left].startTime - time < time - cues[right].startTime ? left : right;
+    // At this point, left and right have swapped.
+    // No direct match was found, left or right element must be the closest. Check which one has the smallest diff.
+    return cues[left].startTime - time < time - cues[right].startTime ? left : right;
+  }
+  function getCuesInRange(cues, start, end) {
+    var cuesFound = [];
+    var firstCueInRange = getFirstCueIndexAfterTime(cues, start);
+    if (firstCueInRange > -1) {
+      for (var i = firstCueInRange, len = cues.length; i < len; i++) {
+        var _cue = cues[i];
+        if (_cue.startTime >= start && _cue.endTime <= end) {
+          cuesFound.push(_cue);
+        } else if (_cue.startTime > end) {
+          return cuesFound;
+        }
+      }
+    }
+    return cuesFound;
+  }
+  function filterSubtitleTracks(textTrackList) {
+    var tracks = [];
+    for (var i = 0; i < textTrackList.length; i++) {
+      var track = textTrackList[i];
+      // Edge adds a track without a label; we don't want to use it
+      if ((track.kind === 'subtitles' || track.kind === 'captions') && track.label) {
+        tracks.push(textTrackList[i]);
+      }
+    }
+    return tracks;
+  }
+
+  var MetadataSchema = {
+    audioId3: "org.id3",
+    dateRange: "com.apple.quicktime.HLS",
+    emsg: "https://aomedia.org/emsg/ID3"
+  };
+
+  /**
+   * 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;
+    }
+    var owner = utf8ArrayToStr(frame.data, true);
+    var 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}
+      */
+      var index = 1;
+      var description = utf8ArrayToStr(frame.data.subarray(index), true);
+      index += description.length + 1;
+      var value = utf8ArrayToStr(frame.data.subarray(index));
+      return {
+        key: frame.type,
+        info: description,
+        data: value
+      };
+    }
+    /*
+    Format:
+    [0]   = {Text Encoding}
+    [1-?] = {Value}
+    */
+    var 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;
+      }
+      var index = 1;
+      var description = utf8ArrayToStr(frame.data.subarray(index), true);
+      index += description.length + 1;
+      var value = utf8ArrayToStr(frame.data.subarray(index));
+      return {
+        key: frame.type,
+        info: description,
+        data: value
+      };
+    }
+    /*
+    Format:
+    [0-?] = {URL}
+    */
+    var url = utf8ArrayToStr(frame.data);
+    return {
+      key: frame.type,
+      info: '',
+      data: url
+    };
+  }
+
+  function toUint8(data, offset, length) {
+    if (offset === void 0) {
+      offset = 0;
+    }
+    if (length === void 0) {
+      length = Infinity;
+    }
+    return view(data, offset, length, Uint8Array);
+  }
+  function view(data, offset, length, Type) {
+    var buffer = unsafeGetArrayBuffer(data);
+    var bytesPerElement = 1;
+    if ('BYTES_PER_ELEMENT' in Type) {
+      bytesPerElement = Type.BYTES_PER_ELEMENT;
+    }
+    // Absolute end of the |data| view within |buffer|.
+    var dataOffset = isArrayBufferView(data) ? data.byteOffset : 0;
+    var dataEnd = (dataOffset + data.byteLength) / bytesPerElement;
+    // Absolute start of the result within |buffer|.
+    var rawStart = (dataOffset + offset) / bytesPerElement;
+    var start = Math.floor(Math.max(0, Math.min(rawStart, dataEnd)));
+    // Absolute end of the result within |buffer|.
+    var 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;
+    }
+  }
+
+  /**
+   * Encodes binary data to base64
+   *
+   * @param binary - The binary data to encode
+   * @returns The base64 encoded string
+   *
+   * @group Utils
+   *
+   * @beta
+   */
+  function base64encode(binary) {
+    return btoa(String.fromCharCode.apply(String, binary));
+  }
+
+  /**
+   * This implements the rounding procedure described in step 2 of the "Serializing a Decimal" specification.
+   * This rounding style is known as "even rounding", "banker's rounding", or "commercial rounding".
+   *
+   * @param value - The value to round
+   * @param precision - The number of decimal places to round to
+   * @returns The rounded value
+   *
+   * @group Utils
+   *
+   * @beta
+   */
+  function roundToEven(value, precision) {
+    if (value < 0) {
+      return -roundToEven(-value, precision);
+    }
+    var decimalShift = Math.pow(10, precision);
+    var isEquidistant = Math.abs(value * decimalShift % 1 - 0.5) < Number.EPSILON;
+    if (isEquidistant) {
+      // If the tail of the decimal place is 'equidistant' we round to the nearest even value
+      var flooredValue = Math.floor(value * decimalShift);
+      return (flooredValue % 2 === 0 ? flooredValue : flooredValue + 1) / decimalShift;
+    } else {
+      // Otherwise, proceed as normal
+      return Math.round(value * decimalShift) / decimalShift;
+    }
+  }
+
+  /**
+   * Constructs a relative path from a URL.
+   *
+   * @param url - The destination URL
+   * @param base - The base URL
+   * @returns The relative path
+   *
+   * @group Utils
+   *
+   * @beta
+   */
+  function urlToRelativePath(url, base) {
+    var to = new URL(url);
+    var from = new URL(base);
+    if (to.origin !== from.origin) {
+      return url;
+    }
+    var toPath = to.pathname.split('/').slice(1);
+    var fromPath = from.pathname.split('/').slice(1, -1);
+    // remove common parents
+    while (toPath[0] === fromPath[0]) {
+      toPath.shift();
+      fromPath.shift();
+    }
+    // add back paths
+    while (fromPath.length) {
+      fromPath.shift();
+      toPath.unshift('..');
+    }
+    return toPath.join('/');
+  }
+
+  /**
+   * Generate a random v4 UUID
+   *
+   * @returns A random v4 UUID
+   *
+   * @group Utils
+   *
+   * @beta
+   */
+  function uuid() {
+    try {
+      return crypto.randomUUID();
+    } catch (error) {
+      try {
+        var url = URL.createObjectURL(new Blob());
+        var _uuid = url.toString();
+        URL.revokeObjectURL(url);
+        return _uuid.slice(_uuid.lastIndexOf('/') + 1);
+      } catch (error) {
+        var dt = new Date().getTime();
+        var _uuid2 = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+          var r = (dt + Math.random() * 16) % 16 | 0;
+          dt = Math.floor(dt / 16);
+          return (c == 'x' ? r : r & 0x3 | 0x8).toString(16);
+        });
+        return _uuid2;
+      }
+    }
+  }
+
+  function decodeId3ImageFrame(frame) {
+    var metadataFrame = {
+      key: frame.type,
+      description: '',
+      data: '',
+      mimeType: null,
+      pictureType: null
+    };
+    var utf8Encoding = 0x03;
+    if (frame.size < 2) {
+      return undefined;
+    }
+    if (frame.data[0] !== utf8Encoding) {
+      console.log('Ignore frame with unrecognized character ' + 'encoding');
+      return undefined;
+    }
+    var mimeTypeEndIndex = frame.data.subarray(1).indexOf(0);
+    if (mimeTypeEndIndex === -1) {
+      return undefined;
+    }
+    var mimeType = utf8ArrayToStr(toUint8(frame.data, 1, mimeTypeEndIndex));
+    var pictureType = frame.data[2 + mimeTypeEndIndex];
+    var descriptionEndIndex = frame.data.subarray(3 + mimeTypeEndIndex).indexOf(0);
+    if (descriptionEndIndex === -1) {
+      return undefined;
+    }
+    var description = utf8ArrayToStr(toUint8(frame.data, 3 + mimeTypeEndIndex, descriptionEndIndex));
+    var 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) {
+    var 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
+    */
+    var type = String.fromCharCode(data[0], data[1], data[2], data[3]);
+    var size = readId3Size(data, 4);
+    // skip frame id, size, and flags
+    var offset = 10;
+    return {
+      type: type,
+      size: 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;
   }
-  function getCuesInRange(cues, start, end) {
-    var cuesFound = [];
-    var firstCueInRange = getFirstCueIndexAfterTime(cues, start);
-    if (firstCueInRange > -1) {
-      for (var i = firstCueInRange, len = cues.length; i < len; i++) {
-        var _cue = cues[i];
-        if (_cue.startTime >= start && _cue.endTime <= end) {
-          cuesFound.push(_cue);
-        } else if (_cue.startTime > end) {
-          return cuesFound;
+
+  var HEADER_FOOTER_SIZE = 10;
+  var 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) {
+    var offset = 0;
+    var frames = [];
+    while (isId3Header(id3Data, offset)) {
+      var 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;
+      var end = offset + size;
+      // loop through frames in the ID3 tag
+      while (offset + FRAME_SIZE < end) {
+        var frameData = getId3FrameData(id3Data.subarray(offset));
+        var frame = decodeId3Frame(frameData);
+        if (frame) {
+          frames.push(frame);
         }
+        // skip frame header and frame data
+        offset += frameData.size + HEADER_FOOTER_SIZE;
       }
-    }
-    return cuesFound;
-  }
-  function filterSubtitleTracks(textTrackList) {
-    var tracks = [];
-    for (var i = 0; i < textTrackList.length; i++) {
-      var track = textTrackList[i];
-      // Edge adds a track without a label; we don't want to use it
-      if ((track.kind === 'subtitles' || track.kind === 'captions') && track.label) {
-        tracks.push(textTrackList[i]);
+      if (isId3Footer(id3Data, offset)) {
+        offset += HEADER_FOOTER_SIZE;
       }
     }
-    return tracks;
+    return frames;
   }
 
-  var MetadataSchema = {
-    audioId3: "org.id3",
-    dateRange: "com.apple.quicktime.HLS",
-    emsg: "https://aomedia.org/emsg/ID3"
-  };
+  /**
+   * 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';
+  }
 
   var MIN_CUE_DURATION = 0.25;
   function getCueClass() {
@@ -4809,7 +5062,7 @@
         if (type === MetadataSchema.emsg && !enableEmsgMetadataCues || !enableID3MetadataCues) {
           continue;
         }
-        var frames = getID3Frames(samples[i].data);
+        var frames = getId3Frames(samples[i].data);
         if (frames) {
           var startTime = samples[i].pts;
           var endTime = startTime + samples[i].duration;
@@ -4823,7 +5076,7 @@
           for (var j = 0; j < frames.length; j++) {
             var 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);
               var cue = createCueWithDataFields(Cue, startTime, endTime, frame, type);
@@ -10900,6 +11153,104 @@
     };
   }
 
+  /**
+   * 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) {
+    var front = offset;
+    var length = 0;
+    while (isId3Header(data, offset)) {
+      // ID3 header is 10 bytes
+      length += 10;
+      var 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) {
+      var 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.
+      var pts33Bit = data[3] & 0x1;
+      var 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) {
+    var frames = getId3Frames(data);
+    for (var i = 0; i < frames.length; i++) {
+      var 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;
+  }
+
   var BaseAudioDemuxer = /*#__PURE__*/function () {
     function BaseAudioDemuxer() {
       this._audioTrack = void 0;
@@ -10943,12 +11294,12 @@
         data = appendUint8Array(this.cachedData, data);
         this.cachedData = null;
       }
-      var id3Data = getID3Data(data, 0);
+      var id3Data = getId3Data(data, 0);
       var offset = id3Data ? id3Data.length : 0;
       var lastDataIndex;
       var track = this._audioTrack;
       var id3Track = this._id3Track;
-      var timestamp = id3Data ? getTimeStamp(id3Data) : undefined;
+      var timestamp = id3Data ? getId3Timestamp(id3Data) : undefined;
       var length = data.length;
       if (this.basePTS === null || this.frameIndex === 0 && isFiniteNumber(timestamp)) {
         this.basePTS = initPTSFn(timestamp, timeOffset, this.initPTS);
@@ -10979,9 +11330,9 @@
           } 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,
@@ -11475,7 +11826,7 @@
       // 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
-      var id3Data = getID3Data(data, 0);
+      var id3Data = getId3Data(data, 0);
       var offset = (id3Data == null ? void 0 : id3Data.length) || 0;
       if (probe(data, offset)) {
         return false;
@@ -11698,14 +12049,14 @@
       if (!data) {
         return false;
       }
-      var id3Data = getID3Data(data, 0);
+      var id3Data = getId3Data(data, 0);
       if (!id3Data) {
         return false;
       }
 
       // look for the ac-3 sync bytes
       var offset = id3Data.length;
-      if (data[offset] === 0x0b && data[offset + 1] === 0x77 && getTimeStamp(id3Data) !== undefined &&
+      if (data[offset] === 0x0b && data[offset + 1] === 0x77 && getId3Timestamp(id3Data) !== undefined &&
       // check the bsid to confirm ac-3
       getAudioBSID(data, offset) < 16) {
         return true;
@@ -14002,11 +14353,11 @@
       // 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
-      var id3Data = getID3Data(data, 0);
+      var id3Data = getId3Data(data, 0);
       var 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;
@@ -24531,20 +24882,6 @@
     return value ? '?1' : '?0';
   }
 
-  /**
-   * Encodes binary data to base64
-   *
-   * @param binary - The binary data to encode
-   * @returns The base64 encoded string
-   *
-   * @group Utils
-   *
-   * @beta
-   */
-  function base64encode(binary) {
-    return btoa(String.fromCharCode.apply(String, binary));
-  }
-
   var BYTES = 'Byte Sequence';
 
   // 4.1.8.  Serializing a Byte Sequence
@@ -24621,34 +24958,6 @@
     return "@" + serializeInteger(value.getTime() / 1000);
   }
 
-  /**
-   * This implements the rounding procedure described in step 2 of the "Serializing a Decimal" specification.
-   * This rounding style is known as "even rounding", "banker's rounding", or "commercial rounding".
-   *
-   * @param value - The value to round
-   * @param precision - The number of decimal places to round to
-   * @returns The rounded value
-   *
-   * @group Utils
-   *
-   * @beta
-   */
-  function roundToEven(value, precision) {
-    if (value < 0) {
-      return -roundToEven(-value, precision);
-    }
-    var decimalShift = Math.pow(10, precision);
-    var isEquidistant = Math.abs(value * decimalShift % 1 - 0.5) < Number.EPSILON;
-    if (isEquidistant) {
-      // If the tail of the decimal place is 'equidistant' we round to the nearest even value
-      var flooredValue = Math.floor(value * decimalShift);
-      return (flooredValue % 2 === 0 ? flooredValue : flooredValue + 1) / decimalShift;
-    } else {
-      // Otherwise, proceed as normal
-      return Math.round(value * decimalShift) / decimalShift;
-    }
-  }
-
   var DECIMAL = 'Decimal';
 
   // 4.1.5.  Serializing a Decimal
@@ -25040,38 +25349,6 @@
     return value != null && value !== '' && value !== false;
   };
 
-  /**
-   * Constructs a relative path from a URL.
-   *
-   * @param url - The destination URL
-   * @param base - The base URL
-   * @returns The relative path
-   *
-   * @group Utils
-   *
-   * @beta
-   */
-  function urlToRelativePath(url, base) {
-    var to = new URL(url);
-    var from = new URL(base);
-    if (to.origin !== from.origin) {
-      return url;
-    }
-    var toPath = to.pathname.split('/').slice(1);
-    var fromPath = from.pathname.split('/').slice(1, -1);
-    // remove common parents
-    while (toPath[0] === fromPath[0]) {
-      toPath.shift();
-      fromPath.shift();
-    }
-    // add back paths
-    while (fromPath.length) {
-      fromPath.shift();
-      toPath.unshift('..');
-    }
-    return toPath.join('/');
-  }
-
   var toRounded = function toRounded(value) {
     return Math.round(value);
   };
@@ -25315,36 +25592,6 @@
     return "" + url + separator + query;
   }
 
-  /**
-   * Generate a random v4 UUID
-   *
-   * @returns A random v4 UUID
-   *
-   * @group Utils
-   *
-   * @beta
-   */
-  function uuid() {
-    try {
-      return crypto.randomUUID();
-    } catch (error) {
-      try {
-        var url = URL.createObjectURL(new Blob());
-        var _uuid = url.toString();
-        URL.revokeObjectURL(url);
-        return _uuid.slice(_uuid.lastIndexOf('/') + 1);
-      } catch (error) {
-        var dt = new Date().getTime();
-        var _uuid2 = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-          var r = (dt + Math.random() * 16) % 16 | 0;
-          dt = Math.floor(dt / 16);
-          return (c == 'x' ? r : r & 0x3 | 0x8).toString(16);
-        });
-        return _uuid2;
-      }
-    }
-  }
-
   /**
    * Controller to deal with Common Media Client Data (CMCD)
    * @see https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf
@@ -30211,7 +30458,7 @@
        * Get the video-dev/hls.js package version.
        */
       function get() {
-        return "1.5.8-0.canary.10153";
+        return "1.5.8-0.canary.10155";
       }
     }, {
       key: "Events",