hls.js 1.6.0-beta.1.0.canary.10743 → 1.6.0-beta.1.0.canary.10746

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -397,7 +397,7 @@ function enableLogs(debugConfig, context, id) {
397
397
  // Some browsers don't allow to use bind on console object anyway
398
398
  // fallback to default if needed
399
399
  try {
400
- newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.1.0.canary.10743"}`);
400
+ newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.0-beta.1.0.canary.10746"}`);
401
401
  } catch (e) {
402
402
  /* log fn threw an exception. All logger methods are no-ops. */
403
403
  return createLogger();
@@ -2766,20 +2766,21 @@ var ElementaryStreamTypes = {
2766
2766
  AUDIOVIDEO: "audiovideo"
2767
2767
  };
2768
2768
  class BaseSegment {
2769
- constructor(baseurl) {
2769
+ constructor(base) {
2770
2770
  this._byteRange = null;
2771
2771
  this._url = null;
2772
+ this._stats = null;
2773
+ this._streams = null;
2772
2774
  // baseurl is the URL to the playlist
2773
- this.baseurl = void 0;
2775
+ this.base = void 0;
2774
2776
  // relurl is the portion of the URL that comes from inside the playlist.
2775
2777
  this.relurl = void 0;
2776
- // Holds the types of data this fragment supports
2777
- this.elementaryStreams = {
2778
- [ElementaryStreamTypes.AUDIO]: null,
2779
- [ElementaryStreamTypes.VIDEO]: null,
2780
- [ElementaryStreamTypes.AUDIOVIDEO]: null
2781
- };
2782
- this.baseurl = baseurl;
2778
+ if (typeof base === 'string') {
2779
+ base = {
2780
+ url: base
2781
+ };
2782
+ }
2783
+ this.base = base;
2783
2784
  }
2784
2785
 
2785
2786
  // setByteRange converts a EXT-X-BYTERANGE attribute into a two element array
@@ -2793,8 +2794,11 @@ class BaseSegment {
2793
2794
  }
2794
2795
  this._byteRange = [start, parseInt(params[0]) + start];
2795
2796
  }
2797
+ get baseurl() {
2798
+ return this.base.url;
2799
+ }
2796
2800
  get byteRange() {
2797
- if (!this._byteRange) {
2801
+ if (this._byteRange === null) {
2798
2802
  return [];
2799
2803
  }
2800
2804
  return this._byteRange;
@@ -2805,6 +2809,34 @@ class BaseSegment {
2805
2809
  get byteRangeEndOffset() {
2806
2810
  return this.byteRange[1];
2807
2811
  }
2812
+ get elementaryStreams() {
2813
+ if (this._streams === null) {
2814
+ this._streams = {
2815
+ [ElementaryStreamTypes.AUDIO]: null,
2816
+ [ElementaryStreamTypes.VIDEO]: null,
2817
+ [ElementaryStreamTypes.AUDIOVIDEO]: null
2818
+ };
2819
+ }
2820
+ return this._streams;
2821
+ }
2822
+ set elementaryStreams(value) {
2823
+ this._streams = value;
2824
+ }
2825
+ get hasStats() {
2826
+ return this._stats !== null;
2827
+ }
2828
+ get hasStreams() {
2829
+ return this._streams !== null;
2830
+ }
2831
+ get stats() {
2832
+ if (this._stats === null) {
2833
+ this._stats = new LoadStats();
2834
+ }
2835
+ return this._stats;
2836
+ }
2837
+ set stats(value) {
2838
+ this._stats = value;
2839
+ }
2808
2840
  get url() {
2809
2841
  if (!this._url && this.baseurl && this.relurl) {
2810
2842
  this._url = urlToolkitExports.buildAbsoluteURL(this.baseurl, this.relurl, {
@@ -2829,11 +2861,12 @@ class BaseSegment {
2829
2861
  * Object representing parsed data from an HLS Segment. Found in {@link hls.js#LevelDetails.fragments}.
2830
2862
  */
2831
2863
  class Fragment extends BaseSegment {
2832
- constructor(type, baseurl) {
2833
- super(baseurl);
2864
+ constructor(type, base) {
2865
+ super(base);
2834
2866
  this._decryptdata = null;
2867
+ this._programDateTime = null;
2868
+ this._ref = null;
2835
2869
  this.rawProgramDateTime = null;
2836
- this.programDateTime = null;
2837
2870
  this.tagList = [];
2838
2871
  // EXTINF has to be present for a m3u8 to be considered valid
2839
2872
  this.duration = 0;
@@ -2871,8 +2904,6 @@ class Fragment extends BaseSegment {
2871
2904
  this.maxStartPTS = void 0;
2872
2905
  // The minimum ending Presentation Time Stamp (audio/video PTS) of the fragment. Set after transmux complete.
2873
2906
  this.minEndPTS = void 0;
2874
- // Load/parse timing information
2875
- this.stats = new LoadStats();
2876
2907
  // Init Segment bytes (unset for media segments)
2877
2908
  this.data = void 0;
2878
2909
  // A flag indicating whether the segment was downloaded in order to test bitrate, and was not buffered
@@ -2916,9 +2947,6 @@ class Fragment extends BaseSegment {
2916
2947
  if (this.programDateTime === null) {
2917
2948
  return null;
2918
2949
  }
2919
- if (!isFiniteNumber(this.programDateTime)) {
2920
- return null;
2921
- }
2922
2950
  const duration = !isFiniteNumber(this.duration) ? 0 : this.duration;
2923
2951
  return this.programDateTime + duration * 1000;
2924
2952
  }
@@ -2938,6 +2966,49 @@ class Fragment extends BaseSegment {
2938
2966
  }
2939
2967
  return false;
2940
2968
  }
2969
+ get programDateTime() {
2970
+ if (this._programDateTime === null && this.rawProgramDateTime) {
2971
+ this.programDateTime = Date.parse(this.rawProgramDateTime);
2972
+ }
2973
+ return this._programDateTime;
2974
+ }
2975
+ set programDateTime(value) {
2976
+ if (!isFiniteNumber(value)) {
2977
+ this._programDateTime = this.rawProgramDateTime = null;
2978
+ return;
2979
+ }
2980
+ this._programDateTime = value;
2981
+ }
2982
+ get ref() {
2983
+ if (this.sn === 'initSegment') {
2984
+ return null;
2985
+ }
2986
+ if (!this._ref) {
2987
+ this._ref = {
2988
+ base: this.base,
2989
+ start: this.start,
2990
+ duration: this.duration,
2991
+ sn: this.sn,
2992
+ programDateTime: this.programDateTime
2993
+ };
2994
+ }
2995
+ return this._ref;
2996
+ }
2997
+ addStart(value) {
2998
+ this.setStart(this.start + value);
2999
+ }
3000
+ setStart(value) {
3001
+ this.start = value;
3002
+ if (this._ref) {
3003
+ this._ref.start = value;
3004
+ }
3005
+ }
3006
+ setDuration(value) {
3007
+ this.duration = value;
3008
+ if (this._ref) {
3009
+ this._ref.duration = value;
3010
+ }
3011
+ }
2941
3012
  setKeyFormat(keyFormat) {
2942
3013
  if (this.levelkeys) {
2943
3014
  const key = this.levelkeys[keyFormat];
@@ -2977,8 +3048,8 @@ class Fragment extends BaseSegment {
2977
3048
  * Object representing parsed data from an HLS Partial Segment. Found in {@link hls.js#LevelDetails.partList}.
2978
3049
  */
2979
3050
  class Part extends BaseSegment {
2980
- constructor(partAttrs, frag, baseurl, index, previous) {
2981
- super(baseurl);
3051
+ constructor(partAttrs, frag, base, index, previous) {
3052
+ super(base);
2982
3053
  this.fragOffset = 0;
2983
3054
  this.duration = 0;
2984
3055
  this.gap = false;
@@ -2986,7 +3057,6 @@ class Part extends BaseSegment {
2986
3057
  this.relurl = void 0;
2987
3058
  this.fragment = void 0;
2988
3059
  this.index = void 0;
2989
- this.stats = new LoadStats();
2990
3060
  this.duration = partAttrs.decimalFloatingPoint('DURATION');
2991
3061
  this.gap = partAttrs.bool('GAP');
2992
3062
  this.independent = partAttrs.bool('INDEPENDENT');
@@ -4398,13 +4468,9 @@ const LEVEL_PLAYLIST_REGEX_FAST = new RegExp([/#EXTINF:\s*(\d*(?:\.\d+)?)(?:,(.*
4398
4468
  // duration (#EXTINF:<duration>,<title>), group 1 => duration, group 2 => title
4399
4469
  /(?!#) *(\S[^\r\n]*)/.source,
4400
4470
  // segment URI, group 3 => the URI (note newline is not eaten)
4401
- /#EXT-X-BYTERANGE:*(.+)/.source,
4402
- // next segment's byterange, group 4 => range spec (x@y)
4403
- /#EXT-X-PROGRAM-DATE-TIME:(.+)/.source,
4404
- // next segment's program date/time group 5 => the datetime spec
4405
4471
  /#.*/.source // All other non-segment oriented tags will match with all groups empty
4406
4472
  ].join('|'), 'g');
4407
- const LEVEL_PLAYLIST_REGEX_SLOW = new RegExp([/#(EXTM3U)/.source, /#EXT-X-(DATERANGE|DEFINE|KEY|MAP|PART|PART-INF|PLAYLIST-TYPE|PRELOAD-HINT|RENDITION-REPORT|SERVER-CONTROL|SKIP|START):(.+)/.source, /#EXT-X-(BITRATE|DISCONTINUITY-SEQUENCE|MEDIA-SEQUENCE|TARGETDURATION|VERSION): *(\d+)/.source, /#EXT-X-(DISCONTINUITY|ENDLIST|GAP|INDEPENDENT-SEGMENTS)/.source, /(#)([^:]*):(.*)/.source, /(#)(.*)(?:.*)\r?\n?/.source].join('|'));
4473
+ const LEVEL_PLAYLIST_REGEX_SLOW = new RegExp([/#(EXTM3U)/.source, /#EXT-X-(PROGRAM-DATE-TIME|BYTERANGE|DATERANGE|DEFINE|KEY|MAP|PART|PART-INF|PLAYLIST-TYPE|PRELOAD-HINT|RENDITION-REPORT|SERVER-CONTROL|SKIP|START):(.+)/.source, /#EXT-X-(BITRATE|DISCONTINUITY-SEQUENCE|MEDIA-SEQUENCE|TARGETDURATION|VERSION): *(\d+)/.source, /#EXT-X-(DISCONTINUITY|ENDLIST|GAP|INDEPENDENT-SEGMENTS)/.source, /(#)([^:]*):(.*)/.source, /(#)(.*)(?:.*)\r?\n?/.source].join('|'));
4408
4474
  class M3U8Parser {
4409
4475
  static findGroup(groups, mediaGroupId) {
4410
4476
  for (let i = 0; i < groups.length; i++) {
@@ -4589,6 +4655,9 @@ class M3U8Parser {
4589
4655
  return results;
4590
4656
  }
4591
4657
  static parseLevelPlaylist(string, baseurl, id, type, levelUrlId, multivariantVariableList) {
4658
+ const base = {
4659
+ url: baseurl
4660
+ };
4592
4661
  const level = new LevelDetails(baseurl);
4593
4662
  const fragments = level.fragments;
4594
4663
  const programDateTimes = [];
@@ -4599,7 +4668,7 @@ class M3U8Parser {
4599
4668
  let totalduration = 0;
4600
4669
  let discontinuityCounter = 0;
4601
4670
  let prevFrag = null;
4602
- let frag = new Fragment(type, baseurl);
4671
+ let frag = new Fragment(type, base);
4603
4672
  let result;
4604
4673
  let i;
4605
4674
  let levelkeys;
@@ -4612,7 +4681,7 @@ class M3U8Parser {
4612
4681
  while ((result = LEVEL_PLAYLIST_REGEX_FAST.exec(string)) !== null) {
4613
4682
  if (createNextFrag) {
4614
4683
  createNextFrag = false;
4615
- frag = new Fragment(type, baseurl);
4684
+ frag = new Fragment(type, base);
4616
4685
  // setup the next fragment for part loading
4617
4686
  frag.playlistOffset = totalduration;
4618
4687
  frag.start = totalduration;
@@ -4621,8 +4690,10 @@ class M3U8Parser {
4621
4690
  frag.level = id;
4622
4691
  if (currentInitSegment) {
4623
4692
  frag.initSegment = currentInitSegment;
4624
- frag.rawProgramDateTime = currentInitSegment.rawProgramDateTime;
4625
- currentInitSegment.rawProgramDateTime = null;
4693
+ if (currentInitSegment.rawProgramDateTime) {
4694
+ frag.rawProgramDateTime = currentInitSegment.rawProgramDateTime;
4695
+ currentInitSegment.rawProgramDateTime = null;
4696
+ }
4626
4697
  if (nextByteRange) {
4627
4698
  frag.setByteRange(nextByteRange);
4628
4699
  nextByteRange = null;
@@ -4659,22 +4730,6 @@ class M3U8Parser {
4659
4730
  currentPart = 0;
4660
4731
  createNextFrag = true;
4661
4732
  }
4662
- } else if (result[4]) {
4663
- // X-BYTERANGE
4664
- const data = (' ' + result[4]).slice(1);
4665
- if (prevFrag) {
4666
- frag.setByteRange(data, prevFrag);
4667
- } else {
4668
- frag.setByteRange(data);
4669
- }
4670
- } else if (result[5]) {
4671
- // PROGRAM-DATE-TIME
4672
- // avoid sliced strings https://github.com/video-dev/hls.js/issues/939
4673
- frag.rawProgramDateTime = (' ' + result[5]).slice(1);
4674
- frag.tagList.push(['PROGRAM-DATE-TIME', frag.rawProgramDateTime]);
4675
- if (firstPdtIndex === -1) {
4676
- firstPdtIndex = fragments.length;
4677
- }
4678
4733
  } else {
4679
4734
  result = result[0].match(LEVEL_PLAYLIST_REGEX_SLOW);
4680
4735
  if (!result) {
@@ -4682,7 +4737,7 @@ class M3U8Parser {
4682
4737
  continue;
4683
4738
  }
4684
4739
  for (i = 1; i < result.length; i++) {
4685
- if (typeof result[i] !== 'undefined') {
4740
+ if (result[i] !== undefined) {
4686
4741
  break;
4687
4742
  }
4688
4743
  }
@@ -4690,8 +4745,23 @@ class M3U8Parser {
4690
4745
  // avoid sliced strings https://github.com/video-dev/hls.js/issues/939
4691
4746
  const tag = (' ' + result[i]).slice(1);
4692
4747
  const value1 = (' ' + result[i + 1]).slice(1);
4693
- const value2 = result[i + 2] ? (' ' + result[i + 2]).slice(1) : '';
4748
+ const value2 = result[i + 2] ? (' ' + result[i + 2]).slice(1) : null;
4694
4749
  switch (tag) {
4750
+ case 'BYTERANGE':
4751
+ if (prevFrag) {
4752
+ frag.setByteRange(value1, prevFrag);
4753
+ } else {
4754
+ frag.setByteRange(value1);
4755
+ }
4756
+ break;
4757
+ case 'PROGRAM-DATE-TIME':
4758
+ // avoid sliced strings https://github.com/video-dev/hls.js/issues/939
4759
+ frag.rawProgramDateTime = value1;
4760
+ frag.tagList.push(['PROGRAM-DATE-TIME', value1]);
4761
+ if (firstPdtIndex === -1) {
4762
+ firstPdtIndex = fragments.length;
4763
+ }
4764
+ break;
4695
4765
  case 'PLAYLIST-TYPE':
4696
4766
  level.type = value1.toUpperCase();
4697
4767
  break;
@@ -4798,7 +4868,7 @@ class M3U8Parser {
4798
4868
  // Initial segment tag is after segment duration tag.
4799
4869
  // #EXTINF: 6.0
4800
4870
  // #EXT-X-MAP:URI="init.mp4
4801
- const init = new Fragment(type, baseurl);
4871
+ const init = new Fragment(type, base);
4802
4872
  setInitSegment(init, mapAttrs, id, levelkeys);
4803
4873
  currentInitSegment = init;
4804
4874
  frag.initSegment = currentInitSegment;
@@ -4847,7 +4917,7 @@ class M3U8Parser {
4847
4917
  const previousFragmentPart = currentPart > 0 ? partList[partList.length - 1] : undefined;
4848
4918
  const index = currentPart++;
4849
4919
  const partAttrs = new AttrList(value1, level);
4850
- const part = new Part(partAttrs, frag, baseurl, index, previousFragmentPart);
4920
+ const part = new Part(partAttrs, frag, base, index, previousFragmentPart);
4851
4921
  partList.push(part);
4852
4922
  frag.duration += part.duration;
4853
4923
  break;
@@ -4938,11 +5008,11 @@ function mapDateRanges(programDateTimes, details) {
4938
5008
  for (let i = dateRangeIds.length; i--;) {
4939
5009
  const dateRange = details.dateRanges[dateRangeIds[i]];
4940
5010
  const startDateTime = dateRange.startDate.getTime();
4941
- dateRange.tagAnchor = lastProgramDateTime;
5011
+ dateRange.tagAnchor = lastProgramDateTime.ref;
4942
5012
  for (let j = programDateTimeCount; j--;) {
4943
5013
  const fragIndex = findFragmentWithStartDate(details, startDateTime, programDateTimes, j, playlistEnd);
4944
5014
  if (fragIndex !== -1) {
4945
- dateRange.tagAnchor = details.fragments[fragIndex];
5015
+ dateRange.tagAnchor = details.fragments[fragIndex].ref;
4946
5016
  break;
4947
5017
  }
4948
5018
  }
@@ -4951,25 +5021,27 @@ function mapDateRanges(programDateTimes, details) {
4951
5021
  function findFragmentWithStartDate(details, startDateTime, programDateTimes, index, endTime) {
4952
5022
  const pdtFragment = programDateTimes[index];
4953
5023
  if (pdtFragment) {
4954
- var _programDateTimes;
4955
5024
  // find matching range between PDT tags
4956
- const durationBetweenPdt = (((_programDateTimes = programDateTimes[index + 1]) == null ? void 0 : _programDateTimes.start) || endTime) - pdtFragment.start;
4957
5025
  const pdtStart = pdtFragment.programDateTime;
4958
- if ((startDateTime >= pdtStart || index === 0) && startDateTime <= pdtStart + durationBetweenPdt * 1000) {
4959
- // map to fragment with date-time range
4960
- const startIndex = programDateTimes[index].sn - details.startSN;
4961
- const fragments = details.fragments;
4962
- if (fragments.length > programDateTimes.length) {
4963
- const endSegment = programDateTimes[index + 1] || fragments[fragments.length - 1];
4964
- const endIndex = endSegment.sn - details.startSN;
4965
- for (let i = endIndex; i > startIndex; i--) {
4966
- const fragStartDateTime = fragments[i].programDateTime;
4967
- if (startDateTime >= fragStartDateTime && startDateTime < fragStartDateTime + fragments[i].duration * 1000) {
4968
- return i;
5026
+ if (startDateTime >= pdtStart || index === 0) {
5027
+ var _programDateTimes;
5028
+ const durationBetweenPdt = (((_programDateTimes = programDateTimes[index + 1]) == null ? void 0 : _programDateTimes.start) || endTime) - pdtFragment.start;
5029
+ if (startDateTime <= pdtStart + durationBetweenPdt * 1000) {
5030
+ // map to fragment with date-time range
5031
+ const startIndex = programDateTimes[index].sn - details.startSN;
5032
+ const fragments = details.fragments;
5033
+ if (fragments.length > programDateTimes.length) {
5034
+ const endSegment = programDateTimes[index + 1] || fragments[fragments.length - 1];
5035
+ const endIndex = endSegment.sn - details.startSN;
5036
+ for (let i = endIndex; i > startIndex; i--) {
5037
+ const fragStartDateTime = fragments[i].programDateTime;
5038
+ if (startDateTime >= fragStartDateTime && startDateTime < fragStartDateTime + fragments[i].duration * 1000) {
5039
+ return i;
5040
+ }
4969
5041
  }
4970
5042
  }
5043
+ return startIndex;
4971
5044
  }
4972
- return startIndex;
4973
5045
  }
4974
5046
  }
4975
5047
  return -1;
@@ -5034,12 +5106,6 @@ function backfillProgramDateTimes(fragments, firstPdtIndex) {
5034
5106
  }
5035
5107
  function assignProgramDateTime(frag, prevFrag, programDateTimes) {
5036
5108
  if (frag.rawProgramDateTime) {
5037
- frag.programDateTime = Date.parse(frag.rawProgramDateTime);
5038
- if (!isFiniteNumber(frag.programDateTime)) {
5039
- frag.programDateTime = null;
5040
- frag.rawProgramDateTime = null;
5041
- return;
5042
- }
5043
5109
  programDateTimes.push(frag);
5044
5110
  } else if (prevFrag != null && prevFrag.programDateTime) {
5045
5111
  frag.programDateTime = prevFrag.endProgramDateTime;
@@ -5083,19 +5149,19 @@ function updateFromToPTS(fragFrom, fragTo) {
5083
5149
  frag = fragTo;
5084
5150
  }
5085
5151
  if (frag.duration !== duration) {
5086
- frag.duration = duration;
5152
+ frag.setDuration(duration);
5087
5153
  }
5088
5154
  // we dont know startPTS[toIdx]
5089
5155
  } else if (fragTo.sn > fragFrom.sn) {
5090
5156
  const contiguous = fragFrom.cc === fragTo.cc;
5091
5157
  // TODO: With part-loading end/durations we need to confirm the whole fragment is loaded before using (or setting) minEndPTS
5092
5158
  if (contiguous && fragFrom.minEndPTS) {
5093
- fragTo.start = fragFrom.start + (fragFrom.minEndPTS - fragFrom.start);
5159
+ fragTo.setStart(fragFrom.start + (fragFrom.minEndPTS - fragFrom.start));
5094
5160
  } else {
5095
- fragTo.start = fragFrom.start + fragFrom.duration;
5161
+ fragTo.setStart(fragFrom.start + fragFrom.duration);
5096
5162
  }
5097
5163
  } else {
5098
- fragTo.start = Math.max(fragFrom.start - fragTo.duration, 0);
5164
+ fragTo.setStart(Math.max(fragFrom.start - fragTo.duration, 0));
5099
5165
  }
5100
5166
  }
5101
5167
  function updateFragPTSDTS(details, frag, startPTS, endPTS, startDTS, endDTS) {
@@ -5126,9 +5192,9 @@ function updateFragPTSDTS(details, frag, startPTS, endPTS, startDTS, endDTS) {
5126
5192
  }
5127
5193
  const drift = startPTS - frag.start;
5128
5194
  if (frag.start !== 0) {
5129
- frag.start = startPTS;
5195
+ frag.setStart(startPTS);
5130
5196
  }
5131
- frag.duration = endPTS - frag.start;
5197
+ frag.setDuration(endPTS - frag.start);
5132
5198
  frag.startPTS = startPTS;
5133
5199
  frag.maxStartPTS = maxStartPTS;
5134
5200
  frag.startDTS = startDTS;
@@ -5191,13 +5257,13 @@ function mergeDetails(oldDetails, newDetails) {
5191
5257
  ccOffset = oldFrag.cc - newFrag.cc;
5192
5258
  }
5193
5259
  if (isFiniteNumber(oldFrag.startPTS) && isFiniteNumber(oldFrag.endPTS)) {
5194
- newFrag.start = newFrag.startPTS = oldFrag.startPTS;
5260
+ newFrag.setStart(newFrag.startPTS = oldFrag.startPTS);
5195
5261
  newFrag.startDTS = oldFrag.startDTS;
5196
5262
  newFrag.maxStartPTS = oldFrag.maxStartPTS;
5197
5263
  newFrag.endPTS = oldFrag.endPTS;
5198
5264
  newFrag.endDTS = oldFrag.endDTS;
5199
5265
  newFrag.minEndPTS = oldFrag.minEndPTS;
5200
- newFrag.duration = oldFrag.endPTS - oldFrag.startPTS;
5266
+ newFrag.setDuration(oldFrag.endPTS - oldFrag.startPTS);
5201
5267
  if (newFrag.duration) {
5202
5268
  PTSFrag = newFrag;
5203
5269
  }
@@ -5205,9 +5271,13 @@ function mergeDetails(oldDetails, newDetails) {
5205
5271
  // PTS is known when any segment has startPTS and endPTS
5206
5272
  newDetails.PTSKnown = newDetails.alignedSliding = true;
5207
5273
  }
5208
- newFrag.elementaryStreams = oldFrag.elementaryStreams;
5274
+ if (oldFrag.hasStreams) {
5275
+ newFrag.elementaryStreams = oldFrag.elementaryStreams;
5276
+ }
5209
5277
  newFrag.loader = oldFrag.loader;
5210
- newFrag.stats = oldFrag.stats;
5278
+ if (oldFrag.hasStats) {
5279
+ newFrag.stats = oldFrag.stats;
5280
+ }
5211
5281
  if (oldFrag.initSegment) {
5212
5282
  newFrag.initSegment = oldFrag.initSegment;
5213
5283
  currentInitSegment = oldFrag.initSegment;
@@ -5373,14 +5443,14 @@ function adjustSliding(oldDetails, newDetails, matchingStableVariantOrRendition
5373
5443
  }
5374
5444
  addSliding(newDetails, sliding);
5375
5445
  }
5376
- function addSliding(details, start) {
5377
- if (start) {
5446
+ function addSliding(details, sliding) {
5447
+ if (sliding) {
5378
5448
  const fragments = details.fragments;
5379
5449
  for (let i = details.skippedSegments; i < fragments.length; i++) {
5380
- fragments[i].start += start;
5450
+ fragments[i].addStart(sliding);
5381
5451
  }
5382
5452
  if (details.fragmentHint) {
5383
- details.fragmentHint.start += start;
5453
+ details.fragmentHint.addStart(sliding);
5384
5454
  }
5385
5455
  }
5386
5456
  }
@@ -17881,13 +17951,14 @@ class LatencyController {
17881
17951
  return this._latency || 0;
17882
17952
  }
17883
17953
  get maxLatency() {
17954
+ var _this$hls;
17884
17955
  const {
17885
17956
  config
17886
17957
  } = this;
17887
17958
  if (config.liveMaxLatencyDuration !== undefined) {
17888
17959
  return config.liveMaxLatencyDuration;
17889
17960
  }
17890
- const levelDetails = this.hls.latestLevelDetails;
17961
+ const levelDetails = (_this$hls = this.hls) == null ? void 0 : _this$hls.latestLevelDetails;
17891
17962
  return levelDetails ? config.liveMaxLatencyDurationCount * levelDetails.targetduration : 0;
17892
17963
  }
17893
17964
  get targetLatency() {
@@ -18962,7 +19033,7 @@ class GapController extends Logger {
18962
19033
  }
18963
19034
  }
18964
19035
 
18965
- const version = "1.6.0-beta.1.0.canary.10743";
19036
+ const version = "1.6.0-beta.1.0.canary.10746";
18966
19037
 
18967
19038
  // ensure the worker ends up in the bundle
18968
19039
  // If the worker should not be included this gets aliased to empty.js