mattebox 0.1.0

package/dist/es2015/protocols/dash-cmaf/parse.js

@@ -0,0 +1,491 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { findBox, parseSidx } from "../../containers/mp4-box/index.js";
+//#region src/protocols/dash-cmaf/parse.ts
+/**
+* MPD into the IR. Pure: no fetching, no state, no side effects. DOMParser
+* carries the XML work at zero bundle cost. URLs are resolved here, against
+* the BaseURL chain, and stored absolute; downstream code never does URL
+* arithmetic.
+*
+* AdaptationSet and Representation already match the IR's Track and
+* Rendition, so unlike HLS there is no decomposition step. The coupling
+* table stays empty: any video representation composes with any audio
+* adaptation set. Preselection and @dependencyId would change that; both
+* are out of scope and noted in the register.
+*
+* Single-period only. Templated addressing stays lazy: SegmentTemplate
+* becomes IndexedSegments and the kernel materializes one segment at a
+* time, so a long window never becomes an array.
+*/
+function manifestError(reason) {
+	return {
+		category: "manifest",
+		code: "MANIFEST_PARSE_FAILED",
+		fatal: true,
+		recoverable: false,
+		context: { reason }
+	};
+}
+function resolve(uri, baseUrl) {
+	try {
+		return new URL(uri, baseUrl).href;
+	} catch (_unused) {
+		return uri;
+	}
+}
+/** ISO 8601 duration to seconds. Date parts use nominal day lengths. */
+function parseDuration(value) {
+	if (value === null) return null;
+	const match = /^-?P(?:(\d+(?:\.\d+)?)Y)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/.exec(value.trim());
+	if (match === null) return null;
+	const [, years, months, days, hours, minutes, seconds] = match;
+	return Number(years !== null && years !== void 0 ? years : 0) * 31536e3 + Number(months !== null && months !== void 0 ? months : 0) * 2592e3 + Number(days !== null && days !== void 0 ? days : 0) * 86400 + Number(hours !== null && hours !== void 0 ? hours : 0) * 3600 + Number(minutes !== null && minutes !== void 0 ? minutes : 0) * 60 + Number(seconds !== null && seconds !== void 0 ? seconds : 0);
+}
+/** Direct children by local name; namespace-agnostic on purpose. */
+function children(parent, name) {
+	const found = [];
+	for (const child of parent.children) if (child.localName === name) found.push(child);
+	return found;
+}
+function attr(element, name) {
+	return element.getAttribute(name);
+}
+function numberAttr(element, name) {
+	const value = element.getAttribute(name);
+	if (value === null) return null;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : null;
+}
+/** @frameRate is "30" or "30000/1001". */
+function parseFrameRate(value) {
+	if (value === null) return null;
+	const [num, den] = value.split("/").map(Number);
+	if (num === void 0 || !Number.isFinite(num)) return null;
+	if (den !== void 0) return Number.isFinite(den) && den > 0 ? num / den : null;
+	return num;
+}
+/** A DASH byte range is "start-end" inclusive (ISO/IEC 23009-1 §5.3.9.2.2). */
+function parseByteRange(value) {
+	if (value === null) return null;
+	const [startText, endText] = value.split("-");
+	const start = Number(startText);
+	const end = Number(endText);
+	if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) return null;
+	return {
+		start,
+		end
+	};
+}
+/** The first BaseURL child resolved against `base`. Siblings are alternatives; the first wins. */
+function applyBaseUrl(element, base) {
+	var _baseElements$;
+	const text = (_baseElements$ = children(element, "BaseURL")[0]) === null || _baseElements$ === void 0 || (_baseElements$ = _baseElements$.textContent) === null || _baseElements$ === void 0 ? void 0 : _baseElements$.trim();
+	return text !== void 0 && text !== "" ? resolve(text, base) : base;
+}
+function base64ToArrayBuffer(text) {
+	try {
+		const binary = atob(text.replace(/\s+/g, ""));
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+		return bytes.buffer;
+	} catch (_unused2) {
+		return null;
+	}
+}
+const MP4_PROTECTION = "urn:mpeg:dash:mp4protection:2011";
+const UUID_URN = /^urn:uuid:([0-9a-f-]{36})$/i;
+/**
+* ContentProtection elements into protection schemes. The mp4protection
+* element carries the common scheme and default key id; each urn:uuid
+* element names one key system, optionally with manifest init data.
+*/
+function parseProtection(elements) {
+	let commonScheme = null;
+	let commonKeyId = null;
+	for (const element of elements) {
+		var _attr;
+		if (((_attr = attr(element, "schemeIdUri")) === null || _attr === void 0 ? void 0 : _attr.toLowerCase()) === MP4_PROTECTION) {
+			var _attr$toLowerCase, _attr2, _attr3;
+			commonScheme = (_attr$toLowerCase = (_attr2 = attr(element, "value")) === null || _attr2 === void 0 ? void 0 : _attr2.toLowerCase()) !== null && _attr$toLowerCase !== void 0 ? _attr$toLowerCase : null;
+			const kid = (_attr3 = attr(element, "cenc:default_KID")) !== null && _attr3 !== void 0 ? _attr3 : attr(element, "default_KID");
+			commonKeyId = kid !== null ? kid.replaceAll("-", "").toLowerCase() : null;
+		}
+	}
+	const schemes = [];
+	for (const element of elements) {
+		var _attr4, _children$;
+		const schemeIdUri = (_attr4 = attr(element, "schemeIdUri")) !== null && _attr4 !== void 0 ? _attr4 : "";
+		const uuid = UUID_URN.exec(schemeIdUri);
+		if (uuid === null) continue;
+		const pssh = (_children$ = children(element, "pssh")[0]) === null || _children$ === void 0 || (_children$ = _children$.textContent) === null || _children$ === void 0 ? void 0 : _children$.trim();
+		const initData = pssh !== void 0 && pssh !== "" ? base64ToArrayBuffer(pssh) : null;
+		schemes.push({
+			systemId: uuid[1].toLowerCase(),
+			scheme: commonScheme,
+			keyId: commonKeyId,
+			licenseUrl: null,
+			initData,
+			initDataType: initData !== null ? "cenc" : null
+		});
+	}
+	if (schemes.length === 0 && (commonScheme !== null || commonKeyId !== null)) schemes.push({
+		systemId: null,
+		scheme: commonScheme,
+		keyId: commonKeyId,
+		licenseUrl: null,
+		initData: null,
+		initDataType: null
+	});
+	return schemes;
+}
+/**
+* A trick-mode AdaptationSet: the DASH-IF trickmode EssentialProperty, or a
+* representation declaring a playout rate other than 1. Both mark an
+* I-frame-only set meant for scrubbing, never for normal playback.
+*/
+function isTrickMode(adaptationSet) {
+	for (const property of children(adaptationSet, "EssentialProperty")) {
+		var _attr5;
+		if (((_attr5 = attr(property, "schemeIdUri")) !== null && _attr5 !== void 0 ? _attr5 : "").includes("trickmode")) return true;
+	}
+	if (numberAttr(adaptationSet, "maxPlayoutRate") !== null) return true;
+	for (const representation of children(adaptationSet, "Representation")) {
+		const rate = numberAttr(representation, "maxPlayoutRate");
+		if (rate !== null && rate !== 1) return true;
+	}
+	return false;
+}
+/** Merges SegmentTemplate attributes down Period, AdaptationSet, Representation. */
+function mergeTemplates(levels) {
+	var _timescale, _startNumber, _pto;
+	let media = null;
+	let initialization = null;
+	let timescale = null;
+	let startNumber = null;
+	let duration = null;
+	let pto = null;
+	let timelineElement = null;
+	let found = false;
+	for (const level of levels) {
+		var _attr6, _attr7, _numberAttr, _numberAttr2, _numberAttr3, _numberAttr4, _children$2;
+		const template = children(level, "SegmentTemplate")[0];
+		if (template === void 0) continue;
+		found = true;
+		media = (_attr6 = attr(template, "media")) !== null && _attr6 !== void 0 ? _attr6 : media;
+		initialization = (_attr7 = attr(template, "initialization")) !== null && _attr7 !== void 0 ? _attr7 : initialization;
+		timescale = (_numberAttr = numberAttr(template, "timescale")) !== null && _numberAttr !== void 0 ? _numberAttr : timescale;
+		startNumber = (_numberAttr2 = numberAttr(template, "startNumber")) !== null && _numberAttr2 !== void 0 ? _numberAttr2 : startNumber;
+		duration = (_numberAttr3 = numberAttr(template, "duration")) !== null && _numberAttr3 !== void 0 ? _numberAttr3 : duration;
+		pto = (_numberAttr4 = numberAttr(template, "presentationTimeOffset")) !== null && _numberAttr4 !== void 0 ? _numberAttr4 : pto;
+		timelineElement = (_children$2 = children(template, "SegmentTimeline")[0]) !== null && _children$2 !== void 0 ? _children$2 : timelineElement;
+	}
+	if (!found) return null;
+	return {
+		media,
+		initialization,
+		timescale: (_timescale = timescale) !== null && _timescale !== void 0 ? _timescale : 1,
+		startNumber: (_startNumber = startNumber) !== null && _startNumber !== void 0 ? _startNumber : 1,
+		duration,
+		presentationTimeOffset: (_pto = pto) !== null && _pto !== void 0 ? _pto : 0,
+		timelineElement
+	};
+}
+/**
+* SegmentTimeline into compressed runs. @r repeats; a negative @r repeats
+* until the next S@t, or the period end on the last S.
+*/
+function parseTimeline(timelineElement, periodEndUnits) {
+	const sElements = children(timelineElement, "S");
+	const runs = [];
+	let time = 0;
+	for (let i = 0; i < sElements.length; i += 1) {
+		var _numberAttr5, _numberAttr6;
+		const s = sElements[i];
+		const d = numberAttr(s, "d");
+		if (d === null || d <= 0) return null;
+		time = (_numberAttr5 = numberAttr(s, "t")) !== null && _numberAttr5 !== void 0 ? _numberAttr5 : time;
+		const r = (_numberAttr6 = numberAttr(s, "r")) !== null && _numberAttr6 !== void 0 ? _numberAttr6 : 0;
+		let count;
+		if (r >= 0) count = r + 1;
+		else {
+			const next = sElements[i + 1];
+			const until = next !== void 0 ? numberAttr(next, "t") : periodEndUnits;
+			if (until === null || until === void 0) return null;
+			count = Math.max(1, Math.ceil((until - time) / d));
+		}
+		runs.push({
+			start: time,
+			duration: d,
+			count
+		});
+		time += d * count;
+	}
+	return runs.length > 0 ? runs : null;
+}
+/** Constant substitutions: $RepresentationID$ and $Bandwidth$, with format tags, and never $$-escaped content. */
+function substituteIdentity(template, id, bandwidth) {
+	return template.replace(/\$RepresentationID\$/g, id).replace(/\$Bandwidth(?:%0(\d+)d)?\$/g, (_, width) => {
+		const text = String(bandwidth);
+		return width === void 0 ? text : text.padStart(Number(width), "0");
+	});
+}
+function contentTypeOf(adaptationSet, mimeType) {
+	const declared = attr(adaptationSet, "contentType");
+	if (declared === "video" || declared === "audio" || declared === "text" || declared === "image" || declared === "metadata") return declared;
+	if (mimeType.startsWith("audio/")) return "audio";
+	if (mimeType.startsWith("image/")) return "image";
+	if (mimeType.startsWith("text/") || mimeType === "application/ttml+xml") return "text";
+	return "video";
+}
+/** parse an MPD document into a Presentation. Never throws. */
+function parse(text, baseUrl) {
+	var _parseDuration, _parseDuration2, _attr15;
+	let doc;
+	try {
+		doc = new DOMParser().parseFromString(text, "text/xml");
+	} catch (cause) {
+		return {
+			presentation: null,
+			error: _objectSpread2(_objectSpread2({}, manifestError("unparsable XML")), {}, { cause })
+		};
+	}
+	const mpd = doc.documentElement;
+	if (mpd === null || mpd.localName !== "MPD" || doc.getElementsByTagName("parsererror").length > 0) return {
+		presentation: null,
+		error: manifestError("not an MPD document")
+	};
+	const isLive = attr(mpd, "type") === "dynamic";
+	const mpdDuration = parseDuration(attr(mpd, "mediaPresentationDuration"));
+	const mpdBase = applyBaseUrl(mpd, baseUrl);
+	let live;
+	if (isLive) {
+		var _attr8, _attr9, _attr10;
+		const availabilityStart = Date.parse((_attr8 = attr(mpd, "availabilityStartTime")) !== null && _attr8 !== void 0 ? _attr8 : "");
+		const updatePeriod = parseDuration(attr(mpd, "minimumUpdatePeriod"));
+		const timeShiftDepth = parseDuration(attr(mpd, "timeShiftBufferDepth"));
+		const holdBack = parseDuration(attr(mpd, "suggestedPresentationDelay"));
+		const timing = children(mpd, "UTCTiming")[0];
+		live = _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, Number.isFinite(availabilityStart) ? { availabilityStart: availabilityStart / 1e3 } : {}), updatePeriod !== null ? { updatePeriod } : {}), timeShiftDepth !== null ? { timeShiftDepth } : {}), holdBack !== null ? { holdBack } : {}), timing !== void 0 ? { timeServer: {
+			scheme: (_attr9 = attr(timing, "schemeIdUri")) !== null && _attr9 !== void 0 ? _attr9 : "",
+			value: (_attr10 = attr(timing, "value")) !== null && _attr10 !== void 0 ? _attr10 : ""
+		} } : {});
+	}
+	let steering;
+	const steeringElement = children(mpd, "ContentSteering")[0];
+	if (steeringElement !== void 0) {
+		var _steeringElement$text, _steeringElement$text2;
+		const serverUri = (_steeringElement$text = (_steeringElement$text2 = steeringElement.textContent) === null || _steeringElement$text2 === void 0 ? void 0 : _steeringElement$text2.trim()) !== null && _steeringElement$text !== void 0 ? _steeringElement$text : "";
+		if (serverUri !== "") {
+			const bases = {};
+			for (const base of children(mpd, "BaseURL")) {
+				var _base$textContent;
+				const location = attr(base, "serviceLocation");
+				const text = (_base$textContent = base.textContent) === null || _base$textContent === void 0 ? void 0 : _base$textContent.trim();
+				if (location !== null && text !== void 0 && text !== "") bases[location] = resolve(text, baseUrl);
+			}
+			steering = _objectSpread2(_objectSpread2({ serverUri: resolve(serverUri, baseUrl) }, attr(steeringElement, "defaultServiceLocation") !== null ? { defaultPathway: attr(steeringElement, "defaultServiceLocation") } : {}), Object.keys(bases).length > 0 ? { bases } : {});
+		}
+	}
+	const periodElement = children(mpd, "Period")[0];
+	if (periodElement === void 0) return {
+		presentation: null,
+		error: {
+			category: "manifest",
+			code: "MANIFEST_EMPTY",
+			fatal: true,
+			recoverable: false,
+			context: { reason: "MPD with no Period" }
+		}
+	};
+	const periodStart = (_parseDuration = parseDuration(attr(periodElement, "start"))) !== null && _parseDuration !== void 0 ? _parseDuration : 0;
+	const periodDuration = (_parseDuration2 = parseDuration(attr(periodElement, "duration"))) !== null && _parseDuration2 !== void 0 ? _parseDuration2 : mpdDuration !== null ? mpdDuration - periodStart : null;
+	const periodBase = applyBaseUrl(periodElement, mpdBase);
+	const tracks = [];
+	const adaptationSets = children(periodElement, "AdaptationSet");
+	for (let asIndex = 0; asIndex < adaptationSets.length; asIndex += 1) {
+		var _children$0$getAttrib, _children$3, _trackMime2;
+		const adaptationSet = adaptationSets[asIndex];
+		if (isTrickMode(adaptationSet)) continue;
+		const asBase = applyBaseUrl(adaptationSet, periodBase);
+		const asMime = attr(adaptationSet, "mimeType");
+		const asCodecs = attr(adaptationSet, "codecs");
+		const lang = attr(adaptationSet, "lang");
+		const role = (_children$0$getAttrib = (_children$3 = children(adaptationSet, "Role")[0]) === null || _children$3 === void 0 ? void 0 : _children$3.getAttribute("value")) !== null && _children$0$getAttrib !== void 0 ? _children$0$getAttrib : null;
+		const protectionSchemes = parseProtection(children(adaptationSet, "ContentProtection"));
+		const renditions = [];
+		let trackMime = null;
+		for (const representation of children(adaptationSet, "Representation")) {
+			var _ref, _attr11, _trackMime, _parseFrameRate2, _attr14;
+			const id = attr(representation, "id");
+			const bandwidth = numberAttr(representation, "bandwidth");
+			if (id === null || bandwidth === null) continue;
+			const repBase = applyBaseUrl(representation, asBase);
+			const mimeType = (_ref = (_attr11 = attr(representation, "mimeType")) !== null && _attr11 !== void 0 ? _attr11 : asMime) !== null && _ref !== void 0 ? _ref : "video/mp4";
+			trackMime = (_trackMime = trackMime) !== null && _trackMime !== void 0 ? _trackMime : mimeType;
+			const segmentBase = children(representation, "SegmentBase")[0];
+			if (segmentBase !== void 0) {
+				var _numberAttr7, _parseFrameRate, _attr12;
+				const indexRange = parseByteRange(attr(segmentBase, "indexRange"));
+				if (indexRange === null) continue;
+				const baseTimescale = (_numberAttr7 = numberAttr(segmentBase, "timescale")) !== null && _numberAttr7 !== void 0 ? _numberAttr7 : 1;
+				const pto = numberAttr(segmentBase, "presentationTimeOffset");
+				const initElement = children(segmentBase, "Initialization")[0];
+				const initRange = initElement !== void 0 ? parseByteRange(attr(initElement, "range")) : null;
+				const sidxSegments = _objectSpread2({
+					kind: "sidx",
+					url: repBase,
+					indexRange,
+					timescale: baseTimescale
+				}, pto !== null && pto !== 0 ? { presentationTimeOffset: pto / baseTimescale } : {});
+				const sidxInit = initRange !== null ? {
+					url: repBase,
+					byteRange: initRange
+				} : null;
+				const w = numberAttr(representation, "width");
+				const h = numberAttr(representation, "height");
+				const fr = (_parseFrameRate = parseFrameRate(attr(representation, "frameRate"))) !== null && _parseFrameRate !== void 0 ? _parseFrameRate : parseFrameRate(attr(adaptationSet, "frameRate"));
+				renditions.push(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({
+					id,
+					bitrate: bandwidth,
+					codecs: (_attr12 = attr(representation, "codecs")) !== null && _attr12 !== void 0 ? _attr12 : asCodecs,
+					mimeType,
+					segments: sidxSegments
+				}, sidxInit !== null ? { init: sidxInit } : {}), w !== null ? { width: w } : {}), h !== null ? { height: h } : {}), fr !== null ? { frameRate: fr } : {}));
+				continue;
+			}
+			const template = mergeTemplates([
+				periodElement,
+				adaptationSet,
+				representation
+			]);
+			if (template === null || template.media === null) {
+				if (contentTypeOf(adaptationSet, mimeType) === "text" && periodDuration !== null) {
+					var _attr13;
+					renditions.push({
+						id,
+						bitrate: bandwidth,
+						codecs: (_attr13 = attr(representation, "codecs")) !== null && _attr13 !== void 0 ? _attr13 : asCodecs,
+						mimeType,
+						segments: [{
+							seq: 0,
+							start: periodStart,
+							duration: periodDuration,
+							url: repBase
+						}]
+					});
+				}
+				continue;
+			}
+			const periodEndUnits = periodDuration !== null ? Math.round(template.presentationTimeOffset + periodDuration * template.timescale) : null;
+			const timeline = template.timelineElement !== null ? parseTimeline(template.timelineElement, periodEndUnits) : null;
+			if (template.timelineElement !== null && timeline === null) return {
+				presentation: null,
+				error: manifestError(`bad SegmentTimeline in '${id}'`)
+			};
+			let endSeq = null;
+			if (timeline !== null) endSeq = template.startNumber - 1 + timeline.reduce((sum, run) => sum + run.count, 0);
+			else if (template.duration !== null && periodDuration !== null) endSeq = template.startNumber - 1 + Math.ceil(periodDuration * template.timescale / template.duration);
+			else if (template.duration === null) return {
+				presentation: null,
+				error: manifestError(`no addressing for '${id}'`)
+			};
+			const segments = _objectSpread2({
+				kind: "indexed",
+				urlTemplate: resolve(substituteIdentity(template.media, id, bandwidth), repBase),
+				startSeq: template.startNumber,
+				endSeq: isLive ? null : endSeq,
+				timescale: template.timescale,
+				segmentDuration: timeline !== null ? null : template.duration,
+				timeline
+			}, template.presentationTimeOffset !== 0 ? { presentationTimeOffset: template.presentationTimeOffset } : {});
+			const init = template.initialization !== null ? { url: resolve(substituteIdentity(template.initialization, id, bandwidth), repBase) } : null;
+			const frameRate = (_parseFrameRate2 = parseFrameRate(attr(representation, "frameRate"))) !== null && _parseFrameRate2 !== void 0 ? _parseFrameRate2 : parseFrameRate(attr(adaptationSet, "frameRate"));
+			const width = numberAttr(representation, "width");
+			const height = numberAttr(representation, "height");
+			renditions.push(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({
+				id,
+				bitrate: bandwidth,
+				codecs: (_attr14 = attr(representation, "codecs")) !== null && _attr14 !== void 0 ? _attr14 : asCodecs,
+				mimeType,
+				segments
+			}, init !== null ? { init } : {}), width !== null ? { width } : {}), height !== null ? { height } : {}), frameRate !== null ? { frameRate } : {}));
+		}
+		if (renditions.length === 0) continue;
+		const mimeType = (_trackMime2 = trackMime) !== null && _trackMime2 !== void 0 ? _trackMime2 : "video/mp4";
+		tracks.push(_objectSpread2(_objectSpread2({
+			id: attr(adaptationSet, "id") !== null ? `as-${attr(adaptationSet, "id")}` : `as-i${asIndex}`,
+			contentType: contentTypeOf(adaptationSet, mimeType),
+			mimeType,
+			protection: protectionSchemes.length > 0 ? { schemes: protectionSchemes } : null,
+			renditions
+		}, lang !== null ? { lang } : {}), role !== null ? { role } : {}));
+	}
+	if (tracks.length === 0) return {
+		presentation: null,
+		error: {
+			category: "manifest",
+			code: "MANIFEST_EMPTY",
+			fatal: true,
+			recoverable: false,
+			context: { reason: "no playable adaptation set" }
+		}
+	};
+	return {
+		presentation: _objectSpread2(_objectSpread2(_objectSpread2({
+			id: baseUrl,
+			isLive
+		}, mpdDuration !== null ? { duration: mpdDuration } : {}), {}, {
+			periods: [_objectSpread2(_objectSpread2({
+				id: (_attr15 = attr(periodElement, "id")) !== null && _attr15 !== void 0 ? _attr15 : "p0",
+				start: periodStart
+			}, periodDuration !== null ? { duration: periodDuration } : {}), {}, { tracks })],
+			couplings: []
+		}, live !== void 0 ? { live } : {}), steering !== void 0 ? { steering } : {}),
+		error: null
+	};
+}
+/**
+* Turns a fetched sidx box into explicit byte-range segments. The first media
+* byte sits immediately after the sidx box (indexRange.end + 1) plus the box's
+* own firstOffset; each reference then names one subsegment's byte size and
+* duration in timescale units. ISO/IEC 14496-12 SegmentIndexBox.
+*/
+function sidxToSegments(sidxBytes, addressing) {
+	var _addressing$presentat;
+	const box = findBox(sidxBytes, "sidx");
+	if (box === null) return [];
+	const sidx = parseSidx(box.payload);
+	if (sidx === null) return [];
+	const timescale = sidx.timescale || addressing.timescale || 1;
+	const pto = (_addressing$presentat = addressing.presentationTimeOffset) !== null && _addressing$presentat !== void 0 ? _addressing$presentat : 0;
+	let offset = addressing.indexRange.end + 1 + sidx.firstOffset;
+	let mediaTime = sidx.earliestPresentationTime;
+	const segments = [];
+	for (let i = 0; i < sidx.references.length; i += 1) {
+		const ref = sidx.references[i];
+		if (ref === void 0) break;
+		segments.push({
+			seq: i,
+			start: mediaTime / timescale - pto,
+			duration: ref.subsegmentDuration / timescale,
+			url: addressing.url,
+			byteRange: {
+				start: offset,
+				end: offset + ref.referencedSize - 1
+			}
+		});
+		offset += ref.referencedSize;
+		mediaTime += ref.subsegmentDuration;
+	}
+	return segments;
+}
+/**
+* Immutably swaps a rendition's unresolved sidx addressing for the explicit
+* segment list parsed from its index box. Everything else about the
+* presentation is already known from the MPD.
+*/
+function mergeSidx(presentation, renditionId, segments) {
+	return _objectSpread2(_objectSpread2({}, presentation), {}, { periods: presentation.periods.map((period) => _objectSpread2(_objectSpread2({}, period), {}, { tracks: period.tracks.map((track) => track.renditions.some((r) => r.id === renditionId) ? _objectSpread2(_objectSpread2({}, track), {}, { renditions: track.renditions.map((rendition) => rendition.id === renditionId ? _objectSpread2(_objectSpread2({}, rendition), {}, { segments }) : rendition) }) : track) })) });
+}
+//#endregion
+export { mergeSidx, parse, parseDuration, sidxToSegments };

