@opendesign-plus/components 0.0.1-rc.103 → 0.0.1-rc.105

package/dist/treeshaking/_virtual/m3u8-parser/dist/m3u8-parser.es.js.mjs

@@ -1,1390 +1,1155 @@
-import Stream from "../../@videojs/vhs-utils/es/stream.js.mjs";
 import _extends from "../../@babel/runtime/helpers/esm/extends.js.mjs";
+import Stream from "../../@videojs/vhs-utils/es/stream.js.mjs";
 import decodeB64ToUint8Array from "../../@videojs/vhs-utils/es/decode-b64-to-uint8-array.js.mjs";
+// ../../node_modules/.pnpm/m3u8-parser@7.2.0/node_modules/m3u8-parser/dist/m3u8-parser.es.js
 /*! @name m3u8-parser @version 7.2.0 @license Apache-2.0 */
-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);
-    }
-  }
-}
-const TAB = String.fromCharCode(9);
-const parseByterange = function(byterangeString) {
-  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;
+/**
+* @file m3u8/line-stream.js
+*/
+/**
+* A stream that buffers string input and generates a `data` event for each
+* line.
+*
+* @class LineStream
+* @extends Stream
+*/
+var LineStream = class 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);
+		}
+	}
+};
+var TAB = String.fromCharCode(9);
+var parseByterange = function(byterangeString) {
+	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      -> '"' [^"]* '"' | [^,]*
+*/
+var attributeSeparator = function() {
+	return /* @__PURE__ */ new RegExp("(?:^|,)((?:[^=]*)=(?:\"[^\"]*\"|[^,]*))");
 };
-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
+*/
+var parseAttributes = function(attributes) {
+	const result = {};
+	if (!attributes) return result;
+	const attrs = attributes.split(attributeSeparator());
+	let i = attrs.length;
+	let attr;
+	while (i--) {
+		if (attrs[i] === "") continue;
+		attr = /([^=]*)=(.*)/.exec(attrs[i]).slice(1);
+		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;
 };
-const parseAttributes = function(attributes) {
-  const result = {};
-  if (!attributes) {
-    return result;
-  }
-  const attrs = attributes.split(attributeSeparator());
-  let i = attrs.length;
-  let attr;
-  while (i--) {
-    if (attrs[i] === "") {
-      continue;
-    }
-    attr = /([^=]*)=(.*)/.exec(attrs[i]).slice(1);
-    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;
+/**
+* Converts a string into a resolution object
+*
+* @param {string} resolution a string such as 3840x2160
+*
+* @return {Object} An object representing the resolution
+*
+*/
+var parseResolution = (resolution) => {
+	const split = resolution.split("x");
+	const result = {};
+	if (split[0]) result.width = parseInt(split[0], 10);
+	if (split[1]) result.height = parseInt(split[1], 10);
+	return result;
 };
-const parseResolution = (resolution) => {
-  const split = resolution.split("x");
-  const result = {};
-  if (split[0]) {
-    result.width = parseInt(split[0], 10);
-  }
-  if (split[1]) {
-    result.height = parseInt(split[1], 10);
-  }
-  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 = class 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;
+		line = line.trim();
+		if (line.length === 0) return;
+		if (line[0] !== "#") {
+			this.trigger("data", {
+				type: "uri",
+				uri: line
+			});
+			return;
+		}
+		this.tagMappers.reduce((acc, mapper) => {
+			const mappedLine = mapper(line);
+			if (mappedLine === line) return acc;
+			return acc.concat([mappedLine]);
+		}, [line]).forEach((newLine) => {
+			for (let i = 0; i < this.customParsers.length; i++) if (this.customParsers[i].call(this, newLine)) return;
+			if (newLine.indexOf("#EXT") !== 0) {
+				this.trigger("data", {
+					type: "comment",
+					text: newLine.slice(1)
+				});
+				return;
+			}
+			newLine = newLine.replace("\r", "");
+			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 = _extends(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) event.attributes.RESOLUTION = parseResolution(event.attributes.RESOLUTION);
+					if (event.attributes.BANDWIDTH) event.attributes.BANDWIDTH = parseInt(event.attributes.BANDWIDTH, 10);
+					if (event.attributes["FRAME-RATE"]) event.attributes["FRAME-RATE"] = parseFloat(event.attributes["FRAME-RATE"]);
+					if (event.attributes["PROGRAM-ID"]) event.attributes["PROGRAM-ID"] = parseInt(event.attributes["PROGRAM-ID"], 10);
+				}
+				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]);
+					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];
+						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;
+			}
+			match = /^#EXT-X-DATERANGE:(.*)$/.exec(newLine);
+			if (match && match[1]) {
+				event = {
+					type: "tag",
+					tagType: "daterange"
+				};
+				event.attributes = parseAttributes(match[1]);
+				["ID", "CLASS"].forEach(function(key) {
+					if (event.attributes.hasOwnProperty(key)) event.attributes[key] = String(event.attributes[key]);
+				});
+				["START-DATE", "END-DATE"].forEach(function(key) {
+					if (event.attributes.hasOwnProperty(key)) event.attributes[key] = new Date(event.attributes[key]);
+				});
+				["DURATION", "PLANNED-DURATION"].forEach(function(key) {
+					if (event.attributes.hasOwnProperty(key)) event.attributes[key] = parseFloat(event.attributes[key]);
+				});
+				["END-ON-NEXT"].forEach(function(key) {
+					if (event.attributes.hasOwnProperty(key)) event.attributes[key] = /YES/i.test(event.attributes[key]);
+				});
+				[
+					"SCTE35-CMD",
+					" SCTE35-OUT",
+					"SCTE35-IN"
+				].forEach(function(key) {
+					if (event.attributes.hasOwnProperty(key)) event.attributes[key] = event.attributes[key].toString(16);
+				});
+				const clientAttributePattern = /^X-([A-Z]+-)+[A-Z]+$/;
+				for (const key in event.attributes) {
+					if (!clientAttributePattern.test(key)) continue;
+					const isHexaDecimal = /[0-9A-Fa-f]{6}/g.test(event.attributes[key]);
+					const isDecimalFloating = /^\d+(\.\d+)?$/.test(event.attributes[key]);
+					event.attributes[key] = isHexaDecimal ? event.attributes[key].toString(16) : isDecimalFloating ? parseFloat(event.attributes[key]) : String(event.attributes[key]);
+				}
+				this.trigger("data", event);
+				return;
+			}
+			match = /^#EXT-X-INDEPENDENT-SEGMENTS/.exec(newLine);
+			if (match) {
+				this.trigger("data", {
+					type: "tag",
+					tagType: "independent-segments"
+				});
+				return;
+			}
+			match = /^#EXT-X-I-FRAMES-ONLY/.exec(newLine);
+			if (match) {
+				this.trigger("data", {
+					type: "tag",
+					tagType: "i-frames-only"
+				});
+				return;
+			}
+			match = /^#EXT-X-CONTENT-STEERING:(.*)$/.exec(newLine);
+			if (match) {
+				event = {
+					type: "tag",
+					tagType: "content-steering"
+				};
+				event.attributes = parseAttributes(match[1]);
+				this.trigger("data", event);
+				return;
+			}
+			match = /^#EXT-X-I-FRAME-STREAM-INF:(.*)$/.exec(newLine);
+			if (match) {
+				event = {
+					type: "tag",
+					tagType: "i-frame-playlist"
+				};
+				event.attributes = parseAttributes(match[1]);
+				if (event.attributes.URI) event.uri = event.attributes.URI;
+				if (event.attributes.BANDWIDTH) event.attributes.BANDWIDTH = parseInt(event.attributes.BANDWIDTH, 10);
+				if (event.attributes.RESOLUTION) event.attributes.RESOLUTION = parseResolution(event.attributes.RESOLUTION);
+				if (event.attributes["AVERAGE-BANDWIDTH"]) event.attributes["AVERAGE-BANDWIDTH"] = parseInt(event.attributes["AVERAGE-BANDWIDTH"], 10);
+				if (event.attributes["FRAME-RATE"]) event.attributes["FRAME-RATE"] = parseFloat(event.attributes["FRAME-RATE"]);
+				this.trigger("data", event);
+				return;
+			}
+			match = /^#EXT-X-DEFINE:(.*)$/.exec(newLine);
+			if (match) {
+				event = {
+					type: "tag",
+					tagType: "define"
+				};
+				event.attributes = parseAttributes(match[1]);
+				this.trigger("data", event);
+				return;
+			}
+			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) => {
+			if (expression.exec(line)) {
+				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);
+	}
 };
-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;
-    line = line.trim();
-    if (line.length === 0) {
-      return;
-    }
-    if (line[0] !== "#") {
-      this.trigger("data", {
-        type: "uri",
-        uri: line
-      });
-      return;
-    }
-    const newLines = this.tagMappers.reduce((acc, mapper) => {
-      const mappedLine = mapper(line);
-      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;
-        }
-      }
-      if (newLine.indexOf("#EXT") !== 0) {
-        this.trigger("data", {
-          type: "comment",
-          text: newLine.slice(1)
-        });
-        return;
-      }
-      newLine = newLine.replace("\r", "");
-      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 = _extends(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) {
-            event.attributes.RESOLUTION = parseResolution(event.attributes.RESOLUTION);
-          }
-          if (event.attributes.BANDWIDTH) {
-            event.attributes.BANDWIDTH = parseInt(event.attributes.BANDWIDTH, 10);
-          }
-          if (event.attributes["FRAME-RATE"]) {
-            event.attributes["FRAME-RATE"] = parseFloat(event.attributes["FRAME-RATE"]);
-          }
-          if (event.attributes["PROGRAM-ID"]) {
-            event.attributes["PROGRAM-ID"] = parseInt(event.attributes["PROGRAM-ID"], 10);
-          }
-        }
-        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]);
-          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];
-            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;
-      }
-      match = /^#EXT-X-DATERANGE:(.*)$/.exec(newLine);
-      if (match && match[1]) {
-        event = {
-          type: "tag",
-          tagType: "daterange"
-        };
-        event.attributes = parseAttributes(match[1]);
-        ["ID", "CLASS"].forEach(function(key) {
-          if (event.attributes.hasOwnProperty(key)) {
-            event.attributes[key] = String(event.attributes[key]);
-          }
-        });
-        ["START-DATE", "END-DATE"].forEach(function(key) {
-          if (event.attributes.hasOwnProperty(key)) {
-            event.attributes[key] = new Date(event.attributes[key]);
-          }
-        });
-        ["DURATION", "PLANNED-DURATION"].forEach(function(key) {
-          if (event.attributes.hasOwnProperty(key)) {
-            event.attributes[key] = parseFloat(event.attributes[key]);
-          }
-        });
-        ["END-ON-NEXT"].forEach(function(key) {
-          if (event.attributes.hasOwnProperty(key)) {
-            event.attributes[key] = /YES/i.test(event.attributes[key]);
-          }
-        });
-        ["SCTE35-CMD", " SCTE35-OUT", "SCTE35-IN"].forEach(function(key) {
-          if (event.attributes.hasOwnProperty(key)) {
-            event.attributes[key] = event.attributes[key].toString(16);
-          }
-        });
-        const clientAttributePattern = /^X-([A-Z]+-)+[A-Z]+$/;
-        for (const key in event.attributes) {
-          if (!clientAttributePattern.test(key)) {
-            continue;
-          }
-          const isHexaDecimal = /[0-9A-Fa-f]{6}/g.test(event.attributes[key]);
-          const isDecimalFloating = /^\d+(\.\d+)?$/.test(event.attributes[key]);
-          event.attributes[key] = isHexaDecimal ? event.attributes[key].toString(16) : isDecimalFloating ? parseFloat(event.attributes[key]) : String(event.attributes[key]);
-        }
-        this.trigger("data", event);
-        return;
-      }
-      match = /^#EXT-X-INDEPENDENT-SEGMENTS/.exec(newLine);
-      if (match) {
-        this.trigger("data", {
-          type: "tag",
-          tagType: "independent-segments"
-        });
-        return;
-      }
-      match = /^#EXT-X-I-FRAMES-ONLY/.exec(newLine);
-      if (match) {
-        this.trigger("data", {
-          type: "tag",
-          tagType: "i-frames-only"
-        });
-        return;
-      }
-      match = /^#EXT-X-CONTENT-STEERING:(.*)$/.exec(newLine);
-      if (match) {
-        event = {
-          type: "tag",
-          tagType: "content-steering"
-        };
-        event.attributes = parseAttributes(match[1]);
-        this.trigger("data", event);
-        return;
-      }
-      match = /^#EXT-X-I-FRAME-STREAM-INF:(.*)$/.exec(newLine);
-      if (match) {
-        event = {
-          type: "tag",
-          tagType: "i-frame-playlist"
-        };
-        event.attributes = parseAttributes(match[1]);
-        if (event.attributes.URI) {
-          event.uri = event.attributes.URI;
-        }
-        if (event.attributes.BANDWIDTH) {
-          event.attributes.BANDWIDTH = parseInt(event.attributes.BANDWIDTH, 10);
-        }
-        if (event.attributes.RESOLUTION) {
-          event.attributes.RESOLUTION = parseResolution(event.attributes.RESOLUTION);
-        }
-        if (event.attributes["AVERAGE-BANDWIDTH"]) {
-          event.attributes["AVERAGE-BANDWIDTH"] = parseInt(event.attributes["AVERAGE-BANDWIDTH"], 10);
-        }
-        if (event.attributes["FRAME-RATE"]) {
-          event.attributes["FRAME-RATE"] = parseFloat(event.attributes["FRAME-RATE"]);
-        }
-        this.trigger("data", event);
-        return;
-      }
-      match = /^#EXT-X-DEFINE:(.*)$/.exec(newLine);
-      if (match) {
-        event = {
-          type: "tag",
-          tagType: "define"
-        };
-        event.attributes = parseAttributes(match[1]);
-        this.trigger("data", event);
-        return;
-      }
-      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);
-  }
-}
-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;
+var camelCase = (str) => str.toLowerCase().replace(/-(\w)/g, (a) => a[1].toUpperCase());
+var camelCaseKeys = function(attributes) {
+	const result = {};
+	Object.keys(attributes).forEach(function(key) {
+		result[camelCase(key)] = attributes[key];
+	});
+	return result;
 };
