mattebox 0.1.0

package/dist/es2015/kernel/rendition-select.js

@@ -0,0 +1,263 @@
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { segmentAtTime } from "./timeline.js";
+import { bufferedEndFrom } from "./scheduler.js";
+//#region src/kernel/rendition-select.ts
+/** The lead time before which a `soon` switch never disturbs the buffer. */
+const SOON_LEAD_SECONDS = 1.5;
+const GAP_TOLERANCE = .25;
+function matches(rendition, constraint) {
+	var _rendition$height, _rendition$width, _rendition$frameRate, _constraint$excludeId;
+	if (constraint.maxHeight !== void 0 && ((_rendition$height = rendition.height) !== null && _rendition$height !== void 0 ? _rendition$height : 0) > constraint.maxHeight) return false;
+	if (constraint.maxWidth !== void 0 && ((_rendition$width = rendition.width) !== null && _rendition$width !== void 0 ? _rendition$width : 0) > constraint.maxWidth) return false;
+	if (constraint.maxBitrate !== void 0 && rendition.bitrate > constraint.maxBitrate) return false;
+	if (constraint.minBitrate !== void 0 && rendition.bitrate < constraint.minBitrate) return false;
+	if (constraint.maxFrameRate !== void 0 && ((_rendition$frameRate = rendition.frameRate) !== null && _rendition$frameRate !== void 0 ? _rendition$frameRate : 0) > constraint.maxFrameRate) return false;
+	if ((_constraint$excludeId = constraint.excludeIds) === null || _constraint$excludeId === void 0 ? void 0 : _constraint$excludeId.includes(rendition.id)) return false;
+	if (constraint.codecs !== void 0) {
+		const codec = rendition.codecs;
+		if (codec === null || !constraint.codecs.some((allowed) => codec.startsWith(allowed))) return false;
+	}
+	if (constraint.filter !== void 0 && !constraint.filter(rendition)) return false;
+	return true;
+}
+function intersect(renditions, constraints) {
+	return renditions.filter((rendition) => constraints.every(([, c]) => matches(rendition, c)));
+}
+function closestByBitrate(allowed, target) {
+	let best = allowed[0];
+	for (const candidate of allowed) if (Math.abs(candidate.bitrate - target.bitrate) < Math.abs(best.bitrate - target.bitrate)) best = candidate;
+	return best;
+}
+function lowest(allowed) {
+	let best = allowed[0];
+	for (const candidate of allowed) if (candidate.bitrate < best.bitrate) best = candidate;
+	return best;
+}
+/** The strict arbitration order from docs/08. Never deviate; never return zero renditions. */
+function arbitrate(ctx) {
+	const events = [];
+	if (ctx.renditions.length === 0) return {
+		result: {
+			allowed: [],
+			droppedConstraints: [],
+			selected: null,
+			reason: "lowest-permitted"
+		},
+		events
+	};
+	let active = [...ctx.constraints.entries()];
+	let allowed = intersect(ctx.renditions, active);
+	const dropped = [];
+	while (allowed.length === 0 && active.length > 0) {
+		const droppedEntry = active[active.length - 1];
+		dropped.push(droppedEntry[0]);
+		active = active.slice(0, -1);
+		allowed = intersect(ctx.renditions, active);
+	}
+	if (dropped.length > 0) events.push({
+		kind: "emit",
+		event: "quality:constraints-unsatisfiable",
+		payload: { dropped }
+	});
+	const coupled = allowed.filter((rendition) => {
+		const coupling = ctx.couplings.find((c) => c.renditionId === rendition.id);
+		if (coupling === void 0) return true;
+		for (const [contentType, requiredTrack] of Object.entries(coupling.requires)) {
+			var _ctx$availableGroups, _ctx$availableGroups2;
+			const activeTrack = ctx.activeTracks.get(contentType);
+			const matchesActive = activeTrack === requiredTrack || (activeTrack === null || activeTrack === void 0 ? void 0 : activeTrack.startsWith(`${requiredTrack}:`)) === true;
+			if (activeTrack === void 0 || matchesActive) continue;
+			if (!(((_ctx$availableGroups = ctx.availableGroups) === null || _ctx$availableGroups === void 0 ? void 0 : _ctx$availableGroups.has(`${contentType}:${requiredTrack}`)) === true || ((_ctx$availableGroups2 = ctx.availableGroups) === null || _ctx$availableGroups2 === void 0 ? void 0 : _ctx$availableGroups2.has(requiredTrack)) === true)) return false;
+		}
+		return true;
+	});
+	if (coupled.length > 0) allowed = coupled;
+	else events.push({
+		kind: "emit",
+		event: "quality:coupling-unsatisfiable",
+		payload: { active: Object.fromEntries(ctx.activeTracks) }
+	});
+	const allowedIds = allowed.map((r) => r.id);
+	if (ctx.pinned !== null) {
+		if (allowedIds.includes(ctx.pinned)) return {
+			result: {
+				allowed: allowedIds,
+				droppedConstraints: dropped,
+				selected: ctx.pinned,
+				reason: "pin"
+			},
+			events
+		};
+		const target = ctx.renditions.find((r) => r.id === ctx.pinned);
+		if (target !== void 0) {
+			const clamped = closestByBitrate(allowed, target);
+			events.push({
+				kind: "emit",
+				event: "quality:pin-unsatisfiable",
+				payload: {
+					pinned: ctx.pinned,
+					resolved: clamped.id
+				}
+			});
+			return {
+				result: {
+					allowed: allowedIds,
+					droppedConstraints: dropped,
+					selected: clamped.id,
+					reason: "pin"
+				},
+				events
+			};
+		}
+	}
+	if (ctx.abr != null) {
+		const choice = ctx.abr.choose(allowed, ctx.telemetry);
+		if (allowedIds.includes(choice)) return {
+			result: {
+				allowed: allowedIds,
+				droppedConstraints: dropped,
+				selected: choice,
+				reason: "abr"
+			},
+			events
+		};
+		events.push({
+			kind: "emit",
+			event: "quality:abr-invalid",
+			payload: {
+				choice,
+				allowed: allowedIds
+			}
+		});
+	}
+	if (ctx.current !== null && allowedIds.includes(ctx.current)) return {
+		result: {
+			allowed: allowedIds,
+			droppedConstraints: dropped,
+			selected: ctx.current,
+			reason: "unchanged"
+		},
+		events
+	};
+	return {
+		result: {
+			allowed: allowedIds,
+			droppedConstraints: dropped,
+			selected: lowest(allowed).id,
+			reason: "lowest-permitted"
+		},
+		events
+	};
+}
+function createArbiter() {
+	let lastVersion = NaN;
+	let lastOutcome = null;
+	let lastPlaying = null;
+	return {
+		run(ctx, version) {
+			if (lastOutcome !== null && version === lastVersion) return _objectSpread2(_objectSpread2({}, lastOutcome), {}, { computed: false });
+			lastOutcome = arbitrate(ctx);
+			lastVersion = version;
+			lastPlaying = null;
+			return _objectSpread2(_objectSpread2({}, lastOutcome), {}, { computed: true });
+		},
+		playingAt(log, currentTime) {
+			var _found, _found$rendition;
+			if (lastPlaying !== null && currentTime >= lastPlaying.start && currentTime < lastPlaying.end) return lastPlaying.rendition;
+			let found = null;
+			for (const [range, renditionId] of log) if (range.start <= currentTime && currentTime < range.end) found = {
+				rendition: renditionId,
+				start: range.start,
+				end: range.end
+			};
+			lastPlaying = (_found = found) !== null && _found !== void 0 ? _found : {
+				rendition: null,
+				start: currentTime,
+				end: currentTime
+			};
+			return (_found$rendition = found === null || found === void 0 ? void 0 : found.rendition) !== null && _found$rendition !== void 0 ? _found$rendition : null;
+		}
+	};
+}
+/** The four-character sample entry a codec string names, before any profile suffix. */
+function codecFamily(codecs) {
+	var _codecs$split$0$trim, _codecs$split$;
+	if (codecs === null) return null;
+	const first = (_codecs$split$0$trim = (_codecs$split$ = codecs.split(",")[0]) === null || _codecs$split$ === void 0 ? void 0 : _codecs$split$.trim()) !== null && _codecs$split$0$trim !== void 0 ? _codecs$split$0$trim : "";
+	const dot = first.indexOf(".");
+	return dot === -1 ? first : first.slice(0, dot);
+}
+/**
+* The kernel's default answer to entanglement #2. codec-switch refines it
+* with real compatibility knowledge (Stage 15); until then: identical codec
+* strings are seamless, a profile or level change inside one family is a
+* changeType-class switch (every ladder rung carries its own profile
+* string, so abr could never move under an identity rule), and a family
+* change reloads.
+*/
+function canSwitchTo(current, target) {
+	if (current === null) return "seamless";
+	if (current.codecs !== null && current.codecs === target.codecs) return "seamless";
+	const family = codecFamily(current.codecs);
+	if (family !== null && family === codecFamily(target.codecs)) return "changeType";
+	return "reload";
+}
+/**
+* The apply strategies from docs/08. `next` costs nothing and waits out
+* the buffer. `soon` flushes from the next segment boundary after
+* currentTime plus a lead, so the switch is usually invisible. `now` pays
+* a visible stall for immediacy.
+*
+* The plan never fetches. Flushing shrinks the buffered ranges, the
+* updateend fact drives the scheduling loop, and the loop refills from the
+* flush point with the init-before-media ordering a direct fetch here
+* would bypass. A pin to a rendition whose playlist is not merged yet
+* flushes the same way and refills once the playlist lands.
+*/
+function planPinApply(input) {
+	if (input.strategy === "next") return {
+		effects: [],
+		requests: [],
+		tokenSeq: input.tokenSeq
+	};
+	const effects = input.inflightTokens.map((token) => ({
+		kind: "abort",
+		token
+	}));
+	if (input.strategy === "soon") {
+		const bufferedEnd = bufferedEndFrom(input.ranges, input.currentTime, GAP_TOLERANCE);
+		const lead = input.currentTime + SOON_LEAD_SECONDS;
+		if (bufferedEnd > lead) {
+			const boundarySegment = segmentAtTime(input.rendition.segments, lead, input.period.start);
+			const safePoint = boundarySegment === null ? lead : boundarySegment.start > lead ? boundarySegment.start : boundarySegment.start + boundarySegment.duration;
+			effects.push({
+				kind: "remove",
+				sbId: input.sbId,
+				start: safePoint,
+				end: Infinity
+			});
+		}
+		return {
+			effects,
+			requests: [],
+			tokenSeq: input.tokenSeq
+		};
+	}
+	effects.push({
+		kind: "remove",
+		sbId: input.sbId,
+		start: input.currentTime,
+		end: Infinity
+	});
+	effects.push({
+		kind: "seekElement",
+		to: input.currentTime
+	});
+	return {
+		effects,
+		requests: [],
+		tokenSeq: input.tokenSeq
+	};
+}
+//#endregion
+export { arbitrate, canSwitchTo, codecFamily, createArbiter, planPinApply };

