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.
package/dist/hls.js CHANGED
@@ -1054,7 +1054,7 @@
1054
1054
  // Some browsers don't allow to use bind on console object anyway
1055
1055
  // fallback to default if needed
1056
1056
  try {
1057
- newLogger.log("Debug logs enabled for \"" + context + "\" in hls.js version " + "1.6.0-beta.1.0.canary.10743");
1057
+ newLogger.log("Debug logs enabled for \"" + context + "\" in hls.js version " + "1.6.0-beta.1.0.canary.10746");
1058
1058
  } catch (e) {
1059
1059
  /* log fn threw an exception. All logger methods are no-ops. */
1060
1060
  return createLogger();
@@ -4211,17 +4211,21 @@
4211
4211
  AUDIOVIDEO: "audiovideo"
4212
4212
  };
4213
4213
  var BaseSegment = /*#__PURE__*/function () {
4214
- function BaseSegment(baseurl) {
4215
- var _this$elementaryStrea;
4214
+ function BaseSegment(base) {
4216
4215
  this._byteRange = null;
4217
4216
  this._url = null;
4217
+ this._stats = null;
4218
+ this._streams = null;
4218
4219
  // baseurl is the URL to the playlist
4219
- this.baseurl = void 0;
4220
+ this.base = void 0;
4220
4221
  // relurl is the portion of the URL that comes from inside the playlist.
4221
4222
  this.relurl = void 0;
4222
- // Holds the types of data this fragment supports
4223
- this.elementaryStreams = (_this$elementaryStrea = {}, _this$elementaryStrea[ElementaryStreamTypes.AUDIO] = null, _this$elementaryStrea[ElementaryStreamTypes.VIDEO] = null, _this$elementaryStrea[ElementaryStreamTypes.AUDIOVIDEO] = null, _this$elementaryStrea);
4224
- this.baseurl = baseurl;
4223
+ if (typeof base === 'string') {
4224
+ base = {
4225
+ url: base
4226
+ };
4227
+ }
4228
+ this.base = base;
4225
4229
  }
4226
4230
 
4227
4231
  // setByteRange converts a EXT-X-BYTERANGE attribute into a two element array
@@ -4243,9 +4247,14 @@
4243
4247
  elementaryStreams[ElementaryStreamTypes.AUDIOVIDEO] = null;
4244
4248
  };
4245
4249
  return _createClass(BaseSegment, [{
4250
+ key: "baseurl",
4251
+ get: function get() {
4252
+ return this.base.url;
4253
+ }
4254
+ }, {
4246
4255
  key: "byteRange",
4247
4256
  get: function get() {
4248
- if (!this._byteRange) {
4257
+ if (this._byteRange === null) {
4249
4258
  return [];
4250
4259
  }
4251
4260
  return this._byteRange;
@@ -4260,6 +4269,39 @@
4260
4269
  get: function get() {
4261
4270
  return this.byteRange[1];
4262
4271
  }
4272
+ }, {
4273
+ key: "elementaryStreams",
4274
+ get: function get() {
4275
+ if (this._streams === null) {
4276
+ var _this$_streams;
4277
+ this._streams = (_this$_streams = {}, _this$_streams[ElementaryStreamTypes.AUDIO] = null, _this$_streams[ElementaryStreamTypes.VIDEO] = null, _this$_streams[ElementaryStreamTypes.AUDIOVIDEO] = null, _this$_streams);
4278
+ }
4279
+ return this._streams;
4280
+ },
4281
+ set: function set(value) {
4282
+ this._streams = value;
4283
+ }
4284
+ }, {
4285
+ key: "hasStats",
4286
+ get: function get() {
4287
+ return this._stats !== null;
4288
+ }
4289
+ }, {
4290
+ key: "hasStreams",
4291
+ get: function get() {
4292
+ return this._streams !== null;
4293
+ }
4294
+ }, {
4295
+ key: "stats",
4296
+ get: function get() {
4297
+ if (this._stats === null) {
4298
+ this._stats = new LoadStats();
4299
+ }
4300
+ return this._stats;
4301
+ },
4302
+ set: function set(value) {
4303
+ this._stats = value;
4304
+ }
4263
4305
  }, {
4264
4306
  key: "url",
4265
4307
  get: function get() {
@@ -4279,12 +4321,13 @@
4279
4321
  * Object representing parsed data from an HLS Segment. Found in {@link hls.js#LevelDetails.fragments}.
4280
4322
  */
4281
4323
  var Fragment = /*#__PURE__*/function (_BaseSegment2) {
4282
- function Fragment(type, baseurl) {
4324
+ function Fragment(type, base) {
4283
4325
  var _this;
4284
- _this = _BaseSegment2.call(this, baseurl) || this;
4326
+ _this = _BaseSegment2.call(this, base) || this;
4285
4327
  _this._decryptdata = null;
4328
+ _this._programDateTime = null;
4329
+ _this._ref = null;
4286
4330
  _this.rawProgramDateTime = null;
4287
- _this.programDateTime = null;
4288
4331
  _this.tagList = [];
4289
4332
  // EXTINF has to be present for a m3u8 to be considered valid
4290
4333
  _this.duration = 0;
@@ -4322,8 +4365,6 @@
4322
4365
  _this.maxStartPTS = void 0;
4323
4366
  // The minimum ending Presentation Time Stamp (audio/video PTS) of the fragment. Set after transmux complete.
4324
4367
  _this.minEndPTS = void 0;
4325
- // Load/parse timing information
4326
- _this.stats = new LoadStats();
4327
4368
  // Init Segment bytes (unset for media segments)
4328
4369
  _this.data = void 0;
4329
4370
  // A flag indicating whether the segment was downloaded in order to test bitrate, and was not buffered
@@ -4343,6 +4384,21 @@
4343
4384
  }
4344
4385
  _inheritsLoose(Fragment, _BaseSegment2);
4345
4386
  var _proto2 = Fragment.prototype;
4387
+ _proto2.addStart = function addStart(value) {
4388
+ this.setStart(this.start + value);
4389
+ };
4390
+ _proto2.setStart = function setStart(value) {
4391
+ this.start = value;
4392
+ if (this._ref) {
4393
+ this._ref.start = value;
4394
+ }
4395
+ };
4396
+ _proto2.setDuration = function setDuration(value) {
4397
+ this.duration = value;
4398
+ if (this._ref) {
4399
+ this._ref.duration = value;
4400
+ }
4401
+ };
4346
4402
  _proto2.setKeyFormat = function setKeyFormat(keyFormat) {
4347
4403
  if (this.levelkeys) {
4348
4404
  var key = this.levelkeys[keyFormat];
@@ -4408,9 +4464,6 @@
4408
4464
  if (this.programDateTime === null) {
4409
4465
  return null;
4410
4466
  }
4411
- if (!isFiniteNumber(this.programDateTime)) {
4412
- return null;
4413
- }
4414
4467
  var duration = !isFiniteNumber(this.duration) ? 0 : this.duration;
4415
4468
  return this.programDateTime + duration * 1000;
4416
4469
  }
@@ -4432,6 +4485,38 @@
4432
4485
  }
4433
4486
  return false;
4434
4487
  }
4488
+ }, {
4489
+ key: "programDateTime",
4490
+ get: function get() {
4491
+ if (this._programDateTime === null && this.rawProgramDateTime) {
4492
+ this.programDateTime = Date.parse(this.rawProgramDateTime);
4493
+ }
4494
+ return this._programDateTime;
4495
+ },
4496
+ set: function set(value) {
4497
+ if (!isFiniteNumber(value)) {
4498
+ this._programDateTime = this.rawProgramDateTime = null;
4499
+ return;
4500
+ }
4501
+ this._programDateTime = value;
4502
+ }
4503
+ }, {
4504
+ key: "ref",
4505
+ get: function get() {
4506
+ if (this.sn === 'initSegment') {
4507
+ return null;
4508
+ }
4509
+ if (!this._ref) {
4510
+ this._ref = {
4511
+ base: this.base,
4512
+ start: this.start,
4513
+ duration: this.duration,
4514
+ sn: this.sn,
4515
+ programDateTime: this.programDateTime
4516
+ };
4517
+ }
4518
+ return this._ref;
4519
+ }
4435
4520
  }]);
4436
4521
  }(BaseSegment);
4437
4522
 
@@ -4439,9 +4524,9 @@
4439
4524
  * Object representing parsed data from an HLS Partial Segment. Found in {@link hls.js#LevelDetails.partList}.
4440
4525
  */
4441
4526
  var Part = /*#__PURE__*/function (_BaseSegment3) {
4442
- function Part(partAttrs, frag, baseurl, index, previous) {
4527
+ function Part(partAttrs, frag, base, index, previous) {
4443
4528
  var _this2;
4444
- _this2 = _BaseSegment3.call(this, baseurl) || this;
4529
+ _this2 = _BaseSegment3.call(this, base) || this;
4445
4530
  _this2.fragOffset = 0;
4446
4531
  _this2.duration = 0;
4447
4532
  _this2.gap = false;
@@ -4449,7 +4534,6 @@
4449
4534
  _this2.relurl = void 0;
4450
4535
  _this2.fragment = void 0;
4451
4536
  _this2.index = void 0;
4452
- _this2.stats = new LoadStats();
4453
4537
  _this2.duration = partAttrs.decimalFloatingPoint('DURATION');
4454
4538
  _this2.gap = partAttrs.bool('GAP');
4455
4539
  _this2.independent = partAttrs.bool('INDEPENDENT');
@@ -7353,13 +7437,9 @@
7353
7437
  // duration (#EXTINF:<duration>,<title>), group 1 => duration, group 2 => title
7354
7438
  /(?!#) *(\S[^\r\n]*)/.source,
7355
7439
  // segment URI, group 3 => the URI (note newline is not eaten)
7356
- /#EXT-X-BYTERANGE:*(.+)/.source,
7357
- // next segment's byterange, group 4 => range spec (x@y)
7358
- /#EXT-X-PROGRAM-DATE-TIME:(.+)/.source,
7359
- // next segment's program date/time group 5 => the datetime spec
7360
7440
  /#.*/.source // All other non-segment oriented tags will match with all groups empty
7361
7441
  ].join('|'), 'g');
7362
- var 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('|'));
7442
+ var 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('|'));
7363
7443
  var M3U8Parser = /*#__PURE__*/function () {
7364
7444
  function M3U8Parser() {}
7365
7445
  M3U8Parser.findGroup = function findGroup(groups, mediaGroupId) {
@@ -7554,6 +7634,9 @@
7554
7634
  return results;
7555
7635
  };
7556
7636
  M3U8Parser.parseLevelPlaylist = function parseLevelPlaylist(string, baseurl, id, type, levelUrlId, multivariantVariableList) {
7637
+ var base = {
7638
+ url: baseurl
7639
+ };
7557
7640
  var level = new LevelDetails(baseurl);
7558
7641
  var fragments = level.fragments;
7559
7642
  var programDateTimes = [];
@@ -7564,7 +7647,7 @@
7564
7647
  var totalduration = 0;
7565
7648
  var discontinuityCounter = 0;
7566
7649
  var prevFrag = null;
7567
- var frag = new Fragment(type, baseurl);
7650
+ var frag = new Fragment(type, base);
7568
7651
  var result;
7569
7652
  var i;
7570
7653
  var levelkeys;
@@ -7577,7 +7660,7 @@
7577
7660
  while ((result = LEVEL_PLAYLIST_REGEX_FAST.exec(string)) !== null) {
7578
7661
  if (createNextFrag) {
7579
7662
  createNextFrag = false;
7580
- frag = new Fragment(type, baseurl);
7663
+ frag = new Fragment(type, base);
7581
7664
  // setup the next fragment for part loading
7582
7665
  frag.playlistOffset = totalduration;
7583
7666
  frag.start = totalduration;
@@ -7586,8 +7669,10 @@
7586
7669
  frag.level = id;
7587
7670
  if (currentInitSegment) {
7588
7671
  frag.initSegment = currentInitSegment;
7589
- frag.rawProgramDateTime = currentInitSegment.rawProgramDateTime;
7590
- currentInitSegment.rawProgramDateTime = null;
7672
+ if (currentInitSegment.rawProgramDateTime) {
7673
+ frag.rawProgramDateTime = currentInitSegment.rawProgramDateTime;
7674
+ currentInitSegment.rawProgramDateTime = null;
7675
+ }
7591
7676
  if (nextByteRange) {
7592
7677
  frag.setByteRange(nextByteRange);
7593
7678
  nextByteRange = null;
@@ -7624,22 +7709,6 @@
7624
7709
  currentPart = 0;
7625
7710
  createNextFrag = true;
7626
7711
  }
7627
- } else if (result[4]) {
7628
- // X-BYTERANGE
7629
- var data = (' ' + result[4]).slice(1);
7630
- if (prevFrag) {
7631
- frag.setByteRange(data, prevFrag);
7632
- } else {
7633
- frag.setByteRange(data);
7634
- }
7635
- } else if (result[5]) {
7636
- // PROGRAM-DATE-TIME
7637
- // avoid sliced strings https://github.com/video-dev/hls.js/issues/939
7638
- frag.rawProgramDateTime = (' ' + result[5]).slice(1);
7639
- frag.tagList.push(['PROGRAM-DATE-TIME', frag.rawProgramDateTime]);
7640
- if (firstPdtIndex === -1) {
7641
- firstPdtIndex = fragments.length;
7642
- }
7643
7712
  } else {
7644
7713
  result = result[0].match(LEVEL_PLAYLIST_REGEX_SLOW);
7645
7714
  if (!result) {
@@ -7647,7 +7716,7 @@
7647
7716
  continue;
7648
7717
  }
7649
7718
  for (i = 1; i < result.length; i++) {
7650
- if (typeof result[i] !== 'undefined') {
7719
+ if (result[i] !== undefined) {
7651
7720
  break;
7652
7721
  }
7653
7722
  }
@@ -7655,8 +7724,23 @@
7655
7724
  // avoid sliced strings https://github.com/video-dev/hls.js/issues/939
7656
7725
  var tag = (' ' + result[i]).slice(1);
7657
7726
  var value1 = (' ' + result[i + 1]).slice(1);
7658
- var value2 = result[i + 2] ? (' ' + result[i + 2]).slice(1) : '';
7727
+ var value2 = result[i + 2] ? (' ' + result[i + 2]).slice(1) : null;
7659
7728
  switch (tag) {
7729
+ case 'BYTERANGE':
7730
+ if (prevFrag) {
7731
+ frag.setByteRange(value1, prevFrag);
7732
+ } else {
7733
+ frag.setByteRange(value1);
7734
+ }
7735
+ break;
7736
+ case 'PROGRAM-DATE-TIME':
7737
+ // avoid sliced strings https://github.com/video-dev/hls.js/issues/939
7738
+ frag.rawProgramDateTime = value1;
7739
+ frag.tagList.push(['PROGRAM-DATE-TIME', value1]);
7740
+ if (firstPdtIndex === -1) {
7741
+ firstPdtIndex = fragments.length;
7742
+ }
7743
+ break;
7660
7744
  case 'PLAYLIST-TYPE':
7661
7745
  level.type = value1.toUpperCase();
7662
7746
  break;
@@ -7771,7 +7855,7 @@
7771
7855
  // Initial segment tag is after segment duration tag.
7772
7856
  // #EXTINF: 6.0
7773
7857
  // #EXT-X-MAP:URI="init.mp4
7774
- var init = new Fragment(type, baseurl);
7858
+ var init = new Fragment(type, base);
7775
7859
  setInitSegment(init, mapAttrs, id, levelkeys);
7776
7860
  currentInitSegment = init;
7777
7861
  frag.initSegment = currentInitSegment;
@@ -7820,7 +7904,7 @@
7820
7904
  var previousFragmentPart = currentPart > 0 ? partList[partList.length - 1] : undefined;
7821
7905
  var index = currentPart++;
7822
7906
  var partAttrs = new AttrList(value1, level);
7823
- var part = new Part(partAttrs, frag, baseurl, index, previousFragmentPart);
7907
+ var part = new Part(partAttrs, frag, base, index, previousFragmentPart);
7824
7908
  partList.push(part);
7825
7909
  frag.duration += part.duration;
7826
7910
  break;
@@ -7912,11 +7996,11 @@
7912
7996
  for (var i = dateRangeIds.length; i--;) {
7913
7997
  var dateRange = details.dateRanges[dateRangeIds[i]];
7914
7998
  var startDateTime = dateRange.startDate.getTime();
7915
- dateRange.tagAnchor = lastProgramDateTime;
7999
+ dateRange.tagAnchor = lastProgramDateTime.ref;
7916
8000
  for (var j = programDateTimeCount; j--;) {
7917
8001
  var fragIndex = findFragmentWithStartDate(details, startDateTime, programDateTimes, j, playlistEnd);
7918
8002
  if (fragIndex !== -1) {
7919
- dateRange.tagAnchor = details.fragments[fragIndex];
8003
+ dateRange.tagAnchor = details.fragments[fragIndex].ref;
7920
8004
  break;
7921
8005
  }
7922
8006
  }
@@ -7925,25 +8009,27 @@
7925
8009
  function findFragmentWithStartDate(details, startDateTime, programDateTimes, index, endTime) {
7926
8010
  var pdtFragment = programDateTimes[index];
7927
8011
  if (pdtFragment) {
7928
- var _programDateTimes;
7929
8012
  // find matching range between PDT tags
7930
- var durationBetweenPdt = (((_programDateTimes = programDateTimes[index + 1]) == null ? void 0 : _programDateTimes.start) || endTime) - pdtFragment.start;
7931
8013
  var pdtStart = pdtFragment.programDateTime;
7932
- if ((startDateTime >= pdtStart || index === 0) && startDateTime <= pdtStart + durationBetweenPdt * 1000) {
7933
- // map to fragment with date-time range
7934
- var startIndex = programDateTimes[index].sn - details.startSN;
7935
- var fragments = details.fragments;
7936
- if (fragments.length > programDateTimes.length) {
7937
- var endSegment = programDateTimes[index + 1] || fragments[fragments.length - 1];
7938
- var endIndex = endSegment.sn - details.startSN;
7939
- for (var i = endIndex; i > startIndex; i--) {
7940
- var fragStartDateTime = fragments[i].programDateTime;
7941
- if (startDateTime >= fragStartDateTime && startDateTime < fragStartDateTime + fragments[i].duration * 1000) {
7942
- return i;
8014
+ if (startDateTime >= pdtStart || index === 0) {
8015
+ var _programDateTimes;
8016
+ var durationBetweenPdt = (((_programDateTimes = programDateTimes[index + 1]) == null ? void 0 : _programDateTimes.start) || endTime) - pdtFragment.start;
8017
+ if (startDateTime <= pdtStart + durationBetweenPdt * 1000) {
8018
+ // map to fragment with date-time range
8019
+ var startIndex = programDateTimes[index].sn - details.startSN;
8020
+ var fragments = details.fragments;
8021
+ if (fragments.length > programDateTimes.length) {
8022
+ var endSegment = programDateTimes[index + 1] || fragments[fragments.length - 1];
8023
+ var endIndex = endSegment.sn - details.startSN;
8024
+ for (var i = endIndex; i > startIndex; i--) {
8025
+ var fragStartDateTime = fragments[i].programDateTime;
8026
+ if (startDateTime >= fragStartDateTime && startDateTime < fragStartDateTime + fragments[i].duration * 1000) {
8027
+ return i;
8028
+ }
7943
8029
  }
7944
8030
  }
8031
+ return startIndex;
7945
8032
  }
7946
- return startIndex;
7947
8033
  }
7948
8034
  }
7949
8035
  return -1;
@@ -8014,12 +8100,6 @@
8014
8100
  }
8015
8101
  function assignProgramDateTime(frag, prevFrag, programDateTimes) {
8016
8102
  if (frag.rawProgramDateTime) {
8017
- frag.programDateTime = Date.parse(frag.rawProgramDateTime);
8018
- if (!isFiniteNumber(frag.programDateTime)) {
8019
- frag.programDateTime = null;
8020
- frag.rawProgramDateTime = null;
8021
- return;
8022
- }
8023
8103
  programDateTimes.push(frag);
8024
8104
  } else if (prevFrag != null && prevFrag.programDateTime) {
8025
8105
  frag.programDateTime = prevFrag.endProgramDateTime;
@@ -8063,19 +8143,19 @@
8063
8143
  frag = fragTo;
8064
8144
  }
8065
8145
  if (frag.duration !== duration) {
8066
- frag.duration = duration;
8146
+ frag.setDuration(duration);
8067
8147
  }
8068
8148
  // we dont know startPTS[toIdx]
8069
8149
  } else if (fragTo.sn > fragFrom.sn) {
8070
8150
  var contiguous = fragFrom.cc === fragTo.cc;
8071
8151
  // TODO: With part-loading end/durations we need to confirm the whole fragment is loaded before using (or setting) minEndPTS
8072
8152
  if (contiguous && fragFrom.minEndPTS) {
8073
- fragTo.start = fragFrom.start + (fragFrom.minEndPTS - fragFrom.start);
8153
+ fragTo.setStart(fragFrom.start + (fragFrom.minEndPTS - fragFrom.start));
8074
8154
  } else {
8075
- fragTo.start = fragFrom.start + fragFrom.duration;
8155
+ fragTo.setStart(fragFrom.start + fragFrom.duration);
8076
8156
  }
8077
8157
  } else {
8078
- fragTo.start = Math.max(fragFrom.start - fragTo.duration, 0);
8158
+ fragTo.setStart(Math.max(fragFrom.start - fragTo.duration, 0));
8079
8159
  }
8080
8160
  }
8081
8161
  function updateFragPTSDTS(details, frag, startPTS, endPTS, startDTS, endDTS) {
@@ -8106,9 +8186,9 @@
8106
8186
  }
8107
8187
  var drift = startPTS - frag.start;
8108
8188
  if (frag.start !== 0) {
8109
- frag.start = startPTS;
8189
+ frag.setStart(startPTS);
8110
8190
  }
8111
- frag.duration = endPTS - frag.start;
8191
+ frag.setDuration(endPTS - frag.start);
8112
8192
  frag.startPTS = startPTS;
8113
8193
  frag.maxStartPTS = maxStartPTS;
8114
8194
  frag.startDTS = startDTS;
@@ -8171,13 +8251,13 @@
8171
8251
  ccOffset = oldFrag.cc - newFrag.cc;
8172
8252
  }
8173
8253
  if (isFiniteNumber(oldFrag.startPTS) && isFiniteNumber(oldFrag.endPTS)) {
8174
- newFrag.start = newFrag.startPTS = oldFrag.startPTS;
8254
+ newFrag.setStart(newFrag.startPTS = oldFrag.startPTS);
8175
8255
  newFrag.startDTS = oldFrag.startDTS;
8176
8256
  newFrag.maxStartPTS = oldFrag.maxStartPTS;
8177
8257
  newFrag.endPTS = oldFrag.endPTS;
8178
8258
  newFrag.endDTS = oldFrag.endDTS;
8179
8259
  newFrag.minEndPTS = oldFrag.minEndPTS;
8180
- newFrag.duration = oldFrag.endPTS - oldFrag.startPTS;
8260
+ newFrag.setDuration(oldFrag.endPTS - oldFrag.startPTS);
8181
8261
  if (newFrag.duration) {
8182
8262
  PTSFrag = newFrag;
8183
8263
  }
@@ -8185,9 +8265,13 @@
8185
8265
  // PTS is known when any segment has startPTS and endPTS
8186
8266
  newDetails.PTSKnown = newDetails.alignedSliding = true;
8187
8267
  }
8188
- newFrag.elementaryStreams = oldFrag.elementaryStreams;
8268
+ if (oldFrag.hasStreams) {
8269
+ newFrag.elementaryStreams = oldFrag.elementaryStreams;
8270
+ }
8189
8271
  newFrag.loader = oldFrag.loader;
8190
- newFrag.stats = oldFrag.stats;
8272
+ if (oldFrag.hasStats) {
8273
+ newFrag.stats = oldFrag.stats;
8274
+ }
8191
8275
  if (oldFrag.initSegment) {
8192
8276
  newFrag.initSegment = oldFrag.initSegment;
8193
8277
  currentInitSegment = oldFrag.initSegment;
@@ -8358,14 +8442,14 @@
8358
8442
  }
8359
8443
  addSliding(newDetails, sliding);
8360
8444
  }
8361
- function addSliding(details, start) {
8362
- if (start) {
8445
+ function addSliding(details, sliding) {
8446
+ if (sliding) {
8363
8447
  var fragments = details.fragments;
8364
8448
  for (var i = details.skippedSegments; i < fragments.length; i++) {
8365
- fragments[i].start += start;
8449
+ fragments[i].addStart(sliding);
8366
8450
  }
8367
8451
  if (details.fragmentHint) {
8368
- details.fragmentHint.start += start;
8452
+ details.fragmentHint.addStart(sliding);
8369
8453
  }
8370
8454
  }
8371
8455
  }
@@ -16086,7 +16170,7 @@
16086
16170
  return !remuxResult.audio && !remuxResult.video && !remuxResult.text && !remuxResult.id3 && !remuxResult.initSegment;
16087
16171
  }
16088
16172
 
16089
- var version = "1.6.0-beta.1.0.canary.10743";
16173
+ var version = "1.6.0-beta.1.0.canary.10746";
16090
16174
 
16091
16175
  // ensure the worker ends up in the bundle
16092
16176
  // If the worker should not be included this gets aliased to empty.js
@@ -22668,7 +22752,7 @@
22668
22752
  }]);
22669
22753
  }();
22670
22754
  function getSnapToFragmentTime(time, frag) {
22671
- return time - frag.start < frag.duration / 2 && !(Math.abs(time - frag.end) < ALIGNED_END_THRESHOLD_SECONDS) ? frag.start : frag.end;
22755
+ return time - frag.start < frag.duration / 2 && !(Math.abs(time - (frag.start + frag.duration)) < ALIGNED_END_THRESHOLD_SECONDS) ? frag.start : frag.start + frag.duration;
22672
22756
  }
22673
22757
  function getInterstitialUrl(uri, sessionId, baseUrl) {
22674
22758
  var url = new self.URL(uri, baseUrl);
@@ -30656,11 +30740,12 @@
30656
30740
  }, {
30657
30741
  key: "maxLatency",
30658
30742
  get: function get() {
30743
+ var _this$hls;
30659
30744
  var config = this.config;
30660
30745
  if (config.liveMaxLatencyDuration !== undefined) {
30661
30746
  return config.liveMaxLatencyDuration;
30662
30747
  }
30663
- var levelDetails = this.hls.latestLevelDetails;
30748
+ var levelDetails = (_this$hls = this.hls) == null ? void 0 : _this$hls.latestLevelDetails;
30664
30749
  return levelDetails ? config.liveMaxLatencyDurationCount * levelDetails.targetduration : 0;
30665
30750
  }
30666
30751
  }, {
package/dist/hls.js.d.ts CHANGED
@@ -222,6 +222,10 @@ export declare interface BackBufferData {
222
222
  bufferEnd: number;
223
223
  }
224
224
 
225
+ declare type Base = {
226
+ url: string;
227
+ };
228
+
225
229
  export declare type BaseData = {
226
230
  url: string;
227
231
  };
@@ -248,14 +252,22 @@ export declare class BasePlaylistController extends Logger implements NetworkCom
248
252
  export declare class BaseSegment {
249
253
  private _byteRange;
250
254
  private _url;
251
- readonly baseurl: string;
255
+ private _stats;
256
+ private _streams;
257
+ readonly base: Base;
252
258
  relurl?: string;
253
- elementaryStreams: ElementaryStreams;
254
- constructor(baseurl: string);
259
+ constructor(base: Base | string);
255
260
  setByteRange(value: string, previous?: BaseSegment): void;
261
+ get baseurl(): string;
256
262
  get byteRange(): [number, number] | [];
257
263
  get byteRangeStartOffset(): number | undefined;
258
264
  get byteRangeEndOffset(): number | undefined;
265
+ get elementaryStreams(): ElementaryStreams;
266
+ set elementaryStreams(value: ElementaryStreams);
267
+ get hasStats(): boolean;
268
+ get hasStreams(): boolean;
269
+ get stats(): LoadStats;
270
+ set stats(value: LoadStats);
259
271
  get url(): string;
260
272
  set url(value: string);
261
273
  clearElementaryStreamInfo(): void;
@@ -784,7 +796,7 @@ export declare interface CuesParsedData {
784
796
 
785
797
  export declare class DateRange {
786
798
  attr: AttrList;
787
- tagAnchor: Fragment | null;
799
+ tagAnchor: MediaFragmentRef | null;
788
800
  tagOrder: number;
789
801
  private _startDate;
790
802
  private _endDate?;
@@ -1273,8 +1285,9 @@ export declare interface FragLoadingData {
1273
1285
  */
1274
1286
  export declare class Fragment extends BaseSegment {
1275
1287
  private _decryptdata;
1288
+ private _programDateTime;
1289
+ private _ref;
1276
1290
  rawProgramDateTime: string | null;
1277
- programDateTime: number | null;
1278
1291
  tagList: Array<string[]>;
1279
1292
  duration: number;
1280
1293
  sn: number | 'initSegment';
@@ -1295,7 +1308,6 @@ export declare class Fragment extends BaseSegment {
1295
1308
  deltaPTS?: number;
1296
1309
  maxStartPTS?: number;
1297
1310
  minEndPTS?: number;
1298
- stats: LoadStats;
1299
1311
  data?: Uint8Array;
1300
1312
  bitrateTest: boolean;
1301
1313
  title: string | null;
@@ -1303,11 +1315,17 @@ export declare class Fragment extends BaseSegment {
1303
1315
  endList?: boolean;
1304
1316
  gap?: boolean;
1305
1317
  urlId: number;
1306
- constructor(type: PlaylistLevelType, baseurl: string);
1318
+ constructor(type: PlaylistLevelType, base: Base | string);
1307
1319
  get decryptdata(): LevelKey | null;
1308
1320
  get end(): number;
1309
1321
  get endProgramDateTime(): number | null;
1310
1322
  get encrypted(): boolean;
1323
+ get programDateTime(): number | null;
1324
+ set programDateTime(value: number | null);
1325
+ get ref(): MediaFragmentRef | null;
1326
+ addStart(value: number): void;
1327
+ setStart(value: number): void;
1328
+ setDuration(value: number): void;
1311
1329
  setKeyFormat(keyFormat: KeySystemFormats): void;
1312
1330
  abortRequests(): void;
1313
1331
  setElementaryStreamInfo(type: ElementaryStreamTypes, startPTS: number, endPTS: number, startDTS: number, endDTS: number, partial?: boolean): void;
@@ -2137,7 +2155,7 @@ export declare class InterstitialEvent {
2137
2155
  assetList: InterstitialAssetItem[];
2138
2156
  assetListLoader?: Loader<LoaderContext>;
2139
2157
  assetListResponse: AssetListJSON | null;
2140
- resumeAnchor?: Fragment;
2158
+ resumeAnchor?: MediaFragmentRef;
2141
2159
  error?: Error;
2142
2160
  constructor(dateRange: DateRange, base: BaseData);
2143
2161
  setDateRange(dateRange: DateRange): void;
@@ -2886,8 +2904,17 @@ export declare interface MediaEndedData {
2886
2904
 
2887
2905
  export declare interface MediaFragment extends Fragment {
2888
2906
  sn: number;
2907
+ ref: MediaFragmentRef;
2889
2908
  }
2890
2909
 
2910
+ declare type MediaFragmentRef = {
2911
+ base: Base;
2912
+ start: number;
2913
+ duration: number;
2914
+ sn: number;
2915
+ programDateTime: number | null;
2916
+ };
2917
+
2891
2918
  export declare type MediaKeyFunc = (keySystem: KeySystems, supportedConfigurations: MediaKeySystemConfiguration[]) => Promise<MediaKeySystemAccess>;
2892
2919
 
2893
2920
  export declare interface MediaKeySessionContext {
@@ -3025,8 +3052,7 @@ export declare class Part extends BaseSegment {
3025
3052
  readonly relurl: string;
3026
3053
  readonly fragment: MediaFragment;
3027
3054
  readonly index: number;
3028
- stats: LoadStats;
3029
- constructor(partAttrs: AttrList, frag: MediaFragment, baseurl: string, index: number, previous?: Part);
3055
+ constructor(partAttrs: AttrList, frag: MediaFragment, base: Base | string, index: number, previous?: Part);
3030
3056
  get start(): number;
3031
3057
  get end(): number;
3032
3058
  get loaded(): boolean;