mattebox 0.1.0

package/dist/es2015/protocols/hls-cmaf/index.js

@@ -0,0 +1,168 @@
+import { normalizeMimeType } from "../../kernel/mime.js";
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { mergePlaylist, parse, parseMediaPlaylist } from "./parse.js";
+//#region src/protocols/hls-cmaf/index.ts
+/**
+* The hls-cmaf protocol adapter as a stage. Inert module: exports a
+* factory, registers nothing at import time.
+*
+* The choreography is a slice reducer, so the whole protocol lives inside
+* the message loop and the trace: manifest bytes arrive as SEGMENT_LOADED
+* facts, parsing is pure, and results loop back through zero-delay
+* schedule effects carrying MANIFEST_LOADED. Media playlists fetch under
+* `hls:pl:` tokens the transport correlates back by token.
+*/
+const PLAYLIST_TOKEN = "hls:pl:";
+/** The playlist MIME types, RFC 8216 §4: the registered type and the three in common use. */
+const MANIFEST_TYPES = [
+	"application/vnd.apple.mpegurl",
+	"application/x-mpegurl",
+	"audio/mpegurl",
+	"audio/x-mpegurl"
+];
+const INITIAL = {
+	manifestUrl: null,
+	mimeType: null,
+	pending: {}
+};
+/**
+* Whether this adapter owns the manifest bytes. An explicit mimeType
+* decides alone: a foreign type declines without reading, an own type
+* parses without sniffing, so a broken playlist reports a parse failure
+* instead of falling through. Without one, RFC 8216 §4.3.1.1: the first
+* line of every playlist is #EXTM3U.
+*/
+function claims(state, text) {
+	if (state.mimeType !== null) return MANIFEST_TYPES.includes(state.mimeType);
+	return text.trimStart().startsWith("#EXTM3U");
+}
+function findRendition(presentation, renditionId) {
+	for (const period of presentation.periods) for (const track of period.tracks) for (const rendition of track.renditions) if (rendition.id === renditionId) return {
+		rendition,
+		track
+	};
+	return null;
+}
+/**
+* The renditions whose media playlists still need fetching: every rendition of
+* every active track. Fetching only the "chosen" one is not enough, because ABR
+* (or any switch policy) selects independently and can pick a rendition this
+* slice would not have; its segments would then stay empty and the scheduler
+* would stall the moment ABR ramped onto it, which looks like playback dying
+* once the buffer drains. Fetching all of an active track's playlists means the
+* rendition ABR lands on is already loaded, and a switch never stalls.
+*/
+function neededPlaylists(kernel) {
+	const presentation = kernel.presentation;
+	if (presentation === null) return [];
+	const activeIds = new Set([
+		"video",
+		"audio",
+		"text"
+	].map((contentType) => kernel.tracks.active.get(contentType)).filter((id) => id !== void 0));
+	const needed = [];
+	for (const period of presentation.periods) for (const track of period.tracks) {
+		if (!activeIds.has(track.id)) continue;
+		for (const rendition of track.renditions) if (rendition.playlistUrl !== void 0 && Array.isArray(rendition.segments) && rendition.segments.length === 0) needed.push(rendition);
+	}
+	return needed;
+}
+/** Loops a message back into the bus through a zero-delay schedule effect. */
+function feed(message) {
+	return {
+		kind: "schedule",
+		token: "hls:loopback",
+		delayMs: 0,
+		then: message
+	};
+}
+function loopBack(presentation) {
+	return feed({
+		type: "MANIFEST_LOADED",
+		presentation
+	});
+}
+const reduceHls = (slice, msg, kernel) => {
+	const state = slice !== null && slice !== void 0 ? slice : INITIAL;
+	if (msg.type === "LOAD") return [{
+		manifestUrl: msg.url,
+		mimeType: msg.mimeType === void 0 ? null : normalizeMimeType(msg.mimeType),
+		pending: {}
+	}, []];
+	if (msg.type === "UNLOAD" || msg.type === "DETACH") return [INITIAL, []];
+	if (msg.type === "SEGMENT_LOADED" && msg.trackId === "manifest" && state.manifestUrl !== null) {
+		const text = new TextDecoder().decode(msg.bytes);
+		if (!claims(state, text)) return [state, []];
+		const result = parse(text, state.manifestUrl);
+		if (result.presentation === null) {
+			var _result$error;
+			return [state, [feed({
+				type: "MANIFEST_FAILED",
+				error: (_result$error = result.error) !== null && _result$error !== void 0 ? _result$error : {
+					category: "manifest",
+					code: "MANIFEST_PARSE_FAILED",
+					fatal: true,
+					recoverable: false
+				}
+			})]];
+		}
+		return [state, [loopBack(result.presentation)]];
+	}
+	if (msg.type === "SEGMENT_LOADED" && msg.trackId.startsWith(PLAYLIST_TOKEN)) {
+		const renditionId = state.pending[msg.trackId];
+		if (renditionId === void 0 || kernel.presentation === null) return [state, []];
+		const site = findRendition(kernel.presentation, renditionId);
+		const pending = _objectSpread2({}, state.pending);
+		delete pending[msg.trackId];
+		if (site === null || site.rendition.playlistUrl === void 0) return [_objectSpread2(_objectSpread2({}, state), {}, { pending }), []];
+		const text = new TextDecoder().decode(msg.bytes);
+		const media = parseMediaPlaylist(text, site.rendition.playlistUrl);
+		if (media.playlist === null) {
+			var _media$error;
+			return [_objectSpread2(_objectSpread2({}, state), {}, { pending }), [feed({
+				type: "MANIFEST_FAILED",
+				error: (_media$error = media.error) !== null && _media$error !== void 0 ? _media$error : {
+					category: "manifest",
+					code: "MANIFEST_PARSE_FAILED",
+					fatal: true,
+					recoverable: false
+				}
+			})]];
+		}
+		const merged = mergePlaylist(kernel.presentation, renditionId, media.playlist);
+		return [_objectSpread2(_objectSpread2({}, state), {}, { pending }), [loopBack(merged)]];
+	}
+	if (msg.type === "MANIFEST_LOADED" || msg.type === "SELECT_TRACK" || msg.type === "TIME_UPDATE") {
+		const needed = neededPlaylists(kernel).filter((rendition) => !Object.values(state.pending).includes(rendition.id));
+		if (needed.length === 0) return [state, []];
+		const effects = [];
+		const pending = _objectSpread2({}, state.pending);
+		for (const rendition of needed) {
+			const token = `${PLAYLIST_TOKEN}${rendition.id}`;
+			if (pending[token] !== void 0) continue;
+			pending[token] = rendition.id;
+			effects.push({
+				kind: "fetch",
+				token,
+				url: rendition.playlistUrl
+			});
+		}
+		return [_objectSpread2(_objectSpread2({}, state), {}, { pending }), effects];
+	}
+	return [state, []];
+};
+/**
+* The stage factory. `mattebox({ stages: [hlsCmaf()] })` is all a consumer
+* needs for HLS-CMAF VOD.
+*/
+function hlsCmaf() {
+	return {
+		name: "hls-cmaf",
+		provides: ["hls-cmaf", ...MANIFEST_TYPES],
+		install(ctx) {
+			ctx.reduce("hls", reduceHls);
+		}
+	};
+}
+//#endregion
+export { hlsCmaf as default };

