@opendesign-plus/components 0.0.1-rc.10 → 0.0.1-rc.100

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

@@ -0,0 +1,1788 @@
+import { __toESM } from "../../_rolldown/runtime.mjs";
+import { require_window } from "../../global/window.js.mjs";
+import resolveUrl from "../../@videojs/vhs-utils/es/resolve-url.js.mjs";
+import decodeB64ToUint8Array from "../../@videojs/vhs-utils/es/decode-b64-to-uint8-array.js.mjs";
+import { forEachMediaGroup } from "../../@videojs/vhs-utils/es/media-groups.js.mjs";
+import { require_lib } from "../../@xmldom/xmldom/lib/index.js.mjs";
+// ../../node_modules/.pnpm/mpd-parser@1.3.1/node_modules/mpd-parser/dist/mpd-parser.es.js
+/*! @name mpd-parser @version 1.3.1 @license Apache-2.0 */
+var import_window = /* @__PURE__ */ __toESM(require_window());
+var import_lib = require_lib();
+var 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;
+	}, {});
+};
+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;
+};
+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;
+};
+var 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;
+	}, {}));
+};
+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"
+};
+/**
+* @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;
+};
+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}`;
+};
+/**
+* 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;
+};
+/**
+* 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)
+		};
+	}
+};
+/**
+* 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
+	};
+};
+/**
+* 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;
+};
+/**
+* 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];
+};
+/**
+* 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;
+};
+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);
+};
+/**
+* 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;
+};
+/**
+* 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;
+};
+/**
+* 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;
+	});
+};
+/**
+* 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
+		});
+	});
+};
+/**
+* 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;
+};
+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;
+	});
+};
+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;
+};
+var 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;
+};
+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;
+};
+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;
+};
+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;
+	}, {});
+};
+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;
+}, {});
+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;
+};
+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;
+		});
+	});
+};
+/**
+* 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);
+	}, []);
+};
+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;
+};
+/**
+* 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);
+};
+/**
+* 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;
+};
+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}`;
+};
+/**
+* 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);
+};
+/**
+* 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
+		};
+	});
+};
+/**
+* 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;
+};
+/**
+* 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);
+};
+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;
+};
+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));
+};
+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);
+};
+var parseDate = (str) => {
+	if (/^\d+-\d+-\d+T\d+:\d+:\d+(\.\d+)?$/.test(str)) str += "Z";
+	return Date.parse(str);
+};
+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;
+	}
+};
+/**
+* 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;
+	}, {});
+};
+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"
+};
+/**
+* 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;
+		});
+	}));
+};
+/**
+* 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;
+};
+/**
+* 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)
+		};
+	});
+};
+/**
+* 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;
+	}, {});
+};
+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;
+	});
+};
+/**
+* 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
+			};
+		});
+	}));
+};
+/**
+* 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)));
+};
+/**
+* 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)));
+};
+/**
+* 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;
+};
+/**
+* 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;
+};
+/**
+* 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))
+	};
+};
+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;
+};
+/**
+* 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;
+};
+var parse = (manifestString, options = {}) => {
+	const parsedManifestInfo = inheritAttributes(stringToMpdXml(manifestString), options);
+	return toM3u8({
+		dashPlaylists: toPlaylists(parsedManifestInfo.representationInfo),
+		locations: parsedManifestInfo.locations,
+		contentSteering: parsedManifestInfo.contentSteeringInfo,
+		sidxMapping: options.sidxMapping,
+		previousManifest: options.previousManifest,
+		eventStream: parsedManifestInfo.eventStream
+	});
+};
+/**
+* Parses the manifest for a UTCTiming node, returning the nodes attributes if found
+*
+* @param {string} manifestString
+*        XML string of the MPD manifest
+* @return {Object|null}
+*         Attributes of UTCTiming node specified in the manifest. Null if none found
+*/
+var parseUTCTiming = (manifestString) => parseUTCTimingScheme(stringToMpdXml(manifestString));
+export { addSidxSegmentsToPlaylist$1 as addSidxSegmentsToPlaylist, generateSidxKey, inheritAttributes, parse, parseUTCTiming, stringToMpdXml, toM3u8, toPlaylists };