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

package/dist/m3u8-parser.cjs.js

@@ -1,22 +1,21 @@
-/*! @name @transmitlive/m3u8-parser @version 4.7.2-beta.6 @license Apache-2.0 */
+/*! @name @transmitlive/m3u8-parser @version 7.1.0-0 @license Apache-2.0 */
 'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _inheritsLoose = require('@babel/runtime/helpers/inheritsLoose');
 var Stream = require('@videojs/vhs-utils/cjs/stream.js');
 var _extends = require('@babel/runtime/helpers/extends');
-var _assertThisInitialized = require('@babel/runtime/helpers/assertThisInitialized');
 var decodeB64ToUint8Array = require('@videojs/vhs-utils/cjs/decode-b64-to-uint8-array.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var _inheritsLoose__default = /*#__PURE__*/_interopDefaultLegacy(_inheritsLoose);
 var Stream__default = /*#__PURE__*/_interopDefaultLegacy(Stream);
 var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
-var _assertThisInitialized__default = /*#__PURE__*/_interopDefaultLegacy(_assertThisInitialized);
 var decodeB64ToUint8Array__default = /*#__PURE__*/_interopDefaultLegacy(decodeB64ToUint8Array);
 
+/**
+ * @file m3u8/line-stream.js
+ */
 /**
  * A stream that buffers string input and generates a `data` event for each
  * line.
@@ -25,15 +24,11 @@ var decodeB64ToUint8Array__default = /*#__PURE__*/_interopDefaultLegacy(decodeB6
  * @extends Stream
  */
 
-var LineStream = /*#__PURE__*/function (_Stream) {
-  _inheritsLoose__default['default'](LineStream, _Stream);
-
-  function LineStream() {
-    var _this;
-
-    _this = _Stream.call(this) || this;
-    _this.buffer = '';
-    return _this;
+class LineStream extends Stream__default["default"] {
+  constructor() {
+    super();
+    this.buffer = '';
+    this.lineNumber = 0;
   }
   /**
    * Add new data to be parsed.
@@ -42,29 +37,27 @@ var LineStream = /*#__PURE__*/function (_Stream) {
    */
 
 
-  var _proto = LineStream.prototype;
-
-  _proto.push = function push(data) {
-    var nextNewline;
+  push(data) {
+    let nextNewline;
     this.buffer += data;
+    this.lineNumber += 1;
     nextNewline = this.buffer.indexOf('\n');
 
     for (; nextNewline > -1; nextNewline = this.buffer.indexOf('\n')) {
       this.trigger('data', this.buffer.substring(0, nextNewline));
       this.buffer = this.buffer.substring(nextNewline + 1);
     }
-  };
+  }
 
-  return LineStream;
-}(Stream__default['default']);
+}
 
-var TAB = String.fromCharCode(0x09);
+const TAB = String.fromCharCode(0x09);
 
-var parseByterange = function parseByterange(byterangeString) {
+const parseByterange = function (byterangeString) {
   // optionally match and capture 0+ digits before `@`
   // optionally match and capture 0+ digits after `@`
-  var match = /([0-9.]*)?@?([0-9.]*)?/.exec(byterangeString || '');
-  var result = {};
+  const match = /([0-9.]*)?@?([0-9.]*)?/.exec(byterangeString || '');
+  const result = {};
 
   if (match[1]) {
     result.length = parseInt(match[1], 10);
@@ -85,10 +78,10 @@ var parseByterange = function parseByterange(byterangeString) {
  */
 
 
-var attributeSeparator = function attributeSeparator() {
-  var key = '[^=]*';
-  var value = '"[^"]*"|[^,]*';
-  var keyvalue = '(?:' + key + ')=(?:' + value + ')';
+const attributeSeparator = function () {
+  const key = '[^=]*';
+  const value = '"[^"]*"|[^,]*';
+  const keyvalue = '(?:' + key + ')=(?:' + value + ')';
   return new RegExp('(?:^|,)(' + keyvalue + ')');
 };
 /**
@@ -98,12 +91,17 @@ var attributeSeparator = function attributeSeparator() {
  */
 
 
-var parseAttributes = function parseAttributes(attributes) {
-  // split the string using attributes as the separator
-  var attrs = attributes.split(attributeSeparator());
-  var result = {};
-  var i = attrs.length;
-  var attr;
+const parseAttributes = function (attributes) {
+  const result = {};
+
+  if (!attributes) {
+    return result;
+  } // split the string using attributes as the separator
+
+
+  const attrs = attributes.split(attributeSeparator());
+  let i = attrs.length;
+  let attr;
 
   while (i--) {
     // filter out unmatched portions of the string
@@ -148,17 +146,11 @@ var parseAttributes = function parseAttributes(attributes) {
  */
 
 
-var ParseStream = /*#__PURE__*/function (_Stream) {
-  _inheritsLoose__default['default'](ParseStream, _Stream);
-
-  function ParseStream() {
-    var _this;
-
-    _this = _Stream.call(this) || this;
-    _this.customParsers = [];
-    _this.tagMappers = [];
-    _this.lineNumber = 0;
-    return _this;
+class ParseStream extends Stream__default["default"] {
+  constructor() {
+    super();
+    this.customParsers = [];
+    this.tagMappers = [];
   }
   /**
    * Parses an additional line of input.
@@ -167,14 +159,9 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
    */
 
 
-  var _proto = ParseStream.prototype;
-
-  _proto.push = function push(line) {
-    var _this2 = this;
-
-    var match;
-    var event;
-    this.lineNumber = this.lineNumber + 1; // strip whitespace
+  push(line) {
+    let match;
+    let event; // strip whitespace
 
     line = line.trim();
 
@@ -193,8 +180,8 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
     } // map tags
 
 
-    var newLines = this.tagMappers.reduce(function (acc, mapper) {
-      var mappedLine = mapper(line); // skip if unchanged
+    const newLines = this.tagMappers.reduce((acc, mapper) => {
+      const mappedLine = mapper(line); // skip if unchanged
 
       if (mappedLine === line) {
         return acc;
@@ -202,20 +189,19 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
 
       return acc.concat([mappedLine]);
     }, [line]);
-    newLines.forEach(function (newLine) {
-      for (var i = 0; i < _this2.customParsers.length; i++) {
-        if (_this2.customParsers[i].call(_this2, newLine)) {
+    newLines.forEach(newLine => {
+      for (let i = 0; i < this.customParsers.length; i++) {
+        if (this.customParsers[i].call(this, newLine)) {
           return;
         }
       } // Comments
 
 
       if (newLine.indexOf('#EXT') !== 0) {
-        _this2.trigger('data', {
+        this.trigger('data', {
           type: 'comment',
           text: newLine.slice(1)
         });
-
         return;
       } // strip off any carriage returns here so the regex matching
       // doesn't have to account for them.
@@ -226,15 +212,14 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
       match = /^#EXTM3U/.exec(newLine);
 
       if (match) {
-        _this2.trigger('data', {
+        this.trigger('data', {
           type: 'tag',
           tagType: 'm3u'
         });
-
         return;
       }
 
-      match = /^#EXTINF:?([0-9\.]*)?,?(.*)?$/.exec(newLine);
+      match = /^#EXTINF:([0-9\.]*)?,?(.*)?$/.exec(newLine);
 
       if (match) {
         event = {
@@ -250,12 +235,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.title = match[2];
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-TARGETDURATION:?([0-9.]*)?/.exec(newLine);
+      match = /^#EXT-X-TARGETDURATION:([0-9.]*)?/.exec(newLine);
 
       if (match) {
         event = {
@@ -267,12 +251,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.duration = parseInt(match[1], 10);
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-VERSION:?([0-9.]*)?/.exec(newLine);
+      match = /^#EXT-X-VERSION:([0-9.]*)?/.exec(newLine);
 
       if (match) {
         event = {
@@ -284,12 +267,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.version = parseInt(match[1], 10);
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-MEDIA-SEQUENCE:?(\-?[0-9.]*)?/.exec(newLine);
+      match = /^#EXT-X-MEDIA-SEQUENCE:(\-?[0-9.]*)?/.exec(newLine);
 
       if (match) {
         event = {
@@ -301,12 +283,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.number = parseInt(match[1], 10);
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-DISCONTINUITY-SEQUENCE:?(\-?[0-9.]*)?/.exec(newLine);
+      match = /^#EXT-X-DISCONTINUITY-SEQUENCE:(\-?[0-9.]*)?/.exec(newLine);
 
       if (match) {
         event = {
@@ -318,12 +299,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.number = parseInt(match[1], 10);
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-PLAYLIST-TYPE:?(.*)?$/.exec(newLine);
+      match = /^#EXT-X-PLAYLIST-TYPE:(.*)?$/.exec(newLine);
 
       if (match) {
         event = {
@@ -335,25 +315,22 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.playlistType = match[1];
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-BYTERANGE:?(.*)?$/.exec(newLine);
+      match = /^#EXT-X-BYTERANGE:(.*)?$/.exec(newLine);
 
       if (match) {
-        event = _extends__default['default'](parseByterange(match[1]), {
+        event = _extends__default["default"](parseByterange(match[1]), {
           type: 'tag',
           tagType: 'byterange'
         });
-
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-ALLOW-CACHE:?(YES|NO)?/.exec(newLine);
+      match = /^#EXT-X-ALLOW-CACHE:(YES|NO)?/.exec(newLine);
 
       if (match) {
         event = {
@@ -365,12 +342,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.allowed = !/NO/.test(match[1]);
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-MAP:?(.*)$/.exec(newLine);
+      match = /^#EXT-X-MAP:(.*)$/.exec(newLine);
 
       if (match) {
         event = {
@@ -379,7 +355,7 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
         };
 
         if (match[1]) {
-          var attributes = parseAttributes(match[1]);
+          const attributes = parseAttributes(match[1]);
 
           if (attributes.URI) {
             event.uri = attributes.URI;
@@ -390,12 +366,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           }
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-STREAM-INF:?(.*)$/.exec(newLine);
+      match = /^#EXT-X-STREAM-INF:(.*)$/.exec(newLine);
 
       if (match) {
         event = {
@@ -407,8 +382,8 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.attributes = parseAttributes(match[1]);
 
           if (event.attributes.RESOLUTION) {
-            var split = event.attributes.RESOLUTION.split('x');
-            var resolution = {};
+            const split = event.attributes.RESOLUTION.split('x');
+            const resolution = {};
 
             if (split[0]) {
               resolution.width = parseInt(split[0], 10);
@@ -425,17 +400,20 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
             event.attributes.BANDWIDTH = parseInt(event.attributes.BANDWIDTH, 10);
           }
 
+          if (event.attributes['FRAME-RATE']) {
+            event.attributes['FRAME-RATE'] = parseFloat(event.attributes['FRAME-RATE']);
+          }
+
           if (event.attributes['PROGRAM-ID']) {
             event.attributes['PROGRAM-ID'] = parseInt(event.attributes['PROGRAM-ID'], 10);
           }
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-MEDIA:?(.*)$/.exec(newLine);
+      match = /^#EXT-X-MEDIA:(.*)$/.exec(newLine);
 
       if (match) {
         event = {
@@ -447,34 +425,31 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.attributes = parseAttributes(match[1]);
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
       match = /^#EXT-X-ENDLIST/.exec(newLine);
 
       if (match) {
-        _this2.trigger('data', {
+        this.trigger('data', {
           type: 'tag',
           tagType: 'endlist'
         });
-
         return;
       }
 
       match = /^#EXT-X-DISCONTINUITY/.exec(newLine);
 
       if (match) {
-        _this2.trigger('data', {
+        this.trigger('data', {
           type: 'tag',
           tagType: 'discontinuity'
         });
-
         return;
       }
 
-      match = /^#EXT-X-PROGRAM-DATE-TIME:?(.*)$/.exec(newLine);
+      match = /^#EXT-X-PROGRAM-DATE-TIME:(.*)$/.exec(newLine);
 
       if (match) {
         event = {
@@ -487,12 +462,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.dateTimeObject = new Date(match[1]);
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-KEY:?(.*)$/.exec(newLine);
+      match = /^#EXT-X-KEY:(.*)$/.exec(newLine);
 
       if (match) {
         event = {
@@ -517,12 +491,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           }
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-START:?(.*)$/.exec(newLine);
+      match = /^#EXT-X-START:(.*)$/.exec(newLine);
 
       if (match) {
         event = {
@@ -536,12 +509,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.attributes.PRECISE = /YES/.test(event.attributes.PRECISE);
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-CUE-OUT-CONT:?(.*)?$/.exec(newLine);
+      match = /^#EXT-X-CUE-OUT-CONT:(.*)?$/.exec(newLine);
 
       if (match) {
         event = {
@@ -555,12 +527,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.data = '';
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-CUE-OUT:?(.*)?$/.exec(newLine);
+      match = /^#EXT-X-CUE-OUT:(.*)?$/.exec(newLine);
 
       if (match) {
         event = {
@@ -574,12 +545,11 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.data = '';
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
-      match = /^#EXT-X-CUE-IN:?(.*)?$/.exec(newLine);
+      match = /^#EXT-X-CUE-IN:(.*)?$/.exec(newLine);
 
       if (match) {
         event = {
@@ -593,8 +563,7 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.data = '';
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
@@ -615,8 +584,7 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.attributes['RECENTLY-REMOVED-DATERANGES'] = event.attributes['RECENTLY-REMOVED-DATERANGES'].split(TAB);
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
@@ -643,8 +611,7 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
           event.attributes.byterange = parseByterange(event.attributes.BYTERANGE);
         }
 
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
@@ -666,9 +633,7 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
             event.attributes[key] = /YES/.test(event.attributes[key]);
           }
         });
-
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
@@ -685,9 +650,7 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
             event.attributes[key] = parseFloat(event.attributes[key]);
           }
         });
-
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
@@ -702,16 +665,14 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
         ['BYTERANGE-START', 'BYTERANGE-LENGTH'].forEach(function (key) {
           if (event.attributes.hasOwnProperty(key)) {
             event.attributes[key] = parseInt(event.attributes[key], 10);
-            var subkey = key === 'BYTERANGE-LENGTH' ? 'length' : 'offset';
+            const subkey = key === 'BYTERANGE-LENGTH' ? 'length' : 'offset';
             event.attributes.byterange = event.attributes.byterange || {};
             event.attributes.byterange[subkey] = event.attributes[key]; // only keep the parsed byterange object.
 
             delete event.attributes[key];
           }
         });
-
-        _this2.trigger('data', event);
-
+        this.trigger('data', event);
         return;
       }
 
@@ -728,14 +689,83 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
             event.attributes[key] = parseInt(event.attributes[key], 10);
           }
         });
+        this.trigger('data', event);
+        return;
+      }
 
-        _this2.trigger('data', event);
+      match = /^#EXT-X-DATERANGE:(.*)$/.exec(newLine);
 
+      if (match && match[1]) {
+        event = {
+          type: 'tag',
+          tagType: 'daterange'
+        };
+        event.attributes = parseAttributes(match[1]);
+        ['ID', 'CLASS'].forEach(function (key) {
+          if (event.attributes.hasOwnProperty(key)) {
+            event.attributes[key] = String(event.attributes[key]);
+          }
+        });
+        ['START-DATE', 'END-DATE'].forEach(function (key) {
+          if (event.attributes.hasOwnProperty(key)) {
+            event.attributes[key] = new Date(event.attributes[key]);
+          }
+        });
+        ['DURATION', 'PLANNED-DURATION'].forEach(function (key) {
+          if (event.attributes.hasOwnProperty(key)) {
+            event.attributes[key] = parseFloat(event.attributes[key]);
+          }
+        });
+        ['END-ON-NEXT'].forEach(function (key) {
+          if (event.attributes.hasOwnProperty(key)) {
+            event.attributes[key] = /YES/i.test(event.attributes[key]);
+          }
+        });
+        ['SCTE35-CMD', ' SCTE35-OUT', 'SCTE35-IN'].forEach(function (key) {
+          if (event.attributes.hasOwnProperty(key)) {
+            event.attributes[key] = event.attributes[key].toString(16);
+          }
+        });
+        const clientAttributePattern = /^X-([A-Z]+-)+[A-Z]+$/;
+
+        for (const key in event.attributes) {
+          if (!clientAttributePattern.test(key)) {
+            continue;
+          }
+
+          const isHexaDecimal = /[0-9A-Fa-f]{6}/g.test(event.attributes[key]);
+          const isDecimalFloating = /^\d+(\.\d+)?$/.test(event.attributes[key]);
+          event.attributes[key] = isHexaDecimal ? event.attributes[key].toString(16) : isDecimalFloating ? parseFloat(event.attributes[key]) : String(event.attributes[key]);
+        }
+
+        this.trigger('data', event);
+        return;
+      }
+
+      match = /^#EXT-X-INDEPENDENT-SEGMENTS/.exec(newLine);
+
+      if (match) {
+        this.trigger('data', {
+          type: 'tag',
+          tagType: 'independent-segments'
+        });
+        return;
+      }
+
+      match = /^#EXT-X-CONTENT-STEERING:(.*)$/.exec(newLine);
+
+      if (match) {
+        event = {
+          type: 'tag',
+          tagType: 'content-steering'
+        };
+        event.attributes = parseAttributes(match[1]);
+        this.trigger('data', event);
         return;
       } // unknown tag type
 
 
-      _this2.trigger('data', {
+      this.trigger('data', {
         type: 'tag',
         data: newLine.slice(4)
       });
@@ -750,33 +780,28 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
    * @param {Function} [options.dataParser] function to parse the line into an object
    * @param {boolean}  [options.segment]    should tag data be attached to the segment object
    */
-  ;
-
-  _proto.addParser = function addParser(_ref) {
-    var _this3 = this;
 
-    var expression = _ref.expression,
-        customType = _ref.customType,
-        dataParser = _ref.dataParser,
-        segment = _ref.segment;
 
+  addParser({
+    expression,
+    customType,
+    dataParser,
+    segment
+  }) {
     if (typeof dataParser !== 'function') {
-      dataParser = function dataParser(line) {
-        return line;
-      };
+      dataParser = line => line;
     }
 
-    this.customParsers.push(function (line) {
-      var match = expression.exec(line);
+    this.customParsers.push(line => {
+      const match = expression.exec(line);
 
       if (match) {
-        _this3.trigger('data', {
+        this.trigger('data', {
           type: 'custom',
           data: dataParser(line),
-          customType: customType,
-          segment: segment
+          customType,
+          segment
         });
-
         return true;
       }
     });
@@ -788,13 +813,13 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
    * @param {RegExp}   options.expression   a regular expression to match the custom header
    * @param {Function} options.map          function to translate tag into a different tag
    */
-  ;
 
-  _proto.addTagMapper = function addTagMapper(_ref2) {
-    var expression = _ref2.expression,
-        map = _ref2.map;
 
-    var mapFn = function mapFn(line) {
+  addTagMapper({
+    expression,
+    map
+  }) {
+    const mapFn = line => {
       if (expression.test(line)) {
         return map(line);
       }
@@ -803,19 +828,14 @@ var ParseStream = /*#__PURE__*/function (_Stream) {
     };
 
     this.tagMappers.push(mapFn);
-  };
+  }
 
-  return ParseStream;
-}(Stream__default['default']);
+}
 
-var camelCase = function camelCase(str) {
-  return str.toLowerCase().replace(/-(\w)/g, function (a) {
-    return a[1].toUpperCase();
-  });
-};
+const camelCase = str => str.toLowerCase().replace(/-(\w)/g, a => a[1].toUpperCase());
 
-var camelCaseKeys = function camelCaseKeys(attributes) {
-  var result = {};
+const camelCaseKeys = function (attributes) {
+  const result = {};
   Object.keys(attributes).forEach(function (key) {
     result[camelCase(key)] = attributes[key];
   });
@@ -826,31 +846,33 @@ var camelCaseKeys = function camelCaseKeys(attributes) {
 // target durations are set.
 
 
-var setHoldBack = function setHoldBack(manifest) {
-  var serverControl = manifest.serverControl,
-      targetDuration = manifest.targetDuration,
-      partTargetDuration = manifest.partTargetDuration;
+const setHoldBack = function (manifest) {
+  const {
+    serverControl,
+    targetDuration,
+    partTargetDuration
+  } = manifest;
 
   if (!serverControl) {
     return;
   }
 
-  var tag = '#EXT-X-SERVER-CONTROL';
-  var hb = 'holdBack';
-  var phb = 'partHoldBack';
-  var minTargetDuration = targetDuration && targetDuration * 3;
-  var minPartDuration = partTargetDuration && partTargetDuration * 2;
+  const tag = '#EXT-X-SERVER-CONTROL';
+  const hb = 'holdBack';
+  const phb = 'partHoldBack';
+  const minTargetDuration = targetDuration && targetDuration * 3;
+  const minPartDuration = partTargetDuration && partTargetDuration * 2;
 
   if (targetDuration && !serverControl.hasOwnProperty(hb)) {
     serverControl[hb] = minTargetDuration;
     this.trigger('info', {
-      message: tag + " defaulting HOLD-BACK to targetDuration * 3 (" + minTargetDuration + ")."
+      message: `${tag} defaulting HOLD-BACK to targetDuration * 3 (${minTargetDuration}).`
     });
   }
 
   if (minTargetDuration && serverControl[hb] < minTargetDuration) {
     this.trigger('warn', {
-      message: tag + " clamping HOLD-BACK (" + serverControl[hb] + ") to targetDuration * 3 (" + minTargetDuration + ")"
+      message: `${tag} clamping HOLD-BACK (${serverControl[hb]}) to targetDuration * 3 (${minTargetDuration})`
     });
     serverControl[hb] = minTargetDuration;
   } // default no part hold back to part target duration * 3
@@ -859,14 +881,14 @@ var setHoldBack = function setHoldBack(manifest) {
   if (partTargetDuration && !serverControl.hasOwnProperty(phb)) {
     serverControl[phb] = partTargetDuration * 3;
     this.trigger('info', {
-      message: tag + " defaulting PART-HOLD-BACK to partTargetDuration * 3 (" + serverControl[phb] + ")."
+      message: `${tag} defaulting PART-HOLD-BACK to partTargetDuration * 3 (${serverControl[phb]}).`
     });
   } // if part hold back is too small default it to part target duration * 2
 
 
   if (partTargetDuration && serverControl[phb] < minPartDuration) {
     this.trigger('warn', {
-      message: tag + " clamping PART-HOLD-BACK (" + serverControl[phb] + ") to partTargetDuration * 2 (" + minPartDuration + ")."
+      message: `${tag} clamping PART-HOLD-BACK (${serverControl[phb]}) to partTargetDuration * 2 (${minPartDuration}).`
     });
     serverControl[phb] = minPartDuration;
   }
@@ -894,36 +916,29 @@ var setHoldBack = function setHoldBack(manifest) {
  */
 
 
-var Parser = /*#__PURE__*/function (_Stream) {
-  _inheritsLoose__default['default'](Parser, _Stream);
-
-  function Parser() {
-    var _this;
-
-    _this = _Stream.call(this) || this;
-    _this.lineStream = new LineStream();
-    _this.parseStream = new ParseStream();
-
-    _this.lineStream.pipe(_this.parseStream);
+class Parser extends Stream__default["default"] {
+  constructor() {
+    super();
+    this.lineStream = new LineStream();
+    this.parseStream = new ParseStream();
+    this.lineStream.pipe(this.parseStream);
+    this.lastProgramDateTime = null;
     /* eslint-disable consistent-this */
 
-
-    var self = _assertThisInitialized__default['default'](_this);
+    const self = this;
     /* eslint-enable consistent-this */
 
+    const uris = [];
+    let currentUri = {}; // if specified, the active EXT-X-MAP definition
 
-    var uris = [];
-    var currentUri = {}; // if specified, the active EXT-X-MAP definition
+    let currentMap; // if specified, the active decryption key
 
-    var currentMap; // if specified, the active decryption key
+    let key;
+    let hasParts = false;
 
-    var _key;
+    const noop = function () {};
 
-    var hasParts = false;
-
-    var noop = function noop() {};
-
-    var defaultMediaGroups = {
+    const defaultMediaGroups = {
       'AUDIO': {},
       'VIDEO': {},
       'CLOSED-CAPTIONS': {},
@@ -931,25 +946,26 @@ var Parser = /*#__PURE__*/function (_Stream) {
     }; // This is the Widevine UUID from DASH IF IOP. The same exact string is
     // used in MPDs with Widevine encrypted streams.
 
-    var widevineUuid = 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed'; // group segments into numbered timelines delineated by discontinuities
+    const widevineUuid = 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed'; // group segments into numbered timelines delineated by discontinuities
 
-    var currentTimeline = 0; // the manifest is empty until the parse stream begins delivering data
+    let currentTimeline = 0; // the manifest is empty until the parse stream begins delivering data
 
-    _this.manifest = {
+    this.manifest = {
       allowCache: true,
       discontinuityStarts: [],
+      dateRanges: [],
       segments: []
     }; // keep track of the last seen segment's byte range end, as segments are not required
     // to provide the offset, in which case it defaults to the next byte after the
     // previous segment
 
-    var lastByterangeEnd = 0; // keep track of the last seen part's byte range end.
-
-    var lastPartByterangeEnd = 0; // track where next segment starts
+    let lastByterangeEnd = 0; // keep track of the last seen part's byte range end.
 
-    var nextSegmentLineNumberStart = 0;
+    let lastPartByterangeEnd = 0;
+    const dateRangeTags = {}; // track where next segment starts
 
-    _this.on('end', function () {
+    let nextSegmentLineNumberStart = 0;
+    this.on('end', () => {
       // only add preloadSegment if we don't yet have a uri for it.
       // and we actually have parts/preloadHints
       if (currentUri.uri || !currentUri.parts && !currentUri.preloadHints) {
@@ -960,36 +976,36 @@ var Parser = /*#__PURE__*/function (_Stream) {
         currentUri.map = currentMap;
       }
 
-      if (!currentUri.key && _key) {
-        currentUri.key = _key;
+      if (!currentUri.key && key) {
+        currentUri.key = key;
       }
 
       if (!currentUri.timeline && typeof currentTimeline === 'number') {
         currentUri.timeline = currentTimeline;
       }
 
-      _this.manifest.preloadSegment = currentUri;
+      this.manifest.preloadSegment = currentUri;
     }); // update the manifest with the m3u8 entry from the parse stream
 
-
-    _this.parseStream.on('data', function (entry) {
-      var mediaGroup;
-      var rendition; // starting a new segment
+    this.parseStream.on('data', function (entry) {
+      let mediaGroup;
+      let rendition; //starting a new segment
 
       if (!Object.keys(currentUri).length) {
-        nextSegmentLineNumberStart = this.lineNumber;
+        nextSegmentLineNumberStart = this.lineStream.lineNumber;
       }
 
       ({
-        tag: function tag() {
+        tag() {
           // switch based on the tag type
           (({
-            version: function version() {
+            version() {
               if (entry.version) {
                 this.manifest.version = entry.version;
               }
             },
-            'allow-cache': function allowCache() {
+
+            'allow-cache'() {
               this.manifest.allowCache = entry.allowed;
 
               if (!('allowed' in entry)) {
@@ -999,8 +1015,9 @@ var Parser = /*#__PURE__*/function (_Stream) {
                 this.manifest.allowCache = true;
               }
             },
-            byterange: function byterange() {
-              var byterange = {};
+
+            byterange() {
+              const byterange = {};
 
               if ('length' in entry) {
                 currentUri.byterange = byterange;
@@ -1028,10 +1045,12 @@ var Parser = /*#__PURE__*/function (_Stream) {
 
               lastByterangeEnd = byterange.offset + byterange.length;
             },
-            endlist: function endlist() {
+
+            endlist() {
               this.manifest.endList = true;
             },
-            inf: function inf() {
+
+            inf() {
               if (!('mediaSequence' in this.manifest)) {
                 this.manifest.mediaSequence = 0;
                 this.trigger('info', {
@@ -1046,6 +1065,10 @@ var Parser = /*#__PURE__*/function (_Stream) {
                 });
               }
 
+              if (entry.title) {
+                currentUri.title = entry.title;
+              }
+
               if (entry.duration > 0) {
                 currentUri.duration = entry.duration;
               }
@@ -1059,7 +1082,8 @@ var Parser = /*#__PURE__*/function (_Stream) {
 
               this.manifest.segments = uris;
             },
-            key: function key() {
+
+            key() {
               if (!entry.attributes) {
                 this.trigger('warn', {
                   message: 'ignoring key declaration without attribute list'
@@ -1069,7 +1093,7 @@ var Parser = /*#__PURE__*/function (_Stream) {
 
 
               if (entry.attributes.METHOD === 'NONE') {
-                _key = null;
+                key = null;
                 return;
               }
 
@@ -1101,7 +1125,7 @@ var Parser = /*#__PURE__*/function (_Stream) {
 
 
               if (entry.attributes.KEYFORMAT === widevineUuid) {
-                var VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR', 'SAMPLE-AES-CENC'];
+                const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR', 'SAMPLE-AES-CENC'];
 
                 if (VALID_METHODS.indexOf(entry.attributes.METHOD) === -1) {
                   this.trigger('warn', {
@@ -1140,7 +1164,7 @@ var Parser = /*#__PURE__*/function (_Stream) {
                     keyId: entry.attributes.KEYID.substring(2)
                   },
                   // decode the base64-encoded PSSH box
-                  pssh: decodeB64ToUint8Array__default['default'](entry.attributes.URI.split(',')[1])
+                  pssh: decodeB64ToUint8Array__default["default"](entry.attributes.URI.split(',')[1])
                 };
                 return;
               }
@@ -1152,16 +1176,17 @@ var Parser = /*#__PURE__*/function (_Stream) {
               } // setup an encryption key for upcoming segments
 
 
-              _key = {
+              key = {
                 method: entry.attributes.METHOD || 'AES-128',
                 uri: entry.attributes.URI
               };
 
               if (typeof entry.attributes.IV !== 'undefined') {
-                _key.iv = entry.attributes.IV;
+                key.iv = entry.attributes.IV;
               }
             },
-            'media-sequence': function mediaSequence() {
+
+            'media-sequence'() {
               if (!isFinite(entry.number)) {
                 this.trigger('warn', {
                   message: 'ignoring invalid media sequence: ' + entry.number
@@ -1171,7 +1196,8 @@ var Parser = /*#__PURE__*/function (_Stream) {
 
               this.manifest.mediaSequence = entry.number;
             },
-            'discontinuity-sequence': function discontinuitySequence() {
+
+            'discontinuity-sequence'() {
               if (!isFinite(entry.number)) {
                 this.trigger('warn', {
                   message: 'ignoring invalid discontinuity sequence: ' + entry.number
@@ -1182,7 +1208,8 @@ var Parser = /*#__PURE__*/function (_Stream) {
               this.manifest.discontinuitySequence = entry.number;
               currentTimeline = entry.number;
             },
-            'playlist-type': function playlistType() {
+
+            'playlist-type'() {
               if (!/VOD|EVENT/.test(entry.playlistType)) {
                 this.trigger('warn', {
                   message: 'ignoring unknown playlist type: ' + entry.playlist
@@ -1192,7 +1219,8 @@ var Parser = /*#__PURE__*/function (_Stream) {
 
               this.manifest.playlistType = entry.playlistType;
             },
-            map: function map() {
+
+            map() {
               currentMap = {};
 
               if (entry.uri) {
@@ -1203,11 +1231,12 @@ var Parser = /*#__PURE__*/function (_Stream) {
                 currentMap.byterange = entry.byterange;
               }
 
-              if (_key) {
-                currentMap.key = _key;
+              if (key) {
+                currentMap.key = key;
               }
             },
-            'stream-inf': function streamInf() {
+
+            'stream-inf'() {
               this.manifest.playlists = uris;
               this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
 
@@ -1222,9 +1251,10 @@ var Parser = /*#__PURE__*/function (_Stream) {
                 currentUri.attributes = {};
               }
 
-              _extends__default['default'](currentUri.attributes, entry.attributes);
+              _extends__default["default"](currentUri.attributes, entry.attributes);
             },
-            media: function media() {
+
+            media() {
               this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
 
               if (!(entry.attributes && entry.attributes.TYPE && entry.attributes['GROUP-ID'] && entry.attributes.NAME)) {
@@ -1235,7 +1265,7 @@ var Parser = /*#__PURE__*/function (_Stream) {
               } // find the media group, creating defaults as necessary
 
 
-              var mediaGroupType = this.manifest.mediaGroups[entry.attributes.TYPE];
+              const mediaGroupType = this.manifest.mediaGroups[entry.attributes.TYPE];
               mediaGroupType[entry.attributes['GROUP-ID']] = mediaGroupType[entry.attributes['GROUP-ID']] || {};
               mediaGroup = mediaGroupType[entry.attributes['GROUP-ID']]; // collect the rendition metadata
 
@@ -1272,12 +1302,14 @@ var Parser = /*#__PURE__*/function (_Stream) {
 
               mediaGroup[entry.attributes.NAME] = rendition;
             },
-            discontinuity: function discontinuity() {
+
+            discontinuity() {
               currentTimeline += 1;
               currentUri.discontinuity = true;
               this.manifest.discontinuityStarts.push(uris.length);
             },
-            'program-date-time': function programDateTime() {
+
+            'program-date-time'() {
               if (typeof this.manifest.dateTimeString === 'undefined') {
                 // PROGRAM-DATE-TIME is a media-segment tag, but for backwards
                 // compatibility, we add the first occurence of the PROGRAM-DATE-TIME tag
@@ -1289,8 +1321,24 @@ var Parser = /*#__PURE__*/function (_Stream) {
 
               currentUri.dateTimeString = entry.dateTimeString;
               currentUri.dateTimeObject = entry.dateTimeObject;
+              const {
+                lastProgramDateTime
+              } = this;
+              this.lastProgramDateTime = new Date(entry.dateTimeString).getTime(); // We should extrapolate Program Date Time backward only during first program date time occurrence.
+              // Once we have at least one program date time point, we can always extrapolate it forward using lastProgramDateTime reference.
+
+              if (lastProgramDateTime === null) {
+                // Extrapolate Program Date Time backward
+                // Since it is first program date time occurrence we're assuming that
+                // all this.manifest.segments have no program date time info
+                this.manifest.segments.reduceRight((programDateTime, segment) => {
+                  segment.programDateTime = programDateTime - segment.duration * 1000;
+                  return segment.programDateTime;
+                }, this.lastProgramDateTime);
+              }
             },
-            targetduration: function targetduration() {
+
+            targetduration() {
               if (!isFinite(entry.duration) || entry.duration < 0) {
                 this.trigger('warn', {
                   message: 'ignoring invalid target duration: ' + entry.duration
@@ -1301,7 +1349,8 @@ var Parser = /*#__PURE__*/function (_Stream) {
               this.manifest.targetDuration = entry.duration;
               setHoldBack.call(this, this.manifest);
             },
-            start: function start() {
+
+            start() {
               if (!entry.attributes || isNaN(entry.attributes['TIME-OFFSET'])) {
                 this.trigger('warn', {
                   message: 'ignoring start declaration without appropriate attribute list'
@@ -1314,26 +1363,29 @@ var Parser = /*#__PURE__*/function (_Stream) {
                 precise: entry.attributes.PRECISE
               };
             },
-            'cue-out': function cueOut() {
+
+            'cue-out'() {
               currentUri.cueOut = entry.data;
             },
-            'cue-out-cont': function cueOutCont() {
+
+            'cue-out-cont'() {
               currentUri.cueOutCont = entry.data;
             },
-            'cue-in': function cueIn() {
+
+            'cue-in'() {
               currentUri.cueIn = entry.data;
             },
-            'skip': function skip() {
+
+            'skip'() {
               this.manifest.skip = camelCaseKeys(entry.attributes);
               this.warnOnMissingAttributes_('#EXT-X-SKIP', entry.attributes, ['SKIPPED-SEGMENTS']);
             },
-            'part': function part() {
-              var _this2 = this;
 
+            'part'() {
               hasParts = true; // parts are always specifed before a segment
 
-              var segmentIndex = this.manifest.segments.length;
-              var part = camelCaseKeys(entry.attributes);
+              const segmentIndex = this.manifest.segments.length;
+              const part = camelCaseKeys(entry.attributes);
               currentUri.parts = currentUri.parts || [];
               currentUri.parts.push(part);
 
@@ -1345,21 +1397,22 @@ var Parser = /*#__PURE__*/function (_Stream) {
                 lastPartByterangeEnd = part.byterange.offset + part.byterange.length;
               }
 
-              var partIndex = currentUri.parts.length - 1;
-              this.warnOnMissingAttributes_("#EXT-X-PART #" + partIndex + " for segment #" + segmentIndex, entry.attributes, ['URI', 'DURATION']);
+              const partIndex = currentUri.parts.length - 1;
+              this.warnOnMissingAttributes_(`#EXT-X-PART #${partIndex} for segment #${segmentIndex}`, entry.attributes, ['URI', 'DURATION']);
 
               if (this.manifest.renditionReports) {
-                this.manifest.renditionReports.forEach(function (r, i) {
+                this.manifest.renditionReports.forEach((r, i) => {
                   if (!r.hasOwnProperty('lastPart')) {
-                    _this2.trigger('warn', {
-                      message: "#EXT-X-RENDITION-REPORT #" + i + " lacks required attribute(s): LAST-PART"
+                    this.trigger('warn', {
+                      message: `#EXT-X-RENDITION-REPORT #${i} lacks required attribute(s): LAST-PART`
                     });
                   }
                 });
               }
             },
-            'server-control': function serverControl() {
-              var attrs = this.manifest.serverControl = camelCaseKeys(entry.attributes);
+
+            'server-control'() {
+              const attrs = this.manifest.serverControl = camelCaseKeys(entry.attributes);
 
               if (!attrs.hasOwnProperty('canBlockReload')) {
                 attrs.canBlockReload = false;
@@ -1376,11 +1429,12 @@ var Parser = /*#__PURE__*/function (_Stream) {
                 });
               }
             },
-            'preload-hint': function preloadHint() {
+
+            'preload-hint'() {
               // parts are always specifed before a segment
-              var segmentIndex = this.manifest.segments.length;
-              var hint = camelCaseKeys(entry.attributes);
-              var isPart = hint.type && hint.type === 'PART';
+              const segmentIndex = this.manifest.segments.length;
+              const hint = camelCaseKeys(entry.attributes);
+              const isPart = hint.type && hint.type === 'PART';
               currentUri.preloadHints = currentUri.preloadHints || [];
               currentUri.preloadHints.push(hint);
 
@@ -1395,8 +1449,8 @@ var Parser = /*#__PURE__*/function (_Stream) {
                 }
               }
 
-              var index = currentUri.preloadHints.length - 1;
-              this.warnOnMissingAttributes_("#EXT-X-PRELOAD-HINT #" + index + " for segment #" + segmentIndex, entry.attributes, ['TYPE', 'URI']);
+              const index = currentUri.preloadHints.length - 1;
+              this.warnOnMissingAttributes_(`#EXT-X-PRELOAD-HINT #${index} for segment #${segmentIndex}`, entry.attributes, ['TYPE', 'URI']);
 
               if (!hint.type) {
                 return;
@@ -1404,8 +1458,8 @@ var Parser = /*#__PURE__*/function (_Stream) {
               // a duplicate type.
 
 
-              for (var i = 0; i < currentUri.preloadHints.length - 1; i++) {
-                var otherHint = currentUri.preloadHints[i];
+              for (let i = 0; i < currentUri.preloadHints.length - 1; i++) {
+                const otherHint = currentUri.preloadHints[i];
 
                 if (!otherHint.type) {
                   continue;
@@ -1413,25 +1467,27 @@ var Parser = /*#__PURE__*/function (_Stream) {
 
                 if (otherHint.type === hint.type) {
                   this.trigger('warn', {
-                    message: "#EXT-X-PRELOAD-HINT #" + index + " for segment #" + segmentIndex + " has the same TYPE " + hint.type + " as preload hint #" + i
+                    message: `#EXT-X-PRELOAD-HINT #${index} for segment #${segmentIndex} has the same TYPE ${hint.type} as preload hint #${i}`
                   });
                 }
               }
             },
-            'rendition-report': function renditionReport() {
-              var report = camelCaseKeys(entry.attributes);
+
+            'rendition-report'() {
+              const report = camelCaseKeys(entry.attributes);
               this.manifest.renditionReports = this.manifest.renditionReports || [];
               this.manifest.renditionReports.push(report);
-              var index = this.manifest.renditionReports.length - 1;
-              var required = ['LAST-MSN', 'URI'];
+              const index = this.manifest.renditionReports.length - 1;
+              const required = ['LAST-MSN', 'URI'];
 
               if (hasParts) {
                 required.push('LAST-PART');
               }
 
-              this.warnOnMissingAttributes_("#EXT-X-RENDITION-REPORT #" + index, entry.attributes, required);
+              this.warnOnMissingAttributes_(`#EXT-X-RENDITION-REPORT #${index}`, entry.attributes, required);
             },
-            'part-inf': function partInf() {
+
+            'part-inf'() {
               this.manifest.partInf = camelCaseKeys(entry.attributes);
               this.warnOnMissingAttributes_('#EXT-X-PART-INF', entry.attributes, ['PART-TARGET']);
 
@@ -1440,13 +1496,89 @@ var Parser = /*#__PURE__*/function (_Stream) {
               }
 
               setHoldBack.call(this, this.manifest);
+            },
+
+            'daterange'() {
+              this.manifest.dateRanges.push(camelCaseKeys(entry.attributes));
+              const index = this.manifest.dateRanges.length - 1;
+              this.warnOnMissingAttributes_(`#EXT-X-DATERANGE #${index}`, entry.attributes, ['ID', 'START-DATE']);
+              const dateRange = this.manifest.dateRanges[index];
+
+              if (dateRange.endDate && dateRange.startDate && new Date(dateRange.endDate) < new Date(dateRange.startDate)) {
+                this.trigger('warn', {
+                  message: 'EXT-X-DATERANGE END-DATE must be equal to or later than the value of the START-DATE'
+                });
+              }
+
+              if (dateRange.duration && dateRange.duration < 0) {
+                this.trigger('warn', {
+                  message: 'EXT-X-DATERANGE DURATION must not be negative'
+                });
+              }
+
+              if (dateRange.plannedDuration && dateRange.plannedDuration < 0) {
+                this.trigger('warn', {
+                  message: 'EXT-X-DATERANGE PLANNED-DURATION must not be negative'
+                });
+              }
+
+              const endOnNextYes = !!dateRange.endOnNext;
+
+              if (endOnNextYes && !dateRange.class) {
+                this.trigger('warn', {
+                  message: 'EXT-X-DATERANGE with an END-ON-NEXT=YES attribute must have a CLASS attribute'
+                });
+              }
+
+              if (endOnNextYes && (dateRange.duration || dateRange.endDate)) {
+                this.trigger('warn', {
+                  message: 'EXT-X-DATERANGE with an END-ON-NEXT=YES attribute must not contain DURATION or END-DATE attributes'
+                });
+              }
+
+              if (dateRange.duration && dateRange.endDate) {
+                const startDate = dateRange.startDate;
+                const newDateInSeconds = startDate.getTime() + dateRange.duration * 1000;
+                this.manifest.dateRanges[index].endDate = new Date(newDateInSeconds);
+              }
+
+              if (!dateRangeTags[dateRange.id]) {
+                dateRangeTags[dateRange.id] = dateRange;
+              } else {
+                for (const attribute in dateRangeTags[dateRange.id]) {
+                  if (!!dateRange[attribute] && JSON.stringify(dateRangeTags[dateRange.id][attribute]) !== JSON.stringify(dateRange[attribute])) {
+                    this.trigger('warn', {
+                      message: 'EXT-X-DATERANGE tags with the same ID in a playlist must have the same attributes values'
+                    });
+                    break;
+                  }
+                } // if tags with the same ID do not have conflicting attributes, merge them
+
+
+                const dateRangeWithSameId = this.manifest.dateRanges.findIndex(dateRangeToFind => dateRangeToFind.id === dateRange.id);
+                this.manifest.dateRanges[dateRangeWithSameId] = _extends__default["default"](this.manifest.dateRanges[dateRangeWithSameId], dateRange);
+                dateRangeTags[dateRange.id] = _extends__default["default"](dateRangeTags[dateRange.id], dateRange); // after merging, delete the duplicate dateRange that was added last
+
+                this.manifest.dateRanges.pop();
+              }
+            },
+
+            'independent-segments'() {
+              this.manifest.independentSegments = true;
+            },
+
+            'content-steering'() {
+              this.manifest.contentSteering = camelCaseKeys(entry.attributes);
+              this.warnOnMissingAttributes_('#EXT-X-CONTENT-STEERING', entry.attributes, ['SERVER-URI']);
             }
+
           })[entry.tagType] || noop).call(self);
         },
-        uri: function uri() {
+
+        uri() {
           currentUri.uri = entry.uri;
           currentUri.lineNumberStart = nextSegmentLineNumberStart;
-          currentUri.lineNumberEnd = this.parseStream.lineNumber;
+          currentUri.lineNumberEnd = this.lineStream.lineNumber;
           uris.push(currentUri); // if no explicit duration was declared, use the target duration
 
           if (this.manifest.targetDuration && !('duration' in currentUri)) {
@@ -1457,8 +1589,8 @@ var Parser = /*#__PURE__*/function (_Stream) {
           } // annotate with encryption information, if necessary
 
 
-          if (_key) {
-            currentUri.key = _key;
+          if (key) {
+            currentUri.key = key;
           }
 
           currentUri.timeline = currentTimeline; // annotate with initialization segment information, if necessary
@@ -1468,13 +1600,21 @@ var Parser = /*#__PURE__*/function (_Stream) {
           } // reset the last byterange end as it needs to be 0 between parts
 
 
-          lastPartByterangeEnd = 0; // prepare for the next URI
+          lastPartByterangeEnd = 0; // Once we have at least one program date time we can always extrapolate it forward
+
+          if (this.lastProgramDateTime !== null) {
+            currentUri.programDateTime = this.lastProgramDateTime;
+            this.lastProgramDateTime += currentUri.duration * 1000;
+          } // prepare for the next URI
+
 
           currentUri = {};
         },
-        comment: function comment() {// comments are not important for playback
+
+        comment() {// comments are not important for playback
         },
-        custom: function custom() {
+
+        custom() {
           // if this is segment-level data attach the output to the segment
           if (entry.segment) {
             currentUri.custom = currentUri.custom || {};
@@ -1484,16 +1624,13 @@ var Parser = /*#__PURE__*/function (_Stream) {
             this.manifest.custom[entry.customType] = entry.data;
           }
         }
+
       })[entry.type].call(self);
     });
-
-    return _this;
   }
 
-  var _proto = Parser.prototype;
-
-  _proto.warnOnMissingAttributes_ = function warnOnMissingAttributes_(identifier, attributes, required) {
-    var missing = [];
+  warnOnMissingAttributes_(identifier, attributes, required) {
+    const missing = [];
     required.forEach(function (key) {
       if (!attributes.hasOwnProperty(key)) {
         missing.push(key);
@@ -1502,7 +1639,7 @@ var Parser = /*#__PURE__*/function (_Stream) {
 
     if (missing.length) {
       this.trigger('warn', {
-        message: identifier + " lacks required attribute(s): " + missing.join(', ')
+        message: `${identifier} lacks required attribute(s): ${missing.join(', ')}`
       });
     }
   }
@@ -1511,9 +1648,9 @@ var Parser = /*#__PURE__*/function (_Stream) {
    *
    * @param {string} chunk a potentially incomplete portion of the manifest
    */
-  ;
 
-  _proto.push = function push(chunk) {
+
+  push(chunk) {
     this.lineStream.push(chunk);
   }
   /**
@@ -1521,11 +1658,19 @@ var Parser = /*#__PURE__*/function (_Stream) {
    * manifest did not contain a trailing newline but the file has been
    * completely received.
    */
-  ;
 
-  _proto.end = function end() {
+
+  end() {
     // flush any buffered input
     this.lineStream.push('\n');
+
+    if (this.manifest.dateRanges.length && this.lastProgramDateTime === null) {
+      this.trigger('warn', {
+        message: 'A playlist with EXT-X-DATERANGE tag must contain atleast one EXT-X-PROGRAM-DATE-TIME tag'
+      });
+    }
+
+    this.lastProgramDateTime = null;
     this.trigger('end');
   }
   /**
@@ -1533,13 +1678,13 @@ var Parser = /*#__PURE__*/function (_Stream) {
    *
    * @param {Object}   options              a map of options for the added parser
    * @param {RegExp}   options.expression   a regular expression to match the custom header
-   * @param {string}   options.type         the type to register to the output
+   * @param {string}   options.customType   the custom type to register to the output
    * @param {Function} [options.dataParser] function to parse the line into an object
    * @param {boolean}  [options.segment]    should tag data be attached to the segment object
    */
-  ;
 
-  _proto.addParser = function addParser(options) {
+
+  addParser(options) {
     this.parseStream.addParser(options);
   }
   /**
@@ -1549,14 +1694,13 @@ var Parser = /*#__PURE__*/function (_Stream) {
    * @param {RegExp}   options.expression   a regular expression to match the custom header
    * @param {Function} options.map          function to translate tag into a different tag
    */
-  ;
 
-  _proto.addTagMapper = function addTagMapper(options) {
+
+  addTagMapper(options) {
     this.parseStream.addTagMapper(options);
-  };
+  }
 
-  return Parser;
-}(Stream__default['default']);
+}
 
 exports.LineStream = LineStream;
 exports.ParseStream = ParseStream;