package/dist/es2015/protocols/hls-cmaf/lexer.js

@@ -0,0 +1,72 @@
+//#region src/protocols/hls-cmaf/lexer.ts
+/** Tags with attribute lists; everything else keeps its raw value. */
+const ATTRIBUTE_TAGS = /* @__PURE__ */ new Set([
+	"EXT-X-STREAM-INF",
+	"EXT-X-MEDIA",
+	"EXT-X-MAP",
+	"EXT-X-KEY",
+	"EXT-X-SESSION-KEY",
+	"EXT-X-I-FRAME-STREAM-INF",
+	"EXT-X-CONTENT-STEERING"
+]);
+/**
+* RFC 8216 §4.2: comma-separated KEY=VALUE pairs where a quoted-string
+* value may contain commas. Walk characters; never split.
+*/
+function parseAttributeList(text) {
+	const out = {};
+	let at = 0;
+	while (at < text.length) {
+		const eq = text.indexOf("=", at);
+		if (eq === -1) break;
+		const key = text.slice(at, eq).trim();
+		at = eq + 1;
+		let value;
+		if (text[at] === "\"") {
+			const close = text.indexOf("\"", at + 1);
+			if (close === -1) {
+				value = text.slice(at + 1);
+				at = text.length;
+			} else {
+				value = text.slice(at + 1, close);
+				at = close + 1;
+			}
+		} else {
+			let end = text.indexOf(",", at);
+			if (end === -1) end = text.length;
+			value = text.slice(at, end).trim();
+			at = end;
+		}
+		if (key !== "") out[key] = value;
+		if (text[at] === ",") at += 1;
+	}
+	return out;
+}
+/** Tokenizes a playlist into tag and URI lines. Comments and blanks drop. */
+function lex(text) {
+	const lines = [];
+	for (const raw of text.split(/\r?\n/)) {
+		const line = raw.trim();
+		if (line === "") continue;
+		if (!line.startsWith("#")) {
+			lines.push({
+				kind: "uri",
+				uri: line
+			});
+			continue;
+		}
+		if (!line.startsWith("#EXT")) continue;
+		const colon = line.indexOf(":");
+		const name = colon === -1 ? line.slice(1) : line.slice(1, colon);
+		const value = colon === -1 ? "" : line.slice(colon + 1);
+		lines.push({
+			kind: "tag",
+			name,
+			value,
+			attributes: ATTRIBUTE_TAGS.has(name) ? parseAttributeList(value) : {}
+		});
+	}
+	return lines;
+}
+//#endregion
+export { lex, parseAttributeList };

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

