@svta/cml-cmaf-ham 0.19.0 → 0.20.0

package/dist/index.js

@@ -1,20 +1,1823 @@
-export * from './services/converters/dashToHam.js';
-export * from './services/converters/hamToDash.js';
-export * from './services/converters/hamToHls.js';
-export * from './services/converters/hlsToHam.js';
-export * from './services/getters/getTracksFromPresentation.js';
-export * from './services/getters/getTracksFromSelectionSet.js';
-export * from './services/getters/getTracksFromSwitchingSet.js';
-export * from './services/validators/validatePresentation.js';
-export * from './services/validators/validateSegment.js';
-export * from './services/validators/validateSegments.js';
-export * from './services/validators/validateSelectionSet.js';
-export * from './services/validators/validateSelectionSets.js';
-export * from './services/validators/validateSwitchingSet.js';
-export * from './services/validators/validateSwitchingSets.js';
-export * from './services/validators/validateTrack.js';
-export * from './services/validators/validateTracks.js';
-export * from './utils/dash/parseDashManifest.js';
-export * from './utils/dash/serializeDashManifest.js';
-export * from './utils/hls/parseHlsManifest.js';
+//#region src/mapper/dash/mapDashToHam/mapSegmentBase.ts
+/**
+* @internal
+*
+* Maps SegmentBase from dash to Segment list from ham.
+*
+* @param representation - Representation to get the SegmentBase from
+* @param duration - Duration of the segment
+* @returns list of ham segments
+*/
+function mapSegmentBase(representation, duration) {
+	return representation.SegmentBase.map((segment) => {
+		return {
+			duration,
+			url: representation.BaseURL[0] ?? "",
+			byteRange: segment.$.indexRange
+		};
+	});
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/calculateDuration.ts
+/**
+* @internal
+*
+* Calculates the duration of a segment.
+*
+* segmentDuration = duration / timescale
+*
+* @param duration - Duration of the segment
+* @param timescale - Timescale of the segment
+* @returns Segment duration
+*/
+function calculateDuration(duration, timescale) {
+	if (!duration || !timescale) return 1;
+	return +(duration ?? 1) / +(timescale ?? 1);
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/mapSegmentList.ts
+/**
+* @internal
+*
+* Maps SegmentList from dash to Segment list from ham.
+*
+* @param segmentList - SegmentList list from dash
+* @returns list of ham segments
+*/
+function mapSegmentList(segmentList) {
+	const segments = [];
+	segmentList.map((segment) => {
+		if (segment.SegmentURL) return segment.SegmentURL.forEach((segmentURL) => {
+			segments.push({
+				duration: calculateDuration(segment.$.duration, segment.$.timescale),
+				url: segmentURL.$.media ?? ""
+			});
+		});
+	});
+	return segments;
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getNumberOfSegments.ts
+/**
+* @internal
+*
+* Calculates the number of segments that a track has to use SegmentTemplate.
+*
+* Equation used:
+* segments = total duration / (segment duration / timescale)
+*
+* **This equation might be wrong, please double-check it**
+*
+* @param segmentTemplate - SegmentTemplate object
+* @param duration - Total duration of the content
+* @returns Number of segments
+*/
+function getNumberOfSegments(segmentTemplate, duration) {
+	return Math.round(duration / calculateDuration(segmentTemplate.$.duration, segmentTemplate.$.timescale));
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getUrlFromTemplate.ts
+/**
+* @internal
+*
+* Create the url from a segment template.
+*
+* Searches for substrings with the format `$value$` and replaces it with the correct value.
+* - RepresentationID: id of the representation
+* - Number: id of the segment. `%0Xd` defines the number `X` of digits it needs to have
+*
+* @param representation - Representation of the template
+* @param segmentTemplate - Segment template
+* @param segmentId - Segment id
+* @returns url from the segment template
+*/
+function getUrlFromTemplate(representation, segmentTemplate, segmentId) {
+	return segmentTemplate.$.media.replace(/\$(.*?)\$/g, (match) => {
+		if (match.includes("RepresentationID")) return representation.$.id;
+		/**
+		* Number with 4 digits e.g: 0001
+		*/
+		if (match.includes("Number%04d")) return segmentId.toString().padStart(4, "0");
+		if (match.includes("Number")) return segmentId;
+		console.error(`Unknown property ${match} from the SegmentTemplate on representation ${representation.$.id}`);
+		return match;
+	});
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/mapSegmentTemplate.ts
+/**
+* @internal
+*
+* Maps SegmentTemplate from dash to Segment list from ham.
+*
+* @param representation - Representation to generate the urls
+* @param duration - Duration of the segments
+* @param segmentTemplate - SegmentTemplate to get the properties from
+* @returns list of ham segments
+*/
+function mapSegmentTemplate(representation, duration, segmentTemplate) {
+	const numberOfSegments = getNumberOfSegments(segmentTemplate, duration);
+	const init = +(segmentTemplate.$.startNumber ?? 0);
+	const segments = [];
+	for (let id = init; id < numberOfSegments + init; id++) segments.push({
+		duration: calculateDuration(segmentTemplate.$.duration, segmentTemplate.$.timescale),
+		url: getUrlFromTemplate(representation, segmentTemplate, id)
+	});
+	return segments;
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/mapSegments.ts
+/**
+* @internal
+*
+* Maps dash segments to ham segment.
+*
+* Checks the type of dash segments used to map them accordingly.
+* @see mapSegmentBase
+* @see mapSegmentList
+* @see mapSegmentTemplate
+*
+* @param adaptationSet - AdaptationSet to get the segments from
+* @param representation - Representation to get the segments from
+* @param duration - Duration of the segments
+* @returns list of ham segments
+*/
+function mapSegments(adaptationSet, representation, duration) {
+	const segmentTemplate = adaptationSet.SegmentTemplate?.at(0) ?? representation.SegmentTemplate?.at(0);
+	const segmentList = adaptationSet.SegmentList ?? representation.SegmentList;
+	if (representation.SegmentBase) return mapSegmentBase(representation, duration);
+	else if (segmentList) return mapSegmentList(segmentList);
+	else if (segmentTemplate) return mapSegmentTemplate(representation, duration, segmentTemplate);
+	else {
+		console.error(`Representation ${representation.$.id} has no segments`);
+		return [];
+	}
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getChannels.ts
+/**
+* @internal
+*
+* Get the channels value (audio). It can be present on adaptationSet or representation.
+*
+* @param adaptationSet - AdaptationSet to try to get the channels from
+* @param representation - Representation to try to get the channels from
+* @returns Channels value
+*/
+function getChannels(adaptationSet, representation) {
+	const channels = +(adaptationSet.AudioChannelConfiguration?.at(0)?.$.value ?? representation.AudioChannelConfiguration?.at(0)?.$.value ?? 0);
+	if (!channels) console.error(`Representation ${representation.$.id} has no channels`);
+	return channels;
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getCodec.ts
+/**
+* @internal
+*
+* Get the codec value (video and audio). It can be present on adaptationSet or representation.
+*
+* @param adaptationSet - AdaptationSet to try to get the codec from
+* @param representation - Representation to try to get the codec from
+* @returns Content codec
+*/
+function getCodec(adaptationSet, representation) {
+	const codec = representation.$.codecs ?? adaptationSet.$.codecs ?? "";
+	if (!codec) console.error(`Representation ${representation.$.id} has no codecs`);
+	return codec;
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getContentType.ts
+/**
+* @internal
+*
+* Get the type of the content. It can be obtained directly from AdaptationSet or Representation
+* or can be inferred with the existing properties.
+*
+* @param adaptationSet - AdaptationSet to get the type from
+* @param representation - Representation to get the type from
+* @returns type of the content
+*/
+function getContentType(adaptationSet, representation) {
+	if (adaptationSet.$.contentType) return adaptationSet.$.contentType;
+	if (adaptationSet.ContentComponent?.at(0)) return adaptationSet.ContentComponent.at(0).$.contentType;
+	if (adaptationSet.$.mimeType || representation?.$.mimeType) {
+		const type = adaptationSet.$.mimeType?.split("/")[0] || representation?.$.mimeType?.split("/")[0];
+		if (type === "audio" || type === "video" || type === "text") return type;
+		if (type === "application") return "text";
+	}
+	if (adaptationSet.$.maxHeight) return "video";
+	const adaptationRef = adaptationSet.$.id ?? `group: ${adaptationSet.$.group}, lang: ${adaptationSet.$.lang}`;
+	console.error(`Could not find contentType from adaptationSet ${adaptationRef}`);
+	console.info("Using \"text\" as default contentType");
+	return "text";
+}
+
+//#endregion
+//#region src/utils/constants.ts
+const TIMESCALE_48000 = 48e3;
+const VIDEO_SAMPLE_RATE = 9e4;
+const TEXT_SAMPLE_RATE = 1e3;
+const FRAME_RATE_NUMERATOR_30 = 30;
+const WHITE_SPACE = " ";
+const WHITE_SPACE_ENCODED = "%20";
+const HYPHEN_MINUS_SEPARATOR = "-";
+const AT_SEPARATOR = "@";
+const FRAME_RATE_SEPARATOR = "/";
+const NUMERATOR = 0;
+const DENOMINATOR = 1;
+const ZERO = 0;
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getFrameRate.ts
+/**
+* @internal
+*
+* Get the frame rate from a dash manifest.
+*
+* This functions assumes the adaptationSet and representation set are type video
+*
+* @param adaptationSet - To try to get the frameRate from
+* @param representation - To try to get the frameRate from
+* @returns object containing numerator and denominator
+*/
+function getFrameRate(adaptationSet, representation) {
+	const frameRateDash = representation.$.frameRate ?? adaptationSet.$.frameRate ?? "";
+	if (!frameRateDash) console.error(`Representation ${representation.$.id} has no frame rate`);
+	const frameRate = frameRateDash.split(FRAME_RATE_SEPARATOR);
+	const frameRateNumerator = parseInt(frameRate.at(NUMERATOR) ?? "");
+	const frameRateDenominator = parseInt(frameRate.at(DENOMINATOR) ?? "");
+	return {
+		frameRateNumerator: isNaN(frameRateNumerator) ? FRAME_RATE_NUMERATOR_30 : frameRateNumerator,
+		frameRateDenominator: isNaN(frameRateDenominator) ? ZERO : frameRateDenominator
+	};
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getGroup.ts
+/**
+* @internal
+*/
+function getGroup(adaptationSet) {
+	return adaptationSet.$.group ?? getContentType(adaptationSet);
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getLanguage.ts
+/**
+* @internal
+*
+* Get the language from an adaptation set.
+*
+* @param adaptationSet - AdaptationSet to get the language from
+* @returns language of the content
+*/
+function getLanguage(adaptationSet) {
+	let language = adaptationSet.$.lang;
+	if (!language) {
+		console.info(`AdaptationSet ${adaptationSet.$.id} has no lang, using "und" as default`);
+		language = "und";
+	}
+	return language;
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getPresentationId.ts
+/**
+* @internal
+*
+* Generates a presentation id. It uses the period id as default or creates one
+* if none is present.
+*
+* @param period - Period to try to get the id from
+* @param duration - Duration of the content
+* @returns Presentation id
+*/
+function getPresentationId(period, duration) {
+	return period.$.id ?? `presentation-id-${duration}`;
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getSampleRate.ts
+/**
+* @internal
+*
+* Get sample rate (audio).
+*
+* @param adaptationSet - AdaptationSet to try to get the sampleRate from
+* @param representation - Representation to try to get the sampleRate from
+* @returns Sample rate. In case it is not presents, it returns 0.
+*/
+function getSampleRate(adaptationSet, representation) {
+	const sampleRate = +(representation.$.audioSamplingRate ?? adaptationSet.$.audioSamplingRate ?? 0);
+	if (!sampleRate) console.error(`Representation ${representation.$.id} has no audioSamplingRate`);
+	return sampleRate;
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getSar.ts
+/**
+* @internal
+*
+* Get the sar value. It can be present on adaptationSet or representation.
+*
+* @param adaptationSet - AdaptationSet to try to get the sar from
+* @param representation - AdaptationSet to try to get the sar from
+* @returns sar value. In case it is not present, returns empty string.
+*/
+function getSar(adaptationSet, representation) {
+	const sar = representation.$.sar ?? adaptationSet.$.sar ?? "";
+	if (!sar) console.error(`Representation ${representation.$.id} has no sar`);
+	return sar;
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getTrackDuration.ts
+/**
+* @internal
+*
+* Calculate the duration of a track.
+*
+* This is calculated using the sum of the duration of all the segments from the
+* track.
+*
+* An alternative to this could be number of segments * duration of a segment.
+*
+* @param segments - Segments to calculate the sum of the durations
+* @returns Duration of the track
+*/
+function getTrackDuration(segments) {
+	return segments.reduce((acc, segment) => {
+		return acc + segment.duration;
+	}, 0);
+}
+
+//#endregion
+//#region src/mapper/dash/mapHamToDash/utils/getTimescale.ts
+/**
+* @internal
+*
+* This function tries to recreate the timescale value.
+*
+* This value is not stored on the ham object, so it is not possible (for now)
+* to get the original one.
+*
+* Just the audio tracks have this value stored on the `sampleRate` key.
+*
+* @param track - Track to get the timescale from
+* @returns Timescale in numbers
+*/
+function getTimescale(track) {
+	if (track?.type === "audio") {
+		const audioTrack = track;
+		return audioTrack.sampleRate !== 0 ? audioTrack.sampleRate : TIMESCALE_48000;
+	}
+	if (track?.type === "video") return VIDEO_SAMPLE_RATE;
+	if (track?.type === "text") return TEXT_SAMPLE_RATE;
+	return VIDEO_SAMPLE_RATE;
+}
+
+//#endregion
+//#region src/mapper/hls/mapHamToHls/utils/encodeByteRange.ts
+/**
+* @internal
+*
+* Get the byterange in hls format from ham track.
+*
+* @param track - Track to get the byterange from
+* @returns string containing the byterange in the hls format
+*
+* @alpha
+*/
+function encodeByteRange(track) {
+	if (track.byteRange) return `BYTERANGE:${track.byteRange.replace(HYPHEN_MINUS_SEPARATOR, AT_SEPARATOR)}\n`;
+	else if (track.segments?.at(0)?.byteRange) return `BYTERANGE:0@${Number(track.segments.at(0)?.byteRange?.replace(HYPHEN_MINUS_SEPARATOR, AT_SEPARATOR).split(AT_SEPARATOR)[0]) - 1}\n`;
+	return "";
+}
+
+//#endregion
+//#region src/mapper/hls/mapHamToHls/utils/getUrlInitialization.ts
+/**
+* @internal
+*
+* Get url initialization from ham track.
+*
+* @param track - Track to get the url initialization from
+* @returns string containing the url initialization in the hls format
+*
+* @alpha
+*/
+function getUrlInitialization(track) {
+	return track.urlInitialization?.replaceAll(WHITE_SPACE, WHITE_SPACE_ENCODED) ?? "";
+}
+
+//#endregion
+//#region src/mapper/hls/mapHamToHls/utils/getPlaylistData.ts
+/**
+* @internal
+*
+* Get the playlist data in hls format from ham track.
+*
+* @param track - Track to get the playlist data from
+* @returns string containing the playlist data in the hls format
+*
+* @alpha
+*/
+function getPlaylistData(track) {
+	return `#EXT-X-MAP:URI="${getUrlInitialization(track)}",${encodeByteRange(track)}\n`;
+}
+
+//#endregion
+//#region src/mapper/hls/mapHamToHls/utils/getSegments.ts
+/**
+* @internal
+*
+* Format the ham segments to hls.
+*
+* @param segments - Segments to be formatted
+* @returns string containing the segments in the hls format
+*
+* @alpha
+*/
+function getSegments(segments) {
+	return segments.map((segment) => {
+		const byteRange = segment.byteRange ? `#EXT-X-BYTERANGE:${segment.byteRange.replace(HYPHEN_MINUS_SEPARATOR, AT_SEPARATOR)}\n` : "";
+		const url = segment.url.replaceAll(WHITE_SPACE, WHITE_SPACE_ENCODED);
+		return `#EXTINF:${segment.duration},\n${byteRange}\n${url}`;
+	}).join("\n");
+}
+
+//#endregion
+//#region src/mapper/hls/mapHlsToHam/utils/decodeByteRange.ts
+/**
+* @internal
+*
+* Get byterange from HLS Manifest.
+*
+* @param byteRange - Byterange object containing length and offset
+* @returns string containing the byterange. If byterange is undefined, it returns undefined
+*
+* @alpha
+*/
+function decodeByteRange(byteRange) {
+	if (!byteRange) return "";
+	return `${byteRange.length}@${byteRange.offset}`;
+}
+
+//#endregion
+//#region src/mapper/hls/mapHlsToHam/utils/formatSegments.ts
+/**
+* @internal
+*
+* Format the hls segments into the ham segments.
+*
+* @param segments - List of HLS segments
+* @returns ham formatted list of segments
+*
+* @alpha
+*/
+function formatSegments(segments) {
+	return segments?.map((segment) => {
+		const byteRange = decodeByteRange(segment?.byterange);
+		return {
+			duration: segment.duration,
+			url: segment.uri,
+			...byteRange && { byteRange }
+		};
+	}) ?? [];
+}
+
+//#endregion
+//#region src/mapper/hls/mapHlsToHam/utils/getDuration.ts
+/**
+* @internal
+*
+* Calculate the duration of a track.
+*
+* `target duration * number of segments`
+*
+* @param manifest - Manifest of the track
+* @param segments - Array of segments in a track
+* @returns duration of a track
+*
+* @alpha
+*/
+function getDuration(manifest, segments) {
+	if (!manifest?.targetDuration) {
+		console.error("Could not calculate duration, manifest is undefined.");
+		return null;
+	}
+	return manifest?.targetDuration * segments.length;
+}
+
+//#endregion
+//#region src/mapper/hls/mapHlsToHam/utils/getHlsCodec.ts
+/**
+* @internal
+*
+* Get the codec for a type of content.
+*
+* @param type - Type of the content to get the codecs from
+* @param codecs - String containing multiple codecs separated with commas
+* @returns string containing codec
+*
+* @alpha
+*/
+function getHlsCodec(type, codecs) {
+	if (type === "audio") return "mp4a.40.2";
+	else if (type === "video") return codecs?.split(",").at(0) ?? "";
+	else return "";
+}
+
+//#endregion
+//#region src/utils/dash/iso8601DurationToNumber.ts
+/**
+* @internal
+*/
+function iso8601DurationToNumber(isoDuration) {
+	const hours = /(?:([.,\d]+)H)/.exec(isoDuration);
+	const minutes = /(?:([.,\d]+)M)/.exec(isoDuration);
+	const seconds = /(?:([.,\d]+)S)/.exec(isoDuration);
+	let duration = 0;
+	if (hours) duration += +hours[1] * 60 * 60;
+	if (minutes) duration += +minutes[1] * 60;
+	if (seconds) duration += +seconds[1];
+	return duration;
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/utils/getInitializationUrl.ts
+/**
+* @internal
+*
+* Get the initialization url. It can be present on AdaptationSet or Representation.
+*
+* Url initialization is present on segments.
+*
+* @param adaptationSet - AdaptationSet to try to get the initialization url from
+* @param representation - Representation to try to get the initialization url from
+*/
+function getInitializationUrl(adaptationSet, representation) {
+	let initializationUrl;
+	if (representation.SegmentBase) initializationUrl = representation.BaseURL[0] ?? "";
+	else if (adaptationSet.SegmentList || representation.SegmentList) initializationUrl = representation.SegmentList?.at(0)?.Initialization[0].$.sourceURL || adaptationSet.SegmentList?.at(0)?.Initialization[0].$.sourceURL;
+	if (adaptationSet.SegmentTemplate || representation.SegmentTemplate) {
+		initializationUrl = adaptationSet.SegmentTemplate?.at(0)?.$.initialization || representation.SegmentTemplate?.at(0)?.$.initialization;
+		if (initializationUrl?.includes("$RepresentationID$")) initializationUrl = initializationUrl.replace("$RepresentationID$", representation.$.id ?? "");
+	}
+	return initializationUrl;
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/mapTracks.ts
+/**
+* @internal
+*
+* Map dash components to ham tracks.
+*
+* @param adaptationSet - AdaptationSet of the dash manifest
+* @param representation - Representation of the dash manifest
+* @param segments - Segments from the representation of the dash manifest
+* @param initializationUrl - Initialization url from the track
+* @returns AudioTrack, VideoTrack or TextTrack depending on the type
+*/
+function mapTracks(adaptationSet, representation, segments, initializationUrl) {
+	if (!adaptationSet) throw new Error("Error: AdaptationSet is undefined");
+	const type = getContentType(adaptationSet, representation);
+	if (type === "video") return {
+		bandwidth: +(representation.$.bandwidth ?? 0),
+		codec: getCodec(adaptationSet, representation),
+		duration: getTrackDuration(segments),
+		frameRate: getFrameRate(adaptationSet, representation),
+		height: +(representation.$.height ?? 0),
+		id: representation.$.id ?? "",
+		language: getLanguage(adaptationSet),
+		par: adaptationSet.$.par ?? "",
+		sar: getSar(adaptationSet, representation),
+		scanType: representation.$.scanType ?? "",
+		segments,
+		type,
+		width: +(representation.$.width ?? 0),
+		urlInitialization: initializationUrl
+	};
+	else if (type === "audio") return {
+		bandwidth: +(representation.$.bandwidth ?? 0),
+		channels: getChannels(adaptationSet, representation),
+		codec: getCodec(adaptationSet, representation),
+		duration: getTrackDuration(segments),
+		id: representation.$.id ?? "",
+		language: getLanguage(adaptationSet),
+		sampleRate: getSampleRate(adaptationSet, representation),
+		segments,
+		type,
+		urlInitialization: initializationUrl
+	};
+	else return {
+		bandwidth: +(representation.$.bandwidth ?? 0),
+		codec: getCodec(adaptationSet, representation),
+		duration: getTrackDuration(segments),
+		id: representation.$.id ?? "",
+		language: getLanguage(adaptationSet),
+		segments,
+		type,
+		urlInitialization: initializationUrl
+	};
+}
+
+//#endregion
+//#region src/mapper/dash/mapDashToHam/mapDashToHam.ts
+/**
+* @internal
+*
+* Main function to map dash to ham.
+*
+* @param dash - Dash manifest to map
+* @returns List of presentations in ham
+*/
+function mapDashToHam(dash) {
+	return dash.MPD.Period.map((period) => {
+		const duration = iso8601DurationToNumber(period.$.duration);
+		const presentationId = getPresentationId(period, duration);
+		const selectionSetGroups = {};
+		period.AdaptationSet.map((adaptationSet) => {
+			const tracks = adaptationSet.Representation.map((representation) => {
+				return mapTracks(adaptationSet, representation, mapSegments(adaptationSet, representation, duration), getInitializationUrl(adaptationSet, representation));
+			});
+			const group = getGroup(adaptationSet);
+			if (!selectionSetGroups[group]) selectionSetGroups[group] = {
+				id: group,
+				switchingSets: []
+			};
+			selectionSetGroups[group].switchingSets.push({
+				id: adaptationSet.$.id ?? adaptationSet.ContentComponent?.at(0)?.$.id ?? group,
+				tracks
+			});
+		});
+		return {
+			id: presentationId,
+			selectionSets: Object.values(selectionSetGroups)
+		};
+	});
+}
+
+//#endregion
+//#region src/mapper/dash/mapHamToDash/trackToSegmentBase.ts
+function trackToSegmentBase(track) {
+	const segments = [];
+	if (track.segments.length > 0 && track.byteRange && track.segments[0].byteRange && track.segments[0].byteRange.includes("@")) {
+		let firstSegment = void 0;
+		const initByteRange = track.byteRange.includes("-") ? track.byteRange.split("-")[1] : track.byteRange.includes("@") ? track.byteRange.split("@")[0] : "";
+		const initRange = +initByteRange - 1;
+		firstSegment = {
+			$: { indexRange: `${initByteRange}-${+(track.segments[0].byteRange.includes("-") ? track.segments[0].byteRange.split("-")[1] : track.segments[0].byteRange.includes("@") ? track.segments[0].byteRange.split("@")[1] : "") - 1}` },
+			Initialization: [{ $: { range: `0-${initRange}` } }]
+		};
+		if (firstSegment && track.type === "audio") {
+			const audioTrack = track;
+			firstSegment.$.timescale = audioTrack.sampleRate.toString() ?? "";
+		}
+		if (firstSegment) segments.push(firstSegment);
+	} else track.segments.forEach((segment) => {
+		let newSegment;
+		if (segment.byteRange) {
+			const initRange = +segment.byteRange.split("-")[0] - 1;
+			newSegment = {
+				$: { indexRange: segment.byteRange },
+				Initialization: [{ $: { range: `0-${initRange}` } }]
+			};
+		}
+		if (newSegment && track.type === "audio") {
+			const audioTrack = track;
+			newSegment.$.timescale = audioTrack.sampleRate.toString() ?? "";
+		}
+		if (newSegment) segments.push(newSegment);
+	});
+	return segments;
+}
+
+//#endregion
+//#region src/mapper/dash/mapHamToDash/trackToSegmentList.ts
+function trackToSegmentList(track) {
+	const segmentList = [];
+	const segmentURLs = [];
+	track.segments.forEach((segment) => {
+		segmentURLs.push({ $: { media: segment.url } });
+	});
+	if (!track.segments.at(0)?.byteRange) {
+		const timescale = getTimescale(track);
+		segmentList.push({
+			$: {
+				duration: (track.duration * timescale / segmentURLs.length).toString(),
+				timescale: timescale.toString()
+			},
+			Initialization: [{ $: { sourceURL: track.urlInitialization } }],
+			SegmentURL: segmentURLs
+		});
+	}
+	return segmentList;
+}
+
+//#endregion
+//#region src/mapper/dash/mapHamToDash/utils/getFrameRate.ts
+/**
+* @internal
+*
+* Get the framerate from a track.
+*
+* If frameRate numerator is not present, it uses 30 as default.
+*
+* @param track - to get the framerate from
+* @returns frame rate as a string formatted as `numerator/denominator`
+*/
+function getFrameRate$1(track) {
+	let frameRate = void 0;
+	if (track?.type === "video") {
+		const videoTrack = track;
+		frameRate = `${videoTrack.frameRate.frameRateNumerator ?? FRAME_RATE_NUMERATOR_30}`;
+		frameRate = videoTrack.frameRate.frameRateDenominator !== ZERO ? `${frameRate}/${videoTrack.frameRate.frameRateDenominator}` : frameRate;
+	}
+	return frameRate;
+}
+
+//#endregion
+//#region src/mapper/dash/mapHamToDash/tracksToRepresentation.ts
+function tracksToRepresentation(tracks) {
+	return tracks.map((track) => {
+		const representation = {
+			$: {
+				id: track.id,
+				bandwidth: track.bandwidth.toString()
+			},
+			SegmentBase: trackToSegmentBase(track),
+			SegmentList: trackToSegmentList(track)
+		};
+		representation.$.mimeType = `${track.type}/mp4`;
+		if (track.type === "video") {
+			const videoTrack = track;
+			representation.$ = {
+				...representation.$,
+				frameRate: getFrameRate$1(track),
+				width: videoTrack.width.toString(),
+				height: videoTrack.height.toString(),
+				codecs: videoTrack.codec
+			};
+			if (videoTrack.scanType) representation.$.scanType = videoTrack.scanType;
+		}
+		if (track.type === "audio") {
+			const audioTrack = track;
+			representation.$ = {
+				...representation.$,
+				audioSamplingRate: audioTrack.sampleRate.toString(),
+				codecs: audioTrack.codec
+			};
+			representation.AudioChannelConfiguration = [{ $: {
+				schemeIdUri: "urn:mpeg:dash:23003:3:audio_channel_configuration:2011",
+				value: audioTrack.channels.toString() ?? ""
+			} }];
+		}
+		if (track.segments[0]?.byteRange) representation.BaseURL = [track.segments[0].url];
+		return representation;
+	});
+}
+
+//#endregion
+//#region src/mapper/dash/mapHamToDash/selectionSetsToAdaptationSet.ts
+function selectionSetsToAdaptationSet(selectionsSets) {
+	return selectionsSets.flatMap((selectionSet) => {
+		return selectionSet.switchingSets.map((switchingSet) => {
+			const track = switchingSet.tracks[0];
+			return {
+				$: {
+					id: switchingSet.id,
+					group: selectionSet.id,
+					contentType: track?.type,
+					mimeType: `${track?.type}/mp4`,
+					frameRate: getFrameRate$1(track),
+					lang: track?.language,
+					codecs: track?.codec
+				},
+				Representation: tracksToRepresentation(switchingSet.tracks)
+			};
+		});
+	});
+}
+
+//#endregion
+//#region src/utils/dash/numberToIso8601Duration.ts
+/**
+* @internal
+*/
+function numberToIso8601Duration(duration) {
+	const hours = Math.floor(duration / 3600);
+	const minutes = Math.floor(duration % 3600 / 60);
+	const seconds = duration % 60;
+	if (hours > 0) return `PT${hours}H${minutes}M${seconds}S`;
+	else if (minutes > 0) return `PT${minutes}M${seconds}S`;
+	return `PT${seconds}S`;
+}
+
+//#endregion
+//#region src/mapper/dash/mapHamToDash/presentationsToPeriods.ts
+function presentationsToPeriods(presentations) {
+	return presentations.map((presentation) => {
+		return {
+			$: {
+				duration: numberToIso8601Duration(presentation.selectionSets[0].switchingSets[0].tracks[0].duration),
+				id: presentation.id,
+				start: "PT0S"
+			},
+			AdaptationSet: selectionSetsToAdaptationSet(presentation.selectionSets)
+		};
+	});
+}
+
+//#endregion
+//#region src/utils/dash/serializeDashManifest.ts
+let xmlSerializer;
+/**
+* @internal
+*/
+function setDashSerializer(serializer) {
+	xmlSerializer = serializer;
+}
+/**
+* @internal
+*/
+function getDashSerializer() {
+	return xmlSerializer;
+}
+/**
+* @internal
+*/
+function serializeDashManifest(json) {
+	return xmlSerializer(json);
+}
+
+//#endregion
+//#region src/mapper/dash/mapHamToDash/mapHamToDash.ts
+function mapHamToDash(hamManifests) {
+	const periods = presentationsToPeriods(hamManifests);
+	return serializeDashManifest({ MPD: {
+		$: {
+			mediaPresentationDuration: periods[0].$.duration,
+			type: "static"
+		},
+		Period: periods
+	} });
+}
+
+//#endregion
+//#region src/utils/dash/parseDashManifest.ts
+let dashParser;
+/**
+* @internal
+*/
+function setDashParser(parser) {
+	dashParser = parser;
+}
+/**
+* @internal
+*/
+function getDashParser() {
+	return dashParser;
+}
+/**
+* @internal
+* Parse XML to Json
+*
+* @param raw - Raw string containing the xml from the Dash Manifest
+* @returns json with the Dash Manifest structure
+*/
+function parseDashManifest(raw) {
+	return dashParser(raw);
+}
+
+//#endregion
+//#region src/utils/manifest/addMetadataToDash.ts
+function addMetadataToDash(dashManifest, manifest) {
+	if (!manifest.metadata) manifest.metadata = /* @__PURE__ */ new Map();
+	if (dashManifest.MPD.$ && dashManifest.MPD.$.profiles) manifest.metadata.set("profiles", dashManifest.MPD.$.profiles);
+	if (dashManifest.MPD.$ && dashManifest.MPD.$.type) manifest.metadata.set("type", dashManifest.MPD.$.type);
+	return manifest;
+}
+
+//#endregion
+//#region src/utils/manifest/getMetadata.ts
+function getMetadata(manifest) {
+	const metadata = manifest?.metadata;
+	return JSON.parse(JSON.stringify(metadata));
+}
+
+//#endregion
+//#region src/mapper/dash/DashMapper.ts
+var DashMapper = class {
+	getManifestMetadata() {
+		return getMetadata(this.manifest);
+	}
+	toHam(manifest) {
+		const dashManifest = parseDashManifest(manifest.manifest);
+		if (!dashManifest) return [];
+		addMetadataToDash(dashManifest, manifest);
+		return mapDashToHam(dashManifest);
+	}
+	toManifest(presentation) {
+		return {
+			manifest: mapHamToDash(presentation),
+			ancillaryManifests: [],
+			type: "dash"
+		};
+	}
+};
+
+//#endregion
+//#region src/mapper/MapperContext.ts
+var MapperContext = class MapperContext {
+	constructor() {}
+	static getInstance() {
+		if (!MapperContext.instance) MapperContext.instance = new MapperContext();
+		return MapperContext.instance;
+	}
+	setStrategy(strategy) {
+		this.strategy = strategy;
+	}
+	getHamFormat(manifest) {
+		return this.strategy.toHam(manifest);
+	}
+	getManifestFormat(presentation) {
+		return this.strategy.toManifest(presentation);
+	}
+	getManifestMetadata() {
+		return this.strategy.getManifestMetadata();
+	}
+};
+
+//#endregion
+//#region src/services/converters/dashToHam.ts
+/**
+* Convert dash manifest into a ham object.
+*
+* @example
+* Example on how to import the cmaf module and convert the dash `manifest`
+* into the ham manifest.
+* ```ts
+* import cmaf from '@svta/common-media-library/cmaf-ham';
+*
+* const manifest = cmaf.dashToHam(dashManifest);
+* ```
+*
+* @param manifest - String of the XML Dash manifest
+* @returns List of presentations from ham
+*
+* @alpha
+*/
+function dashToHam(manifest) {
+	const mapperContext = MapperContext.getInstance();
+	mapperContext.setStrategy(new DashMapper());
+	return mapperContext.getHamFormat({
+		manifest,
+		type: "dash"
+	});
+}
+
+//#endregion
+//#region src/services/converters/hamToDash.ts
+/**
+* Convert HAM object into Dash Manifest.
+*
+* @example
+* Example on how to import the cmaf module and convert the ham `presentations`
+* array into the dash manifest.
+* ```ts
+* import cmaf from '@svta/common-media-library/cmaf-ham';
+*
+* const manifest = cmaf.hamToDash(presentations);
+* ```
+*
+* @param presentation - List of presentations from ham
+* @returns Manifest object containing the Dash manifest as string
+*
+* @alpha
+*/
+function hamToDash(presentation) {
+	const mapperContext = MapperContext.getInstance();
+	mapperContext.setStrategy(new DashMapper());
+	return mapperContext.getManifestFormat(presentation);
+}
+
+//#endregion
+//#region src/mapper/hls/mapHamToHls/generateManifestPlaylistPiece.ts
+function generateManifestPlaylistPiece(track) {
+	const mediaSequence = 0;
+	const trackFileName = track.fileName ?? `${track.id}.m3u8`;
+	let mainRef = "";
+	let playlist = `#EXTM3U\n#EXT-X-TARGETDURATION:${track.duration / track.segments.length}\n#EXT-X-PLAYLIST-TYPE:VOD\n#EXT-X-MEDIA-SEQUENCE:${mediaSequence}\n`;
+	if (track.type.toLowerCase() === "video") {
+		const videoTrack = track;
+		mainRef += `#EXT-X-STREAM-INF:BANDWIDTH=${videoTrack.bandwidth},CODECS="${videoTrack.codec}",RESOLUTION=${videoTrack.width}x${videoTrack.height}\n${trackFileName}\n`;
+		playlist += getPlaylistData(videoTrack);
+	} else if (track.type.toLowerCase() === "audio") {
+		const audioTrack = track;
+		mainRef += `#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="${audioTrack.id}",LANGUAGE="${audioTrack.language}",NAME="${audioTrack.id}",URI="${trackFileName}"\n`;
+		playlist += getPlaylistData(audioTrack);
+	} else if (track.type.toLowerCase() === "text") {
+		const textTrack = track;
+		mainRef += `#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="${textTrack.id}",NAME="${textTrack.id}",LANGUAGE="${textTrack.language}",URI="${trackFileName}"\n`;
+	}
+	playlist += `${getSegments(track.segments)}#EXT-X-ENDLIST`;
+	return {
+		mainRef,
+		playlist
+	};
+}
+
+//#endregion
+//#region src/mapper/hls/mapHamToHls/mapHamToHls.ts
+function mapHamToHls(presentations) {
+	let mainManifest = `#EXTM3U\n#EXT-X-VERSION:7\n\n`;
+	const playlists = [];
+	presentations.map((presentation) => {
+		presentation.selectionSets.map((selectionSet) => {
+			selectionSet.switchingSets.map((switchingSet) => {
+				switchingSet.tracks.map((track) => {
+					const { mainRef, playlist } = generateManifestPlaylistPiece(track);
+					mainManifest += mainRef;
+					const manifestFileName = track.fileName ?? `${track.id}.m3u8`;
+					playlists.push({
+						manifest: playlist,
+						type: "hls",
+						fileName: manifestFileName
+					});
+				});
+			});
+		});
+	});
+	return {
+		manifest: mainManifest,
+		ancillaryManifests: playlists,
+		type: "hls"
+	};
+}
+
+//#endregion
+//#region src/utils/hls/parseHlsManifest.ts
+let hlsParser;
+/**
+* @internal
+*/
+function setHlsParser(parser) {
+	hlsParser = parser;
+}
+/**
+* @internal
+*/
+function getHlsParser() {
+	return hlsParser;
+}
+/**
+* @internal
+*/
+function parseHlsManifest(text) {
+	if (!text) {
+		console.error("Can't parse empty HLS Manifest");
+		return {};
+	}
+	return hlsParser(text);
+}
+
+//#endregion
+//#region src/mapper/hls/mapHlsToHam/audioGroupsToSwitchingSets.ts
+/**
+* @internal
+*
+* This function is used to convert audio groups to switching sets.
+*
+*
+* @param mediaGroupsAudio - Any
+* @param manifestPlaylists - Array of Manifest
+* @returns Array of switchingSet
+*
+* @alpha
+*/
+function audioGroupsToSwitchingSets(mediaGroupsAudio, manifestPlaylists) {
+	const audioSwitchingSets = [];
+	const audioTracks = [];
+	for (const audioEncodings in mediaGroupsAudio) {
+		const encodings = mediaGroupsAudio[audioEncodings];
+		for (const audio in encodings) {
+			const { language, uri } = encodings[audio];
+			const audioParsed = parseHlsManifest(manifestPlaylists.shift()?.manifest);
+			const map = audioParsed?.segments[0]?.map;
+			const segments = formatSegments(audioParsed?.segments);
+			const byteRange = decodeByteRange(map?.byterange);
+			audioTracks.push({
+				id: audio,
+				type: "audio",
+				fileName: uri,
+				codec: getHlsCodec("audio"),
+				duration: getDuration(audioParsed, segments),
+				language,
+				bandwidth: 0,
+				segments,
+				sampleRate: 0,
+				channels: 2,
+				...byteRange && { byteRange },
+				...map?.uri && { urlInitialization: map?.uri }
+			});
+		}
+	}
+	audioSwitchingSets.push({
+		id: "audio",
+		tracks: audioTracks
+	});
+	return audioSwitchingSets;
+}
+
+//#endregion
+//#region src/mapper/hls/mapHlsToHam/subtitleGroupsToSwitchingSets.ts
+function subtitleGroupsToSwitchingSets(mediaGroupsSubtitles, manifestPlaylists) {
+	const subtitleSwitchingSets = [];
+	const textTracks = [];
+	for (const subtitleEncodings in mediaGroupsSubtitles) {
+		const encodings = mediaGroupsSubtitles[subtitleEncodings];
+		for (const subtitle in encodings) {
+			const { language, uri } = encodings[subtitle];
+			const subtitleParsed = parseHlsManifest(manifestPlaylists.shift()?.manifest);
+			const segments = formatSegments(subtitleParsed?.segments);
+			textTracks.push({
+				id: subtitle,
+				type: "text",
+				fileName: uri,
+				codec: getHlsCodec("text"),
+				duration: getDuration(subtitleParsed, segments),
+				language,
+				bandwidth: 0,
+				segments
+			});
+		}
+	}
+	subtitleSwitchingSets.push({
+		id: "text",
+		tracks: textTracks
+	});
+	return subtitleSwitchingSets;
+}
+
+//#endregion
+//#region src/mapper/hls/mapHlsToHam/videoPlaylistsToSwitchingSets.ts
+function videoPlaylistsToSwitchingSets(playlists, manifestPlaylists) {
+	const switchingSetVideos = [];
+	const videoTracks = [];
+	let videoTrackId = 0;
+	playlists.map((playlist) => {
+		const parsedHlsManifest = parseHlsManifest(manifestPlaylists.shift()?.manifest);
+		const segments = formatSegments(parsedHlsManifest?.segments);
+		const { LANGUAGE, CODECS, BANDWIDTH } = playlist.attributes;
+		const map = parsedHlsManifest?.segments?.at(0)?.map;
+		const byteRange = decodeByteRange(map?.byterange);
+		videoTracks.push({
+			id: `video-${videoTrackId++}`,
+			type: "video",
+			fileName: playlist.uri,
+			codec: getHlsCodec("video", CODECS),
+			duration: getDuration(parsedHlsManifest, segments),
+			language: LANGUAGE ?? "und",
+			bandwidth: BANDWIDTH,
+			segments,
+			width: playlist.attributes.RESOLUTION.width,
+			height: playlist.attributes.RESOLUTION.height,
+			frameRate: {
+				frameRateNumerator: playlist.attributes["FRAME-RATE"] ?? FRAME_RATE_NUMERATOR_30,
+				frameRateDenominator: ZERO
+			},
+			par: "",
+			sar: "",
+			scanType: "",
+			...byteRange && { byteRange },
+			...map?.uri && { urlInitialization: map?.uri }
+		});
+	});
+	switchingSetVideos.push({
+		id: `video`,
+		tracks: videoTracks
+	});
+	return switchingSetVideos;
+}
+
+//#endregion
+//#region src/utils/manifest/addMetadataToHls.ts
+function addMetadataToHls(manifest, manifestParsed) {
+	if (!manifest.metadata) manifest.metadata = /* @__PURE__ */ new Map();
+	if (!manifestParsed.version) manifest.metadata.set("version", manifestParsed.version);
+	if (!manifestParsed.mediaSequence) manifest.metadata.set("mediaSequence", manifestParsed.mediaSequence);
+	return manifest;
+}
+
+//#endregion
+//#region src/mapper/hls/mapHlsToHam/mapHlsToHam.ts
+function mapHlsToHam(manifest) {
+	const mainManifestParsed = parseHlsManifest(manifest.manifest);
+	const manifestHls = addMetadataToHls(manifest, mainManifestParsed);
+	const selectionSets = [];
+	const manifestPlaylists = manifestHls.ancillaryManifests ? [...manifestHls.ancillaryManifests] : [];
+	const audioSwitchingSets = audioGroupsToSwitchingSets(mainManifestParsed.mediaGroups?.AUDIO, manifestPlaylists);
+	const subtitleSwitchingSets = subtitleGroupsToSwitchingSets(mainManifestParsed.mediaGroups?.SUBTITLES, manifestPlaylists);
+	const videoSwitchingSets = videoPlaylistsToSwitchingSets(mainManifestParsed.playlists, manifestPlaylists);
+	let selectionSetId = 0;
+	if (audioSwitchingSets.length > 0) selectionSets.push({
+		id: (selectionSetId++).toString(),
+		switchingSets: audioSwitchingSets
+	});
+	if (subtitleSwitchingSets.length > 0) selectionSets.push({
+		id: (selectionSetId++).toString(),
+		switchingSets: subtitleSwitchingSets
+	});
+	if (videoSwitchingSets.length > 0) selectionSets.push({
+		id: (selectionSetId++).toString(),
+		switchingSets: videoSwitchingSets
+	});
+	let presentationId = 0;
+	return [{
+		id: (presentationId++).toString(),
+		selectionSets
+	}];
+}
+
+//#endregion
+//#region src/mapper/hls/HlsMapper.ts
+var HlsMapper = class {
+	getManifestMetadata() {
+		return getMetadata(this.manifest);
+	}
+	toHam(manifest) {
+		const presentations = mapHlsToHam(manifest);
+		this.manifest = manifest;
+		return presentations;
+	}
+	toManifest(presentation) {
+		return mapHamToHls(presentation);
+	}
+};
+
+//#endregion
+//#region src/services/converters/hamToHls.ts
+/**
+* Convert ham object into a hls manifest.
+*
+* @example
+* Example on how to import the cmaf module and convert the ham `presentations`
+* array into the hls manifest.
+* ```ts
+* import cmaf from '@svta/common-media-library/cmaf-ham';
+*
+* const manifest = cmaf.hamToHls(presentations);
+* ```
+*
+* @param presentation - List of presentations from ham
+* @returns Manifest object containing the Hls manifest as string and its playlists
+*
+* @alpha
+*/
+function hamToHls(presentation) {
+	const mapperContext = MapperContext.getInstance();
+	mapperContext.setStrategy(new HlsMapper());
+	return mapperContext.getManifestFormat(presentation);
+}
+
+//#endregion
+//#region src/services/converters/hlsToHam.ts
+/**
+* Convert hls manifest into a ham object.
+*
+* @example
+* Example on how to import the cmaf module and convert the hls `manifest` and
+* `ancillaryManifests` array into the ham manifest.
+* ```ts
+* import cmaf from '@svta/common-media-library/cmaf-ham';
+*
+* const manifest = cmaf.hlsToHam(hlsManifest);
+* ```
+*
+* @param manifest - String of the Main manifest
+* @param ancillaryManifests - Ancillary Manifests . Must be in order, first audio, subtitle and video
+* @returns List of presentations from ham
+*
+* @alpha
+*/
+function hlsToHam(manifest, ancillaryManifests) {
+	const mapperContext = MapperContext.getInstance();
+	mapperContext.setStrategy(new HlsMapper());
+	return mapperContext.getHamFormat({
+		manifest,
+		ancillaryManifests: ancillaryManifests.map((ancillaryManifest) => ({
+			manifest: ancillaryManifest,
+			type: "hls"
+		})),
+		type: "hls"
+	});
+}
+
+//#endregion
+//#region src/services/getters/getTracksFromSwitchingSet.ts
+/**
+* Get a list of Tracks contained on a SwitchingSet
+*
+* @param switchingSet - SwitchingSet object from HAM
+* @param predicate - Filtering function
+* @returns Track[]
+*
+* @alpha
+*/
+function getTracksFromSwitchingSet(switchingSet, predicate) {
+	const tracks = switchingSet.tracks;
+	return predicate ? tracks.filter(predicate) : tracks;
+}
+
+//#endregion
+//#region src/services/getters/getTracksFromSelectionSet.ts
+/**
+* Get a list of Tracks contained on a SelectionSet
+*
+* @param selectionSet - SelectionSet object from HAM
+* @param predicate - Filtering function
+* @returns Track[]
+*
+* @alpha
+*/
+function getTracksFromSelectionSet(selectionSet, predicate) {
+	const tracks = selectionSet.switchingSets.flatMap((switchingSet) => getTracksFromSwitchingSet(switchingSet));
+	return predicate ? tracks.filter(predicate) : tracks;
+}
+
+//#endregion
+//#region src/services/getters/getTracksFromPresentation.ts
+/**
+* Get a list of Tracks contained on a Presentation
+*
+* @param presentation - Presentation object from HAM
+* @param predicate - Filtering function
+* @returns Track[]
+*
+* @alpha
+*/
+function getTracksFromPresentation(presentation, predicate) {
+	const tracks = presentation.selectionSets.flatMap((selectionSet) => getTracksFromSelectionSet(selectionSet));
+	return predicate ? tracks.filter(predicate) : tracks;
+}
+
+//#endregion
+//#region src/services/validators/validateSegment.ts
+/**
+* Validate a segment.
+*
+* Validations:
+* - segment has duration
+* - segment has url
+*
+* @param segment - Segment from cmaf ham model
+* @param trackId - Optional: parent track id
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation
+*
+* @alpha
+*/
+function validateSegment(segment, trackId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	const moreInformation = trackId ? ` in the track with id = ${trackId}` : ".";
+	if (!segment.duration) {
+		validation.status = false;
+		validation.errorMessages.push(`Segment duration is undefined${moreInformation}`);
+	}
+	if (!segment.url) {
+		validation.status = false;
+		validation.errorMessages.push(`Segment url is undefined${moreInformation}`);
+	}
+	return validation;
+}
+
+//#endregion
+//#region src/services/validators/validateSegments.ts
+/**
+* Validate a list of segments.
+*
+* @example
+* ```ts
+* import cmaf, { Segment } from '@svta/common-media-library/cmaf-ham';
+* ...
+*
+* // const segments: Segment[] = ...;
+*
+* const validation = cmaf.validateSegments(segments);
+* ```
+*
+* Example output: `{ status: true|false, errorMessages: [...] }`
+*
+* @param segments - List of Segment from cmaf ham model
+* @param trackId - Optional: parent track id
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation
+*
+* @alpha
+*
+*/
+function validateSegments(segments, trackId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	segments.forEach((segment) => {
+		validateSegment(segment, trackId, validation);
+	});
+	return validation;
+}
+
+//#endregion
+//#region src/services/validators/validateTrack.ts
+/**
+* Validate a track.
+* It validates in cascade, calling each child validation method.
+*
+* Validations:
+* - track has id
+* - Invokes specific audio, video and text validations
+*
+* @example
+* ```ts
+* import cmaf, { Track } from '@svta/common-media-library/cmaf-ham';
+* ...
+*
+* // const track: Track = ...;
+*
+* const validation = cmaf.validateTrack(track);
+* ```
+*
+* Example output: `{ status: true|false, errorMessages: [...] }`
+*
+* @param track - Track from cmaf ham model
+* @param switchingSetId - Optional: parent switching set id
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation
+*
+* @alpha
+*
+*/
+function validateTrack(track, switchingSetId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	const moreInformation = switchingSetId ? ` in the switching set with id = ${switchingSetId}` : ".";
+	if (!track.id) {
+		validation.status = false;
+		validation.errorMessages.push(`Track id is undefined${moreInformation}`);
+	}
+	switch (track.type) {
+		case "video":
+			_validateVideoTrack(track, switchingSetId, validation);
+			break;
+		case "audio":
+			_validateAudioTrack(track, switchingSetId, validation);
+			break;
+		case "text":
+			_validateTextTrack(track, switchingSetId, validation);
+			break;
+	}
+	validateSegments(track.segments, track.id, validation);
+	return validation;
+}
+/**
+* @internal
+*
+* Validate video Track
+*
+* Validations:
+* - track has codec
+*
+* @param videoTrack - Video track to validate
+* @param switchingSetId - Optional: id from the switching set containing the track (Only used for logs)
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation object
+* @see Validation
+*/
+function _validateVideoTrack(videoTrack, switchingSetId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	const moreInformation = switchingSetId ? ` in the switching set with id = ${switchingSetId}` : ".";
+	if (!videoTrack.codec) {
+		validation.status = false;
+		validation.errorMessages.push(`VideoTrack with id: ${videoTrack.id} does not have codec${moreInformation}`);
+	}
+	return validation;
+}
+/**
+* @internal
+*
+* Validate Audio Track
+*
+* Validations:
+* - track has codec
+*
+* @param audioTrack - Audio track to validate
+* @param switchingSetId - Optional: id from the switching set containing the track (Only used for logs)
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation object
+* @see Validation
+*/
+function _validateAudioTrack(audioTrack, switchingSetId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	const moreInformation = switchingSetId ? ` in the switching set with id = ${switchingSetId}` : ".";
+	if (!audioTrack.codec) {
+		validation.status = false;
+		validation.errorMessages.push(`AudioTrack with id: ${audioTrack.id} does not have codec${moreInformation}`);
+	}
+	return validation;
+}
+/**
+* @internal
+*
+* Validate Text Track
+*
+* Validations:
+* - track has language
+*
+* @param textTrack - Text track to validate
+* @param switchingSetId - Optional: id from the switching set containing the track (Only used for logs)
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation object
+* @see Validation
+*/
+function _validateTextTrack(textTrack, switchingSetId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	const moreInformation = switchingSetId ? ` in the switching set with id = ${switchingSetId}` : ".";
+	if (!textTrack.language) {
+		validation.status = false;
+		validation.errorMessages.push(`TextTrack with id: ${textTrack.id} does not have codec${moreInformation}`);
+	}
+	return validation;
+}
+
+//#endregion
+//#region src/services/validators/validateTracks.ts
+/**
+* Validate a list of tracks.
+* It validates in cascade, calling each child validation method.
+*
+* @example
+* ```ts
+* import cmaf, { Track } from '@svta/common-media-library/cmaf-ham';
+* ...
+*
+* // const tracks: Track[] = ...;
+*
+* const validation = cmaf.validateTracks(tracks);
+* ```
+*
+* Example output: `{ status: true|false, errorMessages: [...] }`
+*
+* @param tracks - List of Track from cmaf ham model
+* @param switchingSetId - Optional: parent switching set id
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation
+*
+* @alpha
+*
+*/
+function validateTracks(tracks, switchingSetId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	const moreInformation = switchingSetId ? ` in the switching set with id = ${switchingSetId}` : ".";
+	let tracksDuration;
+	tracks.forEach((track) => {
+		if (!tracksDuration) tracksDuration = track.duration;
+		if (tracksDuration !== track.duration) {
+			validation.status = false;
+			validation.errorMessages.push(`All the tracks must have the same duration${moreInformation}`);
+		}
+		validateTrack(track, switchingSetId, validation);
+	});
+	return validation;
+}
+
+//#endregion
+//#region src/services/validators/validateSwitchingSet.ts
+/**
+* Validate a switching set.
+* It validates in cascade, calling each child validation method.
+*
+* Validations:
+* - SwitchingSet has id
+*
+* @example
+* ```ts
+* import cmaf, { SwitchingSet } from '@svta/common-media-library/cmaf-ham';
+* ...
+*
+* // const switchingSet: SwitchingSet = ...;
+*
+* const validation = cmaf.validateSwitchingSet(switchingSet);
+* ```
+*
+* Example output: `{ status: true|false, errorMessages: [...] }`
+*
+* @param switchingSet - SwitchingSet from cmaf ham model
+* @param selectionSetId - Optional: parent selection set id
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation
+*
+* @alpha
+*
+*/
+function validateSwitchingSet(switchingSet, selectionSetId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	const moreInformation = selectionSetId ? ` in the selection set with id = ${selectionSetId}` : ".";
+	if (!switchingSet.id) {
+		validation.status = false;
+		validation.errorMessages.push(`SwitchingSet id is undefined${moreInformation}`);
+	}
+	validateTracks(switchingSet.tracks, switchingSet.id, validation);
+	return validation;
+}
+
+//#endregion
+//#region src/services/validators/validateSwitchingSets.ts
+/**
+* Validate a list of switching set.
+* It validates in cascade, calling each child validation method.
+*
+* @example
+* ```ts
+* import cmaf, { SwitchingSet } from '@svta/common-media-library/cmaf-ham';
+* ...
+*
+* // const switchingSets: SwitchingSet[] = ...;
+*
+* const validation = cmaf.validateSwitchingSets(switchingSets);
+* ```
+*
+* Example output: `{ status: true|false, errorMessages: [...] }`
+*
+* @param switchingSets - List of SwitchingSets from cmaf ham model
+* @param selectionSetId - Optional: parent selection set id
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation
+*
+* @alpha
+*
+*/
+function validateSwitchingSets(switchingSets, selectionSetId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	switchingSets.forEach((switchingSet) => {
+		validateSwitchingSet(switchingSet, selectionSetId, validation);
+	});
+	return validation;
+}
+
+//#endregion
+//#region src/services/validators/validateSelectionSet.ts
+/**
+* Validate a selection set.
+* It validates in cascade, calling each child validation method.
+*
+* Validations:
+* - SelectionSet has id
+*
+* @example
+* ```ts
+* import cmaf, { SelectionSet } from '@svta/common-media-library/cmaf-ham';
+* ...
+*
+* // const selectionSet: SelectionSet = ...;
+*
+* const validation = cmaf.validateSelectionSet(selectionSet);
+* ```
+*
+* Example output: `{ status: true|false, errorMessages: [...] }`
+*
+* @param selectionSet - SelectionSet from cmaf ham model
+* @param presentationId - Optional: parent presentation id
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation
+*
+* @alpha
+*
+*/
+function validateSelectionSet(selectionSet, presentationId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	const moreInformation = presentationId ? ` in the presentation with id = ${presentationId}` : ".";
+	if (!selectionSet.id) {
+		validation.status = false;
+		validation.errorMessages.push(`SelectionSet id is undefined${moreInformation}`);
+	}
+	validateSwitchingSets(selectionSet.switchingSets, selectionSet.id, validation);
+	return validation;
+}
+
+//#endregion
+//#region src/services/validators/validateSelectionSets.ts
+/**
+* Validate a list of selection set.
+* It validates in cascade, calling each child validation method.
+*
+* @example
+* ```ts
+* import cmaf, { SelectionSet } from '@svta/common-media-library/cmaf-ham';
+* ...
+*
+* // const selectionSets: SelectionSet[] = ...;
+*
+* const validation = cmaf.validateSelectionSets(selectionSets);
+* ```
+*
+* Example output: `{ status: true|false, errorMessages: [...] }`
+*
+* @param selectionSets - List of SelectionSet from cmaf ham model
+* @param presentationId - Optional: parent presentation id
+* @param prevValidation - Optional: validation object from parent previous validate method call
+* @returns Validation
+*
+* @alpha
+*
+*/
+function validateSelectionSets(selectionSets, presentationId, prevValidation) {
+	const validation = prevValidation ?? {
+		status: true,
+		errorMessages: []
+	};
+	selectionSets.forEach((selectionSet) => {
+		validateSelectionSet(selectionSet, presentationId, validation);
+	});
+	return validation;
+}
+
+//#endregion
+//#region src/services/validators/validatePresentation.ts
+/**
+* Validate a presentation.
+* It validates in cascade, calling each child validation method.
+*
+* Validations:
+* - Presentation has id
+*
+* @example
+* ```ts
+* import cmaf, { Presentation } from '@svta/common-media-library/cmaf-ham';
+* ...
+*
+* // const presentation: Presentation = ...;
+*
+* const validation = cmaf.validatePresentation(presentation);
+* ```
+*
+* Example output: `{ status: true|false, errorMessages: [...] }`
+*
+* @param presentation - Presentation from cmaf ham model
+* @returns Validation
+*
+* @alpha
+*
+*/
+function validatePresentation(presentation) {
+	const validation = {
+		status: true,
+		errorMessages: []
+	};
+	if (!presentation.id) {
+		validation.status = false;
+		validation.errorMessages.push("Presentation id is undefined");
+	}
+	validateSelectionSets(presentation.selectionSets, presentation.id, validation);
+	return validation;
+}
+
+//#endregion
+export { calculateDuration, dashToHam, decodeByteRange, encodeByteRange, formatSegments, getChannels, getCodec, getContentType, getDashParser, getDashSerializer, getDuration, getFrameRate, getGroup, getHlsCodec, getHlsParser, getLanguage, getNumberOfSegments, getPlaylistData, getPresentationId, getSampleRate, getSar, getSegments, getTimescale, getTrackDuration, getTracksFromPresentation, getTracksFromSelectionSet, getTracksFromSwitchingSet, getUrlFromTemplate, getUrlInitialization, hamToDash, hamToHls, hlsToHam, iso8601DurationToNumber, mapSegmentBase, mapSegmentList, mapSegmentTemplate, mapSegments, numberToIso8601Duration, parseDashManifest, parseHlsManifest, serializeDashManifest, setDashParser, setDashSerializer, setHlsParser, validatePresentation, validateSegment, validateSegments, validateSelectionSet, validateSelectionSets, validateSwitchingSet, validateSwitchingSets, validateTrack, validateTracks };
 //# sourceMappingURL=index.js.map