@transmitlive/m3u8-parser 4.7.2-beta.6 → 7.1.0-1

package/test/parse-stream.test.js

@@ -242,7 +242,7 @@ QUnit.test('parses #EXTM3U tags', function(assert) {
 
 // #EXTINF
 QUnit.test('parses minimal #EXTINF tags', function(assert) {
-  const manifest = '#EXTINF\n';
+  const manifest = '#EXTINF:\n';
   let element;
 
   this.parseStream.on('data', function(elem) {
@@ -319,7 +319,7 @@ QUnit.test('parses #EXTINF tags with carriage returns', function(assert) {
 
 // #EXT-X-TARGETDURATION
 QUnit.test('parses minimal #EXT-X-TARGETDURATION tags', function(assert) {
-  const manifest = '#EXT-X-TARGETDURATION\n';
+  const manifest = '#EXT-X-TARGETDURATION:\n';
   let element;
 
   this.parseStream.on('data', function(elem) {
@@ -379,7 +379,7 @@ QUnit.test('parses #EXT-X-VERSION with a version', function(assert) {
 
 // #EXT-X-MEDIA-SEQUENCE
 QUnit.test('parses minimal #EXT-X-MEDIA-SEQUENCE tags', function(assert) {
-  const manifest = '#EXT-X-MEDIA-SEQUENCE\n';
+  const manifest = '#EXT-X-MEDIA-SEQUENCE:\n';
   let element;
 
   this.parseStream.on('data', function(elem) {
@@ -453,7 +453,7 @@ QUnit.test('parses #EXT-X-PLAYLIST-TYPE with mutability info', function(assert)
 
 // #EXT-X-BYTERANGE
 QUnit.test('parses minimal #EXT-X-BYTERANGE tags', function(assert) {
-  const manifest = '#EXT-X-BYTERANGE\n';
+  const manifest = '#EXT-X-BYTERANGE:\n';
   let element;
 
   this.parseStream.on('data', function(elem) {
@@ -589,7 +589,7 @@ QUnit.test('parses #EXT-X-MAP tags with arbitrary attributes', function(assert)
 });
 // #EXT-X-STREAM-INF
 QUnit.test('parses minimal #EXT-X-STREAM-INF tags', function(assert) {
-  const manifest = '#EXT-X-STREAM-INF\n';
+  const manifest = '#EXT-X-STREAM-INF:\n';
   let element;
 
   this.parseStream.on('data', function(elem) {
@@ -604,7 +604,7 @@ QUnit.test('parses minimal #EXT-X-STREAM-INF tags', function(assert) {
 });
 // #EXT-X-PROGRAM-DATE-TIME
 QUnit.test('parses minimal EXT-X-PROGRAM-DATE-TIME tags', function(assert) {
-  const manifest = '#EXT-X-PROGRAM-DATE-TIME\n';
+  const manifest = '#EXT-X-PROGRAM-DATE-TIME:\n';
   let element;
 
   this.parseStream.on('data', function(elem) {
@@ -698,6 +698,14 @@ QUnit.test('parses #EXT-X-STREAM-INF with common attributes', function(assert) {
     'avc1.4d400d, mp4a.40.2',
     'codecs are parsed'
   );
+
+  manifest = '#EXT-X-STREAM-INF:PATHWAY-ID="CDN-A"\n';
+  this.lineStream.push(manifest);
+
+  assert.ok(element, 'an event was triggered');
+  assert.strictEqual(element.type, 'tag', 'the line type is tag');
+  assert.strictEqual(element.tagType, 'stream-inf', 'the tag type is stream-inf');
+  assert.strictEqual(element.attributes['PATHWAY-ID'], 'CDN-A', 'pathway-id is parsed');
 });
 QUnit.test('parses #EXT-X-STREAM-INF with arbitrary attributes', function(assert) {
   const manifest = '#EXT-X-STREAM-INF:NUMERIC=24,ALPHA=Value,MIXED=123abc\n';
@@ -809,16 +817,6 @@ QUnit.test('parses lightly-broken #EXT-X-KEY tags', function(assert) {
     'parsed a single-quoted uri'
   );
 
-  element = null;
-  manifest = '#EXT-X-KEYURI="https://example.com/key",METHOD=AES-128\n';
-  this.lineStream.push(manifest);
-  assert.strictEqual(element.tagType, 'key', 'parsed the tag type');
-  assert.strictEqual(
-    element.attributes.URI,
-    'https://example.com/key',
-    'inferred a colon after the tag type'
-  );
-
   element = null;
   manifest = '#EXT-X-KEY:  URI =  "https://example.com/key",METHOD=AES-128\n';
   this.lineStream.push(manifest);
@@ -889,6 +887,104 @@ QUnit.test('parses EXT-X-START PRECISE attribute', function(assert) {
   assert.strictEqual(element.attributes['TIME-OFFSET'], 1.4, 'parses time offset');
   assert.strictEqual(element.attributes.PRECISE, true, 'parses precise attribute');
 });
+//  #EXT-X-DATERANGE:
+QUnit.test('parses minimal EXT-X-DATERANGE tag', function(assert) {
+  const manifest = '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T15:15:15.840000Z"\n';
+  let element;
+
+  this.parseStream.on('data', function(elem) {
+    element = elem;
+  });
+  this.lineStream.push(manifest);
+
+  assert.ok(element, 'an event was triggered');
+  assert.strictEqual(element.type, 'tag', 'the line type is tag');
+  assert.strictEqual(element.tagType, 'daterange', 'the tag type is daterange');
+  assert.strictEqual(element.attributes.ID, '12345');
+  assert.deepEqual(element.attributes['START-DATE'], new Date('2023-04-13T15:15:15.840000Z'));
+});
+
+QUnit.test('parses DURATION and PLANNED-DURATION attributes in EXT-X-DATERANGE tag', function(assert) {
+  const manifest = '#EXT-X-DATERANGE:ID="54545",START-DATE="2023-04-23T18:17:16.54000Z",PLANNED-DURATION="38.4",DURATION="15.5"\n';
+  let element;
+
+  this.parseStream.on('data', function(elem) {
+    element = elem;
+  });
+  this.lineStream.push(manifest);
+
+  assert.ok(element, 'an event was triggered');
+  assert.strictEqual(element.type, 'tag', 'the line type is tag');
+  assert.strictEqual(element.tagType, 'daterange', 'the tag type is daterange');
+  assert.strictEqual(element.attributes.ID, '54545');
+  assert.deepEqual(element.attributes['START-DATE'], new Date('2023-04-23T18:17:16.540000Z'));
+  assert.strictEqual(element.attributes.DURATION, 15.5);
+  assert.strictEqual(element.attributes['PLANNED-DURATION'], 38.4);
+});
+
+QUnit.test('parses SCTE35-CMD, SCTE35-OUT, SCTE35-IN EXT-X-DATERANGE tags', function(assert) {
+  let manifest = '#EXT-X-DATERANGE:ID="splice-6FFFFFF0",START-DATE="2023-04-13T15:15:15.840000Z",SCTE35-OUT="0xFC002F0000000000FF000014056FFFFFFF0"\n';
+  let element;
+
+  this.parseStream.on('data', function(elem) {
+    element = elem;
+  });
+  this.lineStream.push(manifest);
+
+  assert.ok(element, 'an event was triggered');
+  assert.strictEqual(element.attributes['SCTE35-OUT'], '0xFC002F0000000000FF000014056FFFFFFF0');
+
+  manifest = '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T15:15:15.840000Z",SCTE35-IN="0xFC0000425100FFF0140500000300000000E77FEFFE0011FB9EFE0029004D1932E0000100101002A22"\n';
+  this.lineStream.push(manifest);
+
+  assert.ok(element, 'an event was triggered');
+  assert.strictEqual(element.attributes['SCTE35-IN'], '0xFC0000425100FFF0140500000300000000E77FEFFE0011FB9EFE0029004D1932E0000100101002A22');
+
+  manifest = '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T15:15:15.840000Z",SCTE35-CMD="0xFC0000425100FFF014"\n';
+  this.lineStream.push(manifest);
+
+  assert.ok(element, 'an event was triggered');
+  assert.strictEqual(element.attributes['SCTE35-CMD'], '0xFC0000425100FFF014');
+});
+
+QUnit.test('custom attributes in EXT-X-DATERANGE are parsed', function(assert) {
+  let manifest = '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T15:15:15.840000Z",X-CUSTOM-KEY="value"\n';
+  let element;
+
+  this.parseStream.on('data', function(elem) {
+    element = elem;
+  });
+  this.lineStream.push(manifest);
+
+  assert.ok(element, 'an event was triggered');
+  assert.strictEqual(element.attributes['X-CUSTOM-KEY'], 'value');
+
+  manifest = '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T15:15:15.840000Z",X-CUSTOM-KEY="17.8"\n';
+  this.lineStream.push(manifest);
+
+  assert.ok(element, 'an event was triggered');
+  assert.strictEqual(element.attributes['X-CUSTOM-KEY'], 17.8);
+
+  manifest = '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T15:15:15.840000Z",X-CUSTOM-KEY="0X12345abcde"\n';
+  this.lineStream.push(manifest);
+
+  assert.ok(element, 'an event was triggered');
+  assert.strictEqual(element.attributes['X-CUSTOM-KEY'], '0X12345abcde');
+});
+
+QUnit.test('parses EXT-X-INDEPENDENT-SEGMENTS', function(assert) {
+  const manifest = '#EXT-X-INDEPENDENT-SEGMENTS\n';
+  let element;
+
+  this.parseStream.on('data', function(elem) {
+    element = elem;
+  });
+  this.lineStream.push(manifest);
+
+  assert.ok(element, 'an event was triggered');
+  assert.strictEqual(element.type, 'tag', 'the line type is tag');
+  assert.strictEqual(element.tagType, 'independent-segments', 'the tag type is independent-segments');
+});
 
 QUnit.test('ignores empty lines', function(assert) {
   const manifest = '\n';

package/test/parser.test.js

@@ -1,6 +1,6 @@
 import QUnit from 'qunit';
-import testDataExpected from 'data-files!expecteds';
-import testDataManifests from 'data-files!manifests';
+// import testDataExpected from 'data-files!expecteds';
+// import testDataManifests from 'data-files!manifests';
 import {Parser} from '../src';
 
 QUnit.module('m3u8s', function(hooks) {
@@ -108,11 +108,10 @@ QUnit.module('m3u8s', function(hooks) {
       '#EXT-X-CUE-OUT:10',
       '#EXTINF:5,',
       'ex2.ts',
-      '#EXT-X-CUE-OUT15',
       '#EXT-UKNOWN-TAG',
       '#EXTINF:5,',
       'ex3.ts',
-      '#EXT-X-CUE-OUT',
+      '#EXT-X-CUE-OUT:',
       '#EXTINF:5,',
       'ex3.ts',
       '#EXT-X-ENDLIST'
@@ -122,7 +121,6 @@ QUnit.module('m3u8s', function(hooks) {
     this.parser.end();
 
     assert.equal(this.parser.manifest.segments[1].cueOut, '10', 'parser attached cue out tag');
-    assert.equal(this.parser.manifest.segments[2].cueOut, '15', 'cue out without : seperator');
     assert.equal(this.parser.manifest.segments[3].cueOut, '', 'cue out without data');
   });
 
@@ -135,11 +133,10 @@ QUnit.module('m3u8s', function(hooks) {
       '#EXT-X-CUE-OUT-CONT:10/60',
       '#EXTINF:5,',
       'ex2.ts',
-      '#EXT-X-CUE-OUT-CONT15/30',
       '#EXT-UKNOWN-TAG',
       '#EXTINF:5,',
       'ex3.ts',
-      '#EXT-X-CUE-OUT-CONT',
+      '#EXT-X-CUE-OUT-CONT:',
       '#EXTINF:5,',
       'ex3.ts',
       '#EXT-X-ENDLIST'
@@ -152,10 +149,6 @@ QUnit.module('m3u8s', function(hooks) {
       this.parser.manifest.segments[1].cueOutCont, '10/60',
       'parser attached cue out cont tag'
     );
-    assert.equal(
-      this.parser.manifest.segments[2].cueOutCont, '15/30',
-      'cue out cont without : seperator'
-    );
     assert.equal(this.parser.manifest.segments[3].cueOutCont, '', 'cue out cont without data');
   });
 
@@ -165,14 +158,13 @@ QUnit.module('m3u8s', function(hooks) {
       '#EXTINF:5,',
       '#COMMENT',
       'ex1.ts',
-      '#EXT-X-CUE-IN',
+      '#EXT-X-CUE-IN:',
       '#EXTINF:5,',
       'ex2.ts',
       '#EXT-X-CUE-IN:15',
       '#EXT-UKNOWN-TAG',
       '#EXTINF:5,',
       'ex3.ts',
-      '#EXT-X-CUE-IN=abc',
       '#EXTINF:5,',
       'ex3.ts',
       '#EXT-X-ENDLIST'
@@ -183,10 +175,6 @@ QUnit.module('m3u8s', function(hooks) {
 
     assert.equal(this.parser.manifest.segments[1].cueIn, '', 'parser attached cue in tag');
     assert.equal(this.parser.manifest.segments[2].cueIn, '15', 'cue in with data');
-    assert.equal(
-      this.parser.manifest.segments[3].cueIn, '=abc',
-      'cue in without colon seperator'
-    );
   });
 
   QUnit.test('parses characteristics attribute', function(assert) {
@@ -857,8 +845,394 @@ QUnit.module('m3u8s', function(hooks) {
     );
   });
 
+  QUnit.test('PDT value is assigned to segments with explicit #EXT-X-PROGRAM-DATE-TIME tags', function(assert) {
+    this.parser.push([
+      '#EXTM3U',
+      '#EXT-X-VERSION:6',
+      '#EXT-X-TARGETDURATION:8',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXTINF:8.0',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      'https://example.com/playlist1.m3u8',
+      '#EXTINF:8.0,',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T22:14:10.053+00:00',
+      'https://example.com/playlist2.m3u8',
+      '#EXT-X-ENDLIST'
+    ].join('\n'));
+    this.parser.end();
+    assert.equal(this.parser.manifest.segments[0].programDateTime, new Date('2017-07-31T20:35:35.053+00:00').getTime());
+    assert.equal(this.parser.manifest.segments[1].programDateTime, new Date('2017-07-31T22:14:10.053+00:00').getTime());
+  });
+
+  QUnit.test('backfill PDT values when the first EXT-X-PROGRAM-DATE-TIME tag appears after one or more Media Segment URIs', function(assert) {
+    this.parser.push([
+      '#EXTM3U',
+      '#EXT-X-VERSION:6',
+      '#EXT-X-TARGETDURATION:8',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXTINF:8.0',
+      'https://example.com/playlist1.m3u8',
+      '#EXTINF:8.0,',
+      'https://example.com/playlist2.m3u8',
+      '#EXTINF:8.0',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      'https://example.com/playlist3.m3u8',
+      '#EXT-X-ENDLIST'
+    ].join('\n'));
+    this.parser.end();
+    const segments = this.parser.manifest.segments;
+
+    assert.equal(segments[2].programDateTime, new Date('2017-07-31T20:35:35.053+00:00').getTime());
+    assert.equal(segments[1].programDateTime, segments[2].programDateTime - (segments[1].duration * 1000));
+    assert.equal(segments[0].programDateTime, segments[1].programDateTime - (segments[0].duration * 1000));
+  });
+
+  QUnit.test('extrapolates forward when subsequent fragments do not have explicit PDT tags', function(assert) {
+    this.parser.push([
+      '#EXTM3U',
+      '#EXT-X-VERSION:6',
+      '#EXT-X-TARGETDURATION:8',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXTINF:8.0',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      'https://example.com/playlist1.m3u8',
+      '#EXTINF:8.0,',
+      'https://example.com/playlist2.m3u8',
+      '#EXTINF:8.0',
+      'https://example.com/playlist3.m3u8',
+      '#EXT-X-ENDLIST'
+    ].join('\n'));
+    this.parser.end();
+    const segments = this.parser.manifest.segments;
+
+    assert.equal(segments[0].programDateTime, new Date('2017-07-31T20:35:35.053+00:00').getTime());
+    assert.equal(segments[1].programDateTime, segments[0].programDateTime + segments[1].duration * 1000);
+    assert.equal(segments[2].programDateTime, segments[1].programDateTime + segments[2].duration * 1000);
+  });
+
+  QUnit.test('warns when #EXT-X-DATERANGE missing attribute', function(assert) {
+    this.parser.push([
+      '#EXT-X-VERSION:3',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXT-X-DISCONTINUITY-SEQUENCE:0',
+      '#EXTINF:10,',
+      'media-00001.ts',
+      '#EXT-X-ENDLIST',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      '#EXT-X-DATERANGE:ID="12345"'
+    ].join('\n'));
+    this.parser.end();
+
+    const warnings = [
+      '#EXT-X-DATERANGE #0 lacks required attribute(s): START-DATE'
+    ];
+
+    assert.deepEqual(
+      this.warnings,
+      warnings,
+      'warnings as expected'
+    );
+  });
+
+  QUnit.test('warns when #EXT-X-DATERANGE end date attribute is less than start date', function(assert) {
+    this.parser.push([
+      '#EXT-X-VERSION:3',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXT-X-DISCONTINUITY-SEQUENCE:0',
+      '#EXTINF:10,',
+      'media-00001.ts',
+      '#EXT-X-ENDLIST',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T18:16:15.840000Z",END-DATE="2023-04-13T15:15:15.840000Z"'
+    ].join('\n'));
+    this.parser.end();
+
+    const warnings = [
+      'EXT-X-DATERANGE END-DATE must be equal to or later than the value of the START-DATE'
+    ];
+
+    assert.deepEqual(
+      this.warnings,
+      warnings,
+      'warnings as expected'
+    );
+  });
+
+  QUnit.test('warns when #EXT-X-DATERANGE duration or planned duration attribute is negative', function(assert) {
+    this.parser.push([
+      '#EXT-X-VERSION:3',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXT-X-DISCONTINUITY-SEQUENCE:0',
+      '#EXTINF:10,',
+      'media-00001.ts',
+      '#EXT-X-ENDLIST',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T18:16:15.840000Z",PLANNED-DURATION=-38.4,DURATION=-15.5'
+    ].join('\n'));
+    this.parser.end();
+
+    const warnings = [
+      'EXT-X-DATERANGE DURATION must not be negative',
+      'EXT-X-DATERANGE PLANNED-DURATION must not be negative'
+    ];
+
+    assert.deepEqual(
+      this.warnings,
+      warnings,
+      'warnings as expected'
+    );
+  });
+
+  QUnit.test('warns when #EXT-X-DATERANGE has a END-ON-NEXT=YES attribute and a DURATION or END-DATE attribute', function(assert) {
+    this.parser.push([
+      '#EXT-X-VERSION:3',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXT-X-DISCONTINUITY-SEQUENCE:0',
+      '#EXTINF:10,',
+      'media-00001.ts',
+      '#EXT-X-ENDLIST',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T15:15:15.840000Z",END-ON-NEXT=YES, END-DATE="2023-04-13T18:16:15.840000Z",CLASS="CLASSATTRIBUTE"'
+    ].join('\n'));
+    this.parser.end();
+
+    const warnings = [
+      'EXT-X-DATERANGE with an END-ON-NEXT=YES attribute must not contain DURATION or END-DATE attributes'
+    ];
+
+    assert.deepEqual(
+      this.warnings,
+      warnings,
+      'warnings as expected'
+    );
+  });
+
+  QUnit.test('warns when #EXT-X-DATERANGE has a END-ON-NEXT=YES attribute but not a CLASS attribute', function(assert) {
+    this.parser.push([
+      '#EXT-X-VERSION:3',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXT-X-DISCONTINUITY-SEQUENCE:0',
+      '#EXTINF:10,',
+      'media-00001.ts',
+      '#EXT-X-ENDLIST',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T18:16:15.840000Z",END-ON-NEXT=YES'
+    ].join('\n'));
+    this.parser.end();
+
+    const warnings = [
+      'EXT-X-DATERANGE with an END-ON-NEXT=YES attribute must have a CLASS attribute'
+    ];
+
+    assert.deepEqual(
+      this.warnings,
+      warnings,
+      'warnings as expected'
+    );
+  });
+
+  QUnit.test('warns when playlist has multiple #EXT-X-DATERANGE tag same ID but different attribute values', function(assert) {
+    this.parser.push([
+      '#EXT-X-VERSION:3',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXT-X-DISCONTINUITY-SEQUENCE:0',
+      '#EXTINF:10,',
+      'media-00001.ts',
+      '#EXT-X-ENDLIST',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T18:16:15.840000Z",END-ON-NEXT=YES,CLASS="CLASSATTRIBUTE"',
+      '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T18:16:15.840000Z",CLASS="CLASSATTRIBUTE1"'
+    ].join('\n'));
+    this.parser.end();
+
+    const warnings = [
+      'EXT-X-DATERANGE tags with the same ID in a playlist must have the same attributes values'
+    ];
+
+    assert.deepEqual(
+      this.warnings,
+      warnings,
+      'warnings as expected'
+    );
+  });
+
+  QUnit.test('when #EXT-X-DATERANGE has both DURATION and END-DATE attributes, value of the END-DATE attribute must be START-DATE + DURATION', function(assert) {
+    this.parser.push([
+      '#EXT-X-VERSION:3',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXT-X-DISCONTINUITY-SEQUENCE:0',
+      '#EXTINF:10,',
+      'media-00001.ts',
+      '#EXT-X-ENDLIST',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T15:16:15.840000Z",DURATION=14.0,END-DATE="2023-04-13T18:15:15.840000Z"'
+    ].join('\n'));
+    this.parser.end();
+
+    assert.deepEqual(this.parser.manifest.dateRanges[0].endDate, new Date('2023-04-13T15:16:29.840000Z'));
+  });
+
+  QUnit.test('warns when playlist contains #EXT-X-DATERANGE tag but no #EXT-X-PROGRAM-DATE-TIME', function(assert) {
+    this.parser.push([
+      '#EXT-X-VERSION:3',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXT-X-DISCONTINUITY-SEQUENCE:0',
+      '#EXTINF:10,',
+      'media-00001.ts',
+      '#EXT-X-ENDLIST',
+      '#EXT-X-DATERANGE:ID="12345",START-DATE="2023-04-13T18:16:15.840000Z",END-ON-NEXT=YES,CLASS="sampleClassAttrib"'
+    ].join('\n'));
+    this.parser.end();
+
+    const warnings = [
+      'A playlist with EXT-X-DATERANGE tag must contain atleast one EXT-X-PROGRAM-DATE-TIME tag'
+    ];
+
+    assert.deepEqual(
+      this.warnings,
+      warnings,
+      'warnings as expected'
+    );
+  });
+
+  QUnit.test('playlist with multiple ext-x-daterange with same ID but no conflicting attributes', function(assert) {
+    const expectedDateRange = {
+      id: '12345',
+      scte35In: '0xFC30200FFF2',
+      scte35Out: '0xFC30200FFF2',
+      startDate: new Date('2023-04-13T18:16:15.840000Z'),
+      class: 'CLASSATTRIBUTE'
+    };
+
+    this.parser.push([
+      '#EXT-X-VERSION:3',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXT-X-DISCONTINUITY-SEQUENCE:0',
+      '#EXTINF:10,',
+      'media-00001.ts',
+      '#EXT-X-ENDLIST',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      '#EXT-X-DATERANGE:ID="12345",SCTE35-IN=0xFC30200FFF2,START-DATE="2023-04-13T18:16:15.840000Z",CLASS="CLASSATTRIBUTE"',
+      '#EXT-X-DATERANGE:ID="12345",SCTE35-OUT=0xFC30200FFF2,START-DATE="2023-04-13T18:16:15.840000Z"'
+    ].join('\n'));
+    this.parser.end();
+    assert.equal(this.parser.manifest.dateRanges.length, 1, 'two dateranges with same ID are merged');
+    assert.deepEqual(this.parser.manifest.dateRanges[0], expectedDateRange);
+
+  });
+
+  QUnit.test('playlist with multiple ext-x-daterange ', function(assert) {
+    this.parser.push([
+      ' #EXTM3U',
+      '#EXT-X-VERSION:6',
+      '#EXT-X-TARGETDURATION:8',
+      '#EXT-X-MEDIA-SEQUENCE:0',
+      '#EXT-X-PROGRAM-DATE-TIME:2017-07-31T20:35:35.053+00:00',
+      '#EXT-X-DATERANGE:ID="event1",START-DATE="2023-04-20T10:00:00Z",DURATION=30.0,END-DATE="2023-04-20T10:00:30Z",X-CUSTOM-KEY="value"',
+      '#EXTINF:8.0',
+      'https://example.com/playlist1.m3u8',
+      '#EXT-SCTE35-IN:0xFC002F0000000000FF000014056FFFFFFF065870697070657220506F6F7200',
+      '#EXT-X-DATERANGE:ID="event2",START-DATE="2023-04-20T11:00:00Z",DURATION=60.0,END-DATE="2023-04-20T11:01:00Z",X-CUSTOM-KEY="value"',
+      '#EXTINF:8.0,',
+      'https://example.com/playlist2.m3u8',
+      '#EXT-SCTE35-OUT:0xFC002F0000000000FF000014056FFFFFFF065870697070657220506F6F7200',
+      '#EXT-X-DATERANGE:ID="event3",START-DATE="2023-04-20T12:00:00Z",DURATION=120.0,END-DATE="2023-04-20T12:02:00Z",X-CUSTOM-KEY="value"',
+      '#EXTINF:8.0',
+      'https://example.com/playlist3.m3u8',
+      '#EXT-SCTE35-IN:0xFC002F0000000000FF000014056FFFFFFF065870697070657220506F6F7200',
+      '#EXT-SCTE35-OUT:0xFC002F0000000000FF000014056FFFFFFF065870697070657220506F6F7200',
+      '#EXT-X-ENDLIST'
+    ].join('\n'));
+    this.parser.end();
+    assert.equal(this.parser.manifest.dateRanges.length, 3);
+  });
+
+  QUnit.test('parses #EXT-X-INDEPENDENT-SEGMENTS', function(assert) {
+    this.parser.push([
+      '#EXTM3U',
+      '#EXT-X-VERSION:6',
+      '#EXT-X-SERVER-CONTROL:CAN-BLOCK-RELOAD=YES,PART-HOLD-BACK=3.252,CAN-SKIP-UNTIL=42.0',
+      '#EXT-X-INDEPENDENT-SEGMENTS'
+    ].join('\n'));
+    this.parser.end();
+    assert.equal(this.parser.manifest.independentSegments, true);
+  });
+
+  QUnit.test('parses #EXT-X-CONTENT-STEERING', function(assert) {
+    const expectedContentSteeringObject = {
+      serverUri: '/foo?bar=00012',
+      pathwayId: 'CDN-A'
+    };
+
+    this.parser.push('#EXT-X-CONTENT-STEERING:SERVER-URI="/foo?bar=00012",PATHWAY-ID="CDN-A"');
+    this.parser.end();
+    assert.deepEqual(this.parser.manifest.contentSteering, expectedContentSteeringObject);
+  });
+
+  QUnit.test('parses #EXT-X-CONTENT-STEERING without PATHWAY-ID', function(assert) {
+    const expectedContentSteeringObject = {
+      serverUri: '/bar?foo=00012'
+    };
+
+    this.parser.push('#EXT-X-CONTENT-STEERING:SERVER-URI="/bar?foo=00012"');
+    this.parser.end();
+    assert.deepEqual(this.parser.manifest.contentSteering, expectedContentSteeringObject);
+  });
+
+  QUnit.test('warns on #EXT-X-CONTENT-STEERING missing SERVER-URI', function(assert) {
+    const warning = ['#EXT-X-CONTENT-STEERING lacks required attribute(s): SERVER-URI'];
+
+    this.parser.push('#EXT-X-CONTENT-STEERING:PATHWAY-ID="CDN-A"');
+    this.parser.end();
+    assert.deepEqual(this.warnings, warning, 'warnings as expected');
+  });
+
+  QUnit.test('playlist line numbers ', function(assert) {
+    this.parser.push([
+      '#EXTM3U',
+      '#EXT-X-VERSION:7',
+      '#EXT-X-TARGETDURATION:4',
+      '#EXT-X-MEDIA-SEQUENCE:2421',
+      '#EXT-X-MAP:URI="init.mp4"',
+      '#EXTINF:3.989333,',
+      '#EXT-X-PROGRAM-DATE-TIME:2024-04-17T09:43:19.871-0700',
+      'stream2421.m4s',
+      '#EXTINF:4.010667,',
+      '#EXT-X-PROGRAM-DATE-TIME:2024-04-17T09:43:23.860-0700',
+      'stream2422.m4s',
+      '#EXTINF:3.989333,',
+      '#EXT-X-PROGRAM-DATE-TIME:2024-04-17T09:43:27.871-0700',
+      'stream2423.m4s',
+      '#EXTINF:4.010667,',
+      '#EXT-X-PROGRAM-DATE-TIME:2024-04-17T09:43:31.860-0700',
+      'stream2424.m4s',
+      '#EXTINF:3.989333,',
+      '#EXT-X-PROGRAM-DATE-TIME:2024-04-17T09:43:35.871-0700',
+      'stream2425.m4s',
+      '#EXTINF:4.010667,',
+      '#EXT-X-PROGRAM-DATE-TIME:2024-04-17T09:43:39.860-0700',
+      'stream2426.m4s',
+      '#EXTINF:3.989333,',
+      '#EXT-X-PROGRAM-DATE-TIME:2024-04-17T09:43:43.871-0700',
+      'stream2427.m4s',
+      '#EXTINF:4.010667,',
+      '#EXT-X-PROGRAM-DATE-TIME:2024-04-17T09:43:47.860-0700',
+      'stream2428.m4s',
+      '#EXTINF:3.989333,',
+      '#EXT-X-PROGRAM-DATE-TIME:2024-04-17T09:43:51.871-0700',
+      'stream2429.m4s',
+      '#EXTINF:4.010667,',
+      '#EXT-X-PROGRAM-DATE-TIME:2024-04-17T09:43:55.860-0700',
+      'stream2430.m4s`'
+    ].join('\n'));
+    this.parser.end();
+    assert.equal(this.parser.manifest.segments[2].lineNumberStart, 12);
+    assert.equal(this.parser.manifest.segments[2].lineNumberEnd, 14);
+  });
+
   QUnit.module('integration');
 
+  /*
   for (const key in testDataExpected) {
     if (!testDataManifests[key]) {
       throw new Error(`${key}.js does not have an equivelent m3u8 manifest to test against`);
@@ -880,5 +1254,6 @@ QUnit.module('m3u8s', function(hooks) {
       );
     });
   }
+  */
 
 });