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

package/dist/m3u8-parser.js

@@ -1,21 +1,9 @@
-/*! @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 */
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('global/window')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'global/window'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.m3u8Parser = {}, global.window));
-}(this, (function (exports, window) { 'use strict';
-
-  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-  var window__default = /*#__PURE__*/_interopDefaultLegacy(window);
-
-  function _inheritsLoose(subClass, superClass) {
-    subClass.prototype = Object.create(superClass.prototype);
-    subClass.prototype.constructor = subClass;
-    subClass.__proto__ = superClass;
-  }
-
-  var inheritsLoose = _inheritsLoose;
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.m3u8Parser = {}));
+})(this, (function (exports) { 'use strict';
 
   /**
    * @file stream.js
@@ -137,6 +125,9 @@
     return Stream;
   }();
 
+  /**
+   * @file m3u8/line-stream.js
+   */
   /**
    * A stream that buffers string input and generates a `data` event for each
    * line.
@@ -145,15 +136,11 @@
    * @extends Stream
    */
 
-  var LineStream = /*#__PURE__*/function (_Stream) {
-    inheritsLoose(LineStream, _Stream);
-
-    function LineStream() {
-      var _this;
-
-      _this = _Stream.call(this) || this;
-      _this.buffer = '';
-      return _this;
+  class LineStream extends Stream {
+    constructor() {
+      super();
+      this.buffer = '';
+      this.lineNumber = 0;
     }
     /**
      * Add new data to be parsed.
@@ -162,65 +149,48 @@
      */
 
 
-    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);
-
-  function createCommonjsModule(fn, basedir, module) {
-  	return module = {
-  	  path: basedir,
-  	  exports: {},
-  	  require: function (path, base) {
-        return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-      }
-  	}, fn(module, module.exports), module.exports;
-  }
+    }
 
-  function commonjsRequire () {
-  	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
   }
 
-  var _extends_1 = createCommonjsModule(function (module) {
-    function _extends() {
-      module.exports = _extends = Object.assign || function (target) {
-        for (var i = 1; i < arguments.length; i++) {
-          var source = arguments[i];
+  function _extends() {
+    _extends_1 = _extends = Object.assign || function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
 
-          for (var key in source) {
-            if (Object.prototype.hasOwnProperty.call(source, key)) {
-              target[key] = source[key];
-            }
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
           }
         }
+      }
 
-        return target;
-      };
+      return target;
+    };
 
-      return _extends.apply(this, arguments);
-    }
+    return _extends.apply(this, arguments);
+  }
 
-    module.exports = _extends;
-  });
+  var _extends_1 = _extends;
+  var _extends$1 = _extends_1;
 
-  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);
@@ -241,10 +211,10 @@
    */
 
 
-  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 + ')');
   };
   /**
@@ -254,12 +224,17 @@
    */
 
 
-  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
@@ -304,17 +279,11 @@
    */
 
 