@@ -0,0 +1,457 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { lex } from "./lexer.js";
+//#region src/protocols/hls-cmaf/parse.ts
+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;
+	}
+}
+/** n@o or n (continuing after the previous range). RFC 8216 §4.3.2.2. */
+function parseByteRange(value, previousEnd) {
+	const [lengthText, offsetText] = value.split("@");
+	const length = Number(lengthText);
+	if (!Number.isFinite(length)) return null;
+	const start = offsetText !== void 0 ? Number(offsetText) : previousEnd === null ? 0 : previousEnd + 1;
+	if (!Number.isFinite(start)) return null;
+	return {
+		start,
+		end: start + length - 1
+	};
+}
+/**
+* METHOD=AES-128 as a segment key. Anything else (NONE, SAMPLE-AES, the
+* FairPlay and Widevine forms) is not a segment key: NONE ends keying, the
+* rest are DRM and go through `protectionFrom`.
+*/
+function segmentKeyFrom(key, baseUrl) {
+	if (key.attributes.METHOD !== "AES-128" || key.attributes.URI === void 0) return null;
+	const iv = key.attributes.IV;
+	return _objectSpread2({
+		method: "AES-128",
+		uri: resolve(key.attributes.URI, baseUrl)
+	}, iv !== void 0 ? { iv: iv.replace(/^0x/i, "").toLowerCase().padStart(32, "0") } : {});
+}
+function protectionFrom(key, baseUrl) {
+	var _key$attributes$METHO, _key$attributes$KEYFO, _key$attributes$KEYID;
+	const method = (_key$attributes$METHO = key.attributes.METHOD) !== null && _key$attributes$METHO !== void 0 ? _key$attributes$METHO : "";
+	if (method === "" || method === "NONE" || method === "AES-128") return null;
+	return { schemes: [{
+		systemId: (_key$attributes$KEYFO = key.attributes.KEYFORMAT) !== null && _key$attributes$KEYFO !== void 0 ? _key$attributes$KEYFO : null,
+		scheme: method.toLowerCase(),
+		keyId: (_key$attributes$KEYID = key.attributes.KEYID) !== null && _key$attributes$KEYID !== void 0 ? _key$attributes$KEYID : null,
+		licenseUrl: key.attributes.URI !== void 0 ? resolve(key.attributes.URI, baseUrl) : null,
+		initData: null,
+		initDataType: null
+	}] };
+}
+const AUDIO_CODECS = /^(mp4a|ac-3|ec-3|opus|flac)/i;
+/**
+* Rewrites the legacy decimal AVC codec form some packagers still emit into
+* the RFC 6381 hex form MSE demands. `avc1.66.30` (profile 66, level 30) is
+* accepted by Firefox but rejected by Chrome's isTypeSupported, which is why a
+* stream like Unified Streaming's plays audio but no video on one browser and
+* nothing on the other. The constraint byte is not carried in this form, so it
+* is emitted as zero; the real flags ride in the avcC the transmux writes.
+*/
+function normalizeAvcCodec(codec) {
+	const match = /^(avc1|avc3)\.(\d+)\.(\d+)$/.exec(codec);
+	if (match === null) return codec;
+	const hex = (n) => (Number(n) & 255).toString(16).padStart(2, "0");
+	return `${match[1]}.${hex(Number(match[2]))}00${hex(Number(match[3]))}`;
+}
+function splitCodecs(value) {
+	if (value === void 0) return {
+		video: null,
+		audio: null
+	};
+	let video = null;
+	let audio = null;
+	for (const codec of value.split(",").map((c) => c.trim())) {
+		if (codec === "") continue;
+		if (AUDIO_CODECS.test(codec)) {
+			var _audio;
+			audio = (_audio = audio) !== null && _audio !== void 0 ? _audio : codec;
+		} else {
+			var _video;
+			video = (_video = video) !== null && _video !== void 0 ? _video : normalizeAvcCodec(codec);
+		}
+	}
+	return {
+		video,
+		audio
+	};
+}
+/** parse a media playlist body into segments. */
+function parseMediaPlaylist(text, baseUrl) {
+	if (!text.trimStart().startsWith("#EXTM3U")) return {
+		playlist: null,
+		error: manifestError("missing #EXTM3U")
+	};
+	const lines = lex(text);
+	const segments = [];
+	let init = null;
+	let targetDuration = 0;
+	let mediaSequence = 0;
+	let endlist = false;
+	let playlistType = null;
+	let protection = null;
+	let pendingKey = null;
+	let dateAnchor;
+	let pendingDate = null;
+	let pendingDuration = null;
+	let pendingRange = null;
+	let pendingDiscontinuity = false;
+	let previousRangeEnd = null;
+	let start = 0;
+	let seq = 0;
+	for (const line of lines) {
+		if (line.kind === "tag") {
+			switch (line.name) {
+				case "EXT-X-TARGETDURATION":
+					targetDuration = Number(line.value) || 0;
+					break;
+				case "EXT-X-MEDIA-SEQUENCE":
+					mediaSequence = Number(line.value) || 0;
+					seq = mediaSequence;
+					break;
+				case "EXT-X-PLAYLIST-TYPE":
+					playlistType = line.value;
+					break;
+				case "EXT-X-ENDLIST":
+					endlist = true;
+					break;
+				case "EXTINF": {
+					const comma = line.value.indexOf(",");
+					pendingDuration = Number(comma === -1 ? line.value : line.value.slice(0, comma));
+					break;
+				}
+				case "EXT-X-BYTERANGE":
+					pendingRange = parseByteRange(line.value, previousRangeEnd);
+					break;
+				case "EXT-X-DISCONTINUITY":
+					pendingDiscontinuity = true;
+					break;
+				case "EXT-X-MAP": {
+					const uri = line.attributes.URI;
+					if (uri !== void 0) {
+						const range = line.attributes.BYTERANGE !== void 0 ? parseByteRange(line.attributes.BYTERANGE, null) : null;
+						init = _objectSpread2({ url: resolve(uri, baseUrl) }, range !== null ? { byteRange: range } : {});
+					}
+					break;
+				}
+				case "EXT-X-KEY":
+					var _protectionFrom;
+					pendingKey = segmentKeyFrom(line, baseUrl);
+					protection = (_protectionFrom = protectionFrom(line, baseUrl)) !== null && _protectionFrom !== void 0 ? _protectionFrom : protection;
+					break;
+				case "EXT-X-PROGRAM-DATE-TIME": {
+					const parsed = Date.parse(line.value);
+					if (Number.isFinite(parsed)) pendingDate = parsed / 1e3;
+					break;
+				}
+			}
+			continue;
+		}
+		if (pendingDuration === null || !Number.isFinite(pendingDuration)) return {
+			playlist: null,
+			error: manifestError(`segment URI without EXTINF: ${line.uri}`)
+		};
+		if (pendingDate !== null && dateAnchor === void 0) dateAnchor = {
+			wallClock: pendingDate,
+			presentationTime: start
+		};
+		pendingDate = null;
+		segments.push(_objectSpread2(_objectSpread2(_objectSpread2({
+			seq,
+			start,
+			duration: pendingDuration,
+			url: resolve(line.uri, baseUrl)
+		}, pendingRange !== null ? { byteRange: pendingRange } : {}), pendingDiscontinuity ? { discontinuity: true } : {}), pendingKey !== null ? { key: pendingKey } : {}));
+		previousRangeEnd = pendingRange !== null ? pendingRange.end : previousRangeEnd;
+		start += pendingDuration;
+		seq += 1;
+		pendingDuration = null;
+		pendingRange = null;
+		pendingDiscontinuity = false;
+	}
+	return {
+		playlist: _objectSpread2({
+			segments,
+			init,
+			targetDuration,
+			mediaSequence,
+			endlist,
+			playlistType,
+			protection
+		}, dateAnchor !== void 0 ? { dateAnchor } : {}),
+		error: null
+	};
+}
+function mediaContentType(type) {
+	if (type === "AUDIO") return "audio";
+	if (type === "SUBTITLES") return "text";
+	return null;
+}
+/** parse either playlist form into a Presentation. Never throws. */
+function parse(text, baseUrl) {
+	if (!text.trimStart().startsWith("#EXTM3U")) return {
+		presentation: null,
+		error: manifestError("missing #EXTM3U")
+	};
+	const lines = lex(text);
+	if (!lines.some((line) => line.kind === "tag" && line.name === "EXT-X-STREAM-INF")) {
+		const media = parseMediaPlaylist(text, baseUrl);
+		if (media.playlist === null) {
+			var _media$error;
+			return {
+				presentation: null,
+				error: (_media$error = media.error) !== null && _media$error !== void 0 ? _media$error : manifestError("unparsable playlist")
+			};
+		}
+		if (media.playlist.segments.length === 0) return {
+			presentation: null,
+			error: {
+				category: "manifest",
+				code: "MANIFEST_EMPTY",
+				fatal: true,
+				recoverable: false,
+				context: { reason: "no variants and no segments" }
+			}
+		};
+		const duration = media.playlist.segments.reduce((sum, s) => sum + s.duration, 0);
+		const audioOnly = media.playlist.segments.every((s) => /\.(aac|mp3|ac3|ec3|m4a)(\?|$)/i.test(s.url));
+		const contentType = audioOnly ? "audio" : "video";
+		const mimeType = audioOnly ? "audio/mp4" : "video/mp4";
+		const rendition = _objectSpread2({
+			id: "r-0",
+			bitrate: 0,
+			codecs: null,
+			mimeType,
+			segments: media.playlist.segments
+		}, media.playlist.init !== null ? { init: media.playlist.init } : {});
+		return {
+			presentation: _objectSpread2(_objectSpread2(_objectSpread2({
+				id: baseUrl,
+				isLive: !media.playlist.endlist
+			}, media.playlist.endlist ? { duration } : {}), media.playlist.endlist ? {} : { live: _objectSpread2({ updatePeriod: media.playlist.targetDuration || 4 }, media.playlist.dateAnchor !== void 0 ? { dateAnchor: media.playlist.dateAnchor } : {}) }), {}, {
+				periods: [{
+					id: "p0",
+					start: 0,
+					tracks: [{
+						id: "main",
+						contentType,
+						mimeType,
+						protection: media.playlist.protection,
+						renditions: [rendition]
+					}]
+				}],
+				couplings: []
+			}),
+			error: null
+		};
+	}
+	const mediaEntries = [];
+	const variants = [];
+	let sessionProtection = null;
+	let steering;
+	let pendingStreamInf = null;
+	for (const line of lines) {
+		if (line.kind === "tag") {
+			if (line.name === "EXT-X-MEDIA") {
+				var _line$attributes$TYPE, _line$attributes$GROU, _line$attributes$NAME;
+				mediaEntries.push({
+					type: (_line$attributes$TYPE = line.attributes.TYPE) !== null && _line$attributes$TYPE !== void 0 ? _line$attributes$TYPE : "",
+					groupId: (_line$attributes$GROU = line.attributes["GROUP-ID"]) !== null && _line$attributes$GROU !== void 0 ? _line$attributes$GROU : "",
+					name: (_line$attributes$NAME = line.attributes.NAME) !== null && _line$attributes$NAME !== void 0 ? _line$attributes$NAME : "",
+					attributes: line.attributes,
+					uri: line.attributes.URI !== void 0 ? resolve(line.attributes.URI, baseUrl) : null
+				});
+			} else if (line.name === "EXT-X-STREAM-INF") pendingStreamInf = line;
+			else if (line.name === "EXT-X-SESSION-KEY") {
+				var _protectionFrom2;
+				sessionProtection = (_protectionFrom2 = protectionFrom(line, baseUrl)) !== null && _protectionFrom2 !== void 0 ? _protectionFrom2 : sessionProtection;
+			} else if (line.name === "EXT-X-CONTENT-STEERING") {
+				const serverUri = line.attributes["SERVER-URI"];
+				if (serverUri !== void 0) steering = _objectSpread2({ serverUri: resolve(serverUri, baseUrl) }, line.attributes["PATHWAY-ID"] !== void 0 ? { defaultPathway: line.attributes["PATHWAY-ID"] } : {});
+			}
+			continue;
+		}
+		if (pendingStreamInf !== null) {
+			variants.push({
+				attributes: pendingStreamInf.attributes,
+				uri: resolve(line.uri, baseUrl)
+			});
+			pendingStreamInf = null;
+		}
+	}
+	if (variants.length === 0) return {
+		presentation: null,
+		error: manifestError("multivariant playlist with no variants")
+	};
+	const renditions = [];
+	const audioOnlyVariants = [];
+	const couplings = [];
+	for (const variant of variants) {
+		const bandwidth = Number(variant.attributes.BANDWIDTH) || 0;
+		const resolution = variant.attributes.RESOLUTION;
+		const [width, height] = resolution !== void 0 ? resolution.split("x").map((n) => Number(n)) : [];
+		const { video, audio } = splitCodecs(variant.attributes.CODECS);
+		if (video === null && audio !== null) {
+			audioOnlyVariants.push(variant);
+			continue;
+		}
+		const hasAudioGroup = variant.attributes.AUDIO !== void 0;
+		const codecs = video !== null && !hasAudioGroup && audio !== null ? `${video}, ${audio}` : video;
+		const frameRate = Number(variant.attributes["FRAME-RATE"]);
+		const pathway = variant.attributes["PATHWAY-ID"];
+		const id = pathway !== void 0 ? `v-${bandwidth}-${pathway}` : `v-${bandwidth}`;
+		if (renditions.some((r) => r.id === id)) continue;
+		renditions.push(_objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({
+			id,
+			bitrate: bandwidth,
+			codecs,
+			mimeType: "video/mp4",
+			segments: [],
+			playlistUrl: variant.uri
+		}, pathway !== void 0 ? { pathway } : {}), width !== void 0 && Number.isFinite(width) ? { width } : {}), height !== void 0 && Number.isFinite(height) ? { height } : {}), Number.isFinite(frameRate) ? { frameRate } : {}));
+		const requires = {};
+		if (variant.attributes.AUDIO !== void 0) requires.audio = variant.attributes.AUDIO;
+		if (variant.attributes.SUBTITLES !== void 0) requires.text = variant.attributes.SUBTITLES;
+		if (Object.keys(requires).length > 0) couplings.push({
+			renditionId: id,
+			requires
+		});
+	}
+	const tracks = [];
+	if (renditions.length > 0) tracks.push({
+		id: "video-main",
+		contentType: "video",
+		mimeType: "video/mp4",
+		protection: sessionProtection,
+		renditions
+	});
+	else if (audioOnlyVariants.length > 0) {
+		const audioRenditions = [];
+		for (const variant of audioOnlyVariants) {
+			const bandwidth = Number(variant.attributes.BANDWIDTH) || 0;
+			const id = `a-${bandwidth}`;
+			if (audioRenditions.some((r) => r.id === id)) continue;
+			const { audio } = splitCodecs(variant.attributes.CODECS);
+			audioRenditions.push({
+				id,
+				bitrate: bandwidth,
+				codecs: audio,
+				mimeType: "audio/mp4",
+				segments: [],
+				playlistUrl: variant.uri
+			});
+		}
+		tracks.push({
+			id: "audio-main",
+			contentType: "audio",
+			mimeType: "audio/mp4",
+			protection: sessionProtection,
+			renditions: audioRenditions
+		});
+	}
+	for (const entry of mediaEntries) {
+		var _variants$find;
+		const contentType = mediaContentType(entry.type);
+		if (contentType === null || entry.uri === null) continue;
+		const { audio } = splitCodecs((_variants$find = variants.find((v) => v.attributes.AUDIO === entry.groupId)) === null || _variants$find === void 0 ? void 0 : _variants$find.attributes.CODECS);
+		const mimeType = contentType === "audio" ? "audio/mp4" : "text/vtt";
+		tracks.push(_objectSpread2(_objectSpread2(_objectSpread2({
+			id: `${entry.groupId}:${entry.name}`,
+			contentType,
+			mimeType,
+			protection: sessionProtection
+		}, entry.attributes.LANGUAGE !== void 0 ? { lang: entry.attributes.LANGUAGE } : {}), entry.attributes.DEFAULT === "YES" ? { role: "main" } : { role: "alternate" }), {}, { renditions: [{
+			id: `${entry.groupId}:${entry.name}`,
+			bitrate: 0,
+			codecs: contentType === "audio" ? audio : null,
+			mimeType,
+			segments: [],
+			playlistUrl: entry.uri
+		}] }));
+	}
+	return {
+		presentation: _objectSpread2({
+			id: baseUrl,
+			isLive: false,
+			periods: [{
+				id: "p0",
+				start: 0,
+				tracks
+			}],
+			couplings
+		}, steering !== void 0 ? { steering } : {}),
+		error: null
+	};
+}
+/**
+* The presentation-time shift that puts a refreshed live window back on the
+* timeline the previous window established. parseMediaPlaylist numbers every
+* window from zero, but playback needs one stable seq->time map across
+* reloads: without it a sliding window keeps handing the newest segment the
+* same low start, the buffer never advances past the first window, and live
+* stalls with no recovery. The media sequence number shared by the old and new
+* window fixes the offset; a fresh load (no prior segments) shifts by zero.
+*/
+function timelineShift(previous, next) {
+	if (!Array.isArray(previous) || previous.length === 0 || next.length === 0) return 0;
+	const prior = previous;
+	const startBySeq = new Map(prior.map((s) => [s.seq, s.start]));
+	for (const segment of next) {
+		const priorStart = startBySeq.get(segment.seq);
+		if (priorStart !== void 0) return priorStart - segment.start;
+	}
+	const last = prior[prior.length - 1];
+	const first = next[0];
+	const average = prior.reduce((sum, s) => sum + s.duration, 0) / prior.length;
+	return last.start + (first.seq - last.seq) * average - first.start;
+}
+/**
+* Immutably merges a fetched media playlist into the rendition that
+* referenced it. Duration, liveness, init, and protection all come from
+* the media playlist; the presentation learns them here. On a live refresh
+* the new window is rebased onto the running timeline first, so segment start
+* times stay absolute across reloads.
+*/
+function mergePlaylist(presentation, renditionId, playlist) {
+	var _presentation$duratio;
+	let previous = [];
+	for (const period of presentation.periods) for (const track of period.tracks) for (const rendition of track.renditions) if (rendition.id === renditionId) previous = rendition.segments;
+	const knownLast = Array.isArray(previous) ? previous[previous.length - 1] : void 0;
+	const incomingLast = playlist.segments[playlist.segments.length - 1];
+	if (knownLast !== void 0 && incomingLast !== void 0 && !playlist.endlist && incomingLast.seq < knownLast.seq) return presentation;
+	const shift = timelineShift(previous, playlist.segments);
+	const segments = shift === 0 ? playlist.segments : playlist.segments.map((s) => _objectSpread2(_objectSpread2({}, s), {}, { start: s.start + shift }));
+	const duration = segments.reduce((sum, s) => sum + s.duration, 0);
+	const dateAnchor = playlist.dateAnchor !== void 0 ? {
+		wallClock: playlist.dateAnchor.wallClock,
+		presentationTime: playlist.dateAnchor.presentationTime + shift
+	} : void 0;
+	const periods = presentation.periods.map((period) => _objectSpread2(_objectSpread2({}, period), {}, { tracks: period.tracks.map((track) => {
+		var _track$protection;
+		if (!track.renditions.some((r) => r.id === renditionId)) return track;
+		return _objectSpread2(_objectSpread2({}, track), {}, {
+			protection: (_track$protection = track.protection) !== null && _track$protection !== void 0 ? _track$protection : playlist.protection,
+			renditions: track.renditions.map((rendition) => rendition.id === renditionId ? _objectSpread2(_objectSpread2({}, rendition), {}, { segments }, playlist.init !== null ? { init: playlist.init } : {}) : rendition)
+		});
+	}) }));
+	const knownDuration = (_presentation$duratio = presentation.duration) !== null && _presentation$duratio !== void 0 ? _presentation$duratio : 0;
+	return _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, presentation), {}, { isLive: !playlist.endlist }, playlist.endlist ? { duration: Math.max(knownDuration, duration) } : {}), playlist.endlist ? {} : { live: _objectSpread2(_objectSpread2({}, presentation.live), {}, { updatePeriod: playlist.targetDuration || 4 }, dateAnchor !== void 0 ? { dateAnchor } : {}) }), {}, { periods });
+}
+//#endregion
+export { mergePlaylist, normalizeAvcCodec, parse, parseMediaPlaylist };