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

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

@@ -1,1693 +1,1788 @@
+import { __toESM } from "../../_rolldown/runtime.mjs";
+import { require_window } from "../../global/window.js.mjs";
 import resolveUrl from "../../@videojs/vhs-utils/es/resolve-url.js.mjs";
-import window$1 from "../../global/window.js.mjs";
-import { forEachMediaGroup } from "../../@videojs/vhs-utils/es/media-groups.js.mjs";
 import decodeB64ToUint8Array from "../../@videojs/vhs-utils/es/decode-b64-to-uint8-array.js.mjs";
-import { l as libExports } from "../../@xmldom/xmldom/lib/index.js.mjs";
+import { forEachMediaGroup } from "../../@videojs/vhs-utils/es/media-groups.js.mjs";
+import { require_lib } from "../../@xmldom/xmldom/lib/index.js.mjs";
+// ../../node_modules/.pnpm/mpd-parser@1.3.1/node_modules/mpd-parser/dist/mpd-parser.es.js
 /*! @name mpd-parser @version 1.3.1 @license Apache-2.0 */
-const isObject = (obj) => {
-  return !!obj && typeof obj === "object";
+var import_window = /* @__PURE__ */ __toESM(require_window());
+var import_lib = require_lib();
+var isObject = (obj) => {
+	return !!obj && typeof obj === "object";
 };
-const merge = (...objects) => {
-  return objects.reduce((result, source) => {
-    if (typeof source !== "object") {
-      return result;
-    }
-    Object.keys(source).forEach((key) => {
-      if (Array.isArray(result[key]) && Array.isArray(source[key])) {
-        result[key] = result[key].concat(source[key]);
-      } else if (isObject(result[key]) && isObject(source[key])) {
-        result[key] = merge(result[key], source[key]);
-      } else {
-        result[key] = source[key];
-      }
-    });
-    return result;
-  }, {});
+var merge = (...objects) => {
+	return objects.reduce((result, source) => {
+		if (typeof source !== "object") return result;
+		Object.keys(source).forEach((key) => {
+			if (Array.isArray(result[key]) && Array.isArray(source[key])) result[key] = result[key].concat(source[key]);
+			else if (isObject(result[key]) && isObject(source[key])) result[key] = merge(result[key], source[key]);
+			else result[key] = source[key];
+		});
+		return result;
+	}, {});
 };
-const values = (o) => Object.keys(o).map((k) => o[k]);
-const range = (start, end) => {
-  const result = [];
-  for (let i = start; i < end; i++) {
-    result.push(i);
-  }
-  return result;
+var values = (o) => Object.keys(o).map((k) => o[k]);
+var range = (start, end) => {
+	const result = [];
+	for (let i = start; i < end; i++) result.push(i);
+	return result;
 };
-const flatten = (lists) => lists.reduce((x, y) => x.concat(y), []);
-const from = (list) => {
-  if (!list.length) {
-    return [];
-  }
-  const result = [];
-  for (let i = 0; i < list.length; i++) {
-    result.push(list[i]);
-  }
-  return result;
+var flatten = (lists) => lists.reduce((x, y) => x.concat(y), []);
+var from = (list) => {
+	if (!list.length) return [];
+	const result = [];
+	for (let i = 0; i < list.length; i++) result.push(list[i]);
+	return result;
 };
-const findIndexes = (l, key) => l.reduce((a, e, i) => {
-  if (e[key]) {
-    a.push(i);
-  }
-  return a;
+var findIndexes = (l, key) => l.reduce((a, e, i) => {
+	if (e[key]) a.push(i);
+	return a;
 }, []);
-const union = (lists, keyFunction) => {
-  return values(lists.reduce((acc, list) => {
-    list.forEach((el) => {
-      acc[keyFunction(el)] = el;
-    });
-    return acc;
-  }, {}));
+/**
+* Returns a union of the included lists provided each element can be identified by a key.
+*
+* @param {Array} list - list of lists to get the union of
+* @param {Function} keyFunction - the function to use as a key for each element
+*
+* @return {Array} the union of the arrays
+*/
+var union = (lists, keyFunction) => {
+	return values(lists.reduce((acc, list) => {
+		list.forEach((el) => {
+			acc[keyFunction(el)] = el;
+		});
+		return acc;
+	}, {}));
 };
 var errors = {
-  INVALID_NUMBER_OF_PERIOD: "INVALID_NUMBER_OF_PERIOD",
-  DASH_EMPTY_MANIFEST: "DASH_EMPTY_MANIFEST",
-  DASH_INVALID_XML: "DASH_INVALID_XML",
-  NO_BASE_URL: "NO_BASE_URL",
-  SEGMENT_TIME_UNSPECIFIED: "SEGMENT_TIME_UNSPECIFIED",
-  UNSUPPORTED_UTC_TIMING_SCHEME: "UNSUPPORTED_UTC_TIMING_SCHEME"
+	INVALID_NUMBER_OF_PERIOD: "INVALID_NUMBER_OF_PERIOD",
+	INVALID_NUMBER_OF_CONTENT_STEERING: "INVALID_NUMBER_OF_CONTENT_STEERING",
+	DASH_EMPTY_MANIFEST: "DASH_EMPTY_MANIFEST",
+	DASH_INVALID_XML: "DASH_INVALID_XML",
+	NO_BASE_URL: "NO_BASE_URL",
+	MISSING_SEGMENT_INFORMATION: "MISSING_SEGMENT_INFORMATION",
+	SEGMENT_TIME_UNSPECIFIED: "SEGMENT_TIME_UNSPECIFIED",
+	UNSUPPORTED_UTC_TIMING_SCHEME: "UNSUPPORTED_UTC_TIMING_SCHEME"
 };
-const urlTypeToSegment = ({
-  baseUrl = "",
-  source = "",
-  range: range2 = "",
-  indexRange = ""
-}) => {
-  const segment = {
-    uri: source,
-    resolvedUri: resolveUrl(baseUrl || "", source)
-  };
-  if (range2 || indexRange) {
-    const rangeStr = range2 ? range2 : indexRange;
-    const ranges = rangeStr.split("-");
-    let startRange = window$1.BigInt ? window$1.BigInt(ranges[0]) : parseInt(ranges[0], 10);
-    let endRange = window$1.BigInt ? window$1.BigInt(ranges[1]) : parseInt(ranges[1], 10);
-    if (startRange < Number.MAX_SAFE_INTEGER && typeof startRange === "bigint") {
-      startRange = Number(startRange);
-    }
-    if (endRange < Number.MAX_SAFE_INTEGER && typeof endRange === "bigint") {
-      endRange = Number(endRange);
-    }
-    let length;
-    if (typeof endRange === "bigint" || typeof startRange === "bigint") {
-      length = window$1.BigInt(endRange) - window$1.BigInt(startRange) + window$1.BigInt(1);
-    } else {
-      length = endRange - startRange + 1;
-    }
-    if (typeof length === "bigint" && length < Number.MAX_SAFE_INTEGER) {
-      length = Number(length);
-    }
-    segment.byterange = {
-      length,
-      offset: startRange
-    };
-  }
-  return segment;
+/**
+* @typedef {Object} SingleUri
+* @property {string} uri - relative location of segment
+* @property {string} resolvedUri - resolved location of segment
+* @property {Object} byterange - Object containing information on how to make byte range
+*   requests following byte-range-spec per RFC2616.
+* @property {String} byterange.length - length of range request
+* @property {String} byterange.offset - byte offset of range request
+*
+* @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.1
+*/
+/**
+* Converts a URLType node (5.3.9.2.3 Table 13) to a segment object
+* that conforms to how m3u8-parser is structured
+*
+* @see https://github.com/videojs/m3u8-parser
+*
+* @param {string} baseUrl - baseUrl provided by <BaseUrl> nodes
+* @param {string} source - source url for segment
+* @param {string} range - optional range used for range calls,
+*   follows  RFC 2616, Clause 14.35.1
+* @return {SingleUri} full segment information transformed into a format similar
+*   to m3u8-parser
+*/
+var urlTypeToSegment = ({ baseUrl = "", source = "", range = "", indexRange = "" }) => {
+	const segment = {
+		uri: source,
+		resolvedUri: resolveUrl(baseUrl || "", source)
+	};
+	if (range || indexRange) {
+		const ranges = (range ? range : indexRange).split("-");
+		let startRange = import_window.default.BigInt ? import_window.default.BigInt(ranges[0]) : parseInt(ranges[0], 10);
+		let endRange = import_window.default.BigInt ? import_window.default.BigInt(ranges[1]) : parseInt(ranges[1], 10);
+		if (startRange < Number.MAX_SAFE_INTEGER && typeof startRange === "bigint") startRange = Number(startRange);
+		if (endRange < Number.MAX_SAFE_INTEGER && typeof endRange === "bigint") endRange = Number(endRange);
+		let length;
+		if (typeof endRange === "bigint" || typeof startRange === "bigint") length = import_window.default.BigInt(endRange) - import_window.default.BigInt(startRange) + import_window.default.BigInt(1);
+		else length = endRange - startRange + 1;
+		if (typeof length === "bigint" && length < Number.MAX_SAFE_INTEGER) length = Number(length);
+		segment.byterange = {
+			length,
+			offset: startRange
+		};
+	}
+	return segment;
 };
-const byteRangeToString = (byterange) => {
-  let endRange;
-  if (typeof byterange.offset === "bigint" || typeof byterange.length === "bigint") {
-    endRange = window$1.BigInt(byterange.offset) + window$1.BigInt(byterange.length) - window$1.BigInt(1);
-  } else {
-    endRange = byterange.offset + byterange.length - 1;
-  }
-  return `${byterange.offset}-${endRange}`;
+var byteRangeToString = (byterange) => {
+	let endRange;
+	if (typeof byterange.offset === "bigint" || typeof byterange.length === "bigint") endRange = import_window.default.BigInt(byterange.offset) + import_window.default.BigInt(byterange.length) - import_window.default.BigInt(1);
+	else endRange = byterange.offset + byterange.length - 1;
+	return `${byterange.offset}-${endRange}`;
 };
-const parseEndNumber = (endNumber) => {
-  if (endNumber && typeof endNumber !== "number") {
-    endNumber = parseInt(endNumber, 10);
-  }
-  if (isNaN(endNumber)) {
-    return null;
-  }
-  return endNumber;
+/**
+* parse the end number attribue that can be a string
+* number, or undefined.
+*
+* @param {string|number|undefined} endNumber
+*        The end number attribute.
+*
+* @return {number|null}
+*          The result of parsing the end number.
+*/
+var parseEndNumber = (endNumber) => {
+	if (endNumber && typeof endNumber !== "number") endNumber = parseInt(endNumber, 10);
+	if (isNaN(endNumber)) return null;
+	return endNumber;
 };
-const segmentRange = {
-  /**
-   * Returns the entire range of available segments for a static MPD
-   *
-   * @param {Object} attributes
-   *        Inheritied MPD attributes
-   * @return {{ start: number, end: number }}
-   *         The start and end numbers for available segments
-   */
-  static(attributes) {
-    const {
-      duration,
-      timescale = 1,
-      sourceDuration,
-      periodDuration
-    } = attributes;
-    const endNumber = parseEndNumber(attributes.endNumber);
-    const segmentDuration = duration / timescale;
-    if (typeof endNumber === "number") {
-      return {
-        start: 0,
-        end: endNumber
-      };
-    }
-    if (typeof periodDuration === "number") {
-      return {
-        start: 0,
-        end: periodDuration / segmentDuration
-      };
-    }
-    return {
-      start: 0,
-      end: sourceDuration / segmentDuration
-    };
-  },
-  /**
-   * Returns the current live window range of available segments for a dynamic MPD
-   *
-   * @param {Object} attributes
-   *        Inheritied MPD attributes
-   * @return {{ start: number, end: number }}
-   *         The start and end numbers for available segments
-   */
-  dynamic(attributes) {
-    const {
-      NOW,
-      clientOffset,
-      availabilityStartTime,
-      timescale = 1,
-      duration,
-      periodStart = 0,
-      minimumUpdatePeriod = 0,
-      timeShiftBufferDepth = Infinity
-    } = attributes;
-    const endNumber = parseEndNumber(attributes.endNumber);
-    const now = (NOW + clientOffset) / 1e3;
-    const periodStartWC = availabilityStartTime + periodStart;
-    const periodEndWC = now + minimumUpdatePeriod;
-    const periodDuration = periodEndWC - periodStartWC;
-    const segmentCount = Math.ceil(periodDuration * timescale / duration);
-    const availableStart = Math.floor((now - periodStartWC - timeShiftBufferDepth) * timescale / duration);
-    const availableEnd = Math.floor((now - periodStartWC) * timescale / duration);
-    return {
-      start: Math.max(0, availableStart),
-      end: typeof endNumber === "number" ? endNumber : Math.min(segmentCount, availableEnd)
-    };
-  }
+/**
+* Functions for calculating the range of available segments in static and dynamic
+* manifests.
+*/
+var segmentRange = {
+	/**
+	* Returns the entire range of available segments for a static MPD
+	*
+	* @param {Object} attributes
+	*        Inheritied MPD attributes
+	* @return {{ start: number, end: number }}
+	*         The start and end numbers for available segments
+	*/
+	static(attributes) {
+		const { duration, timescale = 1, sourceDuration, periodDuration } = attributes;
+		const endNumber = parseEndNumber(attributes.endNumber);
+		const segmentDuration = duration / timescale;
+		if (typeof endNumber === "number") return {
+			start: 0,
+			end: endNumber
+		};
+		if (typeof periodDuration === "number") return {
+			start: 0,
+			end: periodDuration / segmentDuration
+		};
+		return {
+			start: 0,
+			end: sourceDuration / segmentDuration
+		};
+	},
+	/**
+	* Returns the current live window range of available segments for a dynamic MPD
+	*
+	* @param {Object} attributes
+	*        Inheritied MPD attributes
+	* @return {{ start: number, end: number }}
+	*         The start and end numbers for available segments
+	*/
+	dynamic(attributes) {
+		const { NOW, clientOffset, availabilityStartTime, timescale = 1, duration, periodStart = 0, minimumUpdatePeriod = 0, timeShiftBufferDepth = Infinity } = attributes;
+		const endNumber = parseEndNumber(attributes.endNumber);
+		const now = (NOW + clientOffset) / 1e3;
+		const periodStartWC = availabilityStartTime + periodStart;
+		const periodDuration = now + minimumUpdatePeriod - periodStartWC;
+		const segmentCount = Math.ceil(periodDuration * timescale / duration);
+		const availableStart = Math.floor((now - periodStartWC - timeShiftBufferDepth) * timescale / duration);
+		const availableEnd = Math.floor((now - periodStartWC) * timescale / duration);
+		return {
+			start: Math.max(0, availableStart),
+			end: typeof endNumber === "number" ? endNumber : Math.min(segmentCount, availableEnd)
+		};
+	}
 };
-const toSegments = (attributes) => (number) => {
-  const {
-    duration,
-    timescale = 1,
-    periodStart,
-    startNumber = 1
-  } = attributes;
-  return {
-    number: startNumber + number,
-    duration: duration / timescale,
-    timeline: periodStart,
-    time: number * duration
-  };
+/**
+* Maps a range of numbers to objects with information needed to build the corresponding
+* segment list
+*
+* @name toSegmentsCallback
+* @function
+* @param {number} number
+*        Number of the segment
+* @param {number} index
+*        Index of the number in the range list
+* @return {{ number: Number, duration: Number, timeline: Number, time: Number }}
+*         Object with segment timing and duration info
+*/
+/**
+* Returns a callback for Array.prototype.map for mapping a range of numbers to
+* information needed to build the segment list.
+*
+* @param {Object} attributes
+*        Inherited MPD attributes
+* @return {toSegmentsCallback}
+*         Callback map function
+*/
+var toSegments = (attributes) => (number) => {
+	const { duration, timescale = 1, periodStart, startNumber = 1 } = attributes;
+	return {
+		number: startNumber + number,
+		duration: duration / timescale,
+		timeline: periodStart,
+		time: number * duration
+	};
 };
-const parseByDuration = (attributes) => {
-  const {
-    type,
-    duration,
-    timescale = 1,
-    periodDuration,
-    sourceDuration
-  } = attributes;
-  const {
-    start,
-    end
-  } = segmentRange[type](attributes);
-  const segments = range(start, end).map(toSegments(attributes));
-  if (type === "static") {
-    const index = segments.length - 1;
-    const sectionDuration = typeof periodDuration === "number" ? periodDuration : sourceDuration;
-    segments[index].duration = sectionDuration - duration / timescale * index;
-  }
-  return segments;
+/**
+* Returns a list of objects containing segment timing and duration info used for
+* building the list of segments. This uses the @duration attribute specified
+* in the MPD manifest to derive the range of segments.
+*
+* @param {Object} attributes
+*        Inherited MPD attributes
+* @return {{number: number, duration: number, time: number, timeline: number}[]}
+*         List of Objects with segment timing and duration info
+*/
+var parseByDuration = (attributes) => {
+	const { type, duration, timescale = 1, periodDuration, sourceDuration } = attributes;
+	const { start, end } = segmentRange[type](attributes);
+	const segments = range(start, end).map(toSegments(attributes));
+	if (type === "static") {
+		const index = segments.length - 1;
+		const sectionDuration = typeof periodDuration === "number" ? periodDuration : sourceDuration;
+		segments[index].duration = sectionDuration - duration / timescale * index;
+	}
+	return segments;
 };
-const segmentsFromBase = (attributes) => {
-  const {
-    baseUrl,
-    initialization = {},
-    sourceDuration,
-    indexRange = "",
-    periodStart,
-    presentationTime,
-    number = 0,
-    duration
-  } = attributes;
-  if (!baseUrl) {
-    throw new Error(errors.NO_BASE_URL);
-  }
-  const initSegment = urlTypeToSegment({
-    baseUrl,
-    source: initialization.sourceURL,
-    range: initialization.range
-  });
-  const segment = urlTypeToSegment({
-    baseUrl,
-    source: baseUrl,
-    indexRange
-  });
-  segment.map = initSegment;
-  if (duration) {
-    const segmentTimeInfo = parseByDuration(attributes);
-    if (segmentTimeInfo.length) {
-      segment.duration = segmentTimeInfo[0].duration;
-      segment.timeline = segmentTimeInfo[0].timeline;
-    }
-  } else if (sourceDuration) {
-    segment.duration = sourceDuration;
-    segment.timeline = periodStart;
-  }
-  segment.presentationTime = presentationTime || periodStart;
-  segment.number = number;
-  return [segment];
+/**
+* Translates SegmentBase into a set of segments.
+* (DASH SPEC Section 5.3.9.3.2) contains a set of <SegmentURL> nodes.  Each
+* node should be translated into segment.
+*
+* @param {Object} attributes
+*   Object containing all inherited attributes from parent elements with attribute
+*   names as keys
+* @return {Object.<Array>} list of segments
+*/
+var segmentsFromBase = (attributes) => {
+	const { baseUrl, initialization = {}, sourceDuration, indexRange = "", periodStart, presentationTime, number = 0, duration } = attributes;
+	if (!baseUrl) throw new Error(errors.NO_BASE_URL);
+	const initSegment = urlTypeToSegment({
+		baseUrl,
+		source: initialization.sourceURL,
+		range: initialization.range
+	});
+	const segment = urlTypeToSegment({
+		baseUrl,
+		source: baseUrl,
+		indexRange
+	});
+	segment.map = initSegment;
+	if (duration) {
+		const segmentTimeInfo = parseByDuration(attributes);
+		if (segmentTimeInfo.length) {
+			segment.duration = segmentTimeInfo[0].duration;
+			segment.timeline = segmentTimeInfo[0].timeline;
+		}
+	} else if (sourceDuration) {
+		segment.duration = sourceDuration;
+		segment.timeline = periodStart;
+	}
+	segment.presentationTime = presentationTime || periodStart;
+	segment.number = number;
+	return [segment];
 };
-const addSidxSegmentsToPlaylist$1 = (playlist, sidx, baseUrl) => {
-  const initSegment = playlist.sidx.map ? playlist.sidx.map : null;
-  const sourceDuration = playlist.sidx.duration;
-  const timeline = playlist.timeline || 0;
-  const sidxByteRange = playlist.sidx.byterange;
-  const sidxEnd = sidxByteRange.offset + sidxByteRange.length;
-  const timescale = sidx.timescale;
-  const mediaReferences = sidx.references.filter((r) => r.referenceType !== 1);
-  const segments = [];
-  const type = playlist.endList ? "static" : "dynamic";
-  const periodStart = playlist.sidx.timeline;
-  let presentationTime = periodStart;
-  let number = playlist.mediaSequence || 0;
-  let startIndex;
-  if (typeof sidx.firstOffset === "bigint") {
-    startIndex = window$1.BigInt(sidxEnd) + sidx.firstOffset;
-  } else {
-    startIndex = sidxEnd + sidx.firstOffset;
-  }
-  for (let i = 0; i < mediaReferences.length; i++) {
-    const reference = sidx.references[i];
-    const size = reference.referencedSize;
-    const duration = reference.subsegmentDuration;
-    let endIndex;
-    if (typeof startIndex === "bigint") {
-      endIndex = startIndex + window$1.BigInt(size) - window$1.BigInt(1);
-    } else {
-      endIndex = startIndex + size - 1;
-    }
-    const indexRange = `${startIndex}-${endIndex}`;
-    const attributes = {
-      baseUrl,
-      timescale,
-      timeline,
-      periodStart,
-      presentationTime,
-      number,
-      duration,
-      sourceDuration,
-      indexRange,
-      type
-    };
-    const segment = segmentsFromBase(attributes)[0];
-    if (initSegment) {
-      segment.map = initSegment;
-    }
-    segments.push(segment);
-    if (typeof startIndex === "bigint") {
-      startIndex += window$1.BigInt(size);
-    } else {
-      startIndex += size;
-    }
-    presentationTime += duration / timescale;
-    number++;
-  }
-  playlist.segments = segments;
-  return playlist;
+/**
+* Given a playlist, a sidx box, and a baseUrl, update the segment list of the playlist
+* according to the sidx information given.
+*
+* playlist.sidx has metadadata about the sidx where-as the sidx param
+* is the parsed sidx box itself.
+*
+* @param {Object} playlist the playlist to update the sidx information for
+* @param {Object} sidx the parsed sidx box
+* @return {Object} the playlist object with the updated sidx information
+*/
+var addSidxSegmentsToPlaylist$1 = (playlist, sidx, baseUrl) => {
+	const initSegment = playlist.sidx.map ? playlist.sidx.map : null;
+	const sourceDuration = playlist.sidx.duration;
+	const timeline = playlist.timeline || 0;
+	const sidxByteRange = playlist.sidx.byterange;
+	const sidxEnd = sidxByteRange.offset + sidxByteRange.length;
+	const timescale = sidx.timescale;
+	const mediaReferences = sidx.references.filter((r) => r.referenceType !== 1);
+	const segments = [];
+	const type = playlist.endList ? "static" : "dynamic";
+	const periodStart = playlist.sidx.timeline;
+	let presentationTime = periodStart;
+	let number = playlist.mediaSequence || 0;
+	let startIndex;
+	if (typeof sidx.firstOffset === "bigint") startIndex = import_window.default.BigInt(sidxEnd) + sidx.firstOffset;
+	else startIndex = sidxEnd + sidx.firstOffset;
+	for (let i = 0; i < mediaReferences.length; i++) {
+		const reference = sidx.references[i];
+		const size = reference.referencedSize;
+		const duration = reference.subsegmentDuration;
+		let endIndex;
+		if (typeof startIndex === "bigint") endIndex = startIndex + import_window.default.BigInt(size) - import_window.default.BigInt(1);
+		else endIndex = startIndex + size - 1;
+		const indexRange = `${startIndex}-${endIndex}`;
+		const segment = segmentsFromBase({
+			baseUrl,
+			timescale,
+			timeline,
+			periodStart,
+			presentationTime,
+			number,
+			duration,
+			sourceDuration,
+			indexRange,
+			type
+		})[0];
+		if (initSegment) segment.map = initSegment;
+		segments.push(segment);
+		if (typeof startIndex === "bigint") startIndex += import_window.default.BigInt(size);
+		else startIndex += size;
+		presentationTime += duration / timescale;
+		number++;
+	}
+	playlist.segments = segments;
+	return playlist;
 };
-const SUPPORTED_MEDIA_TYPES = ["AUDIO", "SUBTITLES"];
-const TIME_FUDGE = 1 / 60;
-const getUniqueTimelineStarts = (timelineStarts) => {
-  return union(timelineStarts, ({
-    timeline
-  }) => timeline).sort((a, b) => a.timeline > b.timeline ? 1 : -1);
+var SUPPORTED_MEDIA_TYPES = ["AUDIO", "SUBTITLES"];
+var TIME_FUDGE = 1 / 60;
+/**
+* Given a list of timelineStarts, combines, dedupes, and sorts them.
+*
+* @param {TimelineStart[]} timelineStarts - list of timeline starts
+*
+* @return {TimelineStart[]} the combined and deduped timeline starts
+*/
+var getUniqueTimelineStarts = (timelineStarts) => {
+	return union(timelineStarts, ({ timeline }) => timeline).sort((a, b) => a.timeline > b.timeline ? 1 : -1);
 };
-const findPlaylistWithName = (playlists, name) => {
-  for (let i = 0; i < playlists.length; i++) {
-    if (playlists[i].attributes.NAME === name) {
-      return playlists[i];
-    }
-  }
-  return null;
+/**
+* Finds the playlist with the matching NAME attribute.
+*
+* @param {Array} playlists - playlists to search through
+* @param {string} name - the NAME attribute to search for
+*
+* @return {Object|null} the matching playlist object, or null
+*/
+var findPlaylistWithName = (playlists, name) => {
+	for (let i = 0; i < playlists.length; i++) if (playlists[i].attributes.NAME === name) return playlists[i];
+	return null;
 };
-const getMediaGroupPlaylists = (manifest) => {
-  let mediaGroupPlaylists = [];
-  forEachMediaGroup(manifest, SUPPORTED_MEDIA_TYPES, (properties, type, group, label) => {
-    mediaGroupPlaylists = mediaGroupPlaylists.concat(properties.playlists || []);
-  });
-  return mediaGroupPlaylists;
+/**
+* Gets a flattened array of media group playlists.
+*
+* @param {Object} manifest - the main manifest object
+*
+* @return {Array} the media group playlists
+*/
+var getMediaGroupPlaylists = (manifest) => {
+	let mediaGroupPlaylists = [];
+	forEachMediaGroup(manifest, SUPPORTED_MEDIA_TYPES, (properties, type, group, label) => {
+		mediaGroupPlaylists = mediaGroupPlaylists.concat(properties.playlists || []);
+	});
+	return mediaGroupPlaylists;
 };
-const updateMediaSequenceForPlaylist = ({
-  playlist,
-  mediaSequence
-}) => {
-  playlist.mediaSequence = mediaSequence;
-  playlist.segments.forEach((segment, index) => {
-    segment.number = playlist.mediaSequence + index;
-  });
+/**
+* Updates the playlist's media sequence numbers.
+*
+* @param {Object} config - options object
+* @param {Object} config.playlist - the playlist to update
+* @param {number} config.mediaSequence - the mediaSequence number to start with
+*/
+var updateMediaSequenceForPlaylist = ({ playlist, mediaSequence }) => {
+	playlist.mediaSequence = mediaSequence;
+	playlist.segments.forEach((segment, index) => {
+		segment.number = playlist.mediaSequence + index;
+	});
 };
-const updateSequenceNumbers = ({
-  oldPlaylists,
-  newPlaylists,
-  timelineStarts
-}) => {
-  newPlaylists.forEach((playlist) => {
-    playlist.discontinuitySequence = timelineStarts.findIndex(function({
-      timeline
-    }) {
-      return timeline === playlist.timeline;
-    });
-    const oldPlaylist = findPlaylistWithName(oldPlaylists, playlist.attributes.NAME);
-    if (!oldPlaylist) {
-      return;
-    }
-    if (playlist.sidx) {
-      return;
-    }
-    const firstNewSegment = playlist.segments[0];
-    const oldMatchingSegmentIndex = oldPlaylist.segments.findIndex(function(oldSegment) {
-      return Math.abs(oldSegment.presentationTime - firstNewSegment.presentationTime) < TIME_FUDGE;
-    });
-    if (oldMatchingSegmentIndex === -1) {
-      updateMediaSequenceForPlaylist({
-        playlist,
-        mediaSequence: oldPlaylist.mediaSequence + oldPlaylist.segments.length
-      });
-      playlist.segments[0].discontinuity = true;
-      playlist.discontinuityStarts.unshift(0);
-      if (!oldPlaylist.segments.length && playlist.timeline > oldPlaylist.timeline || oldPlaylist.segments.length && playlist.timeline > oldPlaylist.segments[oldPlaylist.segments.length - 1].timeline) {
-        playlist.discontinuitySequence--;
-      }
-      return;
-    }
-    const oldMatchingSegment = oldPlaylist.segments[oldMatchingSegmentIndex];
-    if (oldMatchingSegment.discontinuity && !firstNewSegment.discontinuity) {
-      firstNewSegment.discontinuity = true;
-      playlist.discontinuityStarts.unshift(0);
-      playlist.discontinuitySequence--;
-    }
-    updateMediaSequenceForPlaylist({
-      playlist,
-      mediaSequence: oldPlaylist.segments[oldMatchingSegmentIndex].number
-    });
-  });
+/**
+* Updates the media and discontinuity sequence numbers of newPlaylists given oldPlaylists
+* and a complete list of timeline starts.
+*
+* If no matching playlist is found, only the discontinuity sequence number of the playlist
+* will be updated.
+*
+* Since early available timelines are not supported, at least one segment must be present.
+*
+* @param {Object} config - options object
+* @param {Object[]} oldPlaylists - the old playlists to use as a reference
+* @param {Object[]} newPlaylists - the new playlists to update
+* @param {Object} timelineStarts - all timelineStarts seen in the stream to this point
+*/
+var updateSequenceNumbers = ({ oldPlaylists, newPlaylists, timelineStarts }) => {
+	newPlaylists.forEach((playlist) => {
+		playlist.discontinuitySequence = timelineStarts.findIndex(function({ timeline }) {
+			return timeline === playlist.timeline;
+		});
+		const oldPlaylist = findPlaylistWithName(oldPlaylists, playlist.attributes.NAME);
+		if (!oldPlaylist) return;
+		if (playlist.sidx) return;
+		const firstNewSegment = playlist.segments[0];
+		const oldMatchingSegmentIndex = oldPlaylist.segments.findIndex(function(oldSegment) {
+			return Math.abs(oldSegment.presentationTime - firstNewSegment.presentationTime) < TIME_FUDGE;
+		});
+		if (oldMatchingSegmentIndex === -1) {
+			updateMediaSequenceForPlaylist({
+				playlist,
+				mediaSequence: oldPlaylist.mediaSequence + oldPlaylist.segments.length
+			});
+			playlist.segments[0].discontinuity = true;
+			playlist.discontinuityStarts.unshift(0);
+			if (!oldPlaylist.segments.length && playlist.timeline > oldPlaylist.timeline || oldPlaylist.segments.length && playlist.timeline > oldPlaylist.segments[oldPlaylist.segments.length - 1].timeline) playlist.discontinuitySequence--;
+			return;
+		}
+		if (oldPlaylist.segments[oldMatchingSegmentIndex].discontinuity && !firstNewSegment.discontinuity) {
+			firstNewSegment.discontinuity = true;
+			playlist.discontinuityStarts.unshift(0);
+			playlist.discontinuitySequence--;
+		}
+		updateMediaSequenceForPlaylist({
+			playlist,
+			mediaSequence: oldPlaylist.segments[oldMatchingSegmentIndex].number
+		});
+	});
 };
-const positionManifestOnTimeline = ({
-  oldManifest,
-  newManifest
-}) => {
-  const oldPlaylists = oldManifest.playlists.concat(getMediaGroupPlaylists(oldManifest));
-  const newPlaylists = newManifest.playlists.concat(getMediaGroupPlaylists(newManifest));
-  newManifest.timelineStarts = getUniqueTimelineStarts([oldManifest.timelineStarts, newManifest.timelineStarts]);
-  updateSequenceNumbers({
-    oldPlaylists,
-    newPlaylists,
-    timelineStarts: newManifest.timelineStarts
-  });
-  return newManifest;
+/**
+* Given an old parsed manifest object and a new parsed manifest object, updates the
+* sequence and timing values within the new manifest to ensure that it lines up with the
+* old.
+*
+* @param {Array} oldManifest - the old main manifest object
+* @param {Array} newManifest - the new main manifest object
+*
+* @return {Object} the updated new manifest object
+*/
+var positionManifestOnTimeline = ({ oldManifest, newManifest }) => {
+	const oldPlaylists = oldManifest.playlists.concat(getMediaGroupPlaylists(oldManifest));
+	const newPlaylists = newManifest.playlists.concat(getMediaGroupPlaylists(newManifest));
+	newManifest.timelineStarts = getUniqueTimelineStarts([oldManifest.timelineStarts, newManifest.timelineStarts]);
+	updateSequenceNumbers({
+		oldPlaylists,
+		newPlaylists,
+		timelineStarts: newManifest.timelineStarts
+	});
+	return newManifest;
 };
-const generateSidxKey = (sidx) => sidx && sidx.uri + "-" + byteRangeToString(sidx.byterange);
-const mergeDiscontiguousPlaylists = (playlists) => {
-  const playlistsByBaseUrl = playlists.reduce(function(acc, cur) {
-    if (!acc[cur.attributes.baseUrl]) {
-      acc[cur.attributes.baseUrl] = [];
-    }
-    acc[cur.attributes.baseUrl].push(cur);
-    return acc;
-  }, {});
-  let allPlaylists = [];
-  Object.values(playlistsByBaseUrl).forEach((playlistGroup) => {
-    const mergedPlaylists = values(playlistGroup.reduce((acc, playlist) => {
-      const name = playlist.attributes.id + (playlist.attributes.lang || "");
-      if (!acc[name]) {
-        acc[name] = playlist;
-        acc[name].attributes.timelineStarts = [];
-      } else {
-        if (playlist.segments) {
-          if (playlist.segments[0]) {
-            playlist.segments[0].discontinuity = true;
-          }
-          acc[name].segments.push(...playlist.segments);
-        }
-        if (playlist.attributes.contentProtection) {
-          acc[name].attributes.contentProtection = playlist.attributes.contentProtection;
-        }
-      }
-      acc[name].attributes.timelineStarts.push({
-        // Although they represent the same number, it's important to have both to make it
-        // compatible with HLS potentially having a similar attribute.
-        start: playlist.attributes.periodStart,
-        timeline: playlist.attributes.periodStart
-      });
-      return acc;
-    }, {}));
-    allPlaylists = allPlaylists.concat(mergedPlaylists);
-  });
-  return allPlaylists.map((playlist) => {
-    playlist.discontinuityStarts = findIndexes(playlist.segments || [], "discontinuity");
-    return playlist;
-  });
+var generateSidxKey = (sidx) => sidx && sidx.uri + "-" + byteRangeToString(sidx.byterange);
+var mergeDiscontiguousPlaylists = (playlists) => {
+	const playlistsByBaseUrl = playlists.reduce(function(acc, cur) {
+		if (!acc[cur.attributes.baseUrl]) acc[cur.attributes.baseUrl] = [];
+		acc[cur.attributes.baseUrl].push(cur);
+		return acc;
+	}, {});
+	let allPlaylists = [];
+	Object.values(playlistsByBaseUrl).forEach((playlistGroup) => {
+		const mergedPlaylists = values(playlistGroup.reduce((acc, playlist) => {
+			const name = playlist.attributes.id + (playlist.attributes.lang || "");
+			if (!acc[name]) {
+				acc[name] = playlist;
+				acc[name].attributes.timelineStarts = [];
+			} else {
+				if (playlist.segments) {
+					if (playlist.segments[0]) playlist.segments[0].discontinuity = true;
+					acc[name].segments.push(...playlist.segments);
+				}
+				if (playlist.attributes.contentProtection) acc[name].attributes.contentProtection = playlist.attributes.contentProtection;
+			}
+			acc[name].attributes.timelineStarts.push({
+				start: playlist.attributes.periodStart,
+				timeline: playlist.attributes.periodStart
+			});
+			return acc;
+		}, {}));
+		allPlaylists = allPlaylists.concat(mergedPlaylists);
+	});
+	return allPlaylists.map((playlist) => {
+		playlist.discontinuityStarts = findIndexes(playlist.segments || [], "discontinuity");
+		return playlist;
+	});
 };
-const addSidxSegmentsToPlaylist = (playlist, sidxMapping) => {
-  const sidxKey = generateSidxKey(playlist.sidx);
-  const sidxMatch = sidxKey && sidxMapping[sidxKey] && sidxMapping[sidxKey].sidx;
-  if (sidxMatch) {
-    addSidxSegmentsToPlaylist$1(playlist, sidxMatch, playlist.sidx.resolvedUri);
-  }
-  return playlist;
+var addSidxSegmentsToPlaylist = (playlist, sidxMapping) => {
+	const sidxKey = generateSidxKey(playlist.sidx);
+	const sidxMatch = sidxKey && sidxMapping[sidxKey] && sidxMapping[sidxKey].sidx;
+	if (sidxMatch) addSidxSegmentsToPlaylist$1(playlist, sidxMatch, playlist.sidx.resolvedUri);
+	return playlist;
 };
-const addSidxSegmentsToPlaylists = (playlists, sidxMapping = {}) => {
-  if (!Object.keys(sidxMapping).length) {
-    return playlists;
-  }
-  for (const i in playlists) {
-    playlists[i] = addSidxSegmentsToPlaylist(playlists[i], sidxMapping);
-  }
-  return playlists;
+var addSidxSegmentsToPlaylists = (playlists, sidxMapping = {}) => {
+	if (!Object.keys(sidxMapping).length) return playlists;
+	for (const i in playlists) playlists[i] = addSidxSegmentsToPlaylist(playlists[i], sidxMapping);
+	return playlists;
 };
-const formatAudioPlaylist = ({
-  attributes,
-  segments,
-  sidx,
-  mediaSequence,
-  discontinuitySequence,
-  discontinuityStarts
-}, isAudioOnly) => {
-  const playlist = {
-    attributes: {
-      NAME: attributes.id,
-      BANDWIDTH: attributes.bandwidth,
-      CODECS: attributes.codecs,
-      ["PROGRAM-ID"]: 1
-    },
-    uri: "",
-    endList: attributes.type === "static",
-    timeline: attributes.periodStart,
-    resolvedUri: attributes.baseUrl || "",
-    targetDuration: attributes.duration,
-    discontinuitySequence,
-    discontinuityStarts,
-    timelineStarts: attributes.timelineStarts,
-    mediaSequence,
-    segments
-  };
-  if (attributes.contentProtection) {
-    playlist.contentProtection = attributes.contentProtection;
-  }
-  if (attributes.serviceLocation) {
-    playlist.attributes.serviceLocation = attributes.serviceLocation;
-  }
-  if (sidx) {
-    playlist.sidx = sidx;
-  }
-  if (isAudioOnly) {
-    playlist.attributes.AUDIO = "audio";
-    playlist.attributes.SUBTITLES = "subs";
-  }
-  return playlist;
+var formatAudioPlaylist = ({ attributes, segments, sidx, mediaSequence, discontinuitySequence, discontinuityStarts }, isAudioOnly) => {
+	const playlist = {
+		attributes: {
+			NAME: attributes.id,
+			BANDWIDTH: attributes.bandwidth,
+			CODECS: attributes.codecs,
+			["PROGRAM-ID"]: 1
+		},
+		uri: "",
+		endList: attributes.type === "static",
+		timeline: attributes.periodStart,
+		resolvedUri: attributes.baseUrl || "",
+		targetDuration: attributes.duration,
+		discontinuitySequence,
+		discontinuityStarts,
+		timelineStarts: attributes.timelineStarts,
+		mediaSequence,
+		segments
+	};
+	if (attributes.contentProtection) playlist.contentProtection = attributes.contentProtection;
+	if (attributes.serviceLocation) playlist.attributes.serviceLocation = attributes.serviceLocation;
+	if (sidx) playlist.sidx = sidx;
+	if (isAudioOnly) {
+		playlist.attributes.AUDIO = "audio";
+		playlist.attributes.SUBTITLES = "subs";
+	}
+	return playlist;
 };
-const formatVttPlaylist = ({
-  attributes,
-  segments,
-  mediaSequence,
-  discontinuityStarts,
-  discontinuitySequence
-}) => {
-  if (typeof segments === "undefined") {
-    segments = [{
-      uri: attributes.baseUrl,
-      timeline: attributes.periodStart,
-      resolvedUri: attributes.baseUrl || "",
-      duration: attributes.sourceDuration,
-      number: 0
-    }];
-    attributes.duration = attributes.sourceDuration;
-  }
-  const m3u8Attributes = {
-    NAME: attributes.id,
-    BANDWIDTH: attributes.bandwidth,
-    ["PROGRAM-ID"]: 1
-  };
-  if (attributes.codecs) {
-    m3u8Attributes.CODECS = attributes.codecs;
-  }
-  const vttPlaylist = {
-    attributes: m3u8Attributes,
-    uri: "",
-    endList: attributes.type === "static",
-    timeline: attributes.periodStart,
-    resolvedUri: attributes.baseUrl || "",
-    targetDuration: attributes.duration,
-    timelineStarts: attributes.timelineStarts,
-    discontinuityStarts,
-    discontinuitySequence,
-    mediaSequence,
-    segments
-  };
-  if (attributes.serviceLocation) {
-    vttPlaylist.attributes.serviceLocation = attributes.serviceLocation;
-  }
-  return vttPlaylist;
+var formatVttPlaylist = ({ attributes, segments, mediaSequence, discontinuityStarts, discontinuitySequence }) => {
+	if (typeof segments === "undefined") {
+		segments = [{
+			uri: attributes.baseUrl,
+			timeline: attributes.periodStart,
+			resolvedUri: attributes.baseUrl || "",
+			duration: attributes.sourceDuration,
+			number: 0
+		}];
+		attributes.duration = attributes.sourceDuration;
+	}
+	const m3u8Attributes = {
+		NAME: attributes.id,
+		BANDWIDTH: attributes.bandwidth,
+		["PROGRAM-ID"]: 1
+	};
+	if (attributes.codecs) m3u8Attributes.CODECS = attributes.codecs;
+	const vttPlaylist = {
+		attributes: m3u8Attributes,
+		uri: "",
+		endList: attributes.type === "static",
+		timeline: attributes.periodStart,
+		resolvedUri: attributes.baseUrl || "",
+		targetDuration: attributes.duration,
+		timelineStarts: attributes.timelineStarts,
+		discontinuityStarts,
+		discontinuitySequence,
+		mediaSequence,
+		segments
+	};
+	if (attributes.serviceLocation) vttPlaylist.attributes.serviceLocation = attributes.serviceLocation;
+	return vttPlaylist;
 };
-const organizeAudioPlaylists = (playlists, sidxMapping = {}, isAudioOnly = false) => {
-  let mainPlaylist;
-  const formattedPlaylists = playlists.reduce((a, playlist) => {
-    const role = playlist.attributes.role && playlist.attributes.role.value || "";
-    const language = playlist.attributes.lang || "";
-    let label = playlist.attributes.label || "main";
-    if (language && !playlist.attributes.label) {
-      const roleLabel = role ? ` (${role})` : "";
-      label = `${playlist.attributes.lang}${roleLabel}`;
-    }
-    if (!a[label]) {
-      a[label] = {
-        language,
-        autoselect: true,
-        default: role === "main",
-        playlists: [],
-        uri: ""
-      };
-    }
-    const formatted = addSidxSegmentsToPlaylist(formatAudioPlaylist(playlist, isAudioOnly), sidxMapping);
-    a[label].playlists.push(formatted);
-    if (typeof mainPlaylist === "undefined" && role === "main") {
-      mainPlaylist = playlist;
-      mainPlaylist.default = true;
-    }
-    return a;
-  }, {});
-  if (!mainPlaylist) {
-    const firstLabel = Object.keys(formattedPlaylists)[0];
-    formattedPlaylists[firstLabel].default = true;
-  }
-  return formattedPlaylists;
+var organizeAudioPlaylists = (playlists, sidxMapping = {}, isAudioOnly = false) => {
+	let mainPlaylist;
+	const formattedPlaylists = playlists.reduce((a, playlist) => {
+		const role = playlist.attributes.role && playlist.attributes.role.value || "";
+		const language = playlist.attributes.lang || "";
+		let label = playlist.attributes.label || "main";
+		if (language && !playlist.attributes.label) {
+			const roleLabel = role ? ` (${role})` : "";
+			label = `${playlist.attributes.lang}${roleLabel}`;
+		}
+		if (!a[label]) a[label] = {
+			language,
+			autoselect: true,
+			default: role === "main",
+			playlists: [],
+			uri: ""
+		};
+		const formatted = addSidxSegmentsToPlaylist(formatAudioPlaylist(playlist, isAudioOnly), sidxMapping);
+		a[label].playlists.push(formatted);
+		if (typeof mainPlaylist === "undefined" && role === "main") {
+			mainPlaylist = playlist;
+			mainPlaylist.default = true;
+		}
+		return a;
+	}, {});
+	if (!mainPlaylist) {
+		const firstLabel = Object.keys(formattedPlaylists)[0];
+		formattedPlaylists[firstLabel].default = true;
+	}
+	return formattedPlaylists;
 };
-const organizeVttPlaylists = (playlists, sidxMapping = {}) => {
-  return playlists.reduce((a, playlist) => {
-    const label = playlist.attributes.label || playlist.attributes.lang || "text";
-    const language = playlist.attributes.lang || "und";
-    if (!a[label]) {
-      a[label] = {
-        language,
-        default: false,
-        autoselect: false,
-        playlists: [],
-        uri: ""
-      };
-    }
-    a[label].playlists.push(addSidxSegmentsToPlaylist(formatVttPlaylist(playlist), sidxMapping));
-    return a;
-  }, {});
+var organizeVttPlaylists = (playlists, sidxMapping = {}) => {
+	return playlists.reduce((a, playlist) => {
+		const label = playlist.attributes.label || playlist.attributes.lang || "text";
+		const language = playlist.attributes.lang || "und";
+		if (!a[label]) a[label] = {
+			language,
+			default: false,
+			autoselect: false,
+			playlists: [],
+			uri: ""
+		};
+		a[label].playlists.push(addSidxSegmentsToPlaylist(formatVttPlaylist(playlist), sidxMapping));
+		return a;
+	}, {});
 };
-const organizeCaptionServices = (captionServices) => captionServices.reduce((svcObj, svc) => {
-  if (!svc) {
-    return svcObj;
-  }
-  svc.forEach((service) => {
-    const {
-      channel,
-      language
-    } = service;
-    svcObj[language] = {
-      autoselect: false,
-      default: false,
-      instreamId: channel,
-      language
-    };
-    if (service.hasOwnProperty("aspectRatio")) {
-      svcObj[language].aspectRatio = service.aspectRatio;
-    }
-    if (service.hasOwnProperty("easyReader")) {
-      svcObj[language].easyReader = service.easyReader;
-    }
-    if (service.hasOwnProperty("3D")) {
-      svcObj[language]["3D"] = service["3D"];
-    }
-  });
-  return svcObj;
+var organizeCaptionServices = (captionServices) => captionServices.reduce((svcObj, svc) => {
+	if (!svc) return svcObj;
+	svc.forEach((service) => {
+		const { channel, language } = service;
+		svcObj[language] = {
+			autoselect: false,
+			default: false,
+			instreamId: channel,
+			language
+		};
+		if (service.hasOwnProperty("aspectRatio")) svcObj[language].aspectRatio = service.aspectRatio;
+		if (service.hasOwnProperty("easyReader")) svcObj[language].easyReader = service.easyReader;
+		if (service.hasOwnProperty("3D")) svcObj[language]["3D"] = service["3D"];
+	});
+	return svcObj;
 }, {});
-const formatVideoPlaylist = ({
-  attributes,
-  segments,
-  sidx,
-  discontinuityStarts
-}) => {
-  const playlist = {
-    attributes: {
-      NAME: attributes.id,
-      AUDIO: "audio",
-      SUBTITLES: "subs",
-      RESOLUTION: {
-        width: attributes.width,
-        height: attributes.height
-      },
-      CODECS: attributes.codecs,
-      BANDWIDTH: attributes.bandwidth,
-      ["PROGRAM-ID"]: 1
-    },
-    uri: "",
-    endList: attributes.type === "static",
-    timeline: attributes.periodStart,
-    resolvedUri: attributes.baseUrl || "",
-    targetDuration: attributes.duration,
-    discontinuityStarts,
-    timelineStarts: attributes.timelineStarts,
-    segments
-  };
-  if (attributes.frameRate) {
-    playlist.attributes["FRAME-RATE"] = attributes.frameRate;
-  }
-  if (attributes.contentProtection) {
-    playlist.contentProtection = attributes.contentProtection;
-  }
-  if (attributes.serviceLocation) {
-    playlist.attributes.serviceLocation = attributes.serviceLocation;
-  }
-  if (sidx) {
-    playlist.sidx = sidx;
-  }
-  return playlist;
-};
-const videoOnly = ({
-  attributes
-}) => attributes.mimeType === "video/mp4" || attributes.mimeType === "video/webm" || attributes.contentType === "video";
-const audioOnly = ({
-  attributes
-}) => attributes.mimeType === "audio/mp4" || attributes.mimeType === "audio/webm" || attributes.contentType === "audio";
-const vttOnly = ({
-  attributes
-}) => attributes.mimeType === "text/vtt" || attributes.contentType === "text";
-const addMediaSequenceValues = (playlists, timelineStarts) => {
-  playlists.forEach((playlist) => {
-    playlist.mediaSequence = 0;
-    playlist.discontinuitySequence = timelineStarts.findIndex(function({
-      timeline
-    }) {
-      return timeline === playlist.timeline;
-    });
-    if (!playlist.segments) {
-      return;
-    }
-    playlist.segments.forEach((segment, index) => {
-      segment.number = index;
-    });
-  });
+var formatVideoPlaylist = ({ attributes, segments, sidx, discontinuityStarts }) => {
+	const playlist = {
+		attributes: {
+			NAME: attributes.id,
+			AUDIO: "audio",
+			SUBTITLES: "subs",
+			RESOLUTION: {
+				width: attributes.width,
+				height: attributes.height
+			},
+			CODECS: attributes.codecs,
+			BANDWIDTH: attributes.bandwidth,
+			["PROGRAM-ID"]: 1
+		},
+		uri: "",
+		endList: attributes.type === "static",
+		timeline: attributes.periodStart,
+		resolvedUri: attributes.baseUrl || "",
+		targetDuration: attributes.duration,
+		discontinuityStarts,
+		timelineStarts: attributes.timelineStarts,
+		segments
+	};
+	if (attributes.frameRate) playlist.attributes["FRAME-RATE"] = attributes.frameRate;
+	if (attributes.contentProtection) playlist.contentProtection = attributes.contentProtection;
+	if (attributes.serviceLocation) playlist.attributes.serviceLocation = attributes.serviceLocation;
+	if (sidx) playlist.sidx = sidx;
+	return playlist;
 };
-const flattenMediaGroupPlaylists = (mediaGroupObject) => {
-  if (!mediaGroupObject) {
-    return [];
-  }
-  return Object.keys(mediaGroupObject).reduce((acc, label) => {
-    const labelContents = mediaGroupObject[label];
-    return acc.concat(labelContents.playlists);
-  }, []);
+var videoOnly = ({ attributes }) => attributes.mimeType === "video/mp4" || attributes.mimeType === "video/webm" || attributes.contentType === "video";
+var audioOnly = ({ attributes }) => attributes.mimeType === "audio/mp4" || attributes.mimeType === "audio/webm" || attributes.contentType === "audio";
+var vttOnly = ({ attributes }) => attributes.mimeType === "text/vtt" || attributes.contentType === "text";
+/**
+* Contains start and timeline properties denoting a timeline start. For DASH, these will
+* be the same number.
+*
+* @typedef {Object} TimelineStart
+* @property {number} start - the start time of the timeline
+* @property {number} timeline - the timeline number
+*/
+/**
+* Adds appropriate media and discontinuity sequence values to the segments and playlists.
+*
+* Throughout mpd-parser, the `number` attribute is used in relation to `startNumber`, a
+* DASH specific attribute used in constructing segment URI's from templates. However, from
+* an HLS perspective, the `number` attribute on a segment would be its `mediaSequence`
+* value, which should start at the original media sequence value (or 0) and increment by 1
+* for each segment thereafter. Since DASH's `startNumber` values are independent per
+* period, it doesn't make sense to use it for `number`. Instead, assume everything starts
+* from a 0 mediaSequence value and increment from there.
+*
+* Note that VHS currently doesn't use the `number` property, but it can be helpful for
+* debugging and making sense of the manifest.
+*
+* For live playlists, to account for values increasing in manifests when periods are
+* removed on refreshes, merging logic should be used to update the numbers to their
+* appropriate values (to ensure they're sequential and increasing).
+*
+* @param {Object[]} playlists - the playlists to update
+* @param {TimelineStart[]} timelineStarts - the timeline starts for the manifest
+*/
+var addMediaSequenceValues = (playlists, timelineStarts) => {
+	playlists.forEach((playlist) => {
+		playlist.mediaSequence = 0;
+		playlist.discontinuitySequence = timelineStarts.findIndex(function({ timeline }) {
+			return timeline === playlist.timeline;
+		});
+		if (!playlist.segments) return;
+		playlist.segments.forEach((segment, index) => {
+			segment.number = index;
+		});
+	});
 };
-const toM3u8 = ({
-  dashPlaylists,
-  locations,
-  contentSteering,
-  sidxMapping = {},
-  previousManifest,
-  eventStream
-}) => {
-  if (!dashPlaylists.length) {
-    return {};
-  }
-  const {
-    sourceDuration: duration,
-    type,
-    suggestedPresentationDelay,
-    minimumUpdatePeriod
-  } = dashPlaylists[0].attributes;
-  const videoPlaylists = mergeDiscontiguousPlaylists(dashPlaylists.filter(videoOnly)).map(formatVideoPlaylist);
-  const audioPlaylists = mergeDiscontiguousPlaylists(dashPlaylists.filter(audioOnly));
-  const vttPlaylists = mergeDiscontiguousPlaylists(dashPlaylists.filter(vttOnly));
-  const captions = dashPlaylists.map((playlist) => playlist.attributes.captionServices).filter(Boolean);
-  const manifest = {
-    allowCache: true,
-    discontinuityStarts: [],
-    segments: [],
-    endList: true,
-    mediaGroups: {
-      AUDIO: {},
-      VIDEO: {},
-      ["CLOSED-CAPTIONS"]: {},
-      SUBTITLES: {}
-    },
-    uri: "",
-    duration,
-    playlists: addSidxSegmentsToPlaylists(videoPlaylists, sidxMapping)
-  };
-  if (minimumUpdatePeriod >= 0) {
-    manifest.minimumUpdatePeriod = minimumUpdatePeriod * 1e3;
-  }
-  if (locations) {
-    manifest.locations = locations;
-  }
-  if (contentSteering) {
-    manifest.contentSteering = contentSteering;
-  }
-  if (type === "dynamic") {
-    manifest.suggestedPresentationDelay = suggestedPresentationDelay;
-  }
-  if (eventStream && eventStream.length > 0) {
-    manifest.eventStream = eventStream;
-  }
-  const isAudioOnly = manifest.playlists.length === 0;
-  const organizedAudioGroup = audioPlaylists.length ? organizeAudioPlaylists(audioPlaylists, sidxMapping, isAudioOnly) : null;
-  const organizedVttGroup = vttPlaylists.length ? organizeVttPlaylists(vttPlaylists, sidxMapping) : null;
-  const formattedPlaylists = videoPlaylists.concat(flattenMediaGroupPlaylists(organizedAudioGroup), flattenMediaGroupPlaylists(organizedVttGroup));
-  const playlistTimelineStarts = formattedPlaylists.map(({
-    timelineStarts
-  }) => timelineStarts);
-  manifest.timelineStarts = getUniqueTimelineStarts(playlistTimelineStarts);
-  addMediaSequenceValues(formattedPlaylists, manifest.timelineStarts);
-  if (organizedAudioGroup) {
-    manifest.mediaGroups.AUDIO.audio = organizedAudioGroup;
-  }
-  if (organizedVttGroup) {
-    manifest.mediaGroups.SUBTITLES.subs = organizedVttGroup;
-  }
-  if (captions.length) {
-    manifest.mediaGroups["CLOSED-CAPTIONS"].cc = organizeCaptionServices(captions);
-  }
-  if (previousManifest) {
-    return positionManifestOnTimeline({
-      oldManifest: previousManifest,
-      newManifest: manifest
-    });
-  }
-  return manifest;
+/**
+* Given a media group object, flattens all playlists within the media group into a single
+* array.
+*
+* @param {Object} mediaGroupObject - the media group object
+*
+* @return {Object[]}
+*         The media group playlists
+*/
+var flattenMediaGroupPlaylists = (mediaGroupObject) => {
+	if (!mediaGroupObject) return [];
+	return Object.keys(mediaGroupObject).reduce((acc, label) => {
+		const labelContents = mediaGroupObject[label];
+		return acc.concat(labelContents.playlists);
+	}, []);
 };
-const getLiveRValue = (attributes, time, duration) => {
-  const {
-    NOW,
-    clientOffset,
-    availabilityStartTime,
-    timescale = 1,
-    periodStart = 0,
-    minimumUpdatePeriod = 0
-  } = attributes;
-  const now = (NOW + clientOffset) / 1e3;
-  const periodStartWC = availabilityStartTime + periodStart;
-  const periodEndWC = now + minimumUpdatePeriod;
-  const periodDuration = periodEndWC - periodStartWC;
-  return Math.ceil((periodDuration * timescale - time) / duration);
+var toM3u8 = ({ dashPlaylists, locations, contentSteering, sidxMapping = {}, previousManifest, eventStream }) => {
+	if (!dashPlaylists.length) return {};
+	const { sourceDuration: duration, type, suggestedPresentationDelay, minimumUpdatePeriod } = dashPlaylists[0].attributes;
+	const videoPlaylists = mergeDiscontiguousPlaylists(dashPlaylists.filter(videoOnly)).map(formatVideoPlaylist);
+	const audioPlaylists = mergeDiscontiguousPlaylists(dashPlaylists.filter(audioOnly));
+	const vttPlaylists = mergeDiscontiguousPlaylists(dashPlaylists.filter(vttOnly));
+	const captions = dashPlaylists.map((playlist) => playlist.attributes.captionServices).filter(Boolean);
+	const manifest = {
+		allowCache: true,
+		discontinuityStarts: [],
+		segments: [],
+		endList: true,
+		mediaGroups: {
+			AUDIO: {},
+			VIDEO: {},
+			["CLOSED-CAPTIONS"]: {},
+			SUBTITLES: {}
+		},
+		uri: "",
+		duration,
+		playlists: addSidxSegmentsToPlaylists(videoPlaylists, sidxMapping)
+	};
+	if (minimumUpdatePeriod >= 0) manifest.minimumUpdatePeriod = minimumUpdatePeriod * 1e3;
+	if (locations) manifest.locations = locations;
+	if (contentSteering) manifest.contentSteering = contentSteering;
+	if (type === "dynamic") manifest.suggestedPresentationDelay = suggestedPresentationDelay;
+	if (eventStream && eventStream.length > 0) manifest.eventStream = eventStream;
+	const isAudioOnly = manifest.playlists.length === 0;
+	const organizedAudioGroup = audioPlaylists.length ? organizeAudioPlaylists(audioPlaylists, sidxMapping, isAudioOnly) : null;
+	const organizedVttGroup = vttPlaylists.length ? organizeVttPlaylists(vttPlaylists, sidxMapping) : null;
+	const formattedPlaylists = videoPlaylists.concat(flattenMediaGroupPlaylists(organizedAudioGroup), flattenMediaGroupPlaylists(organizedVttGroup));
+	manifest.timelineStarts = getUniqueTimelineStarts(formattedPlaylists.map(({ timelineStarts }) => timelineStarts));
+	addMediaSequenceValues(formattedPlaylists, manifest.timelineStarts);
+	if (organizedAudioGroup) manifest.mediaGroups.AUDIO.audio = organizedAudioGroup;
+	if (organizedVttGroup) manifest.mediaGroups.SUBTITLES.subs = organizedVttGroup;
+	if (captions.length) manifest.mediaGroups["CLOSED-CAPTIONS"].cc = organizeCaptionServices(captions);
+	if (previousManifest) return positionManifestOnTimeline({
+		oldManifest: previousManifest,
+		newManifest: manifest
+	});
+	return manifest;
 };
-const parseByTimeline = (attributes, segmentTimeline) => {
-  const {
-    type,
-    minimumUpdatePeriod = 0,
-    media = "",
-    sourceDuration,
-    timescale = 1,
-    startNumber = 1,
-    periodStart: timeline
-  } = attributes;
-  const segments = [];
-  let time = -1;
-  for (let sIndex = 0; sIndex < segmentTimeline.length; sIndex++) {
-    const S = segmentTimeline[sIndex];
-    const duration = S.d;
-    const repeat = S.r || 0;
-    const segmentTime = S.t || 0;
-    if (time < 0) {
-      time = segmentTime;
-    }
-    if (segmentTime && segmentTime > time) {
-      time = segmentTime;
-    }
-    let count;
-    if (repeat < 0) {
-      const nextS = sIndex + 1;
-      if (nextS === segmentTimeline.length) {
-        if (type === "dynamic" && minimumUpdatePeriod > 0 && media.indexOf("$Number$") > 0) {
-          count = getLiveRValue(attributes, time, duration);
-        } else {
-          count = (sourceDuration * timescale - time) / duration;
-        }
-      } else {
-        count = (segmentTimeline[nextS].t - time) / duration;
-      }
-    } else {
-      count = repeat + 1;
-    }
-    const end = startNumber + segments.length + count;
-    let number = startNumber + segments.length;
-    while (number < end) {
-      segments.push({
-        number,
-        duration: duration / timescale,
-        time,
-        timeline
-      });
-      time += duration;
-      number++;
-    }
-  }
-  return segments;
+/**
+* Calculates the R (repetition) value for a live stream (for the final segment
+* in a manifest where the r value is negative 1)
+*
+* @param {Object} attributes
+*        Object containing all inherited attributes from parent elements with attribute
+*        names as keys
+* @param {number} time
+*        current time (typically the total time up until the final segment)
+* @param {number} duration
+*        duration property for the given <S />
+*
+* @return {number}
+*        R value to reach the end of the given period
+*/
+var getLiveRValue = (attributes, time, duration) => {
+	const { NOW, clientOffset, availabilityStartTime, timescale = 1, periodStart = 0, minimumUpdatePeriod = 0 } = attributes;
+	const now = (NOW + clientOffset) / 1e3;
+	const periodStartWC = availabilityStartTime + periodStart;
+	const periodDuration = now + minimumUpdatePeriod - periodStartWC;
+	return Math.ceil((periodDuration * timescale - time) / duration);
 };
-const identifierPattern = /\$([A-z]*)(?:(%0)([0-9]+)d)?\$/g;
-const identifierReplacement = (values2) => (match, identifier, format, width) => {
-  if (match === "$$") {
-    return "$";
-  }
-  if (typeof values2[identifier] === "undefined") {
-    return match;
-  }
-  const value = "" + values2[identifier];
-  if (identifier === "RepresentationID") {
-    return value;
-  }
-  if (!format) {
-    width = 1;
-  } else {
-    width = parseInt(width, 10);
-  }
-  if (value.length >= width) {
-    return value;
-  }
-  return `${new Array(width - value.length + 1).join("0")}${value}`;
+/**
+* Uses information provided by SegmentTemplate.SegmentTimeline to determine segment
+* timing and duration
+*
+* @param {Object} attributes
+*        Object containing all inherited attributes from parent elements with attribute
+*        names as keys
+* @param {Object[]} segmentTimeline
+*        List of objects representing the attributes of each S element contained within
+*
+* @return {{number: number, duration: number, time: number, timeline: number}[]}
+*         List of Objects with segment timing and duration info
+*/
+var parseByTimeline = (attributes, segmentTimeline) => {
+	const { type, minimumUpdatePeriod = 0, media = "", sourceDuration, timescale = 1, startNumber = 1, periodStart: timeline } = attributes;
+	const segments = [];
+	let time = -1;
+	for (let sIndex = 0; sIndex < segmentTimeline.length; sIndex++) {
+		const S = segmentTimeline[sIndex];
+		const duration = S.d;
+		const repeat = S.r || 0;
+		const segmentTime = S.t || 0;
+		if (time < 0) time = segmentTime;
+		if (segmentTime && segmentTime > time) time = segmentTime;
+		let count;
+		if (repeat < 0) {
+			const nextS = sIndex + 1;
+			if (nextS === segmentTimeline.length) {
+				if (type === "dynamic" && minimumUpdatePeriod > 0 && media.indexOf("$Number$") > 0) count = getLiveRValue(attributes, time, duration);
+				else count = (sourceDuration * timescale - time) / duration;
+			} else count = (segmentTimeline[nextS].t - time) / duration;
+		} else count = repeat + 1;
+		const end = startNumber + segments.length + count;
+		let number = startNumber + segments.length;
+		while (number < end) {
+			segments.push({
+				number,
+				duration: duration / timescale,
+				time,
+				timeline
+			});
+			time += duration;
+			number++;
+		}
+	}
+	return segments;
 };
-const constructTemplateUrl = (url, values2) => url.replace(identifierPattern, identifierReplacement(values2));
-const parseTemplateInfo = (attributes, segmentTimeline) => {
-  if (!attributes.duration && !segmentTimeline) {
-    return [{
-      number: attributes.startNumber || 1,
-      duration: attributes.sourceDuration,
-      time: 0,
-      timeline: attributes.periodStart
-    }];
-  }
-  if (attributes.duration) {
-    return parseByDuration(attributes);
-  }
-  return parseByTimeline(attributes, segmentTimeline);
+var identifierPattern = /\$([A-z]*)(?:(%0)([0-9]+)d)?\$/g;
+/**
+* Replaces template identifiers with corresponding values. To be used as the callback
+* for String.prototype.replace
+*
+* @name replaceCallback
+* @function
+* @param {string} match
+*        Entire match of identifier
+* @param {string} identifier
+*        Name of matched identifier
+* @param {string} format
+*        Format tag string. Its presence indicates that padding is expected
+* @param {string} width
+*        Desired length of the replaced value. Values less than this width shall be left
+*        zero padded
+* @return {string}
+*         Replacement for the matched identifier
+*/
+/**
+* Returns a function to be used as a callback for String.prototype.replace to replace
+* template identifiers
+*
+* @param {Obect} values
+*        Object containing values that shall be used to replace known identifiers
+* @param {number} values.RepresentationID
+*        Value of the Representation@id attribute
+* @param {number} values.Number
+*        Number of the corresponding segment
+* @param {number} values.Bandwidth
+*        Value of the Representation@bandwidth attribute.
+* @param {number} values.Time
+*        Timestamp value of the corresponding segment
+* @return {replaceCallback}
+*         Callback to be used with String.prototype.replace to replace identifiers
+*/
+var identifierReplacement = (values) => (match, identifier, format, width) => {
+	if (match === "$$") return "$";
+	if (typeof values[identifier] === "undefined") return match;
+	const value = "" + values[identifier];
+	if (identifier === "RepresentationID") return value;
+	if (!format) width = 1;
+	else width = parseInt(width, 10);
+	if (value.length >= width) return value;
+	return `${new Array(width - value.length + 1).join("0")}${value}`;
 };
-const segmentsFromTemplate = (attributes, segmentTimeline) => {
-  const templateValues = {
-    RepresentationID: attributes.id,
-    Bandwidth: attributes.bandwidth || 0
-  };
-  const {
-    initialization = {
-      sourceURL: "",
-      range: ""
-    }
-  } = attributes;
-  const mapSegment = urlTypeToSegment({
-    baseUrl: attributes.baseUrl,
-    source: constructTemplateUrl(initialization.sourceURL, templateValues),
-    range: initialization.range
-  });
-  const segments = parseTemplateInfo(attributes, segmentTimeline);
-  return segments.map((segment) => {
-    templateValues.Number = segment.number;
-    templateValues.Time = segment.time;
-    const uri = constructTemplateUrl(attributes.media || "", templateValues);
-    const timescale = attributes.timescale || 1;
-    const presentationTimeOffset = attributes.presentationTimeOffset || 0;
-    const presentationTime = (
-      // Even if the @t attribute is not specified for the segment, segment.time is
-      // calculated in mpd-parser prior to this, so it's assumed to be available.
-      attributes.periodStart + (segment.time - presentationTimeOffset) / timescale
-    );
-    const map = {
-      uri,
-      timeline: segment.timeline,
-      duration: segment.duration,
-      resolvedUri: resolveUrl(attributes.baseUrl || "", uri),
-      map: mapSegment,
-      number: segment.number,
-      presentationTime
-    };
-    return map;
-  });
+/**
+* Constructs a segment url from a template string
+*
+* @param {string} url
+*        Template string to construct url from
+* @param {Obect} values
+*        Object containing values that shall be used to replace known identifiers
+* @param {number} values.RepresentationID
+*        Value of the Representation@id attribute
+* @param {number} values.Number
+*        Number of the corresponding segment
+* @param {number} values.Bandwidth
+*        Value of the Representation@bandwidth attribute.
+* @param {number} values.Time
+*        Timestamp value of the corresponding segment
+* @return {string}
+*         Segment url with identifiers replaced
+*/
+var constructTemplateUrl = (url, values) => url.replace(identifierPattern, identifierReplacement(values));
+/**
+* Generates a list of objects containing timing and duration information about each
+* segment needed to generate segment uris and the complete segment object
+*
+* @param {Object} attributes
+*        Object containing all inherited attributes from parent elements with attribute
+*        names as keys
+* @param {Object[]|undefined} segmentTimeline
+*        List of objects representing the attributes of each S element contained within
+*        the SegmentTimeline element
+* @return {{number: number, duration: number, time: number, timeline: number}[]}
+*         List of Objects with segment timing and duration info
+*/
+var parseTemplateInfo = (attributes, segmentTimeline) => {
+	if (!attributes.duration && !segmentTimeline) return [{
+		number: attributes.startNumber || 1,
+		duration: attributes.sourceDuration,
+		time: 0,
+		timeline: attributes.periodStart
+	}];
+	if (attributes.duration) return parseByDuration(attributes);
+	return parseByTimeline(attributes, segmentTimeline);
 };
-const SegmentURLToSegmentObject = (attributes, segmentUrl) => {
-  const {
-    baseUrl,
-    initialization = {}
-  } = attributes;
-  const initSegment = urlTypeToSegment({
-    baseUrl,
-    source: initialization.sourceURL,
-    range: initialization.range
-  });
-  const segment = urlTypeToSegment({
-    baseUrl,
-    source: segmentUrl.media,
-    range: segmentUrl.mediaRange
-  });
-  segment.map = initSegment;
-  return segment;
+/**
+* Generates a list of segments using information provided by the SegmentTemplate element
+*
+* @param {Object} attributes
+*        Object containing all inherited attributes from parent elements with attribute
+*        names as keys
+* @param {Object[]|undefined} segmentTimeline
+*        List of objects representing the attributes of each S element contained within
+*        the SegmentTimeline element
+* @return {Object[]}
+*         List of segment objects
+*/
+var segmentsFromTemplate = (attributes, segmentTimeline) => {
+	const templateValues = {
+		RepresentationID: attributes.id,
+		Bandwidth: attributes.bandwidth || 0
+	};
+	const { initialization = {
+		sourceURL: "",
+		range: ""
+	} } = attributes;
+	const mapSegment = urlTypeToSegment({
+		baseUrl: attributes.baseUrl,
+		source: constructTemplateUrl(initialization.sourceURL, templateValues),
+		range: initialization.range
+	});
+	return parseTemplateInfo(attributes, segmentTimeline).map((segment) => {
+		templateValues.Number = segment.number;
+		templateValues.Time = segment.time;
+		const uri = constructTemplateUrl(attributes.media || "", templateValues);
+		const timescale = attributes.timescale || 1;
+		const presentationTimeOffset = attributes.presentationTimeOffset || 0;
+		const presentationTime = attributes.periodStart + (segment.time - presentationTimeOffset) / timescale;
+		return {
+			uri,
+			timeline: segment.timeline,
+			duration: segment.duration,
+			resolvedUri: resolveUrl(attributes.baseUrl || "", uri),
+			map: mapSegment,
+			number: segment.number,
+			presentationTime
+		};
+	});
 };
-const segmentsFromList = (attributes, segmentTimeline) => {
-  const {
-    duration,
-    segmentUrls = [],
-    periodStart
-  } = attributes;
-  if (!duration && !segmentTimeline || duration && segmentTimeline) {
-    throw new Error(errors.SEGMENT_TIME_UNSPECIFIED);
-  }
-  const segmentUrlMap = segmentUrls.map((segmentUrlObject) => SegmentURLToSegmentObject(attributes, segmentUrlObject));
-  let segmentTimeInfo;
-  if (duration) {
-    segmentTimeInfo = parseByDuration(attributes);
-  }
-  if (segmentTimeline) {
-    segmentTimeInfo = parseByTimeline(attributes, segmentTimeline);
-  }
-  const segments = segmentTimeInfo.map((segmentTime, index) => {
-    if (segmentUrlMap[index]) {
-      const segment = segmentUrlMap[index];
-      const timescale = attributes.timescale || 1;
-      const presentationTimeOffset = attributes.presentationTimeOffset || 0;
-      segment.timeline = segmentTime.timeline;
-      segment.duration = segmentTime.duration;
-      segment.number = segmentTime.number;
-      segment.presentationTime = periodStart + (segmentTime.time - presentationTimeOffset) / timescale;
-      return segment;
-    }
-  }).filter((segment) => segment);
-  return segments;
+/**
+* Converts a <SegmentUrl> (of type URLType from the DASH spec 5.3.9.2 Table 14)
+* to an object that matches the output of a segment in videojs/mpd-parser
+*
+* @param {Object} attributes
+*   Object containing all inherited attributes from parent elements with attribute
+*   names as keys
+* @param {Object} segmentUrl
+*   <SegmentURL> node to translate into a segment object
+* @return {Object} translated segment object
+*/
+var SegmentURLToSegmentObject = (attributes, segmentUrl) => {
+	const { baseUrl, initialization = {} } = attributes;
+	const initSegment = urlTypeToSegment({
+		baseUrl,
+		source: initialization.sourceURL,
+		range: initialization.range
+	});
+	const segment = urlTypeToSegment({
+		baseUrl,
+		source: segmentUrl.media,
+		range: segmentUrl.mediaRange
+	});
+	segment.map = initSegment;
+	return segment;
 };
-const generateSegments = ({
-  attributes,
-  segmentInfo
-}) => {
-  let segmentAttributes;
-  let segmentsFn;
-  if (segmentInfo.template) {
-    segmentsFn = segmentsFromTemplate;
-    segmentAttributes = merge(attributes, segmentInfo.template);
-  } else if (segmentInfo.base) {
-    segmentsFn = segmentsFromBase;
-    segmentAttributes = merge(attributes, segmentInfo.base);
-  } else if (segmentInfo.list) {
-    segmentsFn = segmentsFromList;
-    segmentAttributes = merge(attributes, segmentInfo.list);
-  }
-  const segmentsInfo = {
-    attributes
-  };
-  if (!segmentsFn) {
-    return segmentsInfo;
-  }
-  const segments = segmentsFn(segmentAttributes, segmentInfo.segmentTimeline);
-  if (segmentAttributes.duration) {
-    const {
-      duration,
-      timescale = 1
-    } = segmentAttributes;
-    segmentAttributes.duration = duration / timescale;
-  } else if (segments.length) {
-    segmentAttributes.duration = segments.reduce((max, segment) => {
-      return Math.max(max, Math.ceil(segment.duration));
-    }, 0);
-  } else {
-    segmentAttributes.duration = 0;
-  }
-  segmentsInfo.attributes = segmentAttributes;
-  segmentsInfo.segments = segments;
-  if (segmentInfo.base && segmentAttributes.indexRange) {
-    segmentsInfo.sidx = segments[0];
-    segmentsInfo.segments = [];
-  }
-  return segmentsInfo;
+/**
+* Generates a list of segments using information provided by the SegmentList element
+* SegmentList (DASH SPEC Section 5.3.9.3.2) contains a set of <SegmentURL> nodes.  Each
+* node should be translated into segment.
+*
+* @param {Object} attributes
+*   Object containing all inherited attributes from parent elements with attribute
+*   names as keys
+* @param {Object[]|undefined} segmentTimeline
+*        List of objects representing the attributes of each S element contained within
+*        the SegmentTimeline element
+* @return {Object.<Array>} list of segments
+*/
+var segmentsFromList = (attributes, segmentTimeline) => {
+	const { duration, segmentUrls = [], periodStart } = attributes;
+	if (!duration && !segmentTimeline || duration && segmentTimeline) throw new Error(errors.SEGMENT_TIME_UNSPECIFIED);
+	const segmentUrlMap = segmentUrls.map((segmentUrlObject) => SegmentURLToSegmentObject(attributes, segmentUrlObject));
+	let segmentTimeInfo;
+	if (duration) segmentTimeInfo = parseByDuration(attributes);
+	if (segmentTimeline) segmentTimeInfo = parseByTimeline(attributes, segmentTimeline);
+	return segmentTimeInfo.map((segmentTime, index) => {
+		if (segmentUrlMap[index]) {
+			const segment = segmentUrlMap[index];
+			const timescale = attributes.timescale || 1;
+			const presentationTimeOffset = attributes.presentationTimeOffset || 0;
+			segment.timeline = segmentTime.timeline;
+			segment.duration = segmentTime.duration;
+			segment.number = segmentTime.number;
+			segment.presentationTime = periodStart + (segmentTime.time - presentationTimeOffset) / timescale;
+			return segment;
+		}
+	}).filter((segment) => segment);
 };
-const toPlaylists = (representations) => representations.map(generateSegments);
-const findChildren = (element, name) => from(element.childNodes).filter(({
-  tagName
-}) => tagName === name);
-const getContent = (element) => element.textContent.trim();
-const parseDivisionValue = (value) => {
-  return parseFloat(value.split("/").reduce((prev, current) => prev / current));
+var generateSegments = ({ attributes, segmentInfo }) => {
+	let segmentAttributes;
+	let segmentsFn;
+	if (segmentInfo.template) {
+		segmentsFn = segmentsFromTemplate;
+		segmentAttributes = merge(attributes, segmentInfo.template);
+	} else if (segmentInfo.base) {
+		segmentsFn = segmentsFromBase;
+		segmentAttributes = merge(attributes, segmentInfo.base);
+	} else if (segmentInfo.list) {
+		segmentsFn = segmentsFromList;
+		segmentAttributes = merge(attributes, segmentInfo.list);
+	}
+	const segmentsInfo = { attributes };
+	if (!segmentsFn) return segmentsInfo;
+	const segments = segmentsFn(segmentAttributes, segmentInfo.segmentTimeline);
+	if (segmentAttributes.duration) {
+		const { duration, timescale = 1 } = segmentAttributes;
+		segmentAttributes.duration = duration / timescale;
+	} else if (segments.length) segmentAttributes.duration = segments.reduce((max, segment) => {
+		return Math.max(max, Math.ceil(segment.duration));
+	}, 0);
+	else segmentAttributes.duration = 0;
+	segmentsInfo.attributes = segmentAttributes;
+	segmentsInfo.segments = segments;
+	if (segmentInfo.base && segmentAttributes.indexRange) {
+		segmentsInfo.sidx = segments[0];
+		segmentsInfo.segments = [];
+	}
+	return segmentsInfo;
 };
-const parseDuration = (str) => {
-  const SECONDS_IN_YEAR = 365 * 24 * 60 * 60;
-  const SECONDS_IN_MONTH = 30 * 24 * 60 * 60;
-  const SECONDS_IN_DAY = 24 * 60 * 60;
-  const SECONDS_IN_HOUR = 60 * 60;
-  const SECONDS_IN_MIN = 60;
-  const durationRegex = /P(?:(\d*)Y)?(?:(\d*)M)?(?:(\d*)D)?(?:T(?:(\d*)H)?(?:(\d*)M)?(?:([\d.]*)S)?)?/;
-  const match = durationRegex.exec(str);
-  if (!match) {
-    return 0;
-  }
-  const [year, month, day, hour, minute, second] = match.slice(1);
-  return parseFloat(year || 0) * SECONDS_IN_YEAR + parseFloat(month || 0) * SECONDS_IN_MONTH + parseFloat(day || 0) * SECONDS_IN_DAY + parseFloat(hour || 0) * SECONDS_IN_HOUR + parseFloat(minute || 0) * SECONDS_IN_MIN + parseFloat(second || 0);
+var toPlaylists = (representations) => representations.map(generateSegments);
+var findChildren = (element, name) => from(element.childNodes).filter(({ tagName }) => tagName === name);
+var getContent = (element) => element.textContent.trim();
+/**
+* Converts the provided string that may contain a division operation to a number.
+*
+* @param {string} value - the provided string value
+*
+* @return {number} the parsed string value
+*/
+var parseDivisionValue = (value) => {
+	return parseFloat(value.split("/").reduce((prev, current) => prev / current));
 };
-const parseDate = (str) => {
-  const dateRegex = /^\d+-\d+-\d+T\d+:\d+:\d+(\.\d+)?$/;
-  if (dateRegex.test(str)) {
-    str += "Z";
-  }
-  return Date.parse(str);
+var parseDuration = (str) => {
+	const SECONDS_IN_YEAR = 31536e3;
+	const SECONDS_IN_MONTH = 2592e3;
+	const SECONDS_IN_DAY = 86400;
+	const SECONDS_IN_HOUR = 3600;
+	const SECONDS_IN_MIN = 60;
+	const match = /P(?:(\d*)Y)?(?:(\d*)M)?(?:(\d*)D)?(?:T(?:(\d*)H)?(?:(\d*)M)?(?:([\d.]*)S)?)?/.exec(str);
+	if (!match) return 0;
+	const [year, month, day, hour, minute, second] = match.slice(1);
+	return parseFloat(year || 0) * SECONDS_IN_YEAR + parseFloat(month || 0) * SECONDS_IN_MONTH + parseFloat(day || 0) * SECONDS_IN_DAY + parseFloat(hour || 0) * SECONDS_IN_HOUR + parseFloat(minute || 0) * SECONDS_IN_MIN + parseFloat(second || 0);
 };
-const parsers = {
-  /**
-   * Specifies the duration of the entire Media Presentation. Format is a duration string
-   * as specified in ISO 8601
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The duration in seconds
-   */
-  mediaPresentationDuration(value) {
-    return parseDuration(value);
-  },
-  /**
-   * Specifies the Segment availability start time for all Segments referred to in this
-   * MPD. For a dynamic manifest, it specifies the anchor for the earliest availability
-   * time. Format is a date string as specified in ISO 8601
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The date as seconds from unix epoch
-   */
-  availabilityStartTime(value) {
-    return parseDate(value) / 1e3;
-  },
-  /**
-   * Specifies the smallest period between potential changes to the MPD. Format is a
-   * duration string as specified in ISO 8601
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The duration in seconds
-   */
-  minimumUpdatePeriod(value) {
-    return parseDuration(value);
-  },
-  /**
-   * Specifies the suggested presentation delay. Format is a
-   * duration string as specified in ISO 8601
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The duration in seconds
-   */
-  suggestedPresentationDelay(value) {
-    return parseDuration(value);
-  },
-  /**
-   * specifices the type of mpd. Can be either "static" or "dynamic"
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   *
-   * @return {string}
-   *         The type as a string
-   */
-  type(value) {
-    return value;
-  },
-  /**
-   * Specifies the duration of the smallest time shifting buffer for any Representation
-   * in the MPD. Format is a duration string as specified in ISO 8601
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The duration in seconds
-   */
-  timeShiftBufferDepth(value) {
-    return parseDuration(value);
-  },
-  /**
-   * Specifies the PeriodStart time of the Period relative to the availabilityStarttime.
-   * Format is a duration string as specified in ISO 8601
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The duration in seconds
-   */
-  start(value) {
-    return parseDuration(value);
-  },
-  /**
-   * Specifies the width of the visual presentation
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The parsed width
-   */
-  width(value) {
-    return parseInt(value, 10);
-  },
-  /**
-   * Specifies the height of the visual presentation
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The parsed height
-   */
-  height(value) {
-    return parseInt(value, 10);
-  },
-  /**
-   * Specifies the bitrate of the representation
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The parsed bandwidth
-   */
-  bandwidth(value) {
-    return parseInt(value, 10);
-  },
-  /**
-   * Specifies the frame rate of the representation
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The parsed frame rate
-   */
-  frameRate(value) {
-    return parseDivisionValue(value);
-  },
-  /**
-   * Specifies the number of the first Media Segment in this Representation in the Period
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The parsed number
-   */
-  startNumber(value) {
-    return parseInt(value, 10);
-  },
-  /**
-   * Specifies the timescale in units per seconds
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The parsed timescale
-   */
-  timescale(value) {
-    return parseInt(value, 10);
-  },
-  /**
-   * Specifies the presentationTimeOffset.
-   *
-   * @param {string} value
-   *        value of the attribute as a string
-   *
-   * @return {number}
-   *         The parsed presentationTimeOffset
-   */
-  presentationTimeOffset(value) {
-    return parseInt(value, 10);
-  },
-  /**
-   * Specifies the constant approximate Segment duration
-   * NOTE: The <Period> element also contains an @duration attribute. This duration
-   *       specifies the duration of the Period. This attribute is currently not
-   *       supported by the rest of the parser, however we still check for it to prevent
-   *       errors.
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The parsed duration
-   */
-  duration(value) {
-    const parsedValue = parseInt(value, 10);
-    if (isNaN(parsedValue)) {
-      return parseDuration(value);
-    }
-    return parsedValue;
-  },
-  /**
-   * Specifies the Segment duration, in units of the value of the @timescale.
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The parsed duration
-   */
-  d(value) {
-    return parseInt(value, 10);
-  },
-  /**
-   * Specifies the MPD start time, in @timescale units, the first Segment in the series
-   * starts relative to the beginning of the Period
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The parsed time
-   */
-  t(value) {
-    return parseInt(value, 10);
-  },
-  /**
-   * Specifies the repeat count of the number of following contiguous Segments with the
-   * same duration expressed by the value of @d
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {number}
-   *         The parsed number
-   */
-  r(value) {
-    return parseInt(value, 10);
-  },
-  /**
-   * Specifies the presentationTime.
-   *
-   * @param {string} value
-   *        value of the attribute as a string
-   *
-   * @return {number}
-   *         The parsed presentationTime
-   */
-  presentationTime(value) {
-    return parseInt(value, 10);
-  },
-  /**
-   * Default parser for all other attributes. Acts as a no-op and just returns the value
-   * as a string
-   *
-   * @param {string} value
-   *        value of attribute as a string
-   * @return {string}
-   *         Unparsed value
-   */
-  DEFAULT(value) {
-    return value;
-  }
+var parseDate = (str) => {
+	if (/^\d+-\d+-\d+T\d+:\d+:\d+(\.\d+)?$/.test(str)) str += "Z";
+	return Date.parse(str);
 };
-const parseAttributes = (el) => {
-  if (!(el && el.attributes)) {
-    return {};
-  }
-  return from(el.attributes).reduce((a, e) => {
-    const parseFn = parsers[e.name] || parsers.DEFAULT;
-    a[e.name] = parseFn(e.value);
-    return a;
-  }, {});
+var parsers = {
+	/**
+	* Specifies the duration of the entire Media Presentation. Format is a duration string
+	* as specified in ISO 8601
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The duration in seconds
+	*/
+	mediaPresentationDuration(value) {
+		return parseDuration(value);
+	},
+	/**
+	* Specifies the Segment availability start time for all Segments referred to in this
+	* MPD. For a dynamic manifest, it specifies the anchor for the earliest availability
+	* time. Format is a date string as specified in ISO 8601
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The date as seconds from unix epoch
+	*/
+	availabilityStartTime(value) {
+		return parseDate(value) / 1e3;
+	},
+	/**
+	* Specifies the smallest period between potential changes to the MPD. Format is a
+	* duration string as specified in ISO 8601
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The duration in seconds
+	*/
+	minimumUpdatePeriod(value) {
+		return parseDuration(value);
+	},
+	/**
+	* Specifies the suggested presentation delay. Format is a
+	* duration string as specified in ISO 8601
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The duration in seconds
+	*/
+	suggestedPresentationDelay(value) {
+		return parseDuration(value);
+	},
+	/**
+	* specifices the type of mpd. Can be either "static" or "dynamic"
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	*
+	* @return {string}
+	*         The type as a string
+	*/
+	type(value) {
+		return value;
+	},
+	/**
+	* Specifies the duration of the smallest time shifting buffer for any Representation
+	* in the MPD. Format is a duration string as specified in ISO 8601
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The duration in seconds
+	*/
+	timeShiftBufferDepth(value) {
+		return parseDuration(value);
+	},
+	/**
+	* Specifies the PeriodStart time of the Period relative to the availabilityStarttime.
+	* Format is a duration string as specified in ISO 8601
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The duration in seconds
+	*/
+	start(value) {
+		return parseDuration(value);
+	},
+	/**
+	* Specifies the width of the visual presentation
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The parsed width
+	*/
+	width(value) {
+		return parseInt(value, 10);
+	},
+	/**
+	* Specifies the height of the visual presentation
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The parsed height
+	*/
+	height(value) {
+		return parseInt(value, 10);
+	},
+	/**
+	* Specifies the bitrate of the representation
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The parsed bandwidth
+	*/
+	bandwidth(value) {
+		return parseInt(value, 10);
+	},
+	/**
+	* Specifies the frame rate of the representation
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The parsed frame rate
+	*/
+	frameRate(value) {
+		return parseDivisionValue(value);
+	},
+	/**
+	* Specifies the number of the first Media Segment in this Representation in the Period
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The parsed number
+	*/
+	startNumber(value) {
+		return parseInt(value, 10);
+	},
+	/**
+	* Specifies the timescale in units per seconds
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The parsed timescale
+	*/
+	timescale(value) {
+		return parseInt(value, 10);
+	},
+	/**
+	* Specifies the presentationTimeOffset.
+	*
+	* @param {string} value
+	*        value of the attribute as a string
+	*
+	* @return {number}
+	*         The parsed presentationTimeOffset
+	*/
+	presentationTimeOffset(value) {
+		return parseInt(value, 10);
+	},
+	/**
+	* Specifies the constant approximate Segment duration
+	* NOTE: The <Period> element also contains an @duration attribute. This duration
+	*       specifies the duration of the Period. This attribute is currently not
+	*       supported by the rest of the parser, however we still check for it to prevent
+	*       errors.
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The parsed duration
+	*/
+	duration(value) {
+		const parsedValue = parseInt(value, 10);
+		if (isNaN(parsedValue)) return parseDuration(value);
+		return parsedValue;
+	},
+	/**
+	* Specifies the Segment duration, in units of the value of the @timescale.
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The parsed duration
+	*/
+	d(value) {
+		return parseInt(value, 10);
+	},
+	/**
+	* Specifies the MPD start time, in @timescale units, the first Segment in the series
+	* starts relative to the beginning of the Period
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The parsed time
+	*/
+	t(value) {
+		return parseInt(value, 10);
+	},
+	/**
+	* Specifies the repeat count of the number of following contiguous Segments with the
+	* same duration expressed by the value of @d
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {number}
+	*         The parsed number
+	*/
+	r(value) {
+		return parseInt(value, 10);
+	},
+	/**
+	* Specifies the presentationTime.
+	*
+	* @param {string} value
+	*        value of the attribute as a string
+	*
+	* @return {number}
+	*         The parsed presentationTime
+	*/
+	presentationTime(value) {
+		return parseInt(value, 10);
+	},
+	/**
+	* Default parser for all other attributes. Acts as a no-op and just returns the value
+	* as a string
+	*
+	* @param {string} value
+	*        value of attribute as a string
+	* @return {string}
+	*         Unparsed value
+	*/
+	DEFAULT(value) {
+		return value;
+	}
 };
-const keySystemsMap = {
-  "urn:uuid:1077efec-c0b2-4d02-ace3-3c1e52e2fb4b": "org.w3.clearkey",
-  "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed": "com.widevine.alpha",
-  "urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95": "com.microsoft.playready",
-  "urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb": "com.adobe.primetime",
-  // ISO_IEC 23009-1_2022 5.8.5.2.2 The mp4 Protection Scheme
-  "urn:mpeg:dash:mp4protection:2011": "mp4protection"
+/**
+* Gets all the attributes and values of the provided node, parses attributes with known
+* types, and returns an object with attribute names mapped to values.
+*
+* @param {Node} el
+*        The node to parse attributes from
+* @return {Object}
+*         Object with all attributes of el parsed
+*/
+var parseAttributes = (el) => {
+	if (!(el && el.attributes)) return {};
+	return from(el.attributes).reduce((a, e) => {
+		const parseFn = parsers[e.name] || parsers.DEFAULT;
+		a[e.name] = parseFn(e.value);
+		return a;
+	}, {});
 };
-const buildBaseUrls = (references, baseUrlElements) => {
-  if (!baseUrlElements.length) {
-    return references;
-  }
-  return flatten(references.map(function(reference) {
-    return baseUrlElements.map(function(baseUrlElement) {
-      const initialBaseUrl = getContent(baseUrlElement);
-      const resolvedBaseUrl = resolveUrl(reference.baseUrl, initialBaseUrl);
-      const finalBaseUrl = merge(parseAttributes(baseUrlElement), {
-        baseUrl: resolvedBaseUrl
-      });
-      if (resolvedBaseUrl !== initialBaseUrl && !finalBaseUrl.serviceLocation && reference.serviceLocation) {
-        finalBaseUrl.serviceLocation = reference.serviceLocation;
-      }
-      return finalBaseUrl;
-    });
-  }));
+var keySystemsMap = {
+	"urn:uuid:1077efec-c0b2-4d02-ace3-3c1e52e2fb4b": "org.w3.clearkey",
+	"urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed": "com.widevine.alpha",
+	"urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95": "com.microsoft.playready",
+	"urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb": "com.adobe.primetime",
+	"urn:mpeg:dash:mp4protection:2011": "mp4protection"
 };
-const getSegmentInformation = (adaptationSet) => {
-  const segmentTemplate = findChildren(adaptationSet, "SegmentTemplate")[0];
-  const segmentList = findChildren(adaptationSet, "SegmentList")[0];
-  const segmentUrls = segmentList && findChildren(segmentList, "SegmentURL").map((s) => merge({
-    tag: "SegmentURL"
-  }, parseAttributes(s)));
-  const segmentBase = findChildren(adaptationSet, "SegmentBase")[0];
-  const segmentTimelineParentNode = segmentList || segmentTemplate;
-  const segmentTimeline = segmentTimelineParentNode && findChildren(segmentTimelineParentNode, "SegmentTimeline")[0];
-  const segmentInitializationParentNode = segmentList || segmentBase || segmentTemplate;
-  const segmentInitialization = segmentInitializationParentNode && findChildren(segmentInitializationParentNode, "Initialization")[0];
-  const template = segmentTemplate && parseAttributes(segmentTemplate);
-  if (template && segmentInitialization) {
-    template.initialization = segmentInitialization && parseAttributes(segmentInitialization);
-  } else if (template && template.initialization) {
-    template.initialization = {
-      sourceURL: template.initialization
-    };
-  }
-  const segmentInfo = {
-    template,
-    segmentTimeline: segmentTimeline && findChildren(segmentTimeline, "S").map((s) => parseAttributes(s)),
-    list: segmentList && merge(parseAttributes(segmentList), {
-      segmentUrls,
-      initialization: parseAttributes(segmentInitialization)
-    }),
-    base: segmentBase && merge(parseAttributes(segmentBase), {
-      initialization: parseAttributes(segmentInitialization)
-    })
-  };
-  Object.keys(segmentInfo).forEach((key) => {
-    if (!segmentInfo[key]) {
-      delete segmentInfo[key];
-    }
-  });
-  return segmentInfo;
+/**
+* Builds a list of urls that is the product of the reference urls and BaseURL values
+*
+* @param {Object[]} references
+*        List of objects containing the reference URL as well as its attributes
+* @param {Node[]} baseUrlElements
+*        List of BaseURL nodes from the mpd
+* @return {Object[]}
+*         List of objects with resolved urls and attributes
+*/
+var buildBaseUrls = (references, baseUrlElements) => {
+	if (!baseUrlElements.length) return references;
+	return flatten(references.map(function(reference) {
+		return baseUrlElements.map(function(baseUrlElement) {
+			const initialBaseUrl = getContent(baseUrlElement);
+			const resolvedBaseUrl = resolveUrl(reference.baseUrl, initialBaseUrl);
+			const finalBaseUrl = merge(parseAttributes(baseUrlElement), { baseUrl: resolvedBaseUrl });
+			if (resolvedBaseUrl !== initialBaseUrl && !finalBaseUrl.serviceLocation && reference.serviceLocation) finalBaseUrl.serviceLocation = reference.serviceLocation;
+			return finalBaseUrl;
+		});
+	}));
 };
-const inheritBaseUrls = (adaptationSetAttributes, adaptationSetBaseUrls, adaptationSetSegmentInfo) => (representation) => {
-  const repBaseUrlElements = findChildren(representation, "BaseURL");
-  const repBaseUrls = buildBaseUrls(adaptationSetBaseUrls, repBaseUrlElements);
-  const attributes = merge(adaptationSetAttributes, parseAttributes(representation));
-  const representationSegmentInfo = getSegmentInformation(representation);
-  return repBaseUrls.map((baseUrl) => {
-    return {
-      segmentInfo: merge(adaptationSetSegmentInfo, representationSegmentInfo),
-      attributes: merge(attributes, baseUrl)
-    };
-  });
+/**
+* Contains all Segment information for its containing AdaptationSet
+*
+* @typedef {Object} SegmentInformation
+* @property {Object|undefined} template
+*           Contains the attributes for the SegmentTemplate node
+* @property {Object[]|undefined} segmentTimeline
+*           Contains a list of atrributes for each S node within the SegmentTimeline node
+* @property {Object|undefined} list
+*           Contains the attributes for the SegmentList node
+* @property {Object|undefined} base
+*           Contains the attributes for the SegmentBase node
+*/
+/**
+* Returns all available Segment information contained within the AdaptationSet node
+*
+* @param {Node} adaptationSet
+*        The AdaptationSet node to get Segment information from
+* @return {SegmentInformation}
+*         The Segment information contained within the provided AdaptationSet
+*/
+var getSegmentInformation = (adaptationSet) => {
+	const segmentTemplate = findChildren(adaptationSet, "SegmentTemplate")[0];
+	const segmentList = findChildren(adaptationSet, "SegmentList")[0];
+	const segmentUrls = segmentList && findChildren(segmentList, "SegmentURL").map((s) => merge({ tag: "SegmentURL" }, parseAttributes(s)));
+	const segmentBase = findChildren(adaptationSet, "SegmentBase")[0];
+	const segmentTimelineParentNode = segmentList || segmentTemplate;
+	const segmentTimeline = segmentTimelineParentNode && findChildren(segmentTimelineParentNode, "SegmentTimeline")[0];
+	const segmentInitializationParentNode = segmentList || segmentBase || segmentTemplate;
+	const segmentInitialization = segmentInitializationParentNode && findChildren(segmentInitializationParentNode, "Initialization")[0];
+	const template = segmentTemplate && parseAttributes(segmentTemplate);
+	if (template && segmentInitialization) template.initialization = segmentInitialization && parseAttributes(segmentInitialization);
+	else if (template && template.initialization) template.initialization = { sourceURL: template.initialization };
+	const segmentInfo = {
+		template,
+		segmentTimeline: segmentTimeline && findChildren(segmentTimeline, "S").map((s) => parseAttributes(s)),
+		list: segmentList && merge(parseAttributes(segmentList), {
+			segmentUrls,
+			initialization: parseAttributes(segmentInitialization)
+		}),
+		base: segmentBase && merge(parseAttributes(segmentBase), { initialization: parseAttributes(segmentInitialization) })
+	};
+	Object.keys(segmentInfo).forEach((key) => {
+		if (!segmentInfo[key]) delete segmentInfo[key];
+	});
+	return segmentInfo;
 };
-const generateKeySystemInformation = (contentProtectionNodes) => {
-  return contentProtectionNodes.reduce((acc, node) => {
-    const attributes = parseAttributes(node);
-    if (attributes.schemeIdUri) {
-      attributes.schemeIdUri = attributes.schemeIdUri.toLowerCase();
-    }
-    const keySystem = keySystemsMap[attributes.schemeIdUri];
-    if (keySystem) {
-      acc[keySystem] = {
-        attributes
-      };
-      const psshNode = findChildren(node, "cenc:pssh")[0];
-      if (psshNode) {
-        const pssh = getContent(psshNode);
-        acc[keySystem].pssh = pssh && decodeB64ToUint8Array(pssh);
-      }
-    }
-    return acc;
-  }, {});
+/**
+* Contains Segment information and attributes needed to construct a Playlist object
+* from a Representation
+*
+* @typedef {Object} RepresentationInformation
+* @property {SegmentInformation} segmentInfo
+*           Segment information for this Representation
+* @property {Object} attributes
+*           Inherited attributes for this Representation
+*/
+/**
+* Maps a Representation node to an object containing Segment information and attributes
+*
+* @name inheritBaseUrlsCallback
+* @function
+* @param {Node} representation
+*        Representation node from the mpd
+* @return {RepresentationInformation}
+*         Representation information needed to construct a Playlist object
+*/
+/**
+* Returns a callback for Array.prototype.map for mapping Representation nodes to
+* Segment information and attributes using inherited BaseURL nodes.
+*
+* @param {Object} adaptationSetAttributes
+*        Contains attributes inherited by the AdaptationSet
+* @param {Object[]} adaptationSetBaseUrls
+*        List of objects containing resolved base URLs and attributes
+*        inherited by the AdaptationSet
+* @param {SegmentInformation} adaptationSetSegmentInfo
+*        Contains Segment information for the AdaptationSet
+* @return {inheritBaseUrlsCallback}
+*         Callback map function
+*/
+var inheritBaseUrls = (adaptationSetAttributes, adaptationSetBaseUrls, adaptationSetSegmentInfo) => (representation) => {
+	const repBaseUrls = buildBaseUrls(adaptationSetBaseUrls, findChildren(representation, "BaseURL"));
+	const attributes = merge(adaptationSetAttributes, parseAttributes(representation));
+	const representationSegmentInfo = getSegmentInformation(representation);
+	return repBaseUrls.map((baseUrl) => {
+		return {
+			segmentInfo: merge(adaptationSetSegmentInfo, representationSegmentInfo),
+			attributes: merge(attributes, baseUrl)
+		};
+	});
 };
-const parseCaptionServiceMetadata = (service) => {
-  if (service.schemeIdUri === "urn:scte:dash:cc:cea-608:2015") {
-    const values2 = typeof service.value !== "string" ? [] : service.value.split(";");
-    return values2.map((value) => {
-      let channel;
-      let language;
-      language = value;
-      if (/^CC\d=/.test(value)) {
-        [channel, language] = value.split("=");
-      } else if (/^CC\d$/.test(value)) {
-        channel = value;
-      }
-      return {
-        channel,
-        language
-      };
-    });
-  } else if (service.schemeIdUri === "urn:scte:dash:cc:cea-708:2015") {
-    const values2 = typeof service.value !== "string" ? [] : service.value.split(";");
-    return values2.map((value) => {
-      const flags = {
-        // service or channel number 1-63
-        "channel": void 0,
-        // language is a 3ALPHA per ISO 639.2/B
-        // field is required
-        "language": void 0,
-        // BIT 1/0 or ?
-        // default value is 1, meaning 16:9 aspect ratio, 0 is 4:3, ? is unknown
-        "aspectRatio": 1,
-        // BIT 1/0
-        // easy reader flag indicated the text is tailed to the needs of beginning readers
-        // default 0, or off
-        "easyReader": 0,
-        // BIT 1/0
-        // If 3d metadata is present (CEA-708.1) then 1
-        // default 0
-        "3D": 0
-      };
-      if (/=/.test(value)) {
-        const [channel, opts = ""] = value.split("=");
-        flags.channel = channel;
-        flags.language = value;
-        opts.split(",").forEach((opt) => {
-          const [name, val] = opt.split(":");
-          if (name === "lang") {
-            flags.language = val;
-          } else if (name === "er") {
-            flags.easyReader = Number(val);
-          } else if (name === "war") {
-            flags.aspectRatio = Number(val);
-          } else if (name === "3D") {
-            flags["3D"] = Number(val);
-          }
-        });
-      } else {
-        flags.language = value;
-      }
-      if (flags.channel) {
-        flags.channel = "SERVICE" + flags.channel;
-      }
-      return flags;
-    });
-  }
+/**
+* Tranforms a series of content protection nodes to
+* an object containing pssh data by key system
+*
+* @param {Node[]} contentProtectionNodes
+*        Content protection nodes
+* @return {Object}
+*        Object containing pssh data by key system
+*/
+var generateKeySystemInformation = (contentProtectionNodes) => {
+	return contentProtectionNodes.reduce((acc, node) => {
+		const attributes = parseAttributes(node);
+		if (attributes.schemeIdUri) attributes.schemeIdUri = attributes.schemeIdUri.toLowerCase();
+		const keySystem = keySystemsMap[attributes.schemeIdUri];
+		if (keySystem) {
+			acc[keySystem] = { attributes };
+			const psshNode = findChildren(node, "cenc:pssh")[0];
+			if (psshNode) {
+				const pssh = getContent(psshNode);
+				acc[keySystem].pssh = pssh && decodeB64ToUint8Array(pssh);
+			}
+		}
+		return acc;
+	}, {});
 };
-const toEventStream = (period) => {
-  return flatten(findChildren(period.node, "EventStream").map((eventStream) => {
-    const eventStreamAttributes = parseAttributes(eventStream);
-    const schemeIdUri = eventStreamAttributes.schemeIdUri;
-    return findChildren(eventStream, "Event").map((event) => {
-      const eventAttributes = parseAttributes(event);
-      const presentationTime = eventAttributes.presentationTime || 0;
-      const timescale = eventStreamAttributes.timescale || 1;
-      const duration = eventAttributes.duration || 0;
-      const start = presentationTime / timescale + period.attributes.start;
-      return {
-        schemeIdUri,
-        value: eventStreamAttributes.value,
-        id: eventAttributes.id,
-        start,
-        end: start + duration / timescale,
-        messageData: getContent(event) || eventAttributes.messageData,
-        contentEncoding: eventStreamAttributes.contentEncoding,
-        presentationTimeOffset: eventStreamAttributes.presentationTimeOffset || 0
-      };
-    });
-  }));
+var parseCaptionServiceMetadata = (service) => {
+	if (service.schemeIdUri === "urn:scte:dash:cc:cea-608:2015") return (typeof service.value !== "string" ? [] : service.value.split(";")).map((value) => {
+		let channel;
+		let language;
+		language = value;
+		if (/^CC\d=/.test(value)) [channel, language] = value.split("=");
+		else if (/^CC\d$/.test(value)) channel = value;
+		return {
+			channel,
+			language
+		};
+	});
+	else if (service.schemeIdUri === "urn:scte:dash:cc:cea-708:2015") return (typeof service.value !== "string" ? [] : service.value.split(";")).map((value) => {
+		const flags = {
+			"channel": void 0,
+			"language": void 0,
+			"aspectRatio": 1,
+			"easyReader": 0,
+			"3D": 0
+		};
+		if (/=/.test(value)) {
+			const [channel, opts = ""] = value.split("=");
+			flags.channel = channel;
+			flags.language = value;
+			opts.split(",").forEach((opt) => {
+				const [name, val] = opt.split(":");
+				if (name === "lang") flags.language = val;
+				else if (name === "er") flags.easyReader = Number(val);
+				else if (name === "war") flags.aspectRatio = Number(val);
+				else if (name === "3D") flags["3D"] = Number(val);
+			});
+		} else flags.language = value;
+		if (flags.channel) flags.channel = "SERVICE" + flags.channel;
+		return flags;
+	});
 };
-const toRepresentations = (periodAttributes, periodBaseUrls, periodSegmentInfo) => (adaptationSet) => {
-  const adaptationSetAttributes = parseAttributes(adaptationSet);
-  const adaptationSetBaseUrls = buildBaseUrls(periodBaseUrls, findChildren(adaptationSet, "BaseURL"));
-  const role = findChildren(adaptationSet, "Role")[0];
-  const roleAttributes = {
-    role: parseAttributes(role)
-  };
-  let attrs = merge(periodAttributes, adaptationSetAttributes, roleAttributes);
-  const accessibility = findChildren(adaptationSet, "Accessibility")[0];
-  const captionServices = parseCaptionServiceMetadata(parseAttributes(accessibility));
-  if (captionServices) {
-    attrs = merge(attrs, {
-      captionServices
-    });
-  }
-  const label = findChildren(adaptationSet, "Label")[0];
-  if (label && label.childNodes.length) {
-    const labelVal = label.childNodes[0].nodeValue.trim();
-    attrs = merge(attrs, {
-      label: labelVal
-    });
-  }
-  const contentProtection = generateKeySystemInformation(findChildren(adaptationSet, "ContentProtection"));
-  if (Object.keys(contentProtection).length) {
-    attrs = merge(attrs, {
-      contentProtection
-    });
-  }
-  const segmentInfo = getSegmentInformation(adaptationSet);
-  const representations = findChildren(adaptationSet, "Representation");
-  const adaptationSetSegmentInfo = merge(periodSegmentInfo, segmentInfo);
-  return flatten(representations.map(inheritBaseUrls(attrs, adaptationSetBaseUrls, adaptationSetSegmentInfo)));
+/**
+* A map callback that will parse all event stream data for a collection of periods
+* DASH ISO_IEC_23009 5.10.2.2
+* https://dashif-documents.azurewebsites.net/Events/master/event.html#mpd-event-timing
+*
+* @param {PeriodInformation} period object containing necessary period information
+* @return a collection of parsed eventstream event objects
+*/
+var toEventStream = (period) => {
+	return flatten(findChildren(period.node, "EventStream").map((eventStream) => {
+		const eventStreamAttributes = parseAttributes(eventStream);
+		const schemeIdUri = eventStreamAttributes.schemeIdUri;
+		return findChildren(eventStream, "Event").map((event) => {
+			const eventAttributes = parseAttributes(event);
+			const presentationTime = eventAttributes.presentationTime || 0;
+			const timescale = eventStreamAttributes.timescale || 1;
+			const duration = eventAttributes.duration || 0;
+			const start = presentationTime / timescale + period.attributes.start;
+			return {
+				schemeIdUri,
+				value: eventStreamAttributes.value,
+				id: eventAttributes.id,
+				start,
+				end: start + duration / timescale,
+				messageData: getContent(event) || eventAttributes.messageData,
+				contentEncoding: eventStreamAttributes.contentEncoding,
+				presentationTimeOffset: eventStreamAttributes.presentationTimeOffset || 0
+			};
+		});
+	}));
 };
-const toAdaptationSets = (mpdAttributes, mpdBaseUrls) => (period, index) => {
-  const periodBaseUrls = buildBaseUrls(mpdBaseUrls, findChildren(period.node, "BaseURL"));
-  const periodAttributes = merge(mpdAttributes, {
-    periodStart: period.attributes.start
-  });
-  if (typeof period.attributes.duration === "number") {
-    periodAttributes.periodDuration = period.attributes.duration;
-  }
-  const adaptationSets = findChildren(period.node, "AdaptationSet");
-  const periodSegmentInfo = getSegmentInformation(period.node);
-  return flatten(adaptationSets.map(toRepresentations(periodAttributes, periodBaseUrls, periodSegmentInfo)));
+/**
+* Maps an AdaptationSet node to a list of Representation information objects
+*
+* @name toRepresentationsCallback
+* @function
+* @param {Node} adaptationSet
+*        AdaptationSet node from the mpd
+* @return {RepresentationInformation[]}
+*         List of objects containing Representaion information
+*/
+/**
+* Returns a callback for Array.prototype.map for mapping AdaptationSet nodes to a list of
+* Representation information objects
+*
+* @param {Object} periodAttributes
+*        Contains attributes inherited by the Period
+* @param {Object[]} periodBaseUrls
+*        Contains list of objects with resolved base urls and attributes
+*        inherited by the Period
+* @param {string[]} periodSegmentInfo
+*        Contains Segment Information at the period level
+* @return {toRepresentationsCallback}
+*         Callback map function
+*/
+var toRepresentations = (periodAttributes, periodBaseUrls, periodSegmentInfo) => (adaptationSet) => {
+	const adaptationSetAttributes = parseAttributes(adaptationSet);
+	const adaptationSetBaseUrls = buildBaseUrls(periodBaseUrls, findChildren(adaptationSet, "BaseURL"));
+	const role = findChildren(adaptationSet, "Role")[0];
+	let attrs = merge(periodAttributes, adaptationSetAttributes, { role: parseAttributes(role) });
+	const accessibility = findChildren(adaptationSet, "Accessibility")[0];
+	const captionServices = parseCaptionServiceMetadata(parseAttributes(accessibility));
+	if (captionServices) attrs = merge(attrs, { captionServices });
+	const label = findChildren(adaptationSet, "Label")[0];
+	if (label && label.childNodes.length) {
+		const labelVal = label.childNodes[0].nodeValue.trim();
+		attrs = merge(attrs, { label: labelVal });
+	}
+	const contentProtection = generateKeySystemInformation(findChildren(adaptationSet, "ContentProtection"));
+	if (Object.keys(contentProtection).length) attrs = merge(attrs, { contentProtection });
+	const segmentInfo = getSegmentInformation(adaptationSet);
+	const representations = findChildren(adaptationSet, "Representation");
+	const adaptationSetSegmentInfo = merge(periodSegmentInfo, segmentInfo);
+	return flatten(representations.map(inheritBaseUrls(attrs, adaptationSetBaseUrls, adaptationSetSegmentInfo)));
 };
-const generateContentSteeringInformation = (contentSteeringNodes, eventHandler) => {
-  if (contentSteeringNodes.length > 1) {
-    eventHandler({
-      type: "warn",
-      message: "The MPD manifest should contain no more than one ContentSteering tag"
-    });
-  }
-  if (!contentSteeringNodes.length) {
-    return null;
-  }
-  const infoFromContentSteeringTag = merge({
-    serverURL: getContent(contentSteeringNodes[0])
-  }, parseAttributes(contentSteeringNodes[0]));
-  infoFromContentSteeringTag.queryBeforeStart = infoFromContentSteeringTag.queryBeforeStart === "true";
-  return infoFromContentSteeringTag;
+/**
+* Contains all period information for mapping nodes onto adaptation sets.
+*
+* @typedef {Object} PeriodInformation
+* @property {Node} period.node
+*           Period node from the mpd
+* @property {Object} period.attributes
+*           Parsed period attributes from node plus any added
+*/
+/**
+* Maps a PeriodInformation object to a list of Representation information objects for all
+* AdaptationSet nodes contained within the Period.
+*
+* @name toAdaptationSetsCallback
+* @function
+* @param {PeriodInformation} period
+*        Period object containing necessary period information
+* @param {number} periodStart
+*        Start time of the Period within the mpd
+* @return {RepresentationInformation[]}
+*         List of objects containing Representaion information
+*/
+/**
+* Returns a callback for Array.prototype.map for mapping Period nodes to a list of
+* Representation information objects
+*
+* @param {Object} mpdAttributes
+*        Contains attributes inherited by the mpd
+* @param {Object[]} mpdBaseUrls
+*        Contains list of objects with resolved base urls and attributes
+*        inherited by the mpd
+* @return {toAdaptationSetsCallback}
+*         Callback map function
+*/
+var toAdaptationSets = (mpdAttributes, mpdBaseUrls) => (period, index) => {
+	const periodBaseUrls = buildBaseUrls(mpdBaseUrls, findChildren(period.node, "BaseURL"));
+	const periodAttributes = merge(mpdAttributes, { periodStart: period.attributes.start });
+	if (typeof period.attributes.duration === "number") periodAttributes.periodDuration = period.attributes.duration;
+	const adaptationSets = findChildren(period.node, "AdaptationSet");
+	const periodSegmentInfo = getSegmentInformation(period.node);
+	return flatten(adaptationSets.map(toRepresentations(periodAttributes, periodBaseUrls, periodSegmentInfo)));
 };
-const getPeriodStart = ({
-  attributes,
-  priorPeriodAttributes,
-  mpdType
-}) => {
-  if (typeof attributes.start === "number") {
-    return attributes.start;
-  }
-  if (priorPeriodAttributes && typeof priorPeriodAttributes.start === "number" && typeof priorPeriodAttributes.duration === "number") {
-    return priorPeriodAttributes.start + priorPeriodAttributes.duration;
-  }
-  if (!priorPeriodAttributes && mpdType === "static") {
-    return 0;
-  }
-  return null;
+/**
+* Tranforms an array of content steering nodes into an object
+* containing CDN content steering information from the MPD manifest.
+*
+* For more information on the DASH spec for Content Steering parsing, see:
+* https://dashif.org/docs/DASH-IF-CTS-00XX-Content-Steering-Community-Review.pdf
+*
+* @param {Node[]} contentSteeringNodes
+*        Content steering nodes
+* @param {Function} eventHandler
+*        The event handler passed into the parser options to handle warnings
+* @return {Object}
+*        Object containing content steering data
+*/
+var generateContentSteeringInformation = (contentSteeringNodes, eventHandler) => {
+	if (contentSteeringNodes.length > 1) eventHandler({
+		type: "warn",
+		message: "The MPD manifest should contain no more than one ContentSteering tag"
+	});
+	if (!contentSteeringNodes.length) return null;
+	const infoFromContentSteeringTag = merge({ serverURL: getContent(contentSteeringNodes[0]) }, parseAttributes(contentSteeringNodes[0]));
+	infoFromContentSteeringTag.queryBeforeStart = infoFromContentSteeringTag.queryBeforeStart === "true";
+	return infoFromContentSteeringTag;
 };
-const inheritAttributes = (mpd, options = {}) => {
-  const {
-    manifestUri = "",
-    NOW = Date.now(),
-    clientOffset = 0,
-    // TODO: For now, we are expecting an eventHandler callback function
-    // to be passed into the mpd parser as an option.
-    // In the future, we should enable stream parsing by using the Stream class from vhs-utils.
-    // This will support new features including a standardized event handler.
-    // See the m3u8 parser for examples of how stream parsing is currently used for HLS parsing.
-    // https://github.com/videojs/vhs-utils/blob/88d6e10c631e57a5af02c5a62bc7376cd456b4f5/src/stream.js#L9
-    eventHandler = function() {
-    }
-  } = options;
-  const periodNodes = findChildren(mpd, "Period");
-  if (!periodNodes.length) {
-    throw new Error(errors.INVALID_NUMBER_OF_PERIOD);
-  }
-  const locations = findChildren(mpd, "Location");
-  const mpdAttributes = parseAttributes(mpd);
-  const mpdBaseUrls = buildBaseUrls([{
-    baseUrl: manifestUri
-  }], findChildren(mpd, "BaseURL"));
-  const contentSteeringNodes = findChildren(mpd, "ContentSteering");
-  mpdAttributes.type = mpdAttributes.type || "static";
-  mpdAttributes.sourceDuration = mpdAttributes.mediaPresentationDuration || 0;
-  mpdAttributes.NOW = NOW;
-  mpdAttributes.clientOffset = clientOffset;
-  if (locations.length) {
-    mpdAttributes.locations = locations.map(getContent);
-  }
-  const periods = [];
-  periodNodes.forEach((node, index) => {
-    const attributes = parseAttributes(node);
-    const priorPeriod = periods[index - 1];
-    attributes.start = getPeriodStart({
-      attributes,
-      priorPeriodAttributes: priorPeriod ? priorPeriod.attributes : null,
-      mpdType: mpdAttributes.type
-    });
-    periods.push({
-      node,
-      attributes
-    });
-  });
-  return {
-    locations: mpdAttributes.locations,
-    contentSteeringInfo: generateContentSteeringInformation(contentSteeringNodes, eventHandler),
-    // TODO: There are occurences where this `representationInfo` array contains undesired
-    // duplicates. This generally occurs when there are multiple BaseURL nodes that are
-    // direct children of the MPD node. When we attempt to resolve URLs from a combination of the
-    // parent BaseURL and a child BaseURL, and the value does not resolve,
-    // we end up returning the child BaseURL multiple times.
-    // We need to determine a way to remove these duplicates in a safe way.
-    // See: https://github.com/videojs/mpd-parser/pull/17#discussion_r162750527
-    representationInfo: flatten(periods.map(toAdaptationSets(mpdAttributes, mpdBaseUrls))),
-    eventStream: flatten(periods.map(toEventStream))
-  };
+/**
+* Gets Period@start property for a given period.
+*
+* @param {Object} options
+*        Options object
+* @param {Object} options.attributes
+*        Period attributes
+* @param {Object} [options.priorPeriodAttributes]
+*        Prior period attributes (if prior period is available)
+* @param {string} options.mpdType
+*        The MPD@type these periods came from
+* @return {number|null}
+*         The period start, or null if it's an early available period or error
+*/
+var getPeriodStart = ({ attributes, priorPeriodAttributes, mpdType }) => {
+	if (typeof attributes.start === "number") return attributes.start;
+	if (priorPeriodAttributes && typeof priorPeriodAttributes.start === "number" && typeof priorPeriodAttributes.duration === "number") return priorPeriodAttributes.start + priorPeriodAttributes.duration;
+	if (!priorPeriodAttributes && mpdType === "static") return 0;
+	return null;
 };
-const stringToMpdXml = (manifestString) => {
-  if (manifestString === "") {
-    throw new Error(errors.DASH_EMPTY_MANIFEST);
-  }
-  const parser = new libExports.DOMParser();
-  let xml;
-  let mpd;
-  try {
-    xml = parser.parseFromString(manifestString, "application/xml");
-    mpd = xml && xml.documentElement.tagName === "MPD" ? xml.documentElement : null;
-  } catch (e) {
-  }
-  if (!mpd || mpd && mpd.getElementsByTagName("parsererror").length > 0) {
-    throw new Error(errors.DASH_INVALID_XML);
-  }
-  return mpd;
+/**
+* Traverses the mpd xml tree to generate a list of Representation information objects
+* that have inherited attributes from parent nodes
+*
+* @param {Node} mpd
+*        The root node of the mpd
+* @param {Object} options
+*        Available options for inheritAttributes
+* @param {string} options.manifestUri
+*        The uri source of the mpd
+* @param {number} options.NOW
+*        Current time per DASH IOP.  Default is current time in ms since epoch
+* @param {number} options.clientOffset
+*        Client time difference from NOW (in milliseconds)
+* @return {RepresentationInformation[]}
+*         List of objects containing Representation information
+*/
+var inheritAttributes = (mpd, options = {}) => {
+	const { manifestUri = "", NOW = Date.now(), clientOffset = 0, eventHandler = function() {} } = options;
+	const periodNodes = findChildren(mpd, "Period");
+	if (!periodNodes.length) throw new Error(errors.INVALID_NUMBER_OF_PERIOD);
+	const locations = findChildren(mpd, "Location");
+	const mpdAttributes = parseAttributes(mpd);
+	const mpdBaseUrls = buildBaseUrls([{ baseUrl: manifestUri }], findChildren(mpd, "BaseURL"));
+	const contentSteeringNodes = findChildren(mpd, "ContentSteering");
+	mpdAttributes.type = mpdAttributes.type || "static";
+	mpdAttributes.sourceDuration = mpdAttributes.mediaPresentationDuration || 0;
+	mpdAttributes.NOW = NOW;
+	mpdAttributes.clientOffset = clientOffset;
+	if (locations.length) mpdAttributes.locations = locations.map(getContent);
+	const periods = [];
+	periodNodes.forEach((node, index) => {
+		const attributes = parseAttributes(node);
+		const priorPeriod = periods[index - 1];
+		attributes.start = getPeriodStart({
+			attributes,
+			priorPeriodAttributes: priorPeriod ? priorPeriod.attributes : null,
+			mpdType: mpdAttributes.type
+		});
+		periods.push({
+			node,
+			attributes
+		});
+	});
+	return {
+		locations: mpdAttributes.locations,
+		contentSteeringInfo: generateContentSteeringInformation(contentSteeringNodes, eventHandler),
+		representationInfo: flatten(periods.map(toAdaptationSets(mpdAttributes, mpdBaseUrls))),
+		eventStream: flatten(periods.map(toEventStream))
+	};
 };
-const parseUTCTimingScheme = (mpd) => {
-  const UTCTimingNode = findChildren(mpd, "UTCTiming")[0];
-  if (!UTCTimingNode) {
-    return null;
-  }
-  const attributes = parseAttributes(UTCTimingNode);
-  switch (attributes.schemeIdUri) {
-    case "urn:mpeg:dash:utc:http-head:2014":
-    case "urn:mpeg:dash:utc:http-head:2012":
-      attributes.method = "HEAD";
-      break;
-    case "urn:mpeg:dash:utc:http-xsdate:2014":
-    case "urn:mpeg:dash:utc:http-iso:2014":
-    case "urn:mpeg:dash:utc:http-xsdate:2012":
-    case "urn:mpeg:dash:utc:http-iso:2012":
-      attributes.method = "GET";
-      break;
-    case "urn:mpeg:dash:utc:direct:2014":
-    case "urn:mpeg:dash:utc:direct:2012":
-      attributes.method = "DIRECT";
-      attributes.value = Date.parse(attributes.value);
-      break;
-    case "urn:mpeg:dash:utc:http-ntp:2014":
-    case "urn:mpeg:dash:utc:ntp:2014":
-    case "urn:mpeg:dash:utc:sntp:2014":
-    default:
-      throw new Error(errors.UNSUPPORTED_UTC_TIMING_SCHEME);
-  }
-  return attributes;
+var stringToMpdXml = (manifestString) => {
+	if (manifestString === "") throw new Error(errors.DASH_EMPTY_MANIFEST);
+	const parser = new import_lib.DOMParser();
+	let xml;
+	let mpd;
+	try {
+		xml = parser.parseFromString(manifestString, "application/xml");
+		mpd = xml && xml.documentElement.tagName === "MPD" ? xml.documentElement : null;
+	} catch (e) {}
+	if (!mpd || mpd && mpd.getElementsByTagName("parsererror").length > 0) throw new Error(errors.DASH_INVALID_XML);
+	return mpd;
 };
-const parse = (manifestString, options = {}) => {
-  const parsedManifestInfo = inheritAttributes(stringToMpdXml(manifestString), options);
-  const playlists = toPlaylists(parsedManifestInfo.representationInfo);
-  return toM3u8({
-    dashPlaylists: playlists,
-    locations: parsedManifestInfo.locations,
-    contentSteering: parsedManifestInfo.contentSteeringInfo,
-    sidxMapping: options.sidxMapping,
-    previousManifest: options.previousManifest,
-    eventStream: parsedManifestInfo.eventStream
-  });
+/**
+* Parses the manifest for a UTCTiming node, returning the nodes attributes if found
+*
+* @param {string} mpd
+*        XML string of the MPD manifest
+* @return {Object|null}
+*         Attributes of UTCTiming node specified in the manifest. Null if none found
+*/
+var parseUTCTimingScheme = (mpd) => {
+	const UTCTimingNode = findChildren(mpd, "UTCTiming")[0];
+	if (!UTCTimingNode) return null;
+	const attributes = parseAttributes(UTCTimingNode);
+	switch (attributes.schemeIdUri) {
+		case "urn:mpeg:dash:utc:http-head:2014":
+		case "urn:mpeg:dash:utc:http-head:2012":
+			attributes.method = "HEAD";
+			break;
+		case "urn:mpeg:dash:utc:http-xsdate:2014":
+		case "urn:mpeg:dash:utc:http-iso:2014":
+		case "urn:mpeg:dash:utc:http-xsdate:2012":
+		case "urn:mpeg:dash:utc:http-iso:2012":
+			attributes.method = "GET";
+			break;
+		case "urn:mpeg:dash:utc:direct:2014":
+		case "urn:mpeg:dash:utc:direct:2012":
+			attributes.method = "DIRECT";
+			attributes.value = Date.parse(attributes.value);
+			break;
+		default: throw new Error(errors.UNSUPPORTED_UTC_TIMING_SCHEME);
+	}
+	return attributes;
 };
-const parseUTCTiming = (manifestString) => parseUTCTimingScheme(stringToMpdXml(manifestString));
-export {
-  addSidxSegmentsToPlaylist$1 as addSidxSegmentsToPlaylist,
-  generateSidxKey,
-  inheritAttributes,
-  parse,
-  parseUTCTiming,
-  stringToMpdXml,
-  toM3u8,
-  toPlaylists
+var parse = (manifestString, options = {}) => {
+	const parsedManifestInfo = inheritAttributes(stringToMpdXml(manifestString), options);
+	return toM3u8({
+		dashPlaylists: toPlaylists(parsedManifestInfo.representationInfo),
+		locations: parsedManifestInfo.locations,
+		contentSteering: parsedManifestInfo.contentSteeringInfo,
+		sidxMapping: options.sidxMapping,
+		previousManifest: options.previousManifest,
+		eventStream: parsedManifestInfo.eventStream
+	});
 };
+/**
+* Parses the manifest for a UTCTiming node, returning the nodes attributes if found
+*
+* @param {string} manifestString
+*        XML string of the MPD manifest
+* @return {Object|null}
+*         Attributes of UTCTiming node specified in the manifest. Null if none found
+*/
+var parseUTCTiming = (manifestString) => parseUTCTimingScheme(stringToMpdXml(manifestString));
+export { addSidxSegmentsToPlaylist$1 as addSidxSegmentsToPlaylist, generateSidxKey, inheritAttributes, parse, parseUTCTiming, stringToMpdXml, toM3u8, toPlaylists };