package/dist/es2015/kernel/scheduler.js

@@ -0,0 +1,82 @@
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+import { buildEpochs, epochForSeq, segmentAtTime, timestampOffsetFor } from "./timeline.js";
+//#region src/kernel/scheduler.ts
+const DEFAULT_GAP_TOLERANCE = .25;
+/**
+* The end of continuous buffer from `time`, merging gaps below the
+* tolerance. Returns `time` itself when nothing is buffered there.
+*/
+function bufferedEndFrom(ranges, time, tolerance) {
+	let end = time;
+	let advanced = true;
+	while (advanced) {
+		advanced = false;
+		for (const range of ranges) if (range.start <= end + tolerance && range.end > end) {
+			end = range.end;
+			advanced = true;
+		}
+	}
+	return end;
+}
+/** The buffered range holding the segment's midpoint, the sign it was appended, or null. */
+function coveringMidpoint(ranges, segment) {
+	var _ranges$find;
+	const mid = segment.start + segment.duration / 2;
+	return (_ranges$find = ranges.find((range) => range.start <= mid && range.end > mid)) !== null && _ranges$find !== void 0 ? _ranges$find : null;
+}
+function schedule(input) {
+	var _input$gapToleranceSe;
+	const tolerance = (_input$gapToleranceSe = input.gapToleranceSeconds) !== null && _input$gapToleranceSe !== void 0 ? _input$gapToleranceSe : DEFAULT_GAP_TOLERANCE;
+	const effects = [];
+	const requests = [];
+	let tokenSeq = input.tokenSeq;
+	for (const track of input.tracks) {
+		if (track.inflight.length > 0) continue;
+		const bufferedEnd = bufferedEndFrom(track.ranges, input.currentTime, tolerance);
+		if (bufferedEnd - input.currentTime >= input.bufferGoal) continue;
+		let target = Math.max(bufferedEnd, input.currentTime);
+		if (input.liveWindow != null && target < input.liveWindow.start) target = input.liveWindow.start;
+		let segment = segmentAtTime(track.rendition.segments, target + tolerance, track.period.start);
+		let frontier = bufferedEnd;
+		while (segment !== null) {
+			const covering = coveringMidpoint(track.ranges, segment);
+			if (covering === null) break;
+			frontier = Math.max(frontier, covering.end);
+			if (frontier - input.currentTime >= input.bufferGoal) {
+				segment = null;
+				break;
+			}
+			segment = segmentAtTime(track.rendition.segments, segment.start + segment.duration + tolerance, track.period.start);
+		}
+		if (segment === null) continue;
+		if (input.liveWindow != null && segment.start + segment.duration > input.liveWindow.end) continue;
+		const epochs = buildEpochs([{
+			period: track.period,
+			rendition: track.rendition
+		}]);
+		const epoch = epochForSeq(epochs, segment.seq);
+		tokenSeq += 1;
+		const token = `t${tokenSeq}:${track.trackId}:${segment.seq}`;
+		effects.push(_objectSpread2({
+			kind: "fetch",
+			token,
+			url: segment.url
+		}, segment.byteRange !== void 0 ? { range: segment.byteRange } : {}));
+		requests.push(_objectSpread2(_objectSpread2({
+			token,
+			trackId: track.trackId,
+			seq: segment.seq,
+			url: segment.url,
+			renditionId: track.rendition.id,
+			segmentStart: segment.start,
+			segmentDuration: segment.duration
+		}, track.sbId !== void 0 ? { sbId: track.sbId } : {}), input.mediaTimeNormalized === true ? { timestampOffset: 0 } : epoch !== null ? { timestampOffset: timestampOffsetFor(epoch) } : {}));
+	}
+	return {
+		effects,
+		requests,
+		tokenSeq
+	};
+}
+//#endregion
+export { bufferedEndFrom, schedule };