-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;
-  }
-  if (partTargetDuration && !serverControl.hasOwnProperty(phb)) {
-    serverControl[phb] = partTargetDuration * 3;
-    this.trigger("info", {
-      message: `${tag} defaulting PART-HOLD-BACK to partTargetDuration * 3 (${serverControl[phb]}).`
-    });
-  }
-  if (partTargetDuration && serverControl[phb] < minPartDuration) {
-    this.trigger("warn", {
-      message: `${tag} clamping PART-HOLD-BACK (${serverControl[phb]}) to partTargetDuration * 2 (${minPartDuration}).`
-    });
-    serverControl[phb] = minPartDuration;
-  }
+var 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;
+	}
+	if (partTargetDuration && !serverControl.hasOwnProperty(phb)) {
+		serverControl[phb] = partTargetDuration * 3;
+		this.trigger("info", { message: `${tag} defaulting PART-HOLD-BACK to partTargetDuration * 3 (${serverControl[phb]}).` });
+	}
+	if (partTargetDuration && serverControl[phb] < minPartDuration) {
+		this.trigger("warn", { message: `${tag} clamping PART-HOLD-BACK (${serverControl[phb]}) to partTargetDuration * 2 (${minPartDuration}).` });
+		serverControl[phb] = minPartDuration;
+	}
 };