-  var ParseStream = /*#__PURE__*/function (_Stream) {
-    inheritsLoose(ParseStream, _Stream);
-
-    function ParseStream() {
-      var _this;
-
-      _this = _Stream.call(this) || this;
-      _this.customParsers = [];
-      _this.tagMappers = [];
-      _this.lineNumber = 0;
-      return _this;
+  class ParseStream extends Stream {
+    constructor() {
+      super();
+      this.customParsers = [];
+      this.tagMappers = [];
     }
     /**
      * Parses an additional line of input.
@@ -323,14 +292,9 @@
      */
 
 
-    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();
 
@@ -349,8 +313,8 @@
       } // 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;
@@ -358,20 +322,19 @@
 
         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.
@@ -382,15 +345,14 @@
         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 = {
@@ -406,12 +368,11 @@
             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 = {
@@ -423,12 +384,11 @@
             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 = {
@@ -440,12 +400,11 @@
             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 = {
@@ -457,12 +416,11 @@
             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 = {
@@ -474,12 +432,11 @@
             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 = {
@@ -491,25 +448,22 @@
             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_1(parseByterange(match[1]), {
+          event = _extends$1(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 = {
@@ -521,12 +475,11 @@
             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 = {
@@ -535,7 +488,7 @@
           };
 
           if (match[1]) {
-            var attributes = parseAttributes(match[1]);
+            const attributes = parseAttributes(match[1]);
 
             if (attributes.URI) {
               event.uri = attributes.URI;
@@ -546,12 +499,11 @@
             }
           }
 
-          _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 = {
@@ -563,8 +515,8 @@
             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);
@@ -581,17 +533,20 @@
               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 = {
@@ -603,34 +558,31 @@
             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 = {
@@ -643,12 +595,11 @@
             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 = {
@@ -673,12 +624,11 @@
             }
           }
 
-          _this2.trigger('data', event);
-
+          this.trigger('data', event);
           return;
         }
 
-        match = /^#EXT-X-START:?(.*)$/.exec(newLine);
+        match = /^#EXT-X-START:(.*)$/.exec(newLine);
 
         if (match) {
           event = {
@@ -692,12 +642,11 @@
             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 = {
@@ -711,12 +660,11 @@
             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 = {
@@ -730,12 +678,11 @@
             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 = {
@@ -749,8 +696,7 @@
             event.data = '';
           }
 
-          _this2.trigger('data', event);
-
+          this.trigger('data', event);
           return;
         }
 
@@ -771,8 +717,7 @@
             event.attributes['RECENTLY-REMOVED-DATERANGES'] = event.attributes['RECENTLY-REMOVED-DATERANGES'].split(TAB);
           }
 
-          _this2.trigger('data', event);
-
+          this.trigger('data', event);
           return;
         }
 
@@ -799,8 +744,7 @@
             event.attributes.byterange = parseByterange(event.attributes.BYTERANGE);
           }
 
-          _this2.trigger('data', event);
-
+          this.trigger('data', event);
           return;
         }
 
@@ -822,9 +766,7 @@
               event.attributes[key] = /YES/.test(event.attributes[key]);
             }
           });
-
-          _this2.trigger('data', event);
-
+          this.trigger('data', event);
           return;
         }
 
@@ -841,9 +783,7 @@
               event.attributes[key] = parseFloat(event.attributes[key]);
             }
           });
-
-          _this2.trigger('data', event);
-
+          this.trigger('data', event);
           return;
         }
 
@@ -858,16 +798,14 @@
           ['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;
         }
 
@@ -884,14 +822,83 @@
               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)
         });
@@ -906,33 +913,28 @@
      * @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;
         }
       });
@@ -944,13 +946,13 @@
      * @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);
         }
@@ -959,23 +961,12 @@
       };
 
       this.tagMappers.push(mapFn);
-    };
-
-    return ParseStream;
-  }(Stream);
-
-  function _assertThisInitialized(self) {
-    if (self === void 0) {
-      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
     }
 
-    return self;
   }
 
-  var assertThisInitialized = _assertThisInitialized;
-
   var atob = function atob(s) {
-    return window__default['default'].atob ? window__default['default'].atob(s) : Buffer.from(s, 'base64').toString('binary');
+    return window.atob ? window.atob(s) : Buffer.from(s, 'base64').toString('binary');
   };
 
   function decodeB64ToUint8Array(b64Text) {
@@ -989,14 +980,10 @@
     return array;
   }
 
-  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];
     });
@@ -1007,31 +994,33 @@
   // 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
@@ -1040,14 +1029,14 @@
     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;
     }
@@ -1075,36 +1064,29 @@
    */
 
 