package/dist/es2015/kernel/sinks/metadata-sink.js

@@ -0,0 +1,7 @@
+import { createCueSink } from "./text-track-sink.js";
+//#region src/kernel/sinks/metadata-sink.ts
+function createMetadataSink(deps) {
+	return createCueSink("metadata", "metadata", deps);
+}
+//#endregion
+export { createMetadataSink };

package/dist/es2015/kernel/sinks/mse-sink.js

@@ -0,0 +1,31 @@
+//#region src/kernel/sinks/mse-sink.ts
+/** The sbId naming convention: one SourceBuffer per media content type. */
+function sbIdFor(contentType) {
+	return `sb:${contentType}`;
+}
+function createMseSink(contentType, deps) {
+	const sbId = sbIdFor(contentType);
+	return {
+		contentType,
+		accept(_trackId, data) {
+			return [{
+				kind: "append",
+				sbId,
+				data
+			}];
+		},
+		ranges(_trackId) {
+			return deps.buffered(sbId);
+		},
+		clear(_trackId, start, end) {
+			return [{
+				kind: "remove",
+				sbId,
+				start,
+				end
+			}];
+		}
+	};
+}
+//#endregion
+export { createMseSink, sbIdFor };

package/dist/es2015/kernel/sinks/text-track-sink.js

