hls.js 1.5.8-0.canary.10151 → 1.5.8-0.canary.10154

package/dist/hls.mjs

@@ -512,7 +512,7 @@ function enableLogs(debugConfig, context, id) {
     // 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.10151"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.8-0.canary.10154"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -1022,6 +1022,22 @@ function base64Decode(base64encodedStr) {
   return Uint8Array.from(atob(base64encodedStr), c => c.charCodeAt(0));
 }
 
+// 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)), c => c.charCodeAt(0));
+}
+
 function getKeyIdBytes(str) {
   const keyIdbytes = strToUtf8array(str).subarray(0, 16);
   const paddedkeyIdbytes = new Uint8Array(16);
@@ -1059,9 +1075,6 @@ function convertDataUriToArrayBytes(uri) {
   }
   return keydata;
 }
-function strToUtf8array(str) {
-  return Uint8Array.from(unescape(encodeURIComponent(str)), c => c.charCodeAt(0));
-}
 
 var DecrypterAesMode = {
   cbc: 0,
@@ -1207,421 +1220,152 @@ 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 str;
   }
-  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);
+const UINT32_MAX$1 = Math.pow(2, 32) - 1;
+const push = [].push;
 
-  // skip frame id, size, and flags
-  const offset = 10;
-  return {
-    type,
-    size,
-    data: data.subarray(offset, offset + size)
-  };
+// 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.
+const RemuxerTrackIdConfig = {
+  video: 1,
+  audio: 2,
+  id3: 3,
+  text: 4
 };
+function bin2str(data) {
+  return String.fromCharCode.apply(null, data);
+}
+function readUint16(buffer, offset) {
+  const val = buffer[offset] << 8 | buffer[offset + 1];
+  return val < 0 ? 65536 + val : val;
+}
+function readUint32(buffer, offset) {
+  const val = readSint32(buffer, offset);
+  return val < 0 ? 4294967296 + val : val;
+}
+function readUint64(buffer, offset) {
+  let result = readUint32(buffer, offset);
+  result *= Math.pow(2, 32);
+  result += readUint32(buffer, offset + 4);
+  return result;
+}
+function readSint32(buffer, offset) {
+  return buffer[offset] << 24 | buffer[offset + 1] << 16 | buffer[offset + 2] << 8 | buffer[offset + 3];
+}
+function writeUint32(buffer, offset, value) {
+  buffer[offset] = value >> 24;
+  buffer[offset + 1] = value >> 16 & 0xff;
+  buffer[offset + 2] = value >> 8 & 0xff;
+  buffer[offset + 3] = value & 0xff;
+}
 
