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

package/dist/hls.light.js

@@ -606,7 +606,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();
@@ -1203,273 +1203,6 @@
     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
-   */
-  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
-   */
-  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;
-          }
-        }
-      }
-    }
-    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;
-      }
-      offset += length;
-    }
-    if (length > 0) {
-      return data.subarray(front, front + length);
-    }
-    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);
-      }
-    }
-    return undefined;
-  };
-
-  /**
-   * Returns true if the ID3 frame is an Elementary Stream timestamp frame
-   */
-  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);
-        }
-
-        // skip frame header and frame data
-        offset += frameData.size + 10;
-      }
-      if (isFooter(id3Data, offset)) {
-        offset += 10;
-      }
-    }
-    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
@@ -1479,19 +1212,29 @@
    * LastModified: Dec 25 1999
    * This library is free.  You can redistribute it and/or modify it.
    */
-  var utf8ArrayToStr = function utf8ArrayToStr(array, exitOnNull) {
+  /**
+   * Converts a UTF-8 array to a string.
+   *
+   * @param array - The UTF-8 array to convert
+   *
+   * @returns The string
+   *
+   * @group Utils
+   *
+   * @beta
+   */
+  function utf8ArrayToStr(array, exitOnNull) {
     if (exitOnNull === void 0) {
       exitOnNull = false;
     }
-    var decoder = getTextDecoder();
-    if (decoder) {
+    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;
       }
-
       // remove any null characters
       return decoded.replace(/\0/g, '');
     }
@@ -1536,18 +1279,6 @@
       }
     }
     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;
   }
 
   /**
@@ -4075,78 +3806,483 @@
         track.removeCue(track.cues[i]);
       }
     }
-    if (mode === 'disabled') {
-      track.mode = mode;
+    if (mode === 'disabled') {
+      track.mode = mode;
+    }
+  }
+  function removeCuesInRange(track, start, end, predicate) {
+    var mode = track.mode;
+    if (mode === 'disabled') {
+      track.mode = 'hidden';
+    }
+    if (track.cues && track.cues.length > 0) {
+      var cues = getCuesInRange(track.cues, start, end);
+      for (var i = 0; i < cues.length; i++) {
+        if (!predicate || predicate(cues[i])) {
+          track.removeCue(cues[i]);
+        }
+      }
+    }
+    if (mode === 'disabled') {
+      track.mode = mode;
+    }
+  }
+
+  // Find first cue starting after given time.
+  // Modified version of binary search O(log(n)).
+  function getFirstCueIndexAfterTime(cues, time) {
+    // If first cue starts after time, start there
+    if (time < cues[0].startTime) {
+      return 0;
+    }
+    // If the last cue ends before time there is no overlap
+    var len = cues.length - 1;
+    if (time > cues[len].endTime) {
+      return -1;
+    }
+    var left = 0;
+    var right = len;
+    while (left <= right) {
+      var mid = Math.floor((right + left) / 2);
+      if (time < cues[mid].startTime) {
+        right = mid - 1;
+      } else if (time > cues[mid].startTime && left < len) {
+        left = mid + 1;
+      } else {
+        // If it's not lower or higher, it must be equal.
+        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;
+  }
+  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;
+  }
+
+  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;
+    }
+  }
+
+  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;
   }
-  function removeCuesInRange(track, start, end, predicate) {
-    var mode = track.mode;
-    if (mode === 'disabled') {
-      track.mode = 'hidden';
+
+  /**
+   * 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);
     }
-    if (track.cues && track.cues.length > 0) {
-      var cues = getCuesInRange(track.cues, start, end);
-      for (var i = 0; i < cues.length; i++) {
-        if (!predicate || predicate(cues[i])) {
-          track.removeCue(cues[i]);
+    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;
+          }
         }
       }
     }
-    if (mode === 'disabled') {
-      track.mode = mode;
-    }
+    return false;
   }
 
-  // Find first cue starting after given time.
-  // Modified version of binary search O(log(n)).
-  function getFirstCueIndexAfterTime(cues, time) {
-    // If first cue starts after time, start there
-    if (time < cues[0].startTime) {
-      return 0;
-    }
-    // If the last cue ends before time there is no overlap
-    var len = cues.length - 1;
-    if (time > cues[len].endTime) {
-      return -1;
-    }
-    var left = 0;
-    var right = len;
-    while (left <= right) {
-      var mid = Math.floor((right + left) / 2);
-      if (time < cues[mid].startTime) {
-        right = mid - 1;
-      } else if (time > cues[mid].startTime && left < len) {
-        left = mid + 1;
-      } else {
-        // If it's not lower or higher, it must be equal.
-        return mid;
+  /**
+   * 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;
+          }
+        }
       }
     }
-    // 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;
+    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;
+      }
+      if (isId3Footer(id3Data, offset)) {
+        offset += HEADER_FOOTER_SIZE;
       }
     }
-    return cuesFound;
+    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() {
@@ -4283,7 +4419,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;
@@ -4297,7 +4433,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);
@@ -13760,6 +13896,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;
@@ -13803,12 +14037,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);
@@ -13839,9 +14073,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,
@@ -14335,7 +14569,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;
@@ -16093,11 +16327,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;
@@ -21450,7 +21684,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",