hls.js 1.5.12-0.canary.10340 → 1.5.12-0.canary.10341

package/dist/hls.mjs

@@ -359,87 +359,6 @@ let ErrorDetails = /*#__PURE__*/function (ErrorDetails) {
   return ErrorDetails;
 }({});
 
-const DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/;
-const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
-
-// adapted from https://github.com/kanongil/node-m3u8parse/blob/master/attrlist.js
-class AttrList {
-  constructor(attrs) {
-    if (typeof attrs === 'string') {
-      attrs = AttrList.parseAttrList(attrs);
-    }
-    _extends(this, attrs);
-  }
-  get clientAttrs() {
-    return Object.keys(this).filter(attr => attr.substring(0, 2) === 'X-');
-  }
-  decimalInteger(attrName) {
-    const intValue = parseInt(this[attrName], 10);
-    if (intValue > Number.MAX_SAFE_INTEGER) {
-      return Infinity;
-    }
-    return intValue;
-  }
-  hexadecimalInteger(attrName) {
-    if (this[attrName]) {
-      let stringValue = (this[attrName] || '0x').slice(2);
-      stringValue = (stringValue.length & 1 ? '0' : '') + stringValue;
-      const value = new Uint8Array(stringValue.length / 2);
-      for (let i = 0; i < stringValue.length / 2; i++) {
-        value[i] = parseInt(stringValue.slice(i * 2, i * 2 + 2), 16);
-      }
-      return value;
-    } else {
-      return null;
-    }
-  }
-  hexadecimalIntegerAsNumber(attrName) {
-    const intValue = parseInt(this[attrName], 16);
-    if (intValue > Number.MAX_SAFE_INTEGER) {
-      return Infinity;
-    }
-    return intValue;
-  }
-  decimalFloatingPoint(attrName) {
-    return parseFloat(this[attrName]);
-  }
-  optionalFloat(attrName, defaultValue) {
-    const value = this[attrName];
-    return value ? parseFloat(value) : defaultValue;
-  }
-  enumeratedString(attrName) {
-    return this[attrName];
-  }
-  bool(attrName) {
-    return this[attrName] === 'YES';
-  }
-  decimalResolution(attrName) {
-    const res = DECIMAL_RESOLUTION_REGEX.exec(this[attrName]);
-    if (res === null) {
-      return undefined;
-    }
-    return {
-      width: parseInt(res[1], 10),
-      height: parseInt(res[2], 10)
-    };
-  }
-  static parseAttrList(input) {
-    let match;
-    const attrs = {};
-    const quote = '"';
-    ATTR_LIST_REGEX.lastIndex = 0;
-    while ((match = ATTR_LIST_REGEX.exec(input)) !== null) {
-      let value = match[2];
-      if (value.indexOf(quote) === 0 && value.lastIndexOf(quote) === value.length - 1) {
-        value = value.slice(1, -1);
-      }
-      const name = match[1].trim();
-      attrs[name] = value;
-    }
-    return attrs;
-  }
-}
-
 class Logger {
   constructor(label, logger) {
     this.trace = void 0;
@@ -501,7 +420,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.12-0.canary.10340"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.12-0.canary.10341"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -518,20 +437,234 @@ function enableLogs(debugConfig, context, id) {
 }
 const logger = exportedLogger;
 
+const VARIABLE_REPLACEMENT_REGEX = /\{\$([a-zA-Z0-9-_]+)\}/g;
+function hasVariableReferences(str) {
+  return VARIABLE_REPLACEMENT_REGEX.test(str);
+}
+function substituteVariables(parsed, value) {
+  if (parsed.variableList !== null || parsed.hasVariableRefs) {
+    const variableList = parsed.variableList;
+    return value.replace(VARIABLE_REPLACEMENT_REGEX, variableReference => {
+      const variableName = variableReference.substring(2, variableReference.length - 1);
+      const variableValue = variableList == null ? void 0 : variableList[variableName];
+      if (variableValue === undefined) {
+        parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`Missing preceding EXT-X-DEFINE tag for Variable Reference: "${variableName}"`));
+        return variableReference;
+      }
+      return variableValue;
+    });
+  }
+  return value;
+}
+function addVariableDefinition(parsed, attr, parentUrl) {
+  let variableList = parsed.variableList;
+  if (!variableList) {
+    parsed.variableList = variableList = {};
+  }
+  let NAME;
+  let VALUE;
+  if ('QUERYPARAM' in attr) {
+    NAME = attr.QUERYPARAM;
+    try {
+      const searchParams = new self.URL(parentUrl).searchParams;
+      if (searchParams.has(NAME)) {
+        VALUE = searchParams.get(NAME);
+      } else {
+        throw new Error(`"${NAME}" does not match any query parameter in URI: "${parentUrl}"`);
+      }
+    } catch (error) {
+      parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`EXT-X-DEFINE QUERYPARAM: ${error.message}`));
+    }
+  } else {
+    NAME = attr.NAME;
+    VALUE = attr.VALUE;
+  }
+  if (NAME in variableList) {
+    parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`EXT-X-DEFINE duplicate Variable Name declarations: "${NAME}"`));
+  } else {
+    variableList[NAME] = VALUE || '';
+  }
+}
+function importVariableDefinition(parsed, attr, sourceVariableList) {
+  const IMPORT = attr.IMPORT;
+  if (sourceVariableList && IMPORT in sourceVariableList) {
+    let variableList = parsed.variableList;
+    if (!variableList) {
+      parsed.variableList = variableList = {};
+    }
+    variableList[IMPORT] = sourceVariableList[IMPORT];
+  } else {
+    parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`EXT-X-DEFINE IMPORT attribute not found in Multivariant Playlist: "${IMPORT}"`));
+  }
+}
+
+const DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/;
+const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
+
+// adapted from https://github.com/kanongil/node-m3u8parse/blob/master/attrlist.js
+class AttrList {
+  constructor(attrs, parsed) {
+    if (typeof attrs === 'string') {
+      attrs = AttrList.parseAttrList(attrs, parsed);
+    }
+    _extends(this, attrs);
+  }
+  get clientAttrs() {
+    return Object.keys(this).filter(attr => attr.substring(0, 2) === 'X-');
+  }
+  decimalInteger(attrName) {
+    const intValue = parseInt(this[attrName], 10);
+    if (intValue > Number.MAX_SAFE_INTEGER) {
+      return Infinity;
+    }
+    return intValue;
+  }
+  hexadecimalInteger(attrName) {
+    if (this[attrName]) {
+      let stringValue = (this[attrName] || '0x').slice(2);
+      stringValue = (stringValue.length & 1 ? '0' : '') + stringValue;
+      const value = new Uint8Array(stringValue.length / 2);
+      for (let i = 0; i < stringValue.length / 2; i++) {
+        value[i] = parseInt(stringValue.slice(i * 2, i * 2 + 2), 16);
+      }
+      return value;
+    } else {
+      return null;
+    }
+  }
+  hexadecimalIntegerAsNumber(attrName) {
+    const intValue = parseInt(this[attrName], 16);
+    if (intValue > Number.MAX_SAFE_INTEGER) {
+      return Infinity;
+    }
+    return intValue;
+  }
+  decimalFloatingPoint(attrName) {
+    return parseFloat(this[attrName]);
+  }
+  optionalFloat(attrName, defaultValue) {
+    const value = this[attrName];
+    return value ? parseFloat(value) : defaultValue;
+  }
+  enumeratedString(attrName) {
+    return this[attrName];
+  }
+  enumeratedStringList(attrName, dict) {
+    const attrValue = this[attrName];
+    return (attrValue ? attrValue.split(/[ ,]+/) : []).reduce((result, identifier) => {
+      result[identifier.toLowerCase()] = true;
+      return result;
+    }, dict);
+  }
+  bool(attrName) {
+    return this[attrName] === 'YES';
+  }
+  decimalResolution(attrName) {
+    const res = DECIMAL_RESOLUTION_REGEX.exec(this[attrName]);
+    if (res === null) {
+      return undefined;
+    }
+    return {
+      width: parseInt(res[1], 10),
+      height: parseInt(res[2], 10)
+    };
+  }
+  static parseAttrList(input, parsed) {
+    let match;
+    const attrs = {};
+    const quote = '"';
+    ATTR_LIST_REGEX.lastIndex = 0;
+    while ((match = ATTR_LIST_REGEX.exec(input)) !== null) {
+      const name = match[1].trim();
+      let value = match[2];
+      const quotedString = value.indexOf(quote) === 0 && value.lastIndexOf(quote) === value.length - 1;
+      let hexadecimalSequence = false;
+      if (quotedString) {
+        value = value.slice(1, -1);
+      } else {
+        switch (name) {
+          case 'IV':
+          case 'SCTE35-CMD':
+          case 'SCTE35-IN':
+          case 'SCTE35-OUT':
+            hexadecimalSequence = true;
+        }
+      }
+      if (parsed && (quotedString || hexadecimalSequence)) {
+        {
+          value = substituteVariables(parsed, value);
+        }
+      } else if (!hexadecimalSequence && !quotedString) {
+        switch (name) {
+          case 'CLOSED-CAPTIONS':
+            if (value === 'NONE') {
+              break;
+            }
+          // falls through
+          case 'ALLOWED-CPC':
+          case 'CLASS':
+          case 'ASSOC-LANGUAGE':
+          case 'AUDIO':
+          case 'BYTERANGE':
+          case 'CHANNELS':
+          case 'CHARACTERISTICS':
+          case 'CODECS':
+          case 'DATA-ID':
+          case 'END-DATE':
+          case 'GROUP-ID':
+          case 'ID':
+          case 'IMPORT':
+          case 'INSTREAM-ID':
+          case 'KEYFORMAT':
+          case 'KEYFORMATVERSIONS':
+          case 'LANGUAGE':
+          case 'NAME':
+          case 'PATHWAY-ID':
+          case 'QUERYPARAM':
+          case 'RECENTLY-REMOVED-DATERANGES':
+          case 'SERVER-URI':
+          case 'STABLE-RENDITION-ID':
+          case 'STABLE-VARIANT-ID':
+          case 'START-DATE':
+          case 'SUBTITLES':
+          case 'SUPPLEMENTAL-CODECS':
+          case 'URI':
+          case 'VALUE':
+          case 'VIDEO':
+          case 'X-ASSET-LIST':
+          case 'X-ASSET-URI':
+            // Since we are not checking tag:attribute combination, just warn rather than ignoring attribute
+            logger.warn(`${input}: attribute ${name} is missing quotes`);
+          // continue;
+        }
+      }
+      attrs[name] = value;
+    }
+    return attrs;
+  }
+}
+
 // Avoid exporting const enum so that these values can be inlined
 
