@opendesign-plus-test/components 0.0.1-rc.79 → 0.0.1-rc.81

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

@@ -0,0 +1,1390 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const stream = require("../../@videojs/vhs-utils/es/stream.js.cjs");
+const _extends = require("../../@babel/runtime/helpers/esm/extends.js.cjs");
+const decodeB64ToUint8Array = require("../../@videojs/vhs-utils/es/decode-b64-to-uint8-array.js.cjs");
+/*! @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;
+};
+const attributeSeparator = function() {
+  const key = "[^=]*";
+  const value = '"[^"]*"|[^,]*';
+  const keyvalue = "(?:" + key + ")=(?:" + value + ")";
+  return new RegExp("(?:^|,)(" + keyvalue + ")");
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+  }
+};
+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);
+  }
+}
+exports.LineStream = LineStream;
+exports.ParseStream = ParseStream;
+exports.Parser = Parser;