-class Parser extends Stream {
-  constructor(opts = {}) {
-    super();
-    this.lineStream = new LineStream();
-    this.parseStream = new ParseStream();
-    this.lineStream.pipe(this.parseStream);
-    this.mainDefinitions = opts.mainDefinitions || {};
-    this.params = new URL(opts.uri, "https://a.com").searchParams;
-    this.lastProgramDateTime = null;
-    const self = this;
-    const uris = [];
-    let currentUri = {};
-    let currentMap;
-    let key;
-    let hasParts = false;
-    const noop = function() {
-    };
-    const defaultMediaGroups = {
-      "AUDIO": {},
-      "VIDEO": {},
-      "CLOSED-CAPTIONS": {},
-      "SUBTITLES": {}
-    };
-    const widevineUuid = "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed";
-    let currentTimeline = 0;
-    this.manifest = {
-      allowCache: true,
-      discontinuityStarts: [],
-      dateRanges: [],
-      iFramePlaylists: [],
-      segments: []
-    };
-    let lastByterangeEnd = 0;
-    let lastPartByterangeEnd = 0;
-    const dateRangeTags = {};
-    this.on("end", () => {
-      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;
-    });
-    this.parseStream.on("data", function(entry) {
-      let mediaGroup;
-      let rendition;
-      if (self.manifest.definitions) {
-        for (const def in self.manifest.definitions) {
-          if (entry.uri) {
-            entry.uri = entry.uri.replace(`{$${def}}`, self.manifest.definitions[def]);
-          }
-          if (entry.attributes) {
-            for (const attr in entry.attributes) {
-              if (typeof entry.attributes[attr] === "string") {
-                entry.attributes[attr] = entry.attributes[attr].replace(`{$${def}}`, self.manifest.definitions[def]);
-              }
-            }
-          }
-        }
-      }
-      ({
-        tag() {
-          ({
-            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)) {
-                  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.title) {
-                currentUri.title = entry.title;
-              }
-              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;
-              }
-              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 || {};
-                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 || {};
-                this.manifest.contentProtection["com.microsoft.playready"] = {
-                  uri: entry.attributes.URI
-                };
-                return;
-              }
-              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;
-                }
-                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"
-                });
-              }
-              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 = {};
-              }
-              _extends(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;
-              }
-              const mediaGroupType = this.manifest.mediaGroups[entry.attributes.TYPE];
-              mediaGroupType[entry.attributes["GROUP-ID"]] = mediaGroupType[entry.attributes["GROUP-ID"]] || {};
-              mediaGroup = mediaGroupType[entry.attributes["GROUP-ID"]];
-              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);
-              }
-              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") {
-                this.manifest.dateTimeString = entry.dateTimeString;
-                this.manifest.dateTimeObject = entry.dateTimeObject;
-              }
-              currentUri.dateTimeString = entry.dateTimeString;
-              currentUri.dateTimeObject = entry.dateTimeObject;
-              const {
-                lastProgramDateTime
-              } = this;
-              this.lastProgramDateTime = new Date(entry.dateTimeString).getTime();
-              if (lastProgramDateTime === null) {
-                this.manifest.segments.reduceRight((programDateTime, segment) => {
-                  segment.programDateTime = programDateTime - segment.duration * 1e3;
-                  return segment.programDateTime;
-                }, this.lastProgramDateTime);
-              }
-            },
-            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;
-              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"() {
-              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")) {
-                  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;
-              }
-              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);
-            },
-            "daterange"() {
-              this.manifest.dateRanges.push(camelCaseKeys(entry.attributes));
-              const index = this.manifest.dateRanges.length - 1;
-              this.warnOnMissingAttributes_(`#EXT-X-DATERANGE #${index}`, entry.attributes, ["ID", "START-DATE"]);
-              const dateRange = this.manifest.dateRanges[index];
-              if (dateRange.endDate && dateRange.startDate && new Date(dateRange.endDate) < new Date(dateRange.startDate)) {
-                this.trigger("warn", {
-                  message: "EXT-X-DATERANGE END-DATE must be equal to or later than the value of the START-DATE"
-                });
-              }
-              if (dateRange.duration && dateRange.duration < 0) {
-                this.trigger("warn", {
-                  message: "EXT-X-DATERANGE DURATION must not be negative"
-                });
-              }
-              if (dateRange.plannedDuration && dateRange.plannedDuration < 0) {
-                this.trigger("warn", {
-                  message: "EXT-X-DATERANGE PLANNED-DURATION must not be negative"
-                });
-              }
-              const endOnNextYes = !!dateRange.endOnNext;
-              if (endOnNextYes && !dateRange.class) {
-                this.trigger("warn", {
-                  message: "EXT-X-DATERANGE with an END-ON-NEXT=YES attribute must have a CLASS attribute"
-                });
-              }
-              if (endOnNextYes && (dateRange.duration || dateRange.endDate)) {
-                this.trigger("warn", {
-                  message: "EXT-X-DATERANGE with an END-ON-NEXT=YES attribute must not contain DURATION or END-DATE attributes"
-                });
-              }
-              if (dateRange.duration && dateRange.endDate) {
-                const startDate = dateRange.startDate;
-                const newDateInSeconds = startDate.getTime() + dateRange.duration * 1e3;
-                this.manifest.dateRanges[index].endDate = new Date(newDateInSeconds);
-              }
-              if (!dateRangeTags[dateRange.id]) {
-                dateRangeTags[dateRange.id] = dateRange;
-              } else {
-                for (const attribute in dateRangeTags[dateRange.id]) {
-                  if (!!dateRange[attribute] && JSON.stringify(dateRangeTags[dateRange.id][attribute]) !== JSON.stringify(dateRange[attribute])) {
-                    this.trigger("warn", {
-                      message: "EXT-X-DATERANGE tags with the same ID in a playlist must have the same attributes values"
-                    });
-                    break;
-                  }
-                }
-                const dateRangeWithSameId = this.manifest.dateRanges.findIndex((dateRangeToFind) => dateRangeToFind.id === dateRange.id);
-                this.manifest.dateRanges[dateRangeWithSameId] = _extends(this.manifest.dateRanges[dateRangeWithSameId], dateRange);
-                dateRangeTags[dateRange.id] = _extends(dateRangeTags[dateRange.id], dateRange);
-                this.manifest.dateRanges.pop();
-              }
-            },
-            "independent-segments"() {
-              this.manifest.independentSegments = true;
-            },
-            "i-frames-only"() {
-              this.manifest.iFramesOnly = true;
-              this.requiredCompatibilityversion(this.manifest.version, 4);
-            },
-            "content-steering"() {
-              this.manifest.contentSteering = camelCaseKeys(entry.attributes);
-              this.warnOnMissingAttributes_("#EXT-X-CONTENT-STEERING", entry.attributes, ["SERVER-URI"]);
-            },
-            /** @this {Parser} */
-            define() {
-              this.manifest.definitions = this.manifest.definitions || {};
-              const addDef = (n, v) => {
-                if (n in this.manifest.definitions) {
-                  this.trigger("error", {
-                    message: `EXT-X-DEFINE: Duplicate name ${n}`
-                  });
-                  return;
-                }
-                this.manifest.definitions[n] = v;
-              };
-              if ("QUERYPARAM" in entry.attributes) {
-                if ("NAME" in entry.attributes || "IMPORT" in entry.attributes) {
-                  this.trigger("error", {
-                    message: "EXT-X-DEFINE: Invalid attributes"
-                  });
-                  return;
-                }
-                const val = this.params.get(entry.attributes.QUERYPARAM);
-                if (!val) {
-                  this.trigger("error", {
-                    message: `EXT-X-DEFINE: No query param ${entry.attributes.QUERYPARAM}`
-                  });
-                  return;
-                }
-                addDef(entry.attributes.QUERYPARAM, decodeURIComponent(val));
-                return;
-              }
-              if ("NAME" in entry.attributes) {
-                if ("IMPORT" in entry.attributes) {
-                  this.trigger("error", {
-                    message: "EXT-X-DEFINE: Invalid attributes"
-                  });
-                  return;
-                }
-                if (!("VALUE" in entry.attributes) || typeof entry.attributes.VALUE !== "string") {
-                  this.trigger("error", {
-                    message: `EXT-X-DEFINE: No value for ${entry.attributes.NAME}`
-                  });
-                  return;
-                }
-                addDef(entry.attributes.NAME, entry.attributes.VALUE);
-                return;
-              }
-              if ("IMPORT" in entry.attributes) {
-                if (!this.mainDefinitions[entry.attributes.IMPORT]) {
-                  this.trigger("error", {
-                    message: `EXT-X-DEFINE: No value ${entry.attributes.IMPORT} to import, or IMPORT used on main playlist`
-                  });
-                  return;
-                }
-                addDef(entry.attributes.IMPORT, this.mainDefinitions[entry.attributes.IMPORT]);
-                return;
-              }
-              this.trigger("error", {
-                message: "EXT-X-DEFINE: No attribute"
-              });
-            },
-            "i-frame-playlist"() {
-              this.manifest.iFramePlaylists.push({
-                attributes: entry.attributes,
-                uri: entry.uri,
-                timeline: currentTimeline
-              });
-              this.warnOnMissingAttributes_("#EXT-X-I-FRAME-STREAM-INF", entry.attributes, ["BANDWIDTH", "URI"]);
-            }
-          }[entry.tagType] || noop).call(self);
-        },
-        uri() {
-          currentUri.uri = entry.uri;
-          uris.push(currentUri);
-          if (this.manifest.targetDuration && !("duration" in currentUri)) {
-            this.trigger("warn", {
-              message: "defaulting segment duration to the target duration"
-            });
-            currentUri.duration = this.manifest.targetDuration;
-          }
-          if (key) {
-            currentUri.key = key;
-          }
-          currentUri.timeline = currentTimeline;
-          if (currentMap) {
-            currentUri.map = currentMap;
-          }
-          lastPartByterangeEnd = 0;
-          if (this.lastProgramDateTime !== null) {
-            currentUri.programDateTime = this.lastProgramDateTime;
-            this.lastProgramDateTime += currentUri.duration * 1e3;
-          }
-          currentUri = {};
-        },
-        comment() {
-        },
-        custom() {
-          if (entry.segment) {
-            currentUri.custom = currentUri.custom || {};
-            currentUri.custom[entry.customType] = entry.data;
-          } else {
-            this.manifest.custom = this.manifest.custom || {};
-            this.manifest.custom[entry.customType] = entry.data;
-          }
-        }
-      })[entry.type].call(self);
-    });
-  }
-  requiredCompatibilityversion(currentVersion, targetVersion) {
-    if (currentVersion < targetVersion || !currentVersion) {
-      this.trigger("warn", {
-        message: `manifest must be at least version ${targetVersion}`
-      });
-    }
-  }
-  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() {
-    this.lineStream.push("\n");
-    if (this.manifest.dateRanges.length && this.lastProgramDateTime === null) {
-      this.trigger("warn", {
-        message: "A playlist with EXT-X-DATERANGE tag must contain atleast one EXT-X-PROGRAM-DATE-TIME tag"
-      });
-    }
-    this.lastProgramDateTime = null;
-    this.trigger("end");
-  }
-  /**
-   * 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.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(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);
-  }
-}
-export {
-  LineStream,
-  ParseStream,
-  Parser
+/**
+* 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
+* @param {Object} [opts] Options for the constructor, needed for substitutions
+* @param {string} [opts.uri] URL to check for query params
+* @param {Object} [opts.mainDefinitions] Definitions on main playlist that can be imported
+* @extends Stream
+*/
+var Parser = class extends Stream {
+	constructor(opts = {}) {
+		super();
+		this.lineStream = new LineStream();
+		this.parseStream = new ParseStream();
+		this.lineStream.pipe(this.parseStream);
+		this.mainDefinitions = opts.mainDefinitions || {};
+		this.params = new URL(opts.uri, "https://a.com").searchParams;
+		this.lastProgramDateTime = null;
+		const self = this;
+		const uris = [];
+		let currentUri = {};
+		let currentMap;
+		let key;
+		let hasParts = false;
+		const noop = function() {};
+		const defaultMediaGroups = {
+			"AUDIO": {},
+			"VIDEO": {},
+			"CLOSED-CAPTIONS": {},
+			"SUBTITLES": {}
+		};
+		const widevineUuid = "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed";
+		let currentTimeline = 0;
+		this.manifest = {
+			allowCache: true,
+			discontinuityStarts: [],
+			dateRanges: [],
+			iFramePlaylists: [],
+			segments: []
+		};
+		let lastByterangeEnd = 0;
+		let lastPartByterangeEnd = 0;
+		const dateRangeTags = {};
+		this.on("end", () => {
+			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;
+		});
+		this.parseStream.on("data", function(entry) {
+			let mediaGroup;
+			let rendition;
+			if (self.manifest.definitions) for (const def in self.manifest.definitions) {
+				if (entry.uri) entry.uri = entry.uri.replace(`{$${def}}`, self.manifest.definitions[def]);
+				if (entry.attributes) {
+					for (const attr in entry.attributes) if (typeof entry.attributes[attr] === "string") entry.attributes[attr] = entry.attributes[attr].replace(`{$${def}}`, self.manifest.definitions[def]);
+				}
+			}
+			({
+				tag() {
+					({
+						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)) 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.title) currentUri.title = entry.title;
+							if (entry.duration > 0) currentUri.duration = entry.duration;
+							if (entry.duration === 0) {
+								currentUri.duration = .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;
+							}
+							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 || {};
+								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 || {};
+								this.manifest.contentProtection["com.microsoft.playready"] = { uri: entry.attributes.URI };
+								return;
+							}
+							if (entry.attributes.KEYFORMAT === widevineUuid) {
+								if ([
+									"SAMPLE-AES",
+									"SAMPLE-AES-CTR",
+									"SAMPLE-AES-CENC"
+								].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;
+								}
+								this.manifest.contentProtection = this.manifest.contentProtection || {};
+								this.manifest.contentProtection["com.widevine.alpha"] = {
+									attributes: {
+										schemeIdUri: entry.attributes.KEYFORMAT,
+										keyId: entry.attributes.KEYID.substring(2)
+									},
+									pssh: decodeB64ToUint8Array(entry.attributes.URI.split(",")[1])
+								};
+								return;
+							}
+							if (!entry.attributes.METHOD) this.trigger("warn", { message: "defaulting key method to AES-128" });
+							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 = {};
+							_extends(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;
+							}
+							const mediaGroupType = this.manifest.mediaGroups[entry.attributes.TYPE];
+							mediaGroupType[entry.attributes["GROUP-ID"]] = mediaGroupType[entry.attributes["GROUP-ID"]] || {};
+							mediaGroup = mediaGroupType[entry.attributes["GROUP-ID"]];
+							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);
+							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") {
+								this.manifest.dateTimeString = entry.dateTimeString;
+								this.manifest.dateTimeObject = entry.dateTimeObject;
+							}
+							currentUri.dateTimeString = entry.dateTimeString;
+							currentUri.dateTimeObject = entry.dateTimeObject;
+							const { lastProgramDateTime } = this;
+							this.lastProgramDateTime = new Date(entry.dateTimeString).getTime();
+							if (lastProgramDateTime === null) this.manifest.segments.reduceRight((programDateTime, segment) => {
+								segment.programDateTime = programDateTime - segment.duration * 1e3;
+								return segment.programDateTime;
+							}, this.lastProgramDateTime);
+						},
+						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;
+							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"() {
+							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")) {
+									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;
+							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);
+						},
+						"daterange"() {
+							this.manifest.dateRanges.push(camelCaseKeys(entry.attributes));
+							const index = this.manifest.dateRanges.length - 1;
+							this.warnOnMissingAttributes_(`#EXT-X-DATERANGE #${index}`, entry.attributes, ["ID", "START-DATE"]);
+							const dateRange = this.manifest.dateRanges[index];
+							if (dateRange.endDate && dateRange.startDate && new Date(dateRange.endDate) < new Date(dateRange.startDate)) this.trigger("warn", { message: "EXT-X-DATERANGE END-DATE must be equal to or later than the value of the START-DATE" });
+							if (dateRange.duration && dateRange.duration < 0) this.trigger("warn", { message: "EXT-X-DATERANGE DURATION must not be negative" });
+							if (dateRange.plannedDuration && dateRange.plannedDuration < 0) this.trigger("warn", { message: "EXT-X-DATERANGE PLANNED-DURATION must not be negative" });
+							const endOnNextYes = !!dateRange.endOnNext;
+							if (endOnNextYes && !dateRange.class) this.trigger("warn", { message: "EXT-X-DATERANGE with an END-ON-NEXT=YES attribute must have a CLASS attribute" });
+							if (endOnNextYes && (dateRange.duration || dateRange.endDate)) this.trigger("warn", { message: "EXT-X-DATERANGE with an END-ON-NEXT=YES attribute must not contain DURATION or END-DATE attributes" });
+							if (dateRange.duration && dateRange.endDate) {
+								const newDateInSeconds = dateRange.startDate.getTime() + dateRange.duration * 1e3;
+								this.manifest.dateRanges[index].endDate = new Date(newDateInSeconds);
+							}
+							if (!dateRangeTags[dateRange.id]) dateRangeTags[dateRange.id] = dateRange;
+							else {
+								for (const attribute in dateRangeTags[dateRange.id]) if (!!dateRange[attribute] && JSON.stringify(dateRangeTags[dateRange.id][attribute]) !== JSON.stringify(dateRange[attribute])) {
+									this.trigger("warn", { message: "EXT-X-DATERANGE tags with the same ID in a playlist must have the same attributes values" });
+									break;
+								}
+								const dateRangeWithSameId = this.manifest.dateRanges.findIndex((dateRangeToFind) => dateRangeToFind.id === dateRange.id);
+								this.manifest.dateRanges[dateRangeWithSameId] = _extends(this.manifest.dateRanges[dateRangeWithSameId], dateRange);
+								dateRangeTags[dateRange.id] = _extends(dateRangeTags[dateRange.id], dateRange);
+								this.manifest.dateRanges.pop();
+							}
+						},
+						"independent-segments"() {
+							this.manifest.independentSegments = true;
+						},
+						"i-frames-only"() {
+							this.manifest.iFramesOnly = true;
+							this.requiredCompatibilityversion(this.manifest.version, 4);
+						},
+						"content-steering"() {
+							this.manifest.contentSteering = camelCaseKeys(entry.attributes);
+							this.warnOnMissingAttributes_("#EXT-X-CONTENT-STEERING", entry.attributes, ["SERVER-URI"]);
+						},
+						/** @this {Parser} */
+						define() {
+							this.manifest.definitions = this.manifest.definitions || {};
+							const addDef = (n, v) => {
+								if (n in this.manifest.definitions) {
+									this.trigger("error", { message: `EXT-X-DEFINE: Duplicate name ${n}` });
+									return;
+								}
+								this.manifest.definitions[n] = v;
+							};
+							if ("QUERYPARAM" in entry.attributes) {
+								if ("NAME" in entry.attributes || "IMPORT" in entry.attributes) {
+									this.trigger("error", { message: "EXT-X-DEFINE: Invalid attributes" });
+									return;
+								}
+								const val = this.params.get(entry.attributes.QUERYPARAM);
+								if (!val) {
+									this.trigger("error", { message: `EXT-X-DEFINE: No query param ${entry.attributes.QUERYPARAM}` });
+									return;
+								}
+								addDef(entry.attributes.QUERYPARAM, decodeURIComponent(val));
+								return;
+							}
+							if ("NAME" in entry.attributes) {
+								if ("IMPORT" in entry.attributes) {
+									this.trigger("error", { message: "EXT-X-DEFINE: Invalid attributes" });
+									return;
+								}
+								if (!("VALUE" in entry.attributes) || typeof entry.attributes.VALUE !== "string") {
+									this.trigger("error", { message: `EXT-X-DEFINE: No value for ${entry.attributes.NAME}` });
+									return;
+								}
+								addDef(entry.attributes.NAME, entry.attributes.VALUE);
+								return;
+							}
+							if ("IMPORT" in entry.attributes) {
+								if (!this.mainDefinitions[entry.attributes.IMPORT]) {
+									this.trigger("error", { message: `EXT-X-DEFINE: No value ${entry.attributes.IMPORT} to import, or IMPORT used on main playlist` });
+									return;
+								}
+								addDef(entry.attributes.IMPORT, this.mainDefinitions[entry.attributes.IMPORT]);
+								return;
+							}
+							this.trigger("error", { message: "EXT-X-DEFINE: No attribute" });
+						},
+						"i-frame-playlist"() {
+							this.manifest.iFramePlaylists.push({
+								attributes: entry.attributes,
+								uri: entry.uri,
+								timeline: currentTimeline
+							});
+							this.warnOnMissingAttributes_("#EXT-X-I-FRAME-STREAM-INF", entry.attributes, ["BANDWIDTH", "URI"]);
+						}
+					}[entry.tagType] || noop).call(self);
+				},
+				uri() {
+					currentUri.uri = entry.uri;
+					uris.push(currentUri);
+					if (this.manifest.targetDuration && !("duration" in currentUri)) {
+						this.trigger("warn", { message: "defaulting segment duration to the target duration" });
+						currentUri.duration = this.manifest.targetDuration;
+					}
+					if (key) currentUri.key = key;
+					currentUri.timeline = currentTimeline;
+					if (currentMap) currentUri.map = currentMap;
+					lastPartByterangeEnd = 0;
+					if (this.lastProgramDateTime !== null) {
+						currentUri.programDateTime = this.lastProgramDateTime;
+						this.lastProgramDateTime += currentUri.duration * 1e3;
+					}
+					currentUri = {};
+				},
+				comment() {},
+				custom() {
+					if (entry.segment) {
+						currentUri.custom = currentUri.custom || {};
+						currentUri.custom[entry.customType] = entry.data;
+					} else {
+						this.manifest.custom = this.manifest.custom || {};
+						this.manifest.custom[entry.customType] = entry.data;
+					}
+				}
+			})[entry.type].call(self);
+		});
+	}
+	requiredCompatibilityversion(currentVersion, targetVersion) {
+		if (currentVersion < targetVersion || !currentVersion) this.trigger("warn", { message: `manifest must be at least version ${targetVersion}` });
+	}
+	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() {
+		this.lineStream.push("\n");
+		if (this.manifest.dateRanges.length && this.lastProgramDateTime === null) this.trigger("warn", { message: "A playlist with EXT-X-DATERANGE tag must contain atleast one EXT-X-PROGRAM-DATE-TIME tag" });
+		this.lastProgramDateTime = null;
+		this.trigger("end");
+	}
+	/**
+	* 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.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(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);
+	}
 };
+export { LineStream, ParseStream, Parser };