+const CLASS_INTERSTITIAL = 'com.apple.hls.interstitial';
 function isDateRangeCueAttribute(attrName) {
-  return attrName !== "ID" && attrName !== "CLASS" && attrName !== "START-DATE" && attrName !== "DURATION" && attrName !== "END-DATE" && attrName !== "END-ON-NEXT";
+  return attrName !== "ID" && attrName !== "CLASS" && attrName !== "CUE" && attrName !== "START-DATE" && attrName !== "DURATION" && attrName !== "END-DATE" && attrName !== "END-ON-NEXT";
 }
 function isSCTE35Attribute(attrName) {
-  return attrName === "SCTE35-OUT" || attrName === "SCTE35-IN";
+  return attrName === "SCTE35-OUT" || attrName === "SCTE35-IN" || attrName === "SCTE35-CMD";
 }
 class DateRange {
-  constructor(dateRangeAttr, dateRangeWithSameId) {
+  constructor(dateRangeAttr, dateRangeWithSameId, tagCount = 0) {
+    var _dateRangeWithSameId$;
     this.attr = void 0;
+    this.tagAnchor = void 0;
+    this.tagOrder = void 0;
     this._startDate = void 0;
     this._endDate = void 0;
+    this._cue = void 0;
     this._badValueForSameId = void 0;
+    this.tagAnchor = (dateRangeWithSameId == null ? void 0 : dateRangeWithSameId.tagAnchor) || null;
+    this.tagOrder = (_dateRangeWithSameId$ = dateRangeWithSameId == null ? void 0 : dateRangeWithSameId.tagOrder) != null ? _dateRangeWithSameId$ : tagCount;
     if (dateRangeWithSameId) {
       const previousAttr = dateRangeWithSameId.attr;
       for (const key in previousAttr) {
@@ -545,9 +678,9 @@ class DateRange {
       dateRangeAttr = _extends(new AttrList({}), previousAttr, dateRangeAttr);
     }
     this.attr = dateRangeAttr;
-    this._startDate = new Date(dateRangeAttr["START-DATE"]);
+    this._startDate = dateRangeWithSameId ? dateRangeWithSameId.startDate : new Date(dateRangeAttr["START-DATE"]);
     if ("END-DATE" in this.attr) {
-      const endDate = new Date(this.attr["END-DATE"]);
+      const endDate = (dateRangeWithSameId == null ? void 0 : dateRangeWithSameId.endDate) || new Date(this.attr["END-DATE"]);
       if (isFiniteNumber(endDate.getTime())) {
         this._endDate = endDate;
       }
@@ -559,6 +692,28 @@ class DateRange {
   get class() {
     return this.attr.CLASS;
   }
+  get cue() {
+    const _cue = this._cue;
+    if (_cue === undefined) {
+      return this._cue = this.attr.enumeratedStringList(this.attr.CUE ? 'CUE' : 'X-CUE', {
+        pre: false,
+        post: false,
+        once: false
+      });
+    }
+    return _cue;
+  }
+  get startTime() {
+    const {
+      tagAnchor
+    } = this;
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (tagAnchor === null || tagAnchor.programDateTime === null) {
+      logger.warn(`Expected tagAnchor Fragment with PDT set for DateRange "${this.id}": ${tagAnchor}`);
+      return NaN;
+    }
+    return tagAnchor.start + (this.startDate.getTime() - tagAnchor.programDateTime) / 1000;
+  }
   get startDate() {
     return this._startDate;
   }
@@ -592,8 +747,11 @@ class DateRange {
   get endOnNext() {
     return this.attr.bool("END-ON-NEXT");
   }
+  get isInterstitial() {
+    return this.class === CLASS_INTERSTITIAL;
+  }
   get isValid() {
-    return !!this.id && !this._badValueForSameId && isFiniteNumber(this.startDate.getTime()) && (this.duration === null || this.duration >= 0) && (!this.endOnNext || !!this.class);
+    return !!this.id && !this._badValueForSameId && isFiniteNumber(this.startDate.getTime()) && (this.duration === null || this.duration >= 0) && (!this.endOnNext || !!this.class) && (!this.attr.CUE || !this.cue.pre && !this.cue.post || this.cue.pre !== this.cue.post) && (!this.isInterstitial || 'X-ASSET-URI' in this.attr || 'X-ASSET-LIST' in this.attr);
   }
 }
 
@@ -679,7 +837,6 @@ class BaseSegment {
     this._url = value;
   }
 }
-
 /**
  * Object representing parsed data from an HLS Segment. Found in {@link hls.js#LevelDetails.fragments}.
  */
@@ -892,6 +1049,7 @@ class LevelDetails {
     this.fragmentHint = void 0;
     this.partList = null;
     this.dateRanges = void 0;
+    this.dateRangeTagCount = 0;
     this.live = true;
     this.ageHeader = 0;
     this.advancedDateTime = void 0;
@@ -2574,78 +2732,6 @@ function createInitializationVector(segmentNumber) {
   return uint8View;
 }
 
-const VARIABLE_REPLACEMENT_REGEX = /\{\$([a-zA-Z0-9-_]+)\}/g;
-function hasVariableReferences(str) {
-  return VARIABLE_REPLACEMENT_REGEX.test(str);
-}
-function substituteVariablesInAttributes(parsed, attr, attributeNames) {
-  if (parsed.variableList !== null || parsed.hasVariableRefs) {
-    for (let i = attributeNames.length; i--;) {
-      const name = attributeNames[i];
-      const value = attr[name];
-      if (value) {
-        attr[name] = substituteVariables(parsed, value);
-      }
-    }
-  }
-}
-function substituteVariables(parsed, value) {
-  if (parsed.variableList !== null || parsed.hasVariableRefs) {
-    const variableList = parsed.variableList;
-    return value.replace(VARIABLE_REPLACEMENT_REGEX, variableReference => {
-      const variableName = variableReference.substring(2, variableReference.length - 1);
-      const variableValue = variableList == null ? void 0 : variableList[variableName];
-      if (variableValue === undefined) {
-        parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`Missing preceding EXT-X-DEFINE tag for Variable Reference: "${variableName}"`));
-        return variableReference;
-      }
-      return variableValue;
-    });
-  }
-  return value;
-}
-function addVariableDefinition(parsed, attr, parentUrl) {
-  let variableList = parsed.variableList;
-  if (!variableList) {
-    parsed.variableList = variableList = {};
-  }
-  let NAME;
-  let VALUE;
-  if ('QUERYPARAM' in attr) {
-    NAME = attr.QUERYPARAM;
-    try {
-      const searchParams = new self.URL(parentUrl).searchParams;
-      if (searchParams.has(NAME)) {
-        VALUE = searchParams.get(NAME);
-      } else {
-        throw new Error(`"${NAME}" does not match any query parameter in URI: "${parentUrl}"`);
-      }
-    } catch (error) {
-      parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`EXT-X-DEFINE QUERYPARAM: ${error.message}`));
-    }
-  } else {
-    NAME = attr.NAME;
-    VALUE = attr.VALUE;
-  }
-  if (NAME in variableList) {
-    parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`EXT-X-DEFINE duplicate Variable Name declarations: "${NAME}"`));
-  } else {
-    variableList[NAME] = VALUE || '';
-  }
-}
-function importVariableDefinition(parsed, attr, sourceVariableList) {
-  const IMPORT = attr.IMPORT;
-  if (sourceVariableList && IMPORT in sourceVariableList) {
-    let variableList = parsed.variableList;
-    if (!variableList) {
-      parsed.variableList = variableList = {};
-    }
-    variableList[IMPORT] = sourceVariableList[IMPORT];
-  } else {
-    parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`EXT-X-DEFINE IMPORT attribute not found in Multivariant Playlist: "${IMPORT}"`));
-  }
-}
-
 /**
  * MediaSource helper
  */