-  var Parser = /*#__PURE__*/function (_Stream) {
-    inheritsLoose(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 {
+    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(_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
-
-      var currentMap; // if specified, the active decryption key
+      let currentMap; // if specified, the active decryption key
 
-      var _key;
+      let key;
+      let hasParts = false;
 
-      var hasParts = false;
+      const noop = function () {};
 
-      var noop = function noop() {};
-
-      var defaultMediaGroups = {
+      const defaultMediaGroups = {
         'AUDIO': {},
         'VIDEO': {},
         'CLOSED-CAPTIONS': {},
@@ -1112,25 +1094,26 @@
       }; // 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) {
@@ -1141,36 +1124,36 @@
           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)) {
@@ -1180,8 +1163,9 @@
                   this.manifest.allowCache = true;
                 }
               },
-              byterange: function byterange() {
-                var byterange = {};
+
+              byterange() {
+                const byterange = {};
 
                 if ('length' in entry) {
                   currentUri.byterange = byterange;
@@ -1209,10 +1193,12 @@
 
                 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', {
@@ -1227,6 +1213,10 @@
                   });
                 }
 
+                if (entry.title) {
+                  currentUri.title = entry.title;
+                }
+
                 if (entry.duration > 0) {
                   currentUri.duration = entry.duration;
                 }
@@ -1240,7 +1230,8 @@
 
                 this.manifest.segments = uris;
               },
-              key: function key() {
+
+              key() {
                 if (!entry.attributes) {
                   this.trigger('warn', {
                     message: 'ignoring key declaration without attribute list'
@@ -1250,7 +1241,7 @@
 
 
                 if (entry.attributes.METHOD === 'NONE') {
-                  _key = null;
+                  key = null;
                   return;
                 }
 
@@ -1282,7 +1273,7 @@
 
 
                 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', {
@@ -1333,16 +1324,17 @@
                 } // 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
@@ -1352,7 +1344,8 @@
 
                 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
@@ -1363,7 +1356,8 @@
                 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
@@ -1373,7 +1367,8 @@
 
                 this.manifest.playlistType = entry.playlistType;
               },
-              map: function map() {
+
+              map() {
                 currentMap = {};
 
                 if (entry.uri) {
@@ -1384,11 +1379,12 @@
                   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;
 
@@ -1403,9 +1399,10 @@
                   currentUri.attributes = {};
                 }
 
-                _extends_1(currentUri.attributes, entry.attributes);
+                _extends$1(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)) {
@@ -1416,7 +1413,7 @@
                 } // 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
 
@@ -1453,12 +1450,14 @@
 
                 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
@@ -1470,8 +1469,24 @@
 
                 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
@@ -1482,7 +1497,8 @@
                 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'
@@ -1495,26 +1511,29 @@
                   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);
 
@@ -1526,21 +1545,22 @@
                   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;
@@ -1557,11 +1577,12 @@
                   });
                 }
               },
-              '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);
 
@@ -1576,8 +1597,8 @@
                   }
                 }
 
-                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;
@@ -1585,8 +1606,8 @@
                 // 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;
@@ -1594,25 +1615,27 @@
 
                   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']);
 
@@ -1621,13 +1644,89 @@
                 }
 
                 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$1(this.manifest.dateRanges[dateRangeWithSameId], dateRange);
+                  dateRangeTags[dateRange.id] = _extends$1(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)) {
@@ -1638,8 +1737,8 @@
             } // 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
@@ -1649,13 +1748,21 @@
             } // 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 || {};
@@ -1665,16 +1772,13 @@
               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);
@@ -1683,7 +1787,7 @@
 
       if (missing.length) {
         this.trigger('warn', {
-          message: identifier + " lacks required attribute(s): " + missing.join(', ')
+          message: `${identifier} lacks required attribute(s): ${missing.join(', ')}`
         });
       }
     }
@@ -1692,9 +1796,9 @@
      *
      * @param {string} chunk a potentially incomplete portion of the manifest
      */
-    ;
 
-    _proto.push = function push(chunk) {
+
+    push(chunk) {
       this.lineStream.push(chunk);
     }
     /**
@@ -1702,11 +1806,19 @@
      * 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');
     }
     /**
@@ -1714,13 +1826,13 @@
      *
      * @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);
     }
     /**
@@ -1730,14 +1842,13 @@
      * @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);
+  }
 
   exports.LineStream = LineStream;
   exports.ParseStream = ParseStream;
@@ -1745,4 +1856,4 @@
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));