@transmitlive/m3u8-parser 4.7.2-beta.6

package/dist/m3u8-parser.js

@@ -0,0 +1,1748 @@
+/*! @name @transmitlive/m3u8-parser @version 4.7.2-beta.6 @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;
+
+  /**
+   * @file stream.js
+   */
+
+  /**
+   * A lightweight readable stream implemention that handles event dispatching.
+   *
+   * @class Stream
+   */
+  var Stream = /*#__PURE__*/function () {
+    function Stream() {
+      this.listeners = {};
+    }
+    /**
+     * Add a listener for a specified event type.
+     *
+     * @param {string} type the event name
+     * @param {Function} listener the callback to be invoked when an event of
+     * the specified type occurs
+     */
+
+
+    var _proto = Stream.prototype;
+
+    _proto.on = function on(type, listener) {
+      if (!this.listeners[type]) {
+        this.listeners[type] = [];
+      }
+
+      this.listeners[type].push(listener);
+    }
+    /**
+     * Remove a listener for a specified event type.
+     *
+     * @param {string} type the event name
+     * @param {Function} listener  a function previously registered for this
+     * type of event through `on`
+     * @return {boolean} if we could turn it off or not
+     */
+    ;
+
+    _proto.off = function off(type, listener) {
+      if (!this.listeners[type]) {
+        return false;
+      }
+
+      var index = this.listeners[type].indexOf(listener); // TODO: which is better?
+      // In Video.js we slice listener functions
+      // on trigger so that it does not mess up the order
+      // while we loop through.
+      //
+      // Here we slice on off so that the loop in trigger
+      // can continue using it's old reference to loop without
+      // messing up the order.
+
+      this.listeners[type] = this.listeners[type].slice(0);
+      this.listeners[type].splice(index, 1);
+      return index > -1;
+    }
+    /**
+     * Trigger an event of the specified type on this stream. Any additional
+     * arguments to this function are passed as parameters to event listeners.
+     *
+     * @param {string} type the event name
+     */
+    ;
+
+    _proto.trigger = function trigger(type) {
+      var callbacks = this.listeners[type];
+
+      if (!callbacks) {
+        return;
+      } // Slicing the arguments on every invocation of this method
+      // can add a significant amount of overhead. Avoid the
+      // intermediate object creation for the common case of a
+      // single callback argument
+
+
+      if (arguments.length === 2) {
+        var length = callbacks.length;
+
+        for (var i = 0; i < length; ++i) {
+          callbacks[i].call(this, arguments[1]);
+        }
+      } else {
+        var args = Array.prototype.slice.call(arguments, 1);
+        var _length = callbacks.length;
+
+        for (var _i = 0; _i < _length; ++_i) {
+          callbacks[_i].apply(this, args);
+        }
+      }
+    }
+    /**
+     * Destroys the stream and cleans up.
+     */
+    ;
+
+    _proto.dispose = function dispose() {
+      this.listeners = {};
+    }
+    /**
+     * Forwards all `data` events on this stream to the destination stream. The
+     * destination stream should provide a method `push` to receive the data
+     * events as they arrive.
+     *
+     * @param {Stream} destination the stream that will receive all `data` events
+     * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
+     */
+    ;
+
+    _proto.pipe = function pipe(destination) {
+      this.on('data', function (data) {
+        destination.push(data);
+      });
+    };
+
+    return Stream;
+  }();
+
+  /**
+   * A stream that buffers string input and generates a `data` event for each
+   * line.
+   *
+   * @class LineStream
+   * @extends Stream
+   */
+
+  var LineStream = /*#__PURE__*/function (_Stream) {
+    inheritsLoose(LineStream, _Stream);
+
+    function LineStream() {
+      var _this;
+
+      _this = _Stream.call(this) || this;
+      _this.buffer = '';
+      return _this;
+    }
+    /**
+     * Add new data to be parsed.
+     *
+     * @param {string} data the text to process
+     */
+
+
+    var _proto = LineStream.prototype;
+
+    _proto.push = function push(data) {
+      var nextNewline;
+      this.buffer += data;
+      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];
+
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+
+        return target;
+      };
+
+      return _extends.apply(this, arguments);
+    }
+
+    module.exports = _extends;
+  });
+
+  var TAB = String.fromCharCode(0x09);
+
+  var parseByterange = function parseByterange(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 = {};
+
+    if (match[1]) {
+      result.length = parseInt(match[1], 10);
+    }
+
+    if (match[2]) {
+      result.offset = parseInt(match[2], 10);
+    }
+
+    return result;
+  };
+  /**
+   * "forgiving" attribute list psuedo-grammar:
+   * attributes -> keyvalue (',' keyvalue)*
+   * keyvalue   -> key '=' value
+   * key        -> [^=]*
+   * value      -> '"' [^"]* '"' | [^,]*
+   */
+
+
+  var attributeSeparator = function attributeSeparator() {
+    var key = '[^=]*';
+    var value = '"[^"]*"|[^,]*';
+    var keyvalue = '(?:' + key + ')=(?:' + value + ')';
+    return new RegExp('(?:^|,)(' + keyvalue + ')');
+  };
+  /**
+   * Parse attributes from a line given the separator
+   *
+   * @param {string} attributes the attribute line to parse
+   */
+
+
+  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;
+
+    while (i--) {
+      // filter out unmatched portions of the string
+      if (attrs[i] === '') {
+        continue;
+      } // split the key and value
+
+
+      attr = /([^=]*)=(.*)/.exec(attrs[i]).slice(1); // trim whitespace and remove optional quotes around the value
+
+      attr[0] = attr[0].replace(/^\s+|\s+$/g, '');
+      attr[1] = attr[1].replace(/^\s+|\s+$/g, '');
+      attr[1] = attr[1].replace(/^['"](.*)['"]$/g, '$1');
+      result[attr[0]] = attr[1];
+    }
+
+    return result;
+  };
+  /**
+   * A line-level M3U8 parser event stream. It expects to receive input one
+   * line at a time and performs a context-free parse of its contents. A stream
+   * interpretation of a manifest can be useful if the manifest is expected to
+   * be too large to fit comfortably into memory or the entirety of the input
+   * is not immediately available. Otherwise, it's probably much easier to work
+   * with a regular `Parser` object.
+   *
+   * Produces `data` events with an object that captures the parser's
+   * interpretation of the input. That object has a property `tag` that is one
+   * of `uri`, `comment`, or `tag`. URIs only have a single additional
+   * property, `line`, which captures the entirety of the input without
+   * interpretation. Comments similarly have a single additional property
+   * `text` which is the input without the leading `#`.
+   *
+   * Tags always have a property `tagType` which is the lower-cased version of
+   * the M3U8 directive without the `#EXT` or `#EXT-X-` prefix. For instance,
+   * `#EXT-X-MEDIA-SEQUENCE` becomes `media-sequence` when parsed. Unrecognized
+   * tags are given the tag type `unknown` and a single additional property
+   * `data` with the remainder of the input.
+   *
+   * @class ParseStream
+   * @extends Stream
+   */
+
+
+  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;
+    }
+    /**
+     * Parses an additional line of input.
+     *
+     * @param {string} line a single line of an M3U8 file to parse
+     */
+
+
+    var _proto = ParseStream.prototype;
+
+    _proto.push = function push(line) {
+      var _this2 = this;
+
+      var match;
+      var event;
+      this.lineNumber = this.lineNumber + 1; // strip whitespace
+
+      line = line.trim();
+
+      if (line.length === 0) {
+        // ignore empty lines
+        return;
+      } // URIs
+
+
+      if (line[0] !== '#') {
+        this.trigger('data', {
+          type: 'uri',
+          uri: line
+        });
+        return;
+      } // map tags
+
+
+      var newLines = this.tagMappers.reduce(function (acc, mapper) {
+        var mappedLine = mapper(line); // skip if unchanged
+
+        if (mappedLine === line) {
+          return acc;
+        }
+
+        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)) {
+            return;
+          }
+        } // Comments
+
+
+        if (newLine.indexOf('#EXT') !== 0) {
+          _this2.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.
+
+
+        newLine = newLine.replace('\r', ''); // Tags
+
+        match = /^#EXTM3U/.exec(newLine);
+
+        if (match) {
+          _this2.trigger('data', {
+            type: 'tag',
+            tagType: 'm3u'
+          });
+
+          return;
+        }
+
+        match = /^#EXTINF:?([0-9\.]*)?,?(.*)?$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'inf'
+          };
+
+          if (match[1]) {
+            event.duration = parseFloat(match[1]);
+          }
+
+          if (match[2]) {
+            event.title = match[2];
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-TARGETDURATION:?([0-9.]*)?/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'targetduration'
+          };
+
+          if (match[1]) {
+            event.duration = parseInt(match[1], 10);
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-VERSION:?([0-9.]*)?/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'version'
+          };
+
+          if (match[1]) {
+            event.version = parseInt(match[1], 10);
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-MEDIA-SEQUENCE:?(\-?[0-9.]*)?/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'media-sequence'
+          };
+
+          if (match[1]) {
+            event.number = parseInt(match[1], 10);
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-DISCONTINUITY-SEQUENCE:?(\-?[0-9.]*)?/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'discontinuity-sequence'
+          };
+
+          if (match[1]) {
+            event.number = parseInt(match[1], 10);
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-PLAYLIST-TYPE:?(.*)?$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'playlist-type'
+          };
+
+          if (match[1]) {
+            event.playlistType = match[1];
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-BYTERANGE:?(.*)?$/.exec(newLine);
+
+        if (match) {
+          event = _extends_1(parseByterange(match[1]), {
+            type: 'tag',
+            tagType: 'byterange'
+          });
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-ALLOW-CACHE:?(YES|NO)?/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'allow-cache'
+          };
+
+          if (match[1]) {
+            event.allowed = !/NO/.test(match[1]);
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-MAP:?(.*)$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'map'
+          };
+
+          if (match[1]) {
+            var attributes = parseAttributes(match[1]);
+
+            if (attributes.URI) {
+              event.uri = attributes.URI;
+            }
+
+            if (attributes.BYTERANGE) {
+              event.byterange = parseByterange(attributes.BYTERANGE);
+            }
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-STREAM-INF:?(.*)$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'stream-inf'
+          };
+
+          if (match[1]) {
+            event.attributes = parseAttributes(match[1]);
+
+            if (event.attributes.RESOLUTION) {
+              var split = event.attributes.RESOLUTION.split('x');
+              var resolution = {};
+
+              if (split[0]) {
+                resolution.width = parseInt(split[0], 10);
+              }
+
+              if (split[1]) {
+                resolution.height = parseInt(split[1], 10);
+              }
+
+              event.attributes.RESOLUTION = resolution;
+            }
+
+            if (event.attributes.BANDWIDTH) {
+              event.attributes.BANDWIDTH = parseInt(event.attributes.BANDWIDTH, 10);
+            }
+
+            if (event.attributes['PROGRAM-ID']) {
+              event.attributes['PROGRAM-ID'] = parseInt(event.attributes['PROGRAM-ID'], 10);
+            }
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-MEDIA:?(.*)$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'media'
+          };
+
+          if (match[1]) {
+            event.attributes = parseAttributes(match[1]);
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-ENDLIST/.exec(newLine);
+
+        if (match) {
+          _this2.trigger('data', {
+            type: 'tag',
+            tagType: 'endlist'
+          });
+
+          return;
+        }
+
+        match = /^#EXT-X-DISCONTINUITY/.exec(newLine);
+
+        if (match) {
+          _this2.trigger('data', {
+            type: 'tag',
+            tagType: 'discontinuity'
+          });
+
+          return;
+        }
+
+        match = /^#EXT-X-PROGRAM-DATE-TIME:?(.*)$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'program-date-time'
+          };
+
+          if (match[1]) {
+            event.dateTimeString = match[1];
+            event.dateTimeObject = new Date(match[1]);
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-KEY:?(.*)$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'key'
+          };
+
+          if (match[1]) {
+            event.attributes = parseAttributes(match[1]); // parse the IV string into a Uint32Array
+
+            if (event.attributes.IV) {
+              if (event.attributes.IV.substring(0, 2).toLowerCase() === '0x') {
+                event.attributes.IV = event.attributes.IV.substring(2);
+              }
+
+              event.attributes.IV = event.attributes.IV.match(/.{8}/g);
+              event.attributes.IV[0] = parseInt(event.attributes.IV[0], 16);
+              event.attributes.IV[1] = parseInt(event.attributes.IV[1], 16);
+              event.attributes.IV[2] = parseInt(event.attributes.IV[2], 16);
+              event.attributes.IV[3] = parseInt(event.attributes.IV[3], 16);
+              event.attributes.IV = new Uint32Array(event.attributes.IV);
+            }
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-START:?(.*)$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'start'
+          };
+
+          if (match[1]) {
+            event.attributes = parseAttributes(match[1]);
+            event.attributes['TIME-OFFSET'] = parseFloat(event.attributes['TIME-OFFSET']);
+            event.attributes.PRECISE = /YES/.test(event.attributes.PRECISE);
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-CUE-OUT-CONT:?(.*)?$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'cue-out-cont'
+          };
+
+          if (match[1]) {
+            event.data = match[1];
+          } else {
+            event.data = '';
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-CUE-OUT:?(.*)?$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'cue-out'
+          };
+
+          if (match[1]) {
+            event.data = match[1];
+          } else {
+            event.data = '';
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-CUE-IN:?(.*)?$/.exec(newLine);
+
+        if (match) {
+          event = {
+            type: 'tag',
+            tagType: 'cue-in'
+          };
+
+          if (match[1]) {
+            event.data = match[1];
+          } else {
+            event.data = '';
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-SKIP:(.*)$/.exec(newLine);
+
+        if (match && match[1]) {
+          event = {
+            type: 'tag',
+            tagType: 'skip'
+          };
+          event.attributes = parseAttributes(match[1]);
+
+          if (event.attributes.hasOwnProperty('SKIPPED-SEGMENTS')) {
+            event.attributes['SKIPPED-SEGMENTS'] = parseInt(event.attributes['SKIPPED-SEGMENTS'], 10);
+          }
+
+          if (event.attributes.hasOwnProperty('RECENTLY-REMOVED-DATERANGES')) {
+            event.attributes['RECENTLY-REMOVED-DATERANGES'] = event.attributes['RECENTLY-REMOVED-DATERANGES'].split(TAB);
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-PART:(.*)$/.exec(newLine);
+
+        if (match && match[1]) {
+          event = {
+            type: 'tag',
+            tagType: 'part'
+          };
+          event.attributes = parseAttributes(match[1]);
+          ['DURATION'].forEach(function (key) {
+            if (event.attributes.hasOwnProperty(key)) {
+              event.attributes[key] = parseFloat(event.attributes[key]);
+            }
+          });
+          ['INDEPENDENT', 'GAP'].forEach(function (key) {
+            if (event.attributes.hasOwnProperty(key)) {
+              event.attributes[key] = /YES/.test(event.attributes[key]);
+            }
+          });
+
+          if (event.attributes.hasOwnProperty('BYTERANGE')) {
+            event.attributes.byterange = parseByterange(event.attributes.BYTERANGE);
+          }
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-SERVER-CONTROL:(.*)$/.exec(newLine);
+
+        if (match && match[1]) {
+          event = {
+            type: 'tag',
+            tagType: 'server-control'
+          };
+          event.attributes = parseAttributes(match[1]);
+          ['CAN-SKIP-UNTIL', 'PART-HOLD-BACK', 'HOLD-BACK'].forEach(function (key) {
+            if (event.attributes.hasOwnProperty(key)) {
+              event.attributes[key] = parseFloat(event.attributes[key]);
+            }
+          });
+          ['CAN-SKIP-DATERANGES', 'CAN-BLOCK-RELOAD'].forEach(function (key) {
+            if (event.attributes.hasOwnProperty(key)) {
+              event.attributes[key] = /YES/.test(event.attributes[key]);
+            }
+          });
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-PART-INF:(.*)$/.exec(newLine);
+
+        if (match && match[1]) {
+          event = {
+            type: 'tag',
+            tagType: 'part-inf'
+          };
+          event.attributes = parseAttributes(match[1]);
+          ['PART-TARGET'].forEach(function (key) {
+            if (event.attributes.hasOwnProperty(key)) {
+              event.attributes[key] = parseFloat(event.attributes[key]);
+            }
+          });
+
+          _this2.trigger('data', event);
+
+          return;
+        }
+
+        match = /^#EXT-X-PRELOAD-HINT:(.*)$/.exec(newLine);
+
+        if (match && match[1]) {
+          event = {
+            type: 'tag',
+            tagType: 'preload-hint'
+          };
+          event.attributes = parseAttributes(match[1]);
+          ['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';
+              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);
+
+          return;
+        }
+
+        match = /^#EXT-X-RENDITION-REPORT:(.*)$/.exec(newLine);
+
+        if (match && match[1]) {
+          event = {
+            type: 'tag',
+            tagType: 'rendition-report'
+          };
+          event.attributes = parseAttributes(match[1]);
+          ['LAST-MSN', 'LAST-PART'].forEach(function (key) {
+            if (event.attributes.hasOwnProperty(key)) {
+              event.attributes[key] = parseInt(event.attributes[key], 10);
+            }
+          });
+
+          _this2.trigger('data', event);
+
+          return;
+        } // unknown tag type
+
+
+        _this2.trigger('data', {
+          type: 'tag',
+          data: newLine.slice(4)
+        });
+      });
+    }
+    /**
+     * Add a parser for custom headers
+     *
+     * @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.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(_ref) {
+      var _this3 = this;
+
+      var expression = _ref.expression,
+          customType = _ref.customType,
+          dataParser = _ref.dataParser,
+          segment = _ref.segment;
+
+      if (typeof dataParser !== 'function') {
+        dataParser = function dataParser(line) {
+          return line;
+        };
+      }
+
+      this.customParsers.push(function (line) {
+        var match = expression.exec(line);
+
+        if (match) {
+          _this3.trigger('data', {
+            type: 'custom',
+            data: dataParser(line),
+            customType: customType,
+            segment: segment
+          });
+
+          return true;
+        }
+      });
+    }
+    /**
+     * Add a custom header mapper
+     *
+     * @param {Object}   options
+     * @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) {
+        if (expression.test(line)) {
+          return map(line);
+        }
+
+        return line;
+      };
+
+      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');
+  };
+
+  function decodeB64ToUint8Array(b64Text) {
+    var decodedString = atob(b64Text);
+    var array = new Uint8Array(decodedString.length);
+
+    for (var i = 0; i < decodedString.length; i++) {
+      array[i] = decodedString.charCodeAt(i);
+    }
+
+    return array;
+  }
+
+  var camelCase = function camelCase(str) {
+    return str.toLowerCase().replace(/-(\w)/g, function (a) {
+      return a[1].toUpperCase();
+    });
+  };
+
+  var camelCaseKeys = function camelCaseKeys(attributes) {
+    var result = {};
+    Object.keys(attributes).forEach(function (key) {
+      result[camelCase(key)] = attributes[key];
+    });
+    return result;
+  }; // set SERVER-CONTROL hold back based upon targetDuration and partTargetDuration
+  // we need this helper because defaults are based upon targetDuration and
+  // partTargetDuration being set, but they may not be if SERVER-CONTROL appears before
+  // target durations are set.
+
+
+  var setHoldBack = function setHoldBack(manifest) {
+    var serverControl = manifest.serverControl,
+        targetDuration = manifest.targetDuration,
+        partTargetDuration = manifest.partTargetDuration;
+
+    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;
+
+    if (targetDuration && !serverControl.hasOwnProperty(hb)) {
+      serverControl[hb] = minTargetDuration;
+      this.trigger('info', {
+        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 + ")"
+      });
+      serverControl[hb] = minTargetDuration;
+    } // default no part hold back to part target duration * 3
+
+
+    if (partTargetDuration && !serverControl.hasOwnProperty(phb)) {
+      serverControl[phb] = partTargetDuration * 3;
+      this.trigger('info', {
+        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 + ")."
+      });
+      serverControl[phb] = minPartDuration;
+    }
+  };
+  /**
+   * A parser for M3U8 files. The current interpretation of the input is
+   * exposed as a property `manifest` on parser objects. It's just two lines to
+   * create and parse a manifest once you have the contents available as a string:
+   *
+   * ```js
+   * var parser = new m3u8.Parser();
+   * parser.push(xhr.responseText);
+   * ```
+   *
+   * New input can later be applied to update the manifest object by calling
+   * `push` again.
+   *
+   * The parser attempts to create a usable manifest object even if the
+   * underlying input is somewhat nonsensical. It emits `info` and `warning`
+   * events during the parse if it encounters input that seems invalid or
+   * requires some property of the manifest object to be defaulted.
+   *
+   * @class Parser
+   * @extends Stream
+   */
+
+
+  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);
+      /* eslint-disable consistent-this */
+
+
+      var self = assertThisInitialized(_this);
+      /* eslint-enable consistent-this */
+
+
+      var uris = [];
+      var currentUri = {}; // if specified, the active EXT-X-MAP definition
+
+      var currentMap; // if specified, the active decryption key
+
+      var _key;
+
+      var hasParts = false;
+
+      var noop = function noop() {};
+
+      var defaultMediaGroups = {
+        'AUDIO': {},
+        'VIDEO': {},
+        'CLOSED-CAPTIONS': {},
+        'SUBTITLES': {}
+      }; // 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
+
+      var currentTimeline = 0; // the manifest is empty until the parse stream begins delivering data
+
+      _this.manifest = {
+        allowCache: true,
+        discontinuityStarts: [],
+        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
+
+      var nextSegmentLineNumberStart = 0;
+
+      _this.on('end', function () {
+        // 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) {
+          return;
+        }
+
+        if (!currentUri.map && currentMap) {
+          currentUri.map = currentMap;
+        }
+
+        if (!currentUri.key && _key) {
+          currentUri.key = _key;
+        }
+
+        if (!currentUri.timeline && typeof currentTimeline === 'number') {
+          currentUri.timeline = currentTimeline;
+        }
+
+        _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
+
+        if (!Object.keys(currentUri).length) {
+          nextSegmentLineNumberStart = this.lineNumber;
+        }
+
+        ({
+          tag: function tag() {
+            // switch based on the tag type
+            (({
+              version: function version() {
+                if (entry.version) {
+                  this.manifest.version = entry.version;
+                }
+              },
+              'allow-cache': function allowCache() {
+                this.manifest.allowCache = entry.allowed;
+
+                if (!('allowed' in entry)) {
+                  this.trigger('info', {
+                    message: 'defaulting allowCache to YES'
+                  });
+                  this.manifest.allowCache = true;
+                }
+              },
+              byterange: function byterange() {
+                var byterange = {};
+
+                if ('length' in entry) {
+                  currentUri.byterange = byterange;
+                  byterange.length = entry.length;
+
+                  if (!('offset' in entry)) {
+                    /*
+                     * From the latest spec (as of this writing):
+                     * https://tools.ietf.org/html/draft-pantos-http-live-streaming-23#section-4.3.2.2
+                     *
+                     * Same text since EXT-X-BYTERANGE's introduction in draft 7:
+                     * https://tools.ietf.org/html/draft-pantos-http-live-streaming-07#section-3.3.1)
+                     *
+                     * "If o [offset] is not present, the sub-range begins at the next byte
+                     * following the sub-range of the previous media segment."
+                     */
+                    entry.offset = lastByterangeEnd;
+                  }
+                }
+
+                if ('offset' in entry) {
+                  currentUri.byterange = byterange;
+                  byterange.offset = entry.offset;
+                }
+
+                lastByterangeEnd = byterange.offset + byterange.length;
+              },
+              endlist: function endlist() {
+                this.manifest.endList = true;
+              },
+              inf: function inf() {
+                if (!('mediaSequence' in this.manifest)) {
+                  this.manifest.mediaSequence = 0;
+                  this.trigger('info', {
+                    message: 'defaulting media sequence to zero'
+                  });
+                }
+
+                if (!('discontinuitySequence' in this.manifest)) {
+                  this.manifest.discontinuitySequence = 0;
+                  this.trigger('info', {
+                    message: 'defaulting discontinuity sequence to zero'
+                  });
+                }
+
+                if (entry.duration > 0) {
+                  currentUri.duration = entry.duration;
+                }
+
+                if (entry.duration === 0) {
+                  currentUri.duration = 0.01;
+                  this.trigger('info', {
+                    message: 'updating zero segment duration to a small value'
+                  });
+                }
+
+                this.manifest.segments = uris;
+              },
+              key: function key() {
+                if (!entry.attributes) {
+                  this.trigger('warn', {
+                    message: 'ignoring key declaration without attribute list'
+                  });
+                  return;
+                } // clear the active encryption key
+
+
+                if (entry.attributes.METHOD === 'NONE') {
+                  _key = null;
+                  return;
+                }
+
+                if (!entry.attributes.URI) {
+                  this.trigger('warn', {
+                    message: 'ignoring key declaration without URI'
+                  });
+                  return;
+                }
+
+                if (entry.attributes.KEYFORMAT === 'com.apple.streamingkeydelivery') {
+                  this.manifest.contentProtection = this.manifest.contentProtection || {}; // TODO: add full support for this.
+
+                  this.manifest.contentProtection['com.apple.fps.1_0'] = {
+                    attributes: entry.attributes
+                  };
+                  return;
+                }
+
+                if (entry.attributes.KEYFORMAT === 'com.microsoft.playready') {
+                  this.manifest.contentProtection = this.manifest.contentProtection || {}; // TODO: add full support for this.
+
+                  this.manifest.contentProtection['com.microsoft.playready'] = {
+                    uri: entry.attributes.URI
+                  };
+                  return;
+                } // check if the content is encrypted for Widevine
+                // Widevine/HLS spec: https://storage.googleapis.com/wvdocs/Widevine_DRM_HLS.pdf
+
+
+                if (entry.attributes.KEYFORMAT === widevineUuid) {
+                  var VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR', 'SAMPLE-AES-CENC'];
+
+                  if (VALID_METHODS.indexOf(entry.attributes.METHOD) === -1) {
+                    this.trigger('warn', {
+                      message: 'invalid key method provided for Widevine'
+                    });
+                    return;
+                  }
+
+                  if (entry.attributes.METHOD === 'SAMPLE-AES-CENC') {
+                    this.trigger('warn', {
+                      message: 'SAMPLE-AES-CENC is deprecated, please use SAMPLE-AES-CTR instead'
+                    });
+                  }
+
+                  if (entry.attributes.URI.substring(0, 23) !== 'data:text/plain;base64,') {
+                    this.trigger('warn', {
+                      message: 'invalid key URI provided for Widevine'
+                    });
+                    return;
+                  }
+
+                  if (!(entry.attributes.KEYID && entry.attributes.KEYID.substring(0, 2) === '0x')) {
+                    this.trigger('warn', {
+                      message: 'invalid key ID provided for Widevine'
+                    });
+                    return;
+                  } // if Widevine key attributes are valid, store them as `contentProtection`
+                  // on the manifest to emulate Widevine tag structure in a DASH mpd
+
+
+                  this.manifest.contentProtection = this.manifest.contentProtection || {};
+                  this.manifest.contentProtection['com.widevine.alpha'] = {
+                    attributes: {
+                      schemeIdUri: entry.attributes.KEYFORMAT,
+                      // remove '0x' from the key id string
+                      keyId: entry.attributes.KEYID.substring(2)
+                    },
+                    // decode the base64-encoded PSSH box
+                    pssh: decodeB64ToUint8Array(entry.attributes.URI.split(',')[1])
+                  };
+                  return;
+                }
+
+                if (!entry.attributes.METHOD) {
+                  this.trigger('warn', {
+                    message: 'defaulting key method to AES-128'
+                  });
+                } // setup an encryption key for upcoming segments
+
+
+                _key = {
+                  method: entry.attributes.METHOD || 'AES-128',
+                  uri: entry.attributes.URI
+                };
+
+                if (typeof entry.attributes.IV !== 'undefined') {
+                  _key.iv = entry.attributes.IV;
+                }
+              },
+              'media-sequence': function mediaSequence() {
+                if (!isFinite(entry.number)) {
+                  this.trigger('warn', {
+                    message: 'ignoring invalid media sequence: ' + entry.number
+                  });
+                  return;
+                }
+
+                this.manifest.mediaSequence = entry.number;
+              },
+              'discontinuity-sequence': function discontinuitySequence() {
+                if (!isFinite(entry.number)) {
+                  this.trigger('warn', {
+                    message: 'ignoring invalid discontinuity sequence: ' + entry.number
+                  });
+                  return;
+                }
+
+                this.manifest.discontinuitySequence = entry.number;
+                currentTimeline = entry.number;
+              },
+              'playlist-type': function playlistType() {
+                if (!/VOD|EVENT/.test(entry.playlistType)) {
+                  this.trigger('warn', {
+                    message: 'ignoring unknown playlist type: ' + entry.playlist
+                  });
+                  return;
+                }
+
+                this.manifest.playlistType = entry.playlistType;
+              },
+              map: function map() {
+                currentMap = {};
+
+                if (entry.uri) {
+                  currentMap.uri = entry.uri;
+                }
+
+                if (entry.byterange) {
+                  currentMap.byterange = entry.byterange;
+                }
+
+                if (_key) {
+                  currentMap.key = _key;
+                }
+              },
+              'stream-inf': function streamInf() {
+                this.manifest.playlists = uris;
+                this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
+
+                if (!entry.attributes) {
+                  this.trigger('warn', {
+                    message: 'ignoring empty stream-inf attributes'
+                  });
+                  return;
+                }
+
+                if (!currentUri.attributes) {
+                  currentUri.attributes = {};
+                }
+
+                _extends_1(currentUri.attributes, entry.attributes);
+              },
+              media: function media() {
+                this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
+
+                if (!(entry.attributes && entry.attributes.TYPE && entry.attributes['GROUP-ID'] && entry.attributes.NAME)) {
+                  this.trigger('warn', {
+                    message: 'ignoring incomplete or missing media group'
+                  });
+                  return;
+                } // find the media group, creating defaults as necessary
+
+
+                var 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
+
+                rendition = {
+                  default: /yes/i.test(entry.attributes.DEFAULT)
+                };
+
+                if (rendition.default) {
+                  rendition.autoselect = true;
+                } else {
+                  rendition.autoselect = /yes/i.test(entry.attributes.AUTOSELECT);
+                }
+
+                if (entry.attributes.LANGUAGE) {
+                  rendition.language = entry.attributes.LANGUAGE;
+                }
+
+                if (entry.attributes.URI) {
+                  rendition.uri = entry.attributes.URI;
+                }
+
+                if (entry.attributes['INSTREAM-ID']) {
+                  rendition.instreamId = entry.attributes['INSTREAM-ID'];
+                }
+
+                if (entry.attributes.CHARACTERISTICS) {
+                  rendition.characteristics = entry.attributes.CHARACTERISTICS;
+                }
+
+                if (entry.attributes.FORCED) {
+                  rendition.forced = /yes/i.test(entry.attributes.FORCED);
+                } // insert the new rendition
+
+
+                mediaGroup[entry.attributes.NAME] = rendition;
+              },
+              discontinuity: function discontinuity() {
+                currentTimeline += 1;
+                currentUri.discontinuity = true;
+                this.manifest.discontinuityStarts.push(uris.length);
+              },
+              'program-date-time': function programDateTime() {
+                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
+                  // to the manifest object
+                  // TODO: Consider removing this in future major version
+                  this.manifest.dateTimeString = entry.dateTimeString;
+                  this.manifest.dateTimeObject = entry.dateTimeObject;
+                }
+
+                currentUri.dateTimeString = entry.dateTimeString;
+                currentUri.dateTimeObject = entry.dateTimeObject;
+              },
+              targetduration: function targetduration() {
+                if (!isFinite(entry.duration) || entry.duration < 0) {
+                  this.trigger('warn', {
+                    message: 'ignoring invalid target duration: ' + entry.duration
+                  });
+                  return;
+                }
+
+                this.manifest.targetDuration = entry.duration;
+                setHoldBack.call(this, this.manifest);
+              },
+              start: function start() {
+                if (!entry.attributes || isNaN(entry.attributes['TIME-OFFSET'])) {
+                  this.trigger('warn', {
+                    message: 'ignoring start declaration without appropriate attribute list'
+                  });
+                  return;
+                }
+
+                this.manifest.start = {
+                  timeOffset: entry.attributes['TIME-OFFSET'],
+                  precise: entry.attributes.PRECISE
+                };
+              },
+              'cue-out': function cueOut() {
+                currentUri.cueOut = entry.data;
+              },
+              'cue-out-cont': function cueOutCont() {
+                currentUri.cueOutCont = entry.data;
+              },
+              'cue-in': function cueIn() {
+                currentUri.cueIn = entry.data;
+              },
+              'skip': function skip() {
+                this.manifest.skip = camelCaseKeys(entry.attributes);
+                this.warnOnMissingAttributes_('#EXT-X-SKIP', entry.attributes, ['SKIPPED-SEGMENTS']);
+              },
+              'part': function part() {
+                var _this2 = this;
+
+                hasParts = true; // parts are always specifed before a segment
+
+                var segmentIndex = this.manifest.segments.length;
+                var part = camelCaseKeys(entry.attributes);
+                currentUri.parts = currentUri.parts || [];
+                currentUri.parts.push(part);
+
+                if (part.byterange) {
+                  if (!part.byterange.hasOwnProperty('offset')) {
+                    part.byterange.offset = lastPartByterangeEnd;
+                  }
+
+                  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']);
+
+                if (this.manifest.renditionReports) {
+                  this.manifest.renditionReports.forEach(function (r, i) {
+                    if (!r.hasOwnProperty('lastPart')) {
+                      _this2.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);
+
+                if (!attrs.hasOwnProperty('canBlockReload')) {
+                  attrs.canBlockReload = false;
+                  this.trigger('info', {
+                    message: '#EXT-X-SERVER-CONTROL defaulting CAN-BLOCK-RELOAD to false'
+                  });
+                }
+
+                setHoldBack.call(this, this.manifest);
+
+                if (attrs.canSkipDateranges && !attrs.hasOwnProperty('canSkipUntil')) {
+                  this.trigger('warn', {
+                    message: '#EXT-X-SERVER-CONTROL lacks required attribute CAN-SKIP-UNTIL which is required when CAN-SKIP-DATERANGES is set'
+                  });
+                }
+              },
+              'preload-hint': function preloadHint() {
+                // 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';
+                currentUri.preloadHints = currentUri.preloadHints || [];
+                currentUri.preloadHints.push(hint);
+
+                if (hint.byterange) {
+                  if (!hint.byterange.hasOwnProperty('offset')) {
+                    // use last part byterange end or zero if not a part.
+                    hint.byterange.offset = isPart ? lastPartByterangeEnd : 0;
+
+                    if (isPart) {
+                      lastPartByterangeEnd = hint.byterange.offset + hint.byterange.length;
+                    }
+                  }
+                }
+
+                var index = currentUri.preloadHints.length - 1;
+                this.warnOnMissingAttributes_("#EXT-X-PRELOAD-HINT #" + index + " for segment #" + segmentIndex, entry.attributes, ['TYPE', 'URI']);
+
+                if (!hint.type) {
+                  return;
+                } // search through all preload hints except for the current one for
+                // a duplicate type.
+
+
+                for (var i = 0; i < currentUri.preloadHints.length - 1; i++) {
+                  var otherHint = currentUri.preloadHints[i];
+
+                  if (!otherHint.type) {
+                    continue;
+                  }
+
+                  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
+                    });
+                  }
+                }
+              },
+              'rendition-report': function renditionReport() {
+                var 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'];
+
+                if (hasParts) {
+                  required.push('LAST-PART');
+                }
+
+                this.warnOnMissingAttributes_("#EXT-X-RENDITION-REPORT #" + index, entry.attributes, required);
+              },
+              'part-inf': function partInf() {
+                this.manifest.partInf = camelCaseKeys(entry.attributes);
+                this.warnOnMissingAttributes_('#EXT-X-PART-INF', entry.attributes, ['PART-TARGET']);
+
+                if (this.manifest.partInf.partTarget) {
+                  this.manifest.partTargetDuration = this.manifest.partInf.partTarget;
+                }
+
+                setHoldBack.call(this, this.manifest);
+              }
+            })[entry.tagType] || noop).call(self);
+          },
+          uri: function uri() {
+            currentUri.uri = entry.uri;
+            currentUri.lineNumberStart = nextSegmentLineNumberStart;
+            currentUri.lineNumberEnd = this.parseStream.lineNumber;
+            uris.push(currentUri); // if no explicit duration was declared, use the target duration
+
+            if (this.manifest.targetDuration && !('duration' in currentUri)) {
+              this.trigger('warn', {
+                message: 'defaulting segment duration to the target duration'
+              });
+              currentUri.duration = this.manifest.targetDuration;
+            } // annotate with encryption information, if necessary
+
+
+            if (_key) {
+              currentUri.key = _key;
+            }
+
+            currentUri.timeline = currentTimeline; // annotate with initialization segment information, if necessary
+
+            if (currentMap) {
+              currentUri.map = currentMap;
+            } // reset the last byterange end as it needs to be 0 between parts
+
+
+            lastPartByterangeEnd = 0; // prepare for the next URI
+
+            currentUri = {};
+          },
+          comment: function comment() {// comments are not important for playback
+          },
+          custom: function custom() {
+            // if this is segment-level data attach the output to the segment
+            if (entry.segment) {
+              currentUri.custom = currentUri.custom || {};
+              currentUri.custom[entry.customType] = entry.data; // if this is manifest-level data attach to the top level manifest object
+            } else {
+              this.manifest.custom = this.manifest.custom || {};
+              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 = [];
+      required.forEach(function (key) {
+        if (!attributes.hasOwnProperty(key)) {
+          missing.push(key);
+        }
+      });
+
+      if (missing.length) {
+        this.trigger('warn', {
+          message: identifier + " lacks required attribute(s): " + missing.join(', ')
+        });
+      }
+    }
+    /**
+     * Parse the input string and update the manifest object.
+     *
+     * @param {string} chunk a potentially incomplete portion of the manifest
+     */
+    ;
+
+    _proto.push = function push(chunk) {
+      this.lineStream.push(chunk);
+    }
+    /**
+     * Flush any remaining input. This can be handy if the last line of an M3U8
+     * manifest did not contain a trailing newline but the file has been
+     * completely received.
+     */
+    ;
+
+    _proto.end = function end() {
+      // flush any buffered input
+      this.lineStream.push('\n');
+      this.trigger('end');
+    }
+    /**
+     * Add an additional parser for non-standard tags
+     *
+     * @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 {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) {
+      this.parseStream.addParser(options);
+    }
+    /**
+     * Add a custom header mapper
+     *
+     * @param {Object}   options
+     * @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) {
+      this.parseStream.addTagMapper(options);
+    };
+
+    return Parser;
+  }(Stream);
+
+  exports.LineStream = LineStream;
+  exports.ParseStream = ParseStream;
+  exports.Parser = Parser;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+})));