First release

node_modules/m3u8-parser/src/index.js

@@ -0,0 +1,19 @@
+/**
+ * @file m3u8/index.js
+ *
+ * Utilities for parsing M3U8 files. If the entire manifest is available,
+ * `Parser` will create an object representation with enough detail for managing
+ * playback. `ParseStream` and `LineStream` are lower-level parsing primitives
+ * that do not assume the entirety of the manifest is ready and expose a
+ * ReadableStream-like interface.
+ */
+
+import LineStream from './line-stream';
+import ParseStream from './parse-stream';
+import Parser from './parser';
+
+export {
+  LineStream,
+  ParseStream,
+  Parser
+};

node_modules/m3u8-parser/src/line-stream.js

@@ -0,0 +1,35 @@
+/**
+ * @file m3u8/line-stream.js
+ */
+import Stream from '@videojs/vhs-utils/es/stream.js';
+
+/**
+ * A stream that buffers string input and generates a `data` event for each
+ * line.
+ *
+ * @class LineStream
+ * @extends Stream
+ */
+export default class LineStream extends Stream {
+  constructor() {
+    super();
+    this.buffer = '';
+  }
+
+  /**
+   * Add new data to be parsed.
+   *
+   * @param {string} data the text to process
+   */
+  push(data) {
+    let 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);
+    }
+  }
+}

node_modules/m3u8-parser/src/parse-stream.js