-/**
- * 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;
+// Find "moof" box
+function hasMoofData(data) {
+  const end = data.byteLength;
+  for (let i = 0; i < end;) {
+    const size = readUint32(data, i);
+    if (size > 8 && data[i + 4] === 0x6d && data[i + 5] === 0x6f && data[i + 6] === 0x6f && data[i + 7] === 0x66) {
+      return true;
     }
-  }
-  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;
-  }
-};
-
-const UINT32_MAX$1 = Math.pow(2, 32) - 1;
-const 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.
-const RemuxerTrackIdConfig = {
-  video: 1,
-  audio: 2,
-  id3: 3,
-  text: 4
-};
-function bin2str(data) {
-  return String.fromCharCode.apply(null, data);
-}
-function readUint16(buffer, offset) {
-  const val = buffer[offset] << 8 | buffer[offset + 1];
-  return val < 0 ? 65536 + val : val;
-}
-function readUint32(buffer, offset) {
-  const val = readSint32(buffer, offset);
-  return val < 0 ? 4294967296 + val : val;
-}
-function readUint64(buffer, offset) {
-  let result = readUint32(buffer, offset);
-  result *= Math.pow(2, 32);
-  result += readUint32(buffer, offset + 4);
-  return result;
-}
-function readSint32(buffer, offset) {
-  return buffer[offset] << 24 | buffer[offset + 1] << 16 | buffer[offset + 2] << 8 | buffer[offset + 3];
-}
-function writeUint32(buffer, offset, value) {
-  buffer[offset] = value >> 24;
-  buffer[offset + 1] = value >> 16 & 0xff;
-  buffer[offset + 2] = value >> 8 & 0xff;
-  buffer[offset + 3] = value & 0xff;
-}
-
-// Find "moof" box
-function hasMoofData(data) {
-  const end = data.byteLength;
-  for (let i = 0; i < end;) {
-    const size = readUint32(data, i);
-    if (size > 8 && data[i + 4] === 0x6d && data[i + 5] === 0x6f && data[i + 6] === 0x6f && data[i + 7] === 0x66) {
-      return true;
-    }
-    i = size > 1 ? i + size : end;
+    i = size > 1 ? i + size : end;
   }
   return false;
 }
@@ -4405,42 +4149,545 @@ function getFirstCueIndexAfterTime(cues, time) {
       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) {
+  const cuesFound = [];
+  const firstCueInRange = getFirstCueIndexAfterTime(cues, start);
+  if (firstCueInRange > -1) {
+    for (let i = firstCueInRange, len = cues.length; i < len; i++) {
+      const 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) {
+  const tracks = [];
+  for (let i = 0; i < textTrackList.length; i++) {
+    const 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;
+  }
+  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;
+  }
+}
+
+/**
+ * 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(...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);
+  }
+  const decimalShift = Math.pow(10, precision);
+  const 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
+    const 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) {
+  const to = new URL(url);
+  const from = new URL(base);
+  if (to.origin !== from.origin) {
+    return url;
+  }
+  const toPath = to.pathname.split('/').slice(1);
+  const 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 {
+      const url = URL.createObjectURL(new Blob());
+      const uuid = url.toString();
+      URL.revokeObjectURL(url);
+      return uuid.slice(uuid.lastIndexOf('/') + 1);
+    } catch (error) {
+      let dt = new Date().getTime();
+      const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = (dt + Math.random() * 16) % 16 | 0;
+        dt = Math.floor(dt / 16);
+        return (c == 'x' ? r : r & 0x3 | 0x8).toString(16);
+      });
+      return uuid;
+    }
+  }
+}
+
+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;
 }
-function getCuesInRange(cues, start, end) {
-  const cuesFound = [];
-  const firstCueInRange = getFirstCueIndexAfterTime(cues, start);
-  if (firstCueInRange > -1) {
-    for (let i = firstCueInRange, len = cues.length; i < len; i++) {
-      const cue = cues[i];
-      if (cue.startTime >= start && cue.endTime <= end) {
-        cuesFound.push(cue);
-      } else if (cue.startTime > end) {
-        return cuesFound;
+
+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;
     }
-  }
-  return cuesFound;
-}
-function filterSubtitleTracks(textTrackList) {
-  const tracks = [];
-  for (let i = 0; i < textTrackList.length; i++) {
-    const 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';
+}
 
 const MIN_CUE_DURATION = 0.25;
 function getCueClass() {
@@ -4586,7 +4833,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;
@@ -4600,7 +4847,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);
@@ -10581,6 +10828,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;
@@ -10622,12 +10967,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);
@@ -10658,9 +11003,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,
@@ -11154,7 +11499,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;
@@ -11372,14 +11717,14 @@ class AC3Demuxer extends BaseAudioDemuxer {
     if (!data) {
       return false;
     }
-    const id3Data = getID3Data(data, 0);
+    const id3Data = getId3Data(data, 0);
     if (!id3Data) {
       return false;
     }
 
     // look for the ac-3 sync bytes
     const 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;
@@ -13636,11 +13981,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;
@@ -23946,20 +24291,6 @@ function serializeBoolean(value) {
   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(...binary));
-}
-
 const BYTES = 'Byte Sequence';
 
 // 4.1.8.  Serializing a Byte Sequence
@@ -24036,34 +24367,6 @@ function serializeDate(value) {
   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);
-  }
-  const decimalShift = Math.pow(10, precision);
-  const 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
-    const flooredValue = Math.floor(value * decimalShift);
-    return (flooredValue % 2 === 0 ? flooredValue : flooredValue + 1) / decimalShift;
-  } else {
-    // Otherwise, proceed as normal
-    return Math.round(value * decimalShift) / decimalShift;
-  }
-}
-
 const DECIMAL = 'Decimal';
 
 // 4.1.5.  Serializing a Decimal
@@ -24446,38 +24749,6 @@ const isValid = value => {
   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) {
-  const to = new URL(url);
-  const from = new URL(base);
-  if (to.origin !== from.origin) {
-    return url;
-  }
-  const toPath = to.pathname.split('/').slice(1);
-  const 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('/');
-}
-
 const toRounded = value => Math.round(value);
 const toUrlSafe = (value, options) => {
   if (options === null || options === void 0 ? void 0 : options.baseUrl) {
@@ -24703,36 +24974,6 @@ function appendCmcdQuery(url, cmcd, options) {
   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 {
-      const url = URL.createObjectURL(new Blob());
-      const uuid = url.toString();
-      URL.revokeObjectURL(url);
-      return uuid.slice(uuid.lastIndexOf('/') + 1);
-    } catch (error) {
-      let dt = new Date().getTime();
-      const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
-        const r = (dt + Math.random() * 16) % 16 | 0;
-        dt = Math.floor(dt / 16);
-        return (c == 'x' ? r : r & 0x3 | 0x8).toString(16);
-      });
-      return uuid;
-    }
-  }
-}
-
 /**
  * Controller to deal with Common Media Client Data (CMCD)
  * @see https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf
@@ -28732,7 +28973,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.8-0.canary.10151";
+    return "1.5.8-0.canary.10154";
   }
 
   /**