package/dist/es2015/protocols/dash-live/index.js

@@ -0,0 +1,192 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { registerLiveNamespace } from "../live-shared.js";
+import { parse } from "../dash-cmaf/parse.js";
+//#region src/protocols/dash-live/index.ts
+const MPD_TOKEN = "dash:live:mpd";
+const UTC_TOKEN = "dash:live:utc";
+const TICK_TOKEN = "dash-live:reload";
+const CLOCK_TOKEN = "dash-live:clock";
+/** Fallback hold-back when the MPD suggests nothing, in seconds. */
+const DEFAULT_HOLD_BACK = 10;
+/** Fallback DVR depth, in seconds. */
+const DEFAULT_TIME_SHIFT = 60;
+/** Window movement below this is not worth a fact, in seconds. */
+const WINDOW_QUANTUM = .5;
+const INITIAL = {
+	manifestUrl: null,
+	skew: null,
+	utcPending: false,
+	tickPending: false,
+	clockPending: false,
+	lastWindowEnd: -1,
+	lastWallClock: null
+};
+/** The window arithmetic; null when it cannot move or is not worth a fact. */
+function windowUpdate(state, live) {
+	var _state$skew, _live$timeShiftDepth, _live$holdBack;
+	if (live.availabilityStart === void 0 || state.lastWallClock === null) return null;
+	const end = state.lastWallClock + ((_state$skew = state.skew) !== null && _state$skew !== void 0 ? _state$skew : 0) - live.availabilityStart;
+	if (end <= 0 || Math.abs(end - state.lastWindowEnd) < WINDOW_QUANTUM) return null;
+	const start = Math.max(0, end - ((_live$timeShiftDepth = live.timeShiftDepth) !== null && _live$timeShiftDepth !== void 0 ? _live$timeShiftDepth : DEFAULT_TIME_SHIFT));
+	const edge = Math.max(start, end - ((_live$holdBack = live.holdBack) !== null && _live$holdBack !== void 0 ? _live$holdBack : DEFAULT_HOLD_BACK));
+	return {
+		next: _objectSpread2(_objectSpread2({}, state), {}, { lastWindowEnd: end }),
+		fact: feed({
+			type: "LIVE_WINDOW_CHANGED",
+			start,
+			end,
+			edge
+		})
+	};
+}
+/**
+* Whether this slice owns the presentation's live window: a dynamic MPD,
+* which ISO 23009-1 requires to carry availabilityStartTime. An HLS live
+* presentation is live too but has no availability start; its window is
+* read from playlists by hls-live, and reloading its master as an MPD on
+* a one-second clock is only noise.
+*/
+function drivesWindow(presentation) {
+	var _presentation$live;
+	return (presentation === null || presentation === void 0 ? void 0 : presentation.isLive) === true && ((_presentation$live = presentation.live) === null || _presentation$live === void 0 ? void 0 : _presentation$live.availabilityStart) !== void 0;
+}
+/** Loops a message back into the bus through a zero-delay schedule effect. */
+function feed(message) {
+	return {
+		kind: "schedule",
+		token: "dash-live:loopback",
+		delayMs: 0,
+		then: message
+	};
+}
+function tick(delaySeconds) {
+	return {
+		kind: "schedule",
+		token: TICK_TOKEN,
+		delayMs: Math.max(500, delaySeconds * 1e3),
+		then: {
+			type: "TICK",
+			token: TICK_TOKEN
+		}
+	};
+}
+/** The one-second clock loop that slides the window while playback stalls. */
+function clockTick() {
+	return {
+		kind: "schedule",
+		token: CLOCK_TOKEN,
+		delayMs: 1e3,
+		then: {
+			type: "TICK",
+			token: CLOCK_TOKEN
+		}
+	};
+}
+const reduceDashLive = (slice, msg, kernel) => {
+	let state = slice !== null && slice !== void 0 ? slice : INITIAL;
+	if ((msg.type === "TIME_UPDATE" || msg.type === "SEGMENT_LOADED") && msg.wallClock !== void 0) state = _objectSpread2(_objectSpread2({}, state), {}, { lastWallClock: msg.wallClock });
+	if (msg.type === "LOAD") return [_objectSpread2(_objectSpread2({}, INITIAL), {}, { manifestUrl: msg.url }), []];
+	if (msg.type === "UNLOAD" || msg.type === "DETACH") return [INITIAL, []];
+	if (msg.type === "MANIFEST_LOADED") {
+		if (!drivesWindow(msg.presentation)) return [state, []];
+		const effects = [];
+		let next = state;
+		const server = msg.presentation.live.timeServer;
+		if (server !== void 0 && state.skew === null && !state.utcPending) {
+			if (server.scheme.endsWith(":direct") || server.scheme.endsWith(":direct:2014")) next = _objectSpread2(_objectSpread2({}, next), {}, { skew: null });
+			else if (server.value !== "") {
+				effects.push({
+					kind: "fetch",
+					token: UTC_TOKEN,
+					url: server.value
+				});
+				next = _objectSpread2(_objectSpread2({}, next), {}, { utcPending: true });
+			}
+		}
+		if (!next.tickPending) {
+			var _msg$presentation$liv;
+			effects.push(tick((_msg$presentation$liv = msg.presentation.live.updatePeriod) !== null && _msg$presentation$liv !== void 0 ? _msg$presentation$liv : 4));
+			next = _objectSpread2(_objectSpread2({}, next), {}, { tickPending: true });
+		}
+		if (!next.clockPending) {
+			effects.push(clockTick());
+			next = _objectSpread2(_objectSpread2({}, next), {}, { clockPending: true });
+		}
+		const window = windowUpdate(next, msg.presentation.live);
+		if (window !== null) {
+			next = window.next;
+			effects.push(window.fact);
+		}
+		return [next, effects];
+	}
+	if (msg.type === "TICK" && msg.token === CLOCK_TOKEN) {
+		if (!drivesWindow(kernel.presentation)) return [_objectSpread2(_objectSpread2({}, state), {}, { clockPending: false }), []];
+		let next = _objectSpread2(_objectSpread2({}, state), {}, { clockPending: true });
+		if (msg.wallClock !== void 0) next = _objectSpread2(_objectSpread2({}, next), {}, { lastWallClock: msg.wallClock });
+		const effects = [clockTick()];
+		const live = kernel.presentation.live;
+		if (live !== void 0) {
+			const window = windowUpdate(next, live);
+			if (window !== null) {
+				next = window.next;
+				effects.push(window.fact);
+			}
+		}
+		return [next, effects];
+	}
+	if (msg.type === "TICK" && msg.token === TICK_TOKEN) {
+		if (state.manifestUrl === null || !drivesWindow(kernel.presentation)) return [_objectSpread2(_objectSpread2({}, state), {}, { tickPending: false }), []];
+		return [_objectSpread2(_objectSpread2({}, state), {}, { tickPending: false }), [{
+			kind: "fetch",
+			token: MPD_TOKEN,
+			url: state.manifestUrl
+		}]];
+	}
+	if (msg.type === "SEGMENT_LOADED" && msg.trackId === UTC_TOKEN) {
+		const serverTime = Date.parse(new TextDecoder().decode(msg.bytes).trim());
+		if (!Number.isFinite(serverTime) || msg.wallClock === void 0) return [_objectSpread2(_objectSpread2({}, state), {}, { utcPending: false }), []];
+		return [_objectSpread2(_objectSpread2({}, state), {}, {
+			skew: serverTime / 1e3 - msg.wallClock,
+			utcPending: false
+		}), []];
+	}
+	if (msg.type === "SEGMENT_LOADED" && msg.trackId === MPD_TOKEN) {
+		if (state.manifestUrl === null) return [state, []];
+		const result = parse(new TextDecoder().decode(msg.bytes), state.manifestUrl);
+		const effects = [];
+		let next = state;
+		if (result.presentation !== null) {
+			effects.push(feed({
+				type: "MANIFEST_LOADED",
+				presentation: result.presentation
+			}));
+			if (result.presentation.isLive && result.presentation.live !== void 0) {
+				const window = windowUpdate(next, result.presentation.live);
+				if (window !== null) {
+					next = window.next;
+					effects.push(window.fact);
+				}
+			}
+		}
+		return [next, effects];
+	}
+	if ((msg.type === "TIME_UPDATE" || msg.type === "SEGMENT_LOADED") && drivesWindow(kernel.presentation)) {
+		const window = windowUpdate(state, kernel.presentation.live);
+		if (window !== null) return [window.next, [window.fact]];
+	}
+	return [state, []];
+};
+/** The stage factory. Requires dash-cmaf; the loader enforces it. */
+function dashLive() {
+	return {
+		name: "dash-live",
+		provides: ["dash-live"],
+		requires: ["dash-cmaf"],
+		install(ctx) {
+			ctx.reduce("dash-live", reduceDashLive);
+			registerLiveNamespace(ctx);
+		}
+	};
+}
+//#endregion
+export { dashLive as default };