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

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

@@ -1,1788 +1,1693 @@
-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 decodeB64ToUint8Array from "../../@videojs/vhs-utils/es/decode-b64-to-uint8-array.js.mjs";
+import window$1 from "../../global/window.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
+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";
 /*! @name mpd-parser @version 1.3.1 @license Apache-2.0 */
-var import_window = /* @__PURE__ */ __toESM(require_window());
-var import_lib = require_lib();
-var isObject = (obj) => {
-	return !!obj && typeof obj === "object";
+const isObject = (obj) => {
+  return !!obj && typeof obj === "object";
 };
-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 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 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 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 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 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 findIndexes = (l, key) => l.reduce((a, e, i) => {
-	if (e[key]) a.push(i);
-	return a;
+const findIndexes = (l, key) => l.reduce((a, e, i) => {
+  if (e[key]) {
+    a.push(i);
+  }
+  return a;
 }, []);
-/**
-* 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;
-	}, {}));
+const 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",
-	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"
+  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"
 };
-/**
-* @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 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;
 };
-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 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}`;
 };
-/**
-* 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 parseEndNumber = (endNumber) => {
+  if (endNumber && typeof endNumber !== "number") {
+    endNumber = parseInt(endNumber, 10);
+  }
+  if (isNaN(endNumber)) {
+    return null;
+  }
+  return endNumber;
 };
-/**
-* 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 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)
+    };
+  }
 };
-/**
-* 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 toSegments = (attributes) => (number) => {
+  const {
+    duration,
+    timescale = 1,
+    periodStart,
+    startNumber = 1
+  } = attributes;
+  return {
+    number: startNumber + number,
+    duration: duration / timescale,
+    timeline: periodStart,
+    time: number * duration
+  };
 };
-/**
-* 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 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;
 };
-/**
-* 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 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];
 };
-/**
-* 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 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;
 };
-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 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);
 };
-/**
-* 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 findPlaylistWithName = (playlists, name) => {
+  for (let i = 0; i < playlists.length; i++) {
+    if (playlists[i].attributes.NAME === name) {
+      return playlists[i];
+    }
+  }
+  return null;
 };
-/**
-* 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 getMediaGroupPlaylists = (manifest) => {
+  let mediaGroupPlaylists = [];
+  forEachMediaGroup(manifest, SUPPORTED_MEDIA_TYPES, (properties, type, group, label) => {
+    mediaGroupPlaylists = mediaGroupPlaylists.concat(properties.playlists || []);
+  });
+  return mediaGroupPlaylists;
 };
-/**
-* 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 updateMediaSequenceForPlaylist = ({
+  playlist,
+  mediaSequence
+}) => {
+  playlist.mediaSequence = mediaSequence;
+  playlist.segments.forEach((segment, index) => {
+    segment.number = playlist.mediaSequence + index;
+  });
 };
-/**
-* 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 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
+    });
+  });
 };
-/**
-* 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 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;
 };
-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 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 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 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 addSidxSegmentsToPlaylists = (playlists, sidxMapping = {}) => {
-	if (!Object.keys(sidxMapping).length) return playlists;
-	for (const i in playlists) playlists[i] = addSidxSegmentsToPlaylist(playlists[i], sidxMapping);
-	return playlists;
+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 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 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 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 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 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 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 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 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 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 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 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 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 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 flattenMediaGroupPlaylists = (mediaGroupObject) => {
+  if (!mediaGroupObject) {
+    return [];
+  }
+  return Object.keys(mediaGroupObject).reduce((acc, label) => {
+    const labelContents = mediaGroupObject[label];
+    return acc.concat(labelContents.playlists);
+  }, []);
 };
-/**
-* 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 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;
 };
-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 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);
 };
-/**
-* 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 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;
 };
-/**
-* 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 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}`;
 };
-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 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);
 };
-/**
-* 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 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;
+  });
 };
-/**
-* 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 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;
 };
-/**
-* 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 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;
 };
-/**
-* 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 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;
 };
-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 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 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 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 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 parseDate = (str) => {
+  const dateRegex = /^\d+-\d+-\d+T\d+:\d+:\d+(\.\d+)?$/;
+  if (dateRegex.test(str)) {
+    str += "Z";
+  }
+  return Date.parse(str);
 };
-var parseDate = (str) => {
-	if (/^\d+-\d+-\d+T\d+:\d+:\d+(\.\d+)?$/.test(str)) str += "Z";
-	return Date.parse(str);
+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 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 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;
+  }, {});
 };
-/**
-* 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 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"
 };
-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 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;
+    });
+  }));
 };
-/**
-* 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 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;
 };
-/**
-* 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 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 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 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;
+  }, {});
 };
-/**
-* 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 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;
+    });
+  }
 };
-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 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
+      };
+    });
+  }));
 };
-/**
-* 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 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)));
 };
-/**
-* 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 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)));
 };
-/**
-* 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 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;
 };
-/**
-* 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 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;
 };
-/**
-* 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 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))
+  };
 };
-/**
-* 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 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;
 };
-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 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;
 };
-/**
-* 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 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
+  });
 };
-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
-	});
+const parseUTCTiming = (manifestString) => parseUTCTimingScheme(stringToMpdXml(manifestString));
+export {
+  addSidxSegmentsToPlaylist$1 as addSidxSegmentsToPlaylist,
+  generateSidxKey,
+  inheritAttributes,
+  parse,
+  parseUTCTiming,
+  stringToMpdXml,
+  toM3u8,
+  toPlaylists
 };
-/**
-* 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 };