@@ -0,0 +1,617 @@
+/**
+ * @file m3u8/parse-stream.js
+ */
+import Stream from '@videojs/vhs-utils/es/stream.js';
+
+const TAB = String.fromCharCode(0x09);
+
+const parseByterange = function(byterangeString) {
+  // optionally match and capture 0+ digits before `@`
+  // optionally match and capture 0+ digits after `@`
+  const match = /([0-9.]*)?@?([0-9.]*)?/.exec(byterangeString || '');
+  const 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      -> '"' [^"]* '"' | [^,]*
+ */
+const attributeSeparator = function() {
+  const key = '[^=]*';
+  const value = '"[^"]*"|[^,]*';
+  const keyvalue = '(?:' + key + ')=(?:' + value + ')';
+
+  return new RegExp('(?:^|,)(' + keyvalue + ')');
+};
+
+/**
+ * Parse attributes from a line given the separator
+ *
+ * @param {string} attributes the attribute line to parse
+ */
+const parseAttributes = function(attributes) {
+  // split the string using attributes as the separator
+  const attrs = attributes.split(attributeSeparator());
+  const result = {};
+  let i = attrs.length;
+  let 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
+ */
+export default class ParseStream extends Stream {
+  constructor() {
+    super();
+    this.customParsers = [];
+    this.tagMappers = [];
+  }
+
+  /**
+   * Parses an additional line of input.
+   *
+   * @param {string} line a single line of an M3U8 file to parse
+   */
+  push(line) {
+    let match;
+    let event;
+
+    // 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
+    const newLines = this.tagMappers.reduce((acc, mapper) => {
+      const mappedLine = mapper(line);
+
+      // skip if unchanged
+      if (mappedLine === line) {
+        return acc;
+      }
+
+      return acc.concat([mappedLine]);
+    }, [line]);
+
+    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) {
+        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.
+      newLine = newLine.replace('\r', '');
+
+      // Tags
+      match = (/^#EXTM3U/).exec(newLine);
+      if (match) {
+        this.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];
+        }
+        this.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);
+        }
+        this.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);
+        }
+        this.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);
+        }
+        this.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);
+        }
+        this.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];
+        }
+        this.trigger('data', event);
+        return;
+      }
+      match = (/^#EXT-X-BYTERANGE:?(.*)?$/).exec(newLine);
+      if (match) {
+        event = Object.assign(parseByterange(match[1]), {
+          type: 'tag',
+          tagType: 'byterange'
+        });
+        this.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]);
+        }
+        this.trigger('data', event);
+        return;
+      }
+      match = (/^#EXT-X-MAP:?(.*)$/).exec(newLine);
+      if (match) {
+        event = {
+          type: 'tag',
+          tagType: 'map'
+        };
+
+        if (match[1]) {
+          const attributes = parseAttributes(match[1]);
+
+          if (attributes.URI) {
+            event.uri = attributes.URI;
+          }
+          if (attributes.BYTERANGE) {
+            event.byterange = parseByterange(attributes.BYTERANGE);
+          }
+        }
+
+        this.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) {
+            const split = event.attributes.RESOLUTION.split('x');
+            const 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);
+          }
+        }
+        this.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]);
+        }
+        this.trigger('data', event);
+        return;
+      }
+      match = (/^#EXT-X-ENDLIST/).exec(newLine);
+      if (match) {
+        this.trigger('data', {
+          type: 'tag',
+          tagType: 'endlist'
+        });
+        return;
+      }
+      match = (/^#EXT-X-DISCONTINUITY/).exec(newLine);
+      if (match) {
+        this.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]);
+        }
+        this.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);
+          }
+        }
+        this.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);
+        }
+        this.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 = '';
+        }
+        this.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 = '';
+        }
+        this.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 = '';
+        }
+        this.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);
+        }
+
+        this.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);
+        }
+
+        this.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]);
+          }
+        });
+
+        this.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]);
+          }
+        });
+
+        this.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);
+
+            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];
+          }
+        });
+
+        this.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);
+          }
+        });
+
+        this.trigger('data', event);
+        return;
+      }
+
+      // unknown tag type
+      this.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
+   */
+  addParser({expression, customType, dataParser, segment}) {
+    if (typeof dataParser !== 'function') {
+      dataParser = (line) => line;
+    }
+    this.customParsers.push(line => {
+      const match = expression.exec(line);
+
+      if (match) {
+        this.trigger('data', {
+          type: 'custom',
+          data: dataParser(line),
+          customType,
+          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
+   */
+  addTagMapper({expression, map}) {
+    const mapFn = line => {
+      if (expression.test(line)) {
+        return map(line);
+      }
+
+      return line;
+    };
+
+    this.tagMappers.push(mapFn);
+  }
+}

node_modules/m3u8-parser/src/parser.js

@@ -0,0 +1,727 @@
+/**
+ * @file m3u8/parser.js
+ */
+import Stream from '@videojs/vhs-utils/es/stream.js';
+import decodeB64ToUint8Array from '@videojs/vhs-utils/es/decode-b64-to-uint8-array.js';
+import LineStream from './line-stream';
+import ParseStream from './parse-stream';
+
+const camelCase = (str) => str
+  .toLowerCase()
+  .replace(/-(\w)/g, (a) => a[1].toUpperCase());
+
+const camelCaseKeys = function(attributes) {
+  const 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.
+const setHoldBack = function(manifest) {
+  const {serverControl, targetDuration, partTargetDuration} = manifest;
+
+  if (!serverControl) {
+    return;
+  }
+
+  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}).`
+    });
+  }
+
+  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
+ */
+export default class Parser extends Stream {
+  constructor() {
+    super();
+    this.lineStream = new LineStream();
+    this.parseStream = new ParseStream();
+    this.lineStream.pipe(this.parseStream);
+
+    /* eslint-disable consistent-this */
+    const self = this;
+    /* eslint-enable consistent-this */
+    const uris = [];
+    let currentUri = {};
+    // if specified, the active EXT-X-MAP definition
+    let currentMap;
+    // if specified, the active decryption key
+    let key;
+    let hasParts = false;
+    const noop = function() {};
+    const 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.
+    const widevineUuid = 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed';
+    // group segments into numbered timelines delineated by discontinuities
+    let 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
+    let lastByterangeEnd = 0;
+    // keep track of the last seen part's byte range end.
+    let lastPartByterangeEnd = 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)) {
+        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) {
+      let mediaGroup;
+      let rendition;
+
+      ({
+        tag() {
+          // switch based on the tag type
+          (({
+            version() {
+              if (entry.version) {
+                this.manifest.version = entry.version;
+              }
+            },
+            'allow-cache'() {
+              this.manifest.allowCache = entry.allowed;
+              if (!('allowed' in entry)) {
+                this.trigger('info', {
+                  message: 'defaulting allowCache to YES'
+                });
+                this.manifest.allowCache = true;
+              }
+            },
+            byterange() {
+              const 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() {
+              this.manifest.endList = true;
+            },
+            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() {
+              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;
+              }
+
+              // 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) {
+                const 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'() {
+              if (!isFinite(entry.number)) {
+                this.trigger('warn', {
+                  message: 'ignoring invalid media sequence: ' + entry.number
+                });
+                return;
+              }
+              this.manifest.mediaSequence = entry.number;
+            },
+            'discontinuity-sequence'() {
+              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'() {
+              if (!(/VOD|EVENT/).test(entry.playlistType)) {
+                this.trigger('warn', {
+                  message: 'ignoring unknown playlist type: ' + entry.playlist
+                });
+                return;
+              }
+              this.manifest.playlistType = entry.playlistType;
+            },
+            map() {
+              currentMap = {};
+              if (entry.uri) {
+                currentMap.uri = entry.uri;
+              }
+              if (entry.byterange) {
+                currentMap.byterange = entry.byterange;
+              }
+
+              if (key) {
+                currentMap.key = key;
+              }
+            },
+            'stream-inf'() {
+              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 = {};
+              }
+              Object.assign(currentUri.attributes, entry.attributes);
+            },
+            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
+              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
+              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() {
+              currentTimeline += 1;
+              currentUri.discontinuity = true;
+              this.manifest.discontinuityStarts.push(uris.length);
+            },
+            '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
+                // 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() {
+              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() {
+              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'() {
+              currentUri.cueOut = entry.data;
+            },
+            'cue-out-cont'() {
+              currentUri.cueOutCont = entry.data;
+            },
+            'cue-in'() {
+              currentUri.cueIn = entry.data;
+            },
+            'skip'() {
+              this.manifest.skip = camelCaseKeys(entry.attributes);
+
+              this.warnOnMissingAttributes_(
+                '#EXT-X-SKIP',
+                entry.attributes,
+                ['SKIPPED-SEGMENTS']
+              );
+            },
+            'part'() {
+              hasParts = true;
+              // parts are always specifed before a segment
+              const segmentIndex = this.manifest.segments.length;
+              const 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;
+              }
+
+              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((r, i) => {
+                  if (!r.hasOwnProperty('lastPart')) {
+                    this.trigger('warn', {
+                      message: `#EXT-X-RENDITION-REPORT #${i} lacks required attribute(s): LAST-PART`
+                    });
+                  }
+                });
+              }
+            },
+            'server-control'() {
+              const 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'() {
+              // parts are always specifed before a segment
+              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);
+
+              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;
+                  }
+                }
+              }
+              const 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 (let i = 0; i < currentUri.preloadHints.length - 1; i++) {
+                const 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'() {
+              const report = camelCaseKeys(entry.attributes);
+
+              this.manifest.renditionReports = this.manifest.renditionReports || [];
+              this.manifest.renditionReports.push(report);
+              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
+              );
+            },
+            'part-inf'() {
+              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() {
+          currentUri.uri = entry.uri;
+          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() {
+          // comments are not important for playback
+        },
+        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);
+    });
+  }
+
+  warnOnMissingAttributes_(identifier, attributes, required) {
+    const 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
+   */
+  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.
+   */
+  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
+   */
+  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
+   */
+  addTagMapper(options) {
+    this.parseStream.addTagMapper(options);
+  }
+}