@@ -2881,10 +2967,7 @@ class M3U8Parser {
       if (result[1]) {
         var _level$unknownCodecs;
         // '#EXT-X-STREAM-INF' is found, parse level tag  in group 1
-        const attrs = new AttrList(result[1]);
-        {
-          substituteVariablesInAttributes(parsed, attrs, ['CODECS', 'SUPPLEMENTAL-CODECS', 'ALLOWED-CPC', 'PATHWAY-ID', 'STABLE-VARIANT-ID', 'AUDIO', 'VIDEO', 'SUBTITLES', 'CLOSED-CAPTIONS', 'NAME']);
-        }
+        const attrs = new AttrList(result[1], parsed);
         const uri = substituteVariables(parsed, result[2]) ;
         const level = {
           attrs,
@@ -2909,10 +2992,7 @@ class M3U8Parser {
           case 'SESSION-DATA':
             {
               // #EXT-X-SESSION-DATA
-              const sessionAttrs = new AttrList(attributes);
-              {
-                substituteVariablesInAttributes(parsed, sessionAttrs, ['DATA-ID', 'LANGUAGE', 'VALUE', 'URI']);
-              }
+              const sessionAttrs = new AttrList(attributes, parsed);
               const dataId = sessionAttrs['DATA-ID'];
               if (dataId) {
                 if (parsed.sessionData === null) {
@@ -2940,8 +3020,7 @@ class M3U8Parser {
             {
               // #EXT-X-DEFINE
               {
-                const variableAttributes = new AttrList(attributes);
-                substituteVariablesInAttributes(parsed, variableAttributes, ['NAME', 'VALUE', 'QUERYPARAM']);
+                const variableAttributes = new AttrList(attributes, parsed);
                 addVariableDefinition(parsed, variableAttributes, baseurl);
               }
               break;
@@ -2949,10 +3028,7 @@ class M3U8Parser {
           case 'CONTENT-STEERING':
             {
               // #EXT-X-CONTENT-STEERING
-              const contentSteeringAttributes = new AttrList(attributes);
-              {
-                substituteVariablesInAttributes(parsed, contentSteeringAttributes, ['SERVER-URI', 'PATHWAY-ID']);
-              }
+              const contentSteeringAttributes = new AttrList(attributes, parsed);
               parsed.contentSteering = {
                 uri: M3U8Parser.resolve(contentSteeringAttributes['SERVER-URI'], baseurl),
                 pathwayId: contentSteeringAttributes['PATHWAY-ID'] || '.'
@@ -2994,15 +3070,12 @@ class M3U8Parser {
     let id = 0;
     MASTER_PLAYLIST_MEDIA_REGEX.lastIndex = 0;
     while ((result = MASTER_PLAYLIST_MEDIA_REGEX.exec(string)) !== null) {
-      const attrs = new AttrList(result[1]);
+      const attrs = new AttrList(result[1], parsed);
       const type = attrs.TYPE;
       if (type) {
         const groups = groupsByType[type];
         const medias = results[type] || [];
         results[type] = medias;
-        {
-          substituteVariablesInAttributes(parsed, attrs, ['URI', 'GROUP-ID', 'LANGUAGE', 'ASSOC-LANGUAGE', 'STABLE-RENDITION-ID', 'NAME', 'INSTREAM-ID', 'CHARACTERISTICS', 'CHANNELS']);
-        }
         const lang = attrs.LANGUAGE;
         const assocLang = attrs['ASSOC-LANGUAGE'];
         const channels = attrs.CHANNELS;
@@ -3049,6 +3122,7 @@ class M3U8Parser {
   static parseLevelPlaylist(string, baseurl, id, type, levelUrlId, multivariantVariableList) {
     const level = new LevelDetails(baseurl);
     const fragments = level.fragments;
+    const programDateTimes = [];
     // The most recent init segment seen (applies to all subsequent segments)
     let currentInitSegment = null;
     let currentSN = 0;
@@ -3107,7 +3181,7 @@ class M3U8Parser {
           // avoid sliced strings    https://github.com/video-dev/hls.js/issues/939
           const uri = (' ' + result[3]).slice(1);
           frag.relurl = substituteVariables(level, uri) ;
-          assignProgramDateTime(frag, prevFrag);
+          assignProgramDateTime(frag, prevFrag, programDateTimes);
           prevFrag = frag;
           totalduration += frag.duration;
           currentSN++;
@@ -3155,22 +3229,22 @@ class M3U8Parser {
             break;
           case 'SKIP':
             {
-              const skipAttrs = new AttrList(value1);
-              {
-                substituteVariablesInAttributes(level, skipAttrs, ['RECENTLY-REMOVED-DATERANGES']);
+              if (level.skippedSegments) {
+                level.playlistParsingError = new Error(`#EXT-X-SKIP MUST NOT appear more than once in a Playlist`);
               }
+              const skipAttrs = new AttrList(value1, level);
               const skippedSegments = skipAttrs.decimalInteger('SKIPPED-SEGMENTS');
               if (isFiniteNumber(skippedSegments)) {
-                level.skippedSegments = skippedSegments;
+                level.skippedSegments += skippedSegments;
                 // This will result in fragments[] containing undefined values, which we will fill in with `mergeDetails`
                 for (let _i = skippedSegments; _i--;) {
-                  fragments.unshift(null);
+                  fragments.push(null);
                 }
                 currentSN += skippedSegments;
               }
               const recentlyRemovedDateranges = skipAttrs.enumeratedString('RECENTLY-REMOVED-DATERANGES');
               if (recentlyRemovedDateranges) {
-                level.recentlyRemovedDateranges = recentlyRemovedDateranges.split('\t');
+                level.recentlyRemovedDateranges = (level.recentlyRemovedDateranges || []).concat(recentlyRemovedDateranges.split('\t'));
               }
               break;
             }
@@ -3204,12 +3278,9 @@ class M3U8Parser {
             break;
           case 'DATERANGE':
             {
-              const dateRangeAttr = new AttrList(value1);
-              {
-                substituteVariablesInAttributes(level, dateRangeAttr, ['ID', 'CLASS', 'START-DATE', 'END-DATE', 'SCTE35-CMD', 'SCTE35-OUT', 'SCTE35-IN']);
-                substituteVariablesInAttributes(level, dateRangeAttr, dateRangeAttr.clientAttrs);
-              }
-              const dateRange = new DateRange(dateRangeAttr, level.dateRanges[dateRangeAttr.ID]);
+              const dateRangeAttr = new AttrList(value1, level);
+              const dateRange = new DateRange(dateRangeAttr, level.dateRanges[dateRangeAttr.ID], level.dateRangeTagCount);
+              level.dateRangeTagCount++;
               if (dateRange.isValid || level.skippedSegments) {
                 level.dateRanges[dateRange.id] = dateRange;
               } else {
@@ -3222,8 +3293,7 @@ class M3U8Parser {
           case 'DEFINE':
             {
               {
-                const variableAttributes = new AttrList(value1);
-                substituteVariablesInAttributes(level, variableAttributes, ['NAME', 'VALUE', 'IMPORT', 'QUERYPARAM']);
+                const variableAttributes = new AttrList(value1, level);
                 if ('IMPORT' in variableAttributes) {
                   importVariableDefinition(level, variableAttributes, multivariantVariableList);
                 } else {
@@ -3260,10 +3330,7 @@ class M3U8Parser {
             break;
           case 'MAP':
             {
-              const mapAttrs = new AttrList(value1);
-              {
-                substituteVariablesInAttributes(level, mapAttrs, ['BYTERANGE', 'URI']);
-              }
+              const mapAttrs = new AttrList(value1, level);
               if (frag.duration) {
                 // Initial segment tag is after segment duration tag.
                 //   #EXTINF: 6.0
@@ -3289,6 +3356,7 @@ class M3U8Parser {
                 currentInitSegment = frag;
                 createNextFrag = true;
               }
+              currentInitSegment.cc = discontinuityCounter;
               break;
             }
           case 'SERVER-CONTROL':
@@ -3315,10 +3383,7 @@ class M3U8Parser {
               }
               const previousFragmentPart = currentPart > 0 ? partList[partList.length - 1] : undefined;
               const index = currentPart++;
-              const partAttrs = new AttrList(value1);
-              {
-                substituteVariablesInAttributes(level, partAttrs, ['BYTERANGE', 'URI']);
-              }
+              const partAttrs = new AttrList(value1, level);
               const part = new Part(partAttrs, frag, baseurl, index, previousFragmentPart);
               partList.push(part);
               frag.duration += part.duration;
@@ -3326,19 +3391,13 @@ class M3U8Parser {
             }
           case 'PRELOAD-HINT':
             {
-              const preloadHintAttrs = new AttrList(value1);
-              {
-                substituteVariablesInAttributes(level, preloadHintAttrs, ['URI']);
-              }
+              const preloadHintAttrs = new AttrList(value1, level);
               level.preloadHint = preloadHintAttrs;
               break;
             }
           case 'RENDITION-REPORT':
             {
-              const renditionReportAttrs = new AttrList(value1);
-              {
-                substituteVariablesInAttributes(level, renditionReportAttrs, ['URI']);
-              }
+              const renditionReportAttrs = new AttrList(value1, level);
               level.renditionReports = level.renditionReports || [];
               level.renditionReports.push(renditionReportAttrs);
               break;
@@ -3356,7 +3415,7 @@ class M3U8Parser {
         level.fragmentHint = prevFrag;
       }
     } else if (level.partList) {
-      assignProgramDateTime(frag, prevFrag);
+      assignProgramDateTime(frag, prevFrag, programDateTimes);
       frag.cc = discontinuityCounter;
       level.fragmentHint = frag;
       if (levelkeys) {
@@ -3377,6 +3436,21 @@ class M3U8Parser {
       if (firstFragment) {
         level.startCC = firstFragment.cc;
       }
+      /**
+       * Backfill any missing PDT values
+       * "If the first EXT-X-PROGRAM-DATE-TIME tag in a Playlist appears after
+       * one or more Media Segment URIs, the client SHOULD extrapolate
+       * backward from that tag (using EXTINF durations and/or media
+       * timestamps) to associate dates with those segments."
+       * We have already extrapolated forward, but all fragments up to the first instance of PDT do not have their PDTs
+       * computed.
+       */
+      if (firstPdtIndex > 0) {
+        backfillProgramDateTimes(fragments, firstPdtIndex);
+        if (firstFragment) {
+          programDateTimes.unshift(firstFragment);
+        }
+      }
     } else {
       level.endSN = 0;
       level.startCC = 0;
@@ -3385,30 +3459,62 @@ class M3U8Parser {
       totalduration += level.fragmentHint.duration;
     }
     level.totalduration = totalduration;
-    level.endCC = discontinuityCounter;
-
-    /**
-     * Backfill any missing PDT values
-     * "If the first EXT-X-PROGRAM-DATE-TIME tag in a Playlist appears after
-     * one or more Media Segment URIs, the client SHOULD extrapolate
-     * backward from that tag (using EXTINF durations and/or media
-     * timestamps) to associate dates with those segments."
-     * We have already extrapolated forward, but all fragments up to the first instance of PDT do not have their PDTs
-     * computed.
-     */
-    if (firstPdtIndex > 0) {
-      backfillProgramDateTimes(fragments, firstPdtIndex);
+    if (programDateTimes.length && level.dateRangeTagCount && firstFragment) {
+      mapDateRanges(programDateTimes, level);
     }
+    level.endCC = discontinuityCounter;
     return level;
   }
 }
+function mapDateRanges(programDateTimes, details) {
+  // Make sure DateRanges are mapped to a ProgramDateTime tag that applies a date to a segment that overlaps with its start date
+  const programDateTimeCount = programDateTimes.length;
+  const lastProgramDateTime = programDateTimes[programDateTimeCount - 1];
+  const playlistEnd = details.live ? Infinity : details.totalduration;
+  const dateRangeIds = Object.keys(details.dateRanges);
+  for (let i = dateRangeIds.length; i--;) {
+    const dateRange = details.dateRanges[dateRangeIds[i]];
+    const startDateTime = dateRange.startDate.getTime();
+    dateRange.tagAnchor = lastProgramDateTime;
+    for (let j = programDateTimeCount; j--;) {
+      const fragIndex = findFragmentWithStartDate(details, startDateTime, programDateTimes, j, playlistEnd);
+      if (fragIndex !== -1) {
+        dateRange.tagAnchor = details.fragments[fragIndex];
+        break;
+      }
+    }
+  }
+}
+function findFragmentWithStartDate(details, startDateTime, programDateTimes, index, endTime) {
+  const pdtFragment = programDateTimes[index];
+  if (pdtFragment) {
+    var _programDateTimes;
+    // find matching range between PDT tags
+    const durationBetweenPdt = (((_programDateTimes = programDateTimes[index + 1]) == null ? void 0 : _programDateTimes.start) || endTime) - pdtFragment.start;
+    const pdtStart = pdtFragment.programDateTime;
+    if ((startDateTime >= pdtStart || index === 0) && startDateTime <= pdtStart + durationBetweenPdt * 1000) {
+      // map to fragment with date-time range
+      const startIndex = programDateTimes[index].sn - details.startSN;
+      const fragments = details.fragments;
+      if (fragments.length > programDateTimes.length) {
+        const endSegment = programDateTimes[index + 1] || fragments[fragments.length - 1];
+        const endIndex = endSegment.sn - details.startSN;
+        for (let i = endIndex; i > startIndex; i--) {
+          const fragStartDateTime = fragments[i].programDateTime;
+          if (startDateTime >= fragStartDateTime && startDateTime < fragStartDateTime + fragments[i].duration * 1000) {
+            return i;
+          }
+        }
+      }
+      return startIndex;
+    }
+  }
+  return -1;
+}
 function parseKey(keyTagAttributes, baseurl, parsed) {
   var _keyAttrs$METHOD, _keyAttrs$KEYFORMAT;
   // https://tools.ietf.org/html/rfc8216#section-4.3.2.4
-  const keyAttrs = new AttrList(keyTagAttributes);
-  {
-    substituteVariablesInAttributes(parsed, keyAttrs, ['KEYFORMAT', 'KEYFORMATVERSIONS', 'URI', 'IV', 'URI']);
-  }
+  const keyAttrs = new AttrList(keyTagAttributes, parsed);
   const decryptmethod = (_keyAttrs$METHOD = keyAttrs.METHOD) != null ? _keyAttrs$METHOD : '';
   const decrypturi = keyAttrs.URI;
   const decryptiv = keyAttrs.hexadecimalInteger('IV');
@@ -3463,16 +3569,18 @@ function backfillProgramDateTimes(fragments, firstPdtIndex) {
     fragPrev = frag;
   }
 }
-function assignProgramDateTime(frag, prevFrag) {
+function assignProgramDateTime(frag, prevFrag, programDateTimes) {
   if (frag.rawProgramDateTime) {
     frag.programDateTime = Date.parse(frag.rawProgramDateTime);
+    if (!isFiniteNumber(frag.programDateTime)) {
+      frag.programDateTime = null;
+      frag.rawProgramDateTime = null;
+      return;
+    }
+    programDateTimes.push(frag);
   } else if (prevFrag != null && prevFrag.programDateTime) {
     frag.programDateTime = prevFrag.endProgramDateTime;
   }
-  if (!isFiniteNumber(frag.programDateTime)) {
-    frag.programDateTime = null;
-    frag.rawProgramDateTime = null;
-  }
 }
 function setInitSegment(frag, mapAttrs, id, levelkeys) {
   frag.relurl = mapAttrs.URI;
@@ -4702,9 +4810,6 @@ const MAX_CUE_ENDTIME = (() => {
   }
   return Number.POSITIVE_INFINITY;
 })();
-function dateRangeDateToTimelineSeconds(date, offset) {
-  return date.getTime() / 1000 - offset;
-}
 function hexToArrayBuffer(str) {
   return Uint8Array.from(str.replace(/^0x/, '').replace(/([\da-fA-F]{2}) ?/g, '0x$1 ').replace(/ +$/, '').split(' ')).buffer;
 }
@@ -4735,6 +4840,7 @@ class ID3TrackController {
     hls.on(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
     hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
+    hls.on(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
   }
   _unregisterListeners() {
     const {
@@ -4746,6 +4852,7 @@ class ID3TrackController {
     hls.off(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
     hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
+    hls.off(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
   }
 
   // Add ID3 metatadata text track.
@@ -4886,6 +4993,14 @@ class ID3TrackController {
   onLevelUpdated(event, {
     details
   }) {
+    this.updateDateRangeCues(details, true);
+  }
+  onLevelPtsUpdated(event, data) {
+    if (Math.abs(data.drift) > 0.01) {
+      this.updateDateRangeCues(data.details);
+    }
+  }
+  updateDateRangeCues(details, removeOldCues) {
     if (!this.media || !details.hasProgramDateTime || !this.hls.config.enableDateRangeMetadataCues) {
       return;
     }
@@ -4898,7 +5013,7 @@ class ID3TrackController {
     } = details;
     const ids = Object.keys(dateRanges);
     // Remove cues from track not found in details.dateRanges
-    if (id3Track) {
+    if (id3Track && removeOldCues) {
       const idsToRemove = Object.keys(dateRangeCuesAppended).filter(id => !ids.includes(id));
       for (let i = idsToRemove.length; i--;) {
         const id = idsToRemove[i];
@@ -4916,21 +5031,23 @@ class ID3TrackController {
     if (!this.id3Track) {
       this.id3Track = this.createTrack(this.media);
     }
-    const dateTimeOffset = lastFragment.programDateTime / 1000 - lastFragment.start;
     const Cue = getCueClass();
     for (let i = 0; i < ids.length; i++) {
       const id = ids[i];
       const dateRange = dateRanges[id];
-      const startTime = dateRangeDateToTimelineSeconds(dateRange.startDate, dateTimeOffset);
+      const startTime = dateRange.startTime;
 
       // Process DateRanges to determine end-time (known DURATION, END-DATE, or END-ON-NEXT)
       const appendedDateRangeCues = dateRangeCuesAppended[id];
       const cues = (appendedDateRangeCues == null ? void 0 : appendedDateRangeCues.cues) || {};
       let durationKnown = (appendedDateRangeCues == null ? void 0 : appendedDateRangeCues.durationKnown) || false;
       let endTime = MAX_CUE_ENDTIME;
-      const endDate = dateRange.endDate;
-      if (endDate) {
-        endTime = dateRangeDateToTimelineSeconds(endDate, dateTimeOffset);
+      const {
+        duration,
+        endDate
+      } = dateRange;
+      if (endDate && duration !== null) {
+        endTime = startTime + duration;
         durationKnown = true;
       } else if (dateRange.endOnNext && !durationKnown) {
         const nextDateRangeWithSameClass = ids.reduce((candidateDateRange, id) => {
@@ -4943,7 +5060,7 @@ class ID3TrackController {
           return candidateDateRange;
         }, null);
         if (nextDateRangeWithSameClass) {
-          endTime = dateRangeDateToTimelineSeconds(nextDateRangeWithSameClass.startDate, dateTimeOffset);
+          endTime = nextDateRangeWithSameClass.startTime;
           durationKnown = true;
         }
       }
@@ -4960,6 +5077,9 @@ class ID3TrackController {
         if (cue) {
           if (durationKnown && !appendedDateRangeCues.durationKnown) {
             cue.endTime = endTime;
+          } else if (Math.abs(cue.startTime - startTime) > 0.01) {
+            cue.startTime = startTime;
+            cue.endTime = endTime;
           }
         } else if (Cue) {
           let data = dateRange.attr[key];
@@ -5451,7 +5571,7 @@ function updateFragPTSDTS(details, frag, startPTS, endPTS, startDTS, endDTS) {
   frag.endPTS = endPTS;
   frag.minEndPTS = minEndPTS;
   frag.endDTS = endDTS;
-  const sn = frag.sn; // 'initSegment'
+  const sn = frag.sn;
   // exit if sn out of range
   if (!details || sn < details.startSN || sn > details.endSN) {
     return 0;
@@ -5529,8 +5649,8 @@ function mergeDetails(oldDetails, newDetails) {
       currentInitSegment = oldFrag.initSegment;
     }
   });
+  const fragmentsToCheck = newDetails.fragmentHint ? newDetails.fragments.concat(newDetails.fragmentHint) : newDetails.fragments;
   if (currentInitSegment) {
-    const fragmentsToCheck = newDetails.fragmentHint ? newDetails.fragments.concat(newDetails.fragmentHint) : newDetails.fragments;
     fragmentsToCheck.forEach(frag => {
       var _currentInitSegment;
       if (frag && (!frag.initSegment || frag.initSegment.relurl === ((_currentInitSegment = currentInitSegment) == null ? void 0 : _currentInitSegment.relurl))) {
@@ -5547,8 +5667,19 @@ function mergeDetails(oldDetails, newDetails) {
       }
       newDetails.startSN = newDetails.fragments[0].sn;
       newDetails.startCC = newDetails.fragments[0].cc;
-    } else if (newDetails.canSkipDateRanges) {
-      newDetails.dateRanges = mergeDateRanges(oldDetails.dateRanges, newDetails.dateRanges, newDetails.recentlyRemovedDateranges);
+    } else {
+      if (newDetails.canSkipDateRanges) {
+        newDetails.dateRanges = mergeDateRanges(oldDetails.dateRanges, newDetails);
+      }
+      const programDateTimes = oldDetails.fragments.filter(frag => frag.rawProgramDateTime);
+      if (oldDetails.hasProgramDateTime && !newDetails.hasProgramDateTime) {
+        for (let i = 1; i < fragmentsToCheck.length; i++) {
+          if (fragmentsToCheck[i].programDateTime === null) {
+            assignProgramDateTime(fragmentsToCheck[i], fragmentsToCheck[i - 1], programDateTimes);
+          }
+        }
+      }
+      mapDateRanges(programDateTimes, newDetails);
     }
   }
   const newFragments = newDetails.fragments;
@@ -5597,21 +5728,33 @@ function mergeDetails(oldDetails, newDetails) {
     newDetails.advancedDateTime = oldDetails.advancedDateTime;
   }
 }
-function mergeDateRanges(oldDateRanges, deltaDateRanges, recentlyRemovedDateranges) {
+function mergeDateRanges(oldDateRanges, newDetails) {
+  const {
+    dateRanges: deltaDateRanges,
+    recentlyRemovedDateranges
+  } = newDetails;
   const dateRanges = _extends({}, oldDateRanges);
   if (recentlyRemovedDateranges) {
     recentlyRemovedDateranges.forEach(id => {
       delete dateRanges[id];
     });
   }
-  Object.keys(deltaDateRanges).forEach(id => {
-    const dateRange = new DateRange(deltaDateRanges[id].attr, dateRanges[id]);
-    if (dateRange.isValid) {
-      dateRanges[id] = dateRange;
-    } else {
-      logger.warn(`Ignoring invalid Playlist Delta Update DATERANGE tag: "${JSON.stringify(deltaDateRanges[id].attr)}"`);
-    }
-  });
+  const mergeIds = Object.keys(dateRanges);
+  const mergeCount = mergeIds.length;
+  if (mergeCount) {
+    Object.keys(deltaDateRanges).forEach(id => {
+      const mergedDateRange = dateRanges[id];
+      const dateRange = new DateRange(deltaDateRanges[id].attr, mergedDateRange);
+      if (dateRange.isValid) {
+        dateRanges[id] = dateRange;
+        if (!mergedDateRange) {
+          dateRange.tagOrder += mergeCount;
+        }
+      } else {
+        logger.warn(`Ignoring invalid Playlist Delta Update DATERANGE tag: "${JSON.stringify(deltaDateRanges[id].attr)}"`);
+      }
+    });
+  }
   return dateRanges;
 }
 function mapPartIntersection(oldParts, newParts, intersectionFn) {
@@ -5638,7 +5781,7 @@ function mapFragmentIntersection(oldDetails, newDetails, intersectionFn) {
   for (let i = start; i <= end; i++) {
     const oldFrag = oldFrags[delta + i];
     let newFrag = newFrags[i];
-    if (skippedSegments && !newFrag && i < skippedSegments) {
+    if (skippedSegments && !newFrag && oldFrag) {
       // Fill in skipped segments in delta playlist
       newFrag = newDetails.fragments[i] = oldFrag;
     }
@@ -5688,19 +5831,19 @@ function computeReloadInterval(newDetails, distanceToLiveEdgeMs = Infinity) {
   return Math.round(reloadInterval);
 }
 function getFragmentWithSN(level, sn, fragCurrent) {
-  if (!(level != null && level.details)) {
+  const details = level == null ? void 0 : level.details;
+  if (!details) {
     return null;
   }
-  const levelDetails = level.details;
-  let fragment = levelDetails.fragments[sn - levelDetails.startSN];
+  let fragment = details.fragments[sn - details.startSN];
   if (fragment) {
     return fragment;
   }
-  fragment = levelDetails.fragmentHint;
+  fragment = details.fragmentHint;
   if (fragment && fragment.sn === sn) {
     return fragment;
   }
-  if (sn < levelDetails.startSN && fragCurrent && fragCurrent.sn === sn) {
+  if (sn < details.startSN && fragCurrent && fragCurrent.sn === sn) {
     return fragCurrent;
   }
   return null;
@@ -8023,13 +8166,10 @@ class FragmentTracker {
    */
   detectPartialFragments(data) {
     const timeRanges = this.timeRanges;
-    const {
-      frag,
-      part
-    } = data;
-    if (!timeRanges || frag.sn === 'initSegment') {
+    if (!timeRanges || data.frag.sn === 'initSegment') {
       return;
     }
+    const frag = data.frag;
     const fragKey = getFragmentKey(frag);
     const fragmentEntity = this.fragments[fragKey];
     if (!fragmentEntity || fragmentEntity.buffered && frag.gap) {
@@ -8043,7 +8183,7 @@ class FragmentTracker {
       }
       const timeRange = timeRanges[elementaryStream];
       const partial = isFragHint || streamInfo.partial === true;
-      fragmentEntity.range[elementaryStream] = this.getBufferedTimes(frag, part, partial, timeRange);
+      fragmentEntity.range[elementaryStream] = this.getBufferedTimes(frag, data.part, partial, timeRange);
     });
     fragmentEntity.loaded = null;
     if (Object.keys(fragmentEntity.range).length) {
@@ -8196,18 +8336,14 @@ class FragmentTracker {
     return false;
   }
   onFragLoaded(event, data) {
-    const {
-      frag,
-      part
-    } = data;
     // don't track initsegment (for which sn is not a number)
     // don't track frags used for bitrateTest, they're irrelevant.
-    if (frag.sn === 'initSegment' || frag.bitrateTest) {
+    if (data.frag.sn === 'initSegment' || data.frag.bitrateTest) {
       return;
     }
-
+    const frag = data.frag;
     // Fragment entity `loaded` FragLoadedData is null when loading parts
-    const loaded = part ? null : data;
+    const loaded = data.part ? null : data;
     const fragKey = getFragmentKey(frag);
     this.fragments[fragKey] = {
       body: frag,
@@ -10052,14 +10188,12 @@ class BaseStreamController extends TaskLoop {
       part.stats.parsing.end = now;
     }
     // See if part loading should be disabled/enabled based on buffer and playback position.
-    if (frag.sn !== 'initSegment') {
-      const levelDetails = this.getLevelDetails();
-      const loadingPartsAtEdge = levelDetails && frag.sn > levelDetails.endSN;
-      const shouldLoadParts = loadingPartsAtEdge || this.shouldLoadParts(levelDetails, frag.end);
-      if (shouldLoadParts !== this.loadingParts) {
-        this.log(`LL-Part loading ${shouldLoadParts ? 'ON' : 'OFF'} after parsing segment ending @${frag.end.toFixed(2)}`);
-        this.loadingParts = shouldLoadParts;
-      }
+    const levelDetails = this.getLevelDetails();
+    const loadingPartsAtEdge = levelDetails && frag.sn > levelDetails.endSN;
+    const shouldLoadParts = loadingPartsAtEdge || this.shouldLoadParts(levelDetails, frag.end);
+    if (shouldLoadParts !== this.loadingParts) {
+      this.log(`LL-Part loading ${shouldLoadParts ? 'ON' : 'OFF'} after parsing segment ending @${frag.end.toFixed(2)}`);
+      this.loadingParts = shouldLoadParts;
     }
     this.updateLevelTiming(frag, part, level, chunkMeta.partial);
   }
@@ -16957,7 +17091,7 @@ class AudioStreamController extends BaseStreamController {
         baseTime: initPTS,
         timescale
       };
-      this.log(`InitPTS for cc: ${cc} found from main: ${initPTS}`);
+      this.log(`InitPTS for cc: ${cc} found from main: ${initPTS}/${timescale}`);
       this.videoTrackCC = cc;
       // If we are waiting, tick immediately to unblock audio fragment transmuxing
       if (this.state === State.WAITING_INIT_PTS) {
@@ -17306,8 +17440,8 @@ class AudioStreamController extends BaseStreamController {
   }
   _handleFragmentLoadProgress(data) {
     var _frag$initSegment;
+    const frag = data.frag;
     const {
-      frag,
       part,
       payload
     } = data;
@@ -28374,8 +28508,8 @@ class StreamController extends BaseStreamController {
   }
   _handleFragmentLoadProgress(data) {
     var _frag$initSegment;
+    const frag = data.frag;
     const {
-      frag,
       part,
       payload
     } = data;
@@ -28736,7 +28870,7 @@ class StreamController extends BaseStreamController {
     }
 
     // Avoid buffering if backtracking this fragment
-    if (video && details && frag.sn !== 'initSegment') {
+    if (video && details) {
       const prevFrag = details.fragments[frag.sn - 1 - details.startSN];
       const isFirstFragment = frag.sn === details.startSN;
       const isFirstInDiscontinuity = !prevFrag || frag.cc > prevFrag.cc;
@@ -29022,7 +29156,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.12-0.canary.10340";
+    return "1.5.12-0.canary.10341";
   }
 
   /**