@@ -0,0 +1,167 @@
+//#region src/kernel/sinks/text-track-sink.ts
+/** Applies the WebVTT settings string's known keys onto a native cue. */
+function applySettings(cue, settings) {
+	if (settings === void 0) return;
+	for (const part of settings.split(/\s+/)) {
+		const [key, value] = part.split(":");
+		if (value === void 0) continue;
+		const percent = value.endsWith("%") ? Number(value.slice(0, -1)) : null;
+		switch (key) {
+			case "line":
+				cue.line = percent !== null && percent !== void 0 ? percent : Number(value);
+				if (percent !== null) cue.snapToLines = false;
+				break;
+			case "position":
+				if (percent !== null) cue.position = percent;
+				break;
+			case "size":
+				if (percent !== null) cue.size = percent;
+				break;
+			case "align":
+				cue.align = value;
+				break;
+			case "vertical": cue.vertical = value;
+		}
+	}
+}
+function mergeRange(coverage, added) {
+	const merged = [];
+	let pending = added;
+	for (const range of [...coverage].sort((a, b) => a.start - b.start)) if (range.end < pending.start || range.start > pending.end) merged.push(range);
+	else pending = {
+		start: Math.min(range.start, pending.start),
+		end: Math.max(range.end, pending.end)
+	};
+	merged.push(pending);
+	return merged.sort((a, b) => a.start - b.start);
+}
+function createCueSink(contentType, kind, deps) {
+	const tracks = /* @__PURE__ */ new Map();
+	/**
+	* A native track for the id. The element has no removeTextTrack, so a
+	* previous attach on the same element (a rebuild, an element swap back)
+	* leaves its tracks behind; one with our kind and label is adopted and
+	* emptied rather than duplicated in the browser's caption menu.
+	*/
+	/** Empties a native track. `cues` reads null while disabled; hidden makes them removable. */
+	function empty(textTrack) {
+		textTrack.mode = "hidden";
+		const { cues } = textTrack;
+		if (cues !== null) for (let i = cues.length - 1; i >= 0; i -= 1) {
+			const cue = cues[i];
+			if (cue !== void 0) textTrack.removeCue(cue);
+		}
+	}
+	function adopt(label) {
+		for (const existing of deps.element.textTracks) {
+			if (existing.kind !== kind || existing.label !== label) continue;
+			empty(existing);
+			return existing;
+		}
+		return deps.element.addTextTrack(kind, label);
+	}
+	function retire(trackId) {
+		const entry = tracks.get(trackId);
+		if (entry === void 0) return;
+		empty(entry.textTrack);
+		entry.textTrack.mode = "disabled";
+		tracks.delete(trackId);
+	}
+	function ensure(trackId) {
+		let entry = tracks.get(trackId);
+		if (entry === void 0) {
+			var _deps$label;
+			const textTrack = adopt(`${(_deps$label = deps.label) !== null && _deps$label !== void 0 ? _deps$label : "mattebox"}:${trackId}`);
+			textTrack.mode = "hidden";
+			entry = {
+				textTrack,
+				coverage: [],
+				ids: /* @__PURE__ */ new Set()
+			};
+			tracks.set(trackId, entry);
+		}
+		return entry;
+	}
+	return {
+		contentType,
+		accept(trackId, data, meta) {
+			const entry = ensure(trackId);
+			if (!meta.isInit) entry.coverage = mergeRange(entry.coverage, {
+				start: meta.start,
+				end: meta.start + meta.duration
+			});
+			if (deps.parse === void 0) return [];
+			const cues = deps.parse(new Uint8Array(data), meta);
+			if (cues.length === 0) return [];
+			return [{
+				kind: "emitCues",
+				trackId,
+				cues
+			}];
+		},
+		ranges(trackId) {
+			var _tracks$get$coverage, _tracks$get;
+			return (_tracks$get$coverage = (_tracks$get = tracks.get(trackId)) === null || _tracks$get === void 0 ? void 0 : _tracks$get.coverage) !== null && _tracks$get$coverage !== void 0 ? _tracks$get$coverage : [];
+		},
+		clear(trackId, start, end) {
+			const entry = tracks.get(trackId);
+			if (entry === void 0) return [];
+			const { cues } = entry.textTrack;
+			if (cues !== null) for (let i = cues.length - 1; i >= 0; i -= 1) {
+				const cue = cues[i];
+				if (cue !== void 0 && cue.startTime >= start && cue.endTime <= end) {
+					entry.textTrack.removeCue(cue);
+					if (cue.id !== "") entry.ids.delete(cue.id);
+				}
+			}
+			entry.coverage = entry.coverage.flatMap((range) => {
+				if (range.end <= start || range.start >= end) return [range];
+				const kept = [];
+				if (range.start < start) kept.push({
+					start: range.start,
+					end: start
+				});
+				if (range.end > end) kept.push({
+					start: end,
+					end: range.end
+				});
+				return kept;
+			});
+			return [];
+		},
+		handleEmitCues(trackId, cues) {
+			const entry = ensure(trackId);
+			for (const cue of cues) {
+				var _cue$text;
+				if (cue.id !== void 0 && entry.ids.has(cue.id)) continue;
+				const vtt = new VTTCue(cue.start, cue.end, (_cue$text = cue.text) !== null && _cue$text !== void 0 ? _cue$text : "");
+				if (cue.id !== void 0) {
+					vtt.id = cue.id;
+					entry.ids.add(cue.id);
+				}
+				applySettings(vtt, cue.settings);
+				entry.textTrack.addCue(vtt);
+			}
+		},
+		declare(trackId) {
+			return ensure(trackId).textTrack;
+		},
+		nativeTrack(trackId) {
+			var _tracks$get$textTrack, _tracks$get2;
+			return (_tracks$get$textTrack = (_tracks$get2 = tracks.get(trackId)) === null || _tracks$get2 === void 0 ? void 0 : _tracks$get2.textTrack) !== null && _tracks$get$textTrack !== void 0 ? _tracks$get$textTrack : null;
+		},
+		trackIds() {
+			return [...tracks.keys()];
+		},
+		retire,
+		dispose() {
+			for (const trackId of [...tracks.keys()]) retire(trackId);
+		}
+	};
+}
+/** Subtitles and captions to a native TextTrack. */
+function createTextTrackSink(deps) {
+	return createCueSink("text", "subtitles", deps);
+}
+//#endregion
+export { createCueSink, createTextTrackSink };

package/dist/es2015/kernel/timeline.js

@@ -0,0 +1,127 @@
+//#region src/kernel/timeline.ts
+function isIndexed(addressing) {
+	return !Array.isArray(addressing) && addressing.kind === "indexed";
+}
+/**
+* An on-demand addressing whose index box has not been fetched yet: it
+* carries no resolvable segments. Once the adapter parses the index it swaps
+* this for an explicit array, so every consumer treats it as empty until then.
+*/
+function isUnresolved(addressing) {
+	return !Array.isArray(addressing) && addressing.kind === "sidx";
+}
+/**
+* Epochs for one rendition timeline across periods. A period boundary opens
+* an epoch; inside a period, every segment flagged `discontinuity` opens
+* another. One code path for both.
+*/
+function buildEpochs(parts) {
+	const epochs = [];
+	for (const { period, rendition } of parts) {
+		const addressing = rendition.segments;
+		if (isIndexed(addressing)) {
+			var _addressing$presentat;
+			const pto = ((_addressing$presentat = addressing.presentationTimeOffset) !== null && _addressing$presentat !== void 0 ? _addressing$presentat : 0) / addressing.timescale;
+			epochs.push({
+				periodId: period.id,
+				firstSeq: addressing.startSeq,
+				presentationStart: period.start,
+				mediaStart: pto
+			});
+			continue;
+		}
+		if (isUnresolved(addressing)) continue;
+		let open = false;
+		for (const segment of addressing) if (!open || segment.discontinuity === true) {
+			const mediaStart = open ? 0 : segment.start - period.start;
+			epochs.push({
+				periodId: period.id,
+				firstSeq: segment.seq,
+				presentationStart: segment.start,
+				mediaStart
+			});
+			open = true;
+		}
+	}
+	return epochs;
+}
+/** The epoch a sequence number belongs to, or null before the first epoch. */
+function epochForSeq(epochs, seq) {
+	let match = null;
+	for (const epoch of epochs) if (epoch.firstSeq <= seq) match = epoch;
+	return match;
+}
+/** The timestampOffset an append from this epoch requires. */
+function timestampOffsetFor(epoch) {
+	return epoch.presentationStart - epoch.mediaStart;
+}
+/** Materializes one segment from an indexed form. Null outside the window. */
+function segmentAt(addressing, seq, periodStart = 0) {
+	var _addressing$presentat2;
+	if (!isIndexed(addressing)) {
+		var _find;
+		if (isUnresolved(addressing)) return null;
+		return (_find = addressing.find((segment) => segment.seq === seq)) !== null && _find !== void 0 ? _find : null;
+	}
+	if (seq < addressing.startSeq) return null;
+	if (addressing.endSeq !== null && seq > addressing.endSeq) return null;
+	const { timescale } = addressing;
+	const pto = (_addressing$presentat2 = addressing.presentationTimeOffset) !== null && _addressing$presentat2 !== void 0 ? _addressing$presentat2 : 0;
+	let startUnits;
+	let durationUnits;
+	if (addressing.timeline !== null) {
+		let cursor = addressing.startSeq;
+		let found = null;
+		for (const run of addressing.timeline) {
+			if (seq < cursor + run.count) {
+				found = {
+					start: run.start + (seq - cursor) * run.duration,
+					duration: run.duration
+				};
+				break;
+			}
+			cursor += run.count;
+		}
+		if (found === null) return null;
+		startUnits = found.start;
+		durationUnits = found.duration;
+	} else if (addressing.segmentDuration !== null) {
+		durationUnits = addressing.segmentDuration;
+		startUnits = pto + (seq - addressing.startSeq) * durationUnits;
+	} else return null;
+	const url = addressing.urlTemplate.replace(/\$(Number|Time)(?:%0(\d+)d)?\$/g, (_, name, width) => {
+		const text = String(name === "Number" ? seq : startUnits);
+		return width === void 0 ? text : text.padStart(Number(width), "0");
+	}).replaceAll("$$", "$");
+	return {
+		seq,
+		start: periodStart + (startUnits - pto) / timescale,
+		duration: durationUnits / timescale,
+		url
+	};
+}
+/** The first segment whose interval contains or follows `time`, or null past the end. */
+function segmentAtTime(addressing, time, periodStart = 0) {
+	if (!isIndexed(addressing)) {
+		if (isUnresolved(addressing)) return null;
+		for (const segment of addressing) if (segment.start + segment.duration > time) return segment;
+		return null;
+	}
+	if (addressing.timeline === null && addressing.segmentDuration !== null) {
+		const dur = addressing.segmentDuration / addressing.timescale;
+		const relative = Math.max(0, time - periodStart);
+		const seq = addressing.startSeq + Math.floor(relative / dur);
+		return segmentAt(addressing, Math.max(seq, addressing.startSeq), periodStart);
+	}
+	let seq = addressing.startSeq;
+	const last = addressing.endSeq;
+	while (last === null || seq <= last) {
+		const segment = segmentAt(addressing, seq, periodStart);
+		if (segment === null) return null;
+		if (segment.start + segment.duration > time) return segment;
+		seq += 1;
+	}
+	return null;
+}
+//#endregion
+export { buildEpochs, epochForSeq, segmentAt, segmentAtTime, timestampOffsetFor };