mattebox 0.1.0

package/dist/es2015/stages/recovery/index.js

@@ -0,0 +1,283 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+//#region src/stages/recovery/index.ts
+const DEFAULTS = {
+	excludeAfter: 2,
+	readmitAfterSeconds: 15,
+	skipAfter: 3,
+	maxConsecutiveSkips: 3,
+	maxGapSeconds: 2
+};
+const READMIT_TOKEN = "recovery:readmit";
+const INITIAL = {
+	renditionFails: {},
+	seqFails: {},
+	excluded: [],
+	readmitPending: false,
+	lastJump: null,
+	stall: null,
+	flushes: 0,
+	skips: 0
+};
+/** Loops a message back into the bus through a zero-delay schedule effect. */
+function feed(message) {
+	return {
+		kind: "schedule",
+		token: "recovery:loopback",
+		delayMs: 0,
+		then: message
+	};
+}
+function constrainExcluded(excluded) {
+	return excluded.length === 0 ? feed({
+		type: "RELEASE_CONSTRAINT",
+		source: "recovery"
+	}) : feed({
+		type: "CONSTRAIN",
+		source: "recovery",
+		constraint: { excludeIds: excluded }
+	});
+}
+function isCueTrack(kernel, trackId) {
+	var _kernel$presentation$, _kernel$presentation;
+	for (const period of (_kernel$presentation$ = (_kernel$presentation = kernel.presentation) === null || _kernel$presentation === void 0 ? void 0 : _kernel$presentation.periods) !== null && _kernel$presentation$ !== void 0 ? _kernel$presentation$ : []) for (const track of period.tracks) if (track.id === trackId) return track.contentType === "text" || track.contentType === "metadata";
+	return false;
+}
+function segmentWindow(kernel, seq) {
+	var _kernel$presentation$2, _kernel$presentation2;
+	for (const period of (_kernel$presentation$2 = (_kernel$presentation2 = kernel.presentation) === null || _kernel$presentation2 === void 0 ? void 0 : _kernel$presentation2.periods) !== null && _kernel$presentation$2 !== void 0 ? _kernel$presentation$2 : []) for (const track of period.tracks) for (const rendition of track.renditions) {
+		if (!Array.isArray(rendition.segments)) continue;
+		const segment = rendition.segments.find((s) => s.seq === seq);
+		if (segment !== void 0) return {
+			start: segment.start,
+			end: segment.start + segment.duration
+		};
+	}
+	return null;
+}
+/** The segment of the active video rendition that covers `time`. */
+function segmentAt(kernel, time) {
+	var _kernel$presentation$3, _kernel$presentation3;
+	const active = kernel.quality.active;
+	for (const period of (_kernel$presentation$3 = (_kernel$presentation3 = kernel.presentation) === null || _kernel$presentation3 === void 0 ? void 0 : _kernel$presentation3.periods) !== null && _kernel$presentation$3 !== void 0 ? _kernel$presentation$3 : []) for (const track of period.tracks) {
+		if (track.contentType !== "video") continue;
+		for (const rendition of track.renditions) {
+			if (active !== null && rendition.id !== active) continue;
+			if (!Array.isArray(rendition.segments)) continue;
+			const segment = rendition.segments.find((s) => s.start <= time && time < s.start + s.duration);
+			if (segment !== void 0) return {
+				start: segment.start,
+				end: segment.start + segment.duration
+			};
+		}
+	}
+	return null;
+}
+function createRecoveryReducer(options) {
+	return (slice, msg, kernel) => {
+		const state = slice !== null && slice !== void 0 ? slice : INITIAL;
+		if (msg.type === "DETACH" || msg.type === "UNLOAD" || msg.type === "LOAD") return [INITIAL, msg.type === "LOAD" ? [] : []];
+		if (msg.type === "SEGMENT_FAILED") {
+			var _state$renditionFails, _state$seqFails$seqKe;
+			if (msg.renditionId === void 0 || isCueTrack(kernel, msg.trackId)) return [state, []];
+			const effects = [];
+			const renditionFails = _objectSpread2(_objectSpread2({}, state.renditionFails), {}, { [msg.renditionId]: ((_state$renditionFails = state.renditionFails[msg.renditionId]) !== null && _state$renditionFails !== void 0 ? _state$renditionFails : 0) + 1 });
+			const seqKey = `${msg.trackId}:${msg.seq}`;
+			const seqFails = _objectSpread2(_objectSpread2({}, state.seqFails), {}, { [seqKey]: ((_state$seqFails$seqKe = state.seqFails[seqKey]) !== null && _state$seqFails$seqKe !== void 0 ? _state$seqFails$seqKe : 0) + 1 });
+			let excluded = state.excluded;
+			let readmitPending = state.readmitPending;
+			if (seqFails[seqKey] >= options.skipAfter && state.skips < options.maxConsecutiveSkips) {
+				const window = segmentWindow(kernel, msg.seq);
+				if (window !== null && kernel.playback.currentTime < window.end) {
+					effects.push({
+						kind: "emit",
+						event: "recovery:skip",
+						payload: {
+							seq: msg.seq,
+							to: window.end
+						}
+					}, feed({
+						type: "SEEK",
+						to: window.end + .1
+					}));
+					return [_objectSpread2(_objectSpread2({}, state), {}, {
+						renditionFails,
+						seqFails: {},
+						skips: state.skips + 1
+					}), effects];
+				}
+			}
+			if (renditionFails[msg.renditionId] >= options.excludeAfter && !excluded.includes(msg.renditionId)) {
+				excluded = [...excluded, msg.renditionId];
+				effects.push({
+					kind: "emit",
+					event: "recovery:excluded",
+					payload: { renditionId: msg.renditionId }
+				}, constrainExcluded(excluded));
+				if (!readmitPending) {
+					effects.push({
+						kind: "schedule",
+						token: READMIT_TOKEN,
+						delayMs: options.readmitAfterSeconds * 1e3,
+						then: {
+							type: "TICK",
+							token: READMIT_TOKEN
+						}
+					});
+					readmitPending = true;
+				}
+			}
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				renditionFails,
+				seqFails,
+				excluded,
+				readmitPending
+			}), effects];
+		}
+		if (msg.type === "SEGMENT_LOADED" && msg.trackId !== "manifest") {
+			var _state$renditionFails2;
+			const rendition = kernel.quality.active;
+			if (rendition !== null && ((_state$renditionFails2 = state.renditionFails[rendition]) !== null && _state$renditionFails2 !== void 0 ? _state$renditionFails2 : 0) > 0 || state.skips > 0) {
+				const renditionFails = _objectSpread2({}, state.renditionFails);
+				if (rendition !== null) delete renditionFails[rendition];
+				return [_objectSpread2(_objectSpread2({}, state), {}, {
+					renditionFails,
+					skips: 0
+				}), []];
+			}
+			return [state, []];
+		}
+		if (msg.type === "TICK" && msg.token === READMIT_TOKEN) {
+			const [readmitted, ...rest] = state.excluded;
+			if (readmitted === void 0) return [_objectSpread2(_objectSpread2({}, state), {}, { readmitPending: false }), []];
+			const renditionFails = _objectSpread2({}, state.renditionFails);
+			delete renditionFails[readmitted];
+			const effects = [{
+				kind: "emit",
+				event: "recovery:readmitted",
+				payload: { renditionId: readmitted }
+			}, constrainExcluded(rest)];
+			let readmitPending = false;
+			if (rest.length > 0) {
+				effects.push({
+					kind: "schedule",
+					token: READMIT_TOKEN,
+					delayMs: options.readmitAfterSeconds * 1e3,
+					then: {
+						type: "TICK",
+						token: READMIT_TOKEN
+					}
+				});
+				readmitPending = true;
+			}
+			return [_objectSpread2(_objectSpread2({}, state), {}, {
+				excluded: rest,
+				renditionFails,
+				readmitPending
+			}), effects];
+		}
+		if (msg.type === "STALLED") {
+			const buffered = kernel.playback.buffered;
+			if (buffered.find((range) => range.start <= msg.at + .3 && range.end > msg.at + 1) !== void 0) {
+				const count = state.stall !== null && Math.abs(state.stall.at - msg.at) < .3 ? state.stall.count + 1 : 1;
+				const stall = {
+					at: msg.at,
+					count
+				};
+				if (count === 1) return [_objectSpread2(_objectSpread2({}, state), {}, { stall }), []];
+				if (count === 2) return [_objectSpread2(_objectSpread2({}, state), {}, { stall }), [{
+					kind: "emit",
+					event: "recovery:nudge",
+					payload: { at: msg.at }
+				}, feed({
+					type: "SEEK",
+					to: msg.at + .1
+				})]];
+				if (count === 3) {
+					const effects = [{
+						kind: "emit",
+						event: "recovery:flush",
+						payload: { at: msg.at }
+					}];
+					for (const sbId of kernel.buffers.keys()) effects.push({
+						kind: "remove",
+						sbId,
+						start: msg.at,
+						end: Number.POSITIVE_INFINITY
+					});
+					effects.push(feed({
+						type: "SEEK",
+						to: msg.at
+					}));
+					return [_objectSpread2(_objectSpread2({}, state), {}, { stall }), effects];
+				}
+				if (count === 4) {
+					const window = segmentAt(kernel, msg.at);
+					if (window !== null) return [_objectSpread2(_objectSpread2({}, state), {}, { stall }), [{
+						kind: "emit",
+						event: "recovery:skip",
+						payload: {
+							at: msg.at,
+							to: window.end
+						}
+					}, feed({
+						type: "SEEK",
+						to: window.end + .1
+					})]];
+				}
+				return [_objectSpread2(_objectSpread2({}, state), {}, { stall: null }), []];
+			}
+			const next = buffered.filter((range) => range.start > msg.at && range.start - msg.at <= options.maxGapSeconds).sort((a, b) => a.start - b.start)[0];
+			if (next !== void 0 && (state.lastJump === null || Math.abs(next.start - state.lastJump) > .5)) return [_objectSpread2(_objectSpread2({}, state), {}, {
+				lastJump: next.start,
+				stall: null
+			}), [{
+				kind: "emit",
+				event: "recovery:gap-jump",
+				payload: {
+					from: msg.at,
+					to: next.start
+				}
+			}, feed({
+				type: "SEEK",
+				to: next.start + .1
+			})]];
+			return [_objectSpread2(_objectSpread2({}, state), {}, { stall: null }), []];
+		}
+		if (msg.type === "SOURCEBUFFER_ERROR") {
+			var _kernel$bufferErrors$;
+			if (((_kernel$bufferErrors$ = kernel.bufferErrors.get(msg.sbId)) !== null && _kernel$bufferErrors$ !== void 0 ? _kernel$bufferErrors$ : 0) === 2 && state.flushes < 1) return [_objectSpread2(_objectSpread2({}, state), {}, { flushes: state.flushes + 1 }), [
+				{
+					kind: "emit",
+					event: "recovery:flush",
+					payload: { sbId: msg.sbId }
+				},
+				{
+					kind: "remove",
+					sbId: msg.sbId,
+					start: kernel.playback.currentTime,
+					end: Number.POSITIVE_INFINITY
+				},
+				feed({
+					type: "SEEK",
+					to: kernel.playback.currentTime
+				})
+			]];
+			return [state, []];
+		}
+		return [state, []];
+	};
+}
+/** The stage factory. */
+function recovery(options) {
+	const resolved = _objectSpread2(_objectSpread2({}, DEFAULTS), options);
+	return {
+		name: "recovery",
+		provides: ["recovery"],
+		requires: ["scheduler", "mse"],
+		install(ctx) {
+			ctx.reduce("recovery", createRecoveryReducer(resolved));
+		}
+	};
+}
+//#endregion
+export { recovery as default };

package/dist/es2015/stages/text-cea608/decode.js

@@ -0,0 +1,201 @@
+import _defineProperty from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/defineProperty.js";
+//#region src/stages/text-cea608/decode.ts
+const ROWS = 15;
+/** The basic CEA-608 character set: ASCII with a handful of substitutions. */
+const BASIC = {
+	42: "á",
+	92: "é",
+	94: "í",
+	95: "ó",
+	96: "ú",
+	123: "ç",
+	124: "÷",
+	125: "Ñ",
+	126: "ñ",
+	127: "█"
+};
+/** Special characters, PAC-selected via 0x11/0x19 with 0x30-0x3f. */
+const SPECIAL = {
+	48: "®",
+	49: "°",
+	50: "½",
+	51: "¿",
+	52: "™",
+	53: "¢",
+	54: "£",
+	55: "♪",
+	56: "à",
+	57: " ",
+	58: "è",
+	59: "â",
+	60: "ê",
+	61: "î",
+	62: "ô",
+	63: "û"
+};
+/** PAC row from the two control bytes; the standard's non-linear row map. */
+const PAC_ROWS = [
+	11,
+	1,
+	3,
+	12,
+	14,
+	5,
+	7,
+	9
+];
+function basicChar(code) {
+	if (code in BASIC) return BASIC[code];
+	if (code >= 32 && code < 128) return String.fromCharCode(code);
+	return "";
+}
+var Cea608Decoder = class {
+	constructor() {
+		_defineProperty(this, "mode", "none");
+		_defineProperty(this, "displayed", blankScreen());
+		_defineProperty(this, "nonDisplayed", blankScreen());
+		_defineProperty(this, "row", 14);
+		_defineProperty(this, "col", 0);
+		_defineProperty(this, "rollUpRows", 2);
+		_defineProperty(this, "lastControl", 0);
+		_defineProperty(this, "cues", []);
+		_defineProperty(this, "openText", null);
+		_defineProperty(this, "openStart", 0);
+	}
+	/** Feeds one CEA-608 byte pair at a presentation time in seconds. */
+	push(a, b, time) {
+		const b0 = a & 127;
+		const b1 = b & 127;
+		if (b0 >= 16 && b0 <= 31) {
+			const packed = b0 << 8 | b1;
+			if (packed === this.lastControl) {
+				this.lastControl = 0;
+				return;
+			}
+			this.lastControl = packed;
+			this.control(b0, b1, time);
+			return;
+		}
+		this.lastControl = 0;
+		if (b0 !== 0) this.write(basicChar(b0));
+		if (b1 !== 0) this.write(basicChar(b1));
+		if (this.mode === "paintOn" || this.mode === "rollUp") this.refresh(time);
+	}
+	control(b0, b1, time) {
+		if (b0 === 17 && b1 >= 32 && b1 <= 47) {
+			this.write(" ");
+			return;
+		}
+		if ((b0 === 17 || b0 === 25) && b1 >= 48 && b1 <= 63) {
+			var _SPECIAL$b;
+			this.write((_SPECIAL$b = SPECIAL[b1]) !== null && _SPECIAL$b !== void 0 ? _SPECIAL$b : "");
+			if (this.mode !== "popOn") this.refresh(time);
+			return;
+		}
+		if (b0 >= 16 && b0 <= 23 && b1 >= 64 && b1 <= 127) {
+			this.pac(b0, b1);
+			return;
+		}
+		if (b0 === 20 || b0 === 21 || b0 === 28) this.miscControl(b1, time);
+	}
+	miscControl(b1, time) {
+		switch (b1) {
+			case 32:
+				this.mode = "popOn";
+				break;
+			case 37:
+			case 38:
+			case 39:
+				this.rollUpRows = b1 - 35;
+				if (this.mode !== "rollUp") {
+					this.mode = "rollUp";
+					this.displayed = blankScreen();
+				}
+				this.row = 14;
+				this.col = 0;
+				break;
+			case 41:
+				this.mode = "paintOn";
+				break;
+			case 44:
+				this.closeCue(time);
+				this.displayed = blankScreen();
+				break;
+			case 45:
+				this.rollUp(time);
+				break;
+			case 46:
+				this.nonDisplayed = blankScreen();
+				break;
+			case 47:
+				this.closeCue(time);
+				[this.displayed, this.nonDisplayed] = [this.nonDisplayed, this.displayed];
+				this.refresh(time);
+		}
+	}
+	pac(b0, b1) {
+		var _PAC_ROWS;
+		const rowBase = (_PAC_ROWS = PAC_ROWS[b0 & 7]) !== null && _PAC_ROWS !== void 0 ? _PAC_ROWS : 1;
+		const rowOffset = (b1 & 32) !== 0 ? 1 : 0;
+		this.row = Math.min(14, rowBase - 1 + rowOffset);
+		this.col = (b1 & 16) !== 0 ? ((b1 & 14) >> 1) * 4 : 0;
+	}
+	target() {
+		return this.mode === "popOn" ? this.nonDisplayed : this.displayed;
+	}
+	write(char) {
+		var _screen$this$row;
+		if (char === "") return;
+		const screen = this.target();
+		const padded = ((_screen$this$row = screen[this.row]) !== null && _screen$this$row !== void 0 ? _screen$this$row : "").padEnd(this.col, " ");
+		screen[this.row] = padded.slice(0, this.col) + char + padded.slice(this.col + 1);
+		this.col = Math.min(31, this.col + 1);
+	}
+	rollUp(time) {
+		var _this$displayed;
+		this.closeCue(time);
+		const top = ROWS - this.rollUpRows;
+		for (let r = top; r < 14; r += 1) this.displayed[r] = (_this$displayed = this.displayed[r + 1]) !== null && _this$displayed !== void 0 ? _this$displayed : "";
+		this.displayed[14] = "";
+		this.row = 14;
+		this.col = 0;
+		this.refresh(time);
+	}
+	refresh(time) {
+		var _this$openText;
+		const text = screenText(this.displayed);
+		if (text === ((_this$openText = this.openText) !== null && _this$openText !== void 0 ? _this$openText : "")) return;
+		this.closeCue(time);
+		if (text !== "") {
+			this.openText = text;
+			this.openStart = time;
+		}
+	}
+	closeCue(time) {
+		if (this.openText === null) return;
+		if (time > this.openStart) this.cues.push({
+			start: this.openStart,
+			end: time,
+			text: this.openText
+		});
+		this.openText = null;
+	}
+	/** Closes any open caption at the final time and returns every cue. */
+	flush(time) {
+		this.closeCue(time);
+		return this.cues;
+	}
+	/** Returns cues completed since the last drain and forgets them. */
+	drain() {
+		if (this.cues.length === 0) return [];
+		return this.cues.splice(0, this.cues.length);
+	}
+};
+function blankScreen() {
+	return Array.from({ length: ROWS }, () => "");
+}
+function screenText(screen) {
+	return screen.map((line) => line.replace(/\s+$/, "")).filter((line) => line !== "").join("\n");
+}
+//#endregion
+export { Cea608Decoder };

package/dist/es2015/stages/text-cea608/index.js

@@ -0,0 +1,71 @@
+import { registerCaptionConsumer } from "../../containers/captions.js";
+import { Cea608Decoder } from "./decode.js";
+//#region src/stages/text-cea608/index.ts
+/**
+* CEA-608 in-band captions as a stage. It owns the decoder and the seam to
+* its SEI source: it registers one caption consumer, and whichever source is
+* composed (ts-transmux for TS, nal-scan for fMP4) delivers the byte pairs.
+* The stage imports neither source, only the shared registry, which is what
+* lets one decoder serve both routes (entanglement #1).
+*
+* Decoded captions become native VTTCues on a caption TextTrack, rendered by
+* the browser like any text track. The track is created on the first cue and
+* left off by default; the viewer or the app turns it on.
+*/
+function textCea608() {
+	return {
+		name: "text-cea608",
+		provides: ["text-cea608", {
+			contentType: "text",
+			mimeType: "application/cea-608"
+		}],
+		requires: [["ts-transmux", "nal-scan"]],
+		install(ctx) {
+			const decoder = new Cea608Decoder();
+			const element = ctx.element;
+			let track = null;
+			/** Empties the track. `cues` reads null while disabled; hidden makes them removable. */
+			function empty(target) {
+				target.mode = "hidden";
+				const { cues } = target;
+				if (cues === null) return;
+				for (let i = cues.length - 1; i >= 0; i -= 1) {
+					const cue = cues[i];
+					if (cue !== void 0) target.removeCue(cue);
+				}
+			}
+			function ensureTrack() {
+				if (track === null) {
+					var _track;
+					for (const existing of element.textTracks) if (existing.kind === "captions" && existing.label === "CC1") {
+						track = existing;
+						empty(track);
+						break;
+					}
+					(_track = track) !== null && _track !== void 0 || (track = element.addTextTrack("captions", "CC1", "en"));
+					track.mode = "hidden";
+				}
+				return track;
+			}
+			const unregister = registerCaptionConsumer((packets) => {
+				for (const packet of packets) for (const triple of packet.triples) if (triple.type === 0) decoder.push(triple.a, triple.b, packet.time);
+				const cues = decoder.drain();
+				if (cues.length === 0) return;
+				const VttCue = globalThis.VTTCue;
+				if (VttCue === void 0) return;
+				const target = ensureTrack();
+				for (const cue of cues) target.addCue(new VttCue(cue.start, cue.end, cue.text));
+			});
+			return () => {
+				unregister();
+				if (track !== null) {
+					empty(track);
+					track.mode = "disabled";
+					track = null;
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { textCea608 as default };

package/dist/es2015/stages/text-webvtt/index.js

@@ -0,0 +1,82 @@
+import { createTextTrackSink } from "../../kernel/sinks/text-track-sink.js";
+import { parseVtt } from "./parse.js";
+//#region src/stages/text-webvtt/index.ts
+/**
+* WebVTT as a stage: a parser for text/vtt and the text sink registration
+* that makes text tracks selectable. Cues become native VTTCues through the
+* kernel's TextTrackSink; the browser renders, styles, and exposes the
+* caption UI, which is why this stage stays small.
+*
+* The stage also keeps the element's TextTrackList and the engine's text
+* selection in step, both ways. Every text track exists natively from the
+* manifest on, so the browser's caption menu lists all of them; the active
+* one is `showing`, the rest `disabled`. A pick in that menu selects in the
+* engine, and switching captions off there deselects.
+*/
+function parseSegment(data, _meta) {
+	return parseVtt(new TextDecoder().decode(data)).cues;
+}
+function textWebvtt() {
+	return {
+		name: "text-webvtt",
+		provides: ["text-webvtt", {
+			contentType: "text",
+			mimeType: "text/vtt"
+		}],
+		requires: ["scheduler"],
+		install(ctx) {
+			const { element } = ctx;
+			const sink = createTextTrackSink({
+				element,
+				parse: parseSegment
+			});
+			ctx.registerParser("text/vtt", parseSegment);
+			ctx.registerSink("text", () => sink);
+			function textTracks() {
+				const presentation = ctx.getState().presentation;
+				if (presentation === null) return [];
+				return presentation.periods.flatMap((period) => period.tracks.filter((track) => track.contentType === "text"));
+			}
+			function activeId() {
+				return ctx.getState().tracks.active.get("text");
+			}
+			function mirror() {
+				const active = activeId();
+				const current = new Set(textTracks().map((track) => track.id));
+				for (const id of sink.trackIds()) if (!current.has(id)) sink.retire(id);
+				for (const track of textTracks()) {
+					const native = sink.declare(track.id);
+					const mode = track.id === active ? "showing" : "disabled";
+					if (native.mode !== mode) native.mode = mode;
+				}
+			}
+			function onNativeChange() {
+				const active = activeId();
+				const showing = textTracks().find((track) => {
+					var _sink$nativeTrack;
+					return ((_sink$nativeTrack = sink.nativeTrack(track.id)) === null || _sink$nativeTrack === void 0 ? void 0 : _sink$nativeTrack.mode) === "showing";
+				});
+				if (showing !== void 0) {
+					if (showing.id !== active) ctx.dispatch({
+						type: "SELECT_TRACK",
+						trackId: showing.id
+					});
+				} else if (active !== void 0) ctx.dispatch({
+					type: "DESELECT_TRACK",
+					contentType: "text"
+				});
+			}
+			ctx.on("tracks:changed", mirror);
+			ctx.on("tracks:selected", (payload) => {
+				if (payload.contentType === "text") mirror();
+			});
+			element.textTracks.addEventListener("change", onNativeChange);
+			return () => {
+				element.textTracks.removeEventListener("change", onNativeChange);
+				sink.dispose();
+			};
+		}
+	};
+}
+//#endregion
+export { textWebvtt as default };

package/dist/es2015/stages/text-webvtt/parse.js

@@ -0,0 +1,60 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+//#region src/stages/text-webvtt/parse.ts
+/** `HH:MM:SS.mmm` or `MM:SS.mmm` to seconds, or null. */
+function parseTimestamp(text) {
+	const match = /^(?:(\d+):)?([0-5]\d):([0-5]\d)\.(\d{3})$/.exec(text.trim());
+	if (match === null) return null;
+	const [, hours, minutes, seconds, millis] = match;
+	return Number(hours !== null && hours !== void 0 ? hours : 0) * 3600 + Number(minutes) * 60 + Number(seconds) + Number(millis) / 1e3;
+}
+/** djb2 over the cue text; enough identity for dedup, not cryptography. */
+function hash(text) {
+	let value = 5381;
+	for (let i = 0; i < text.length; i += 1) value = (value << 5) + value + text.charCodeAt(i) >>> 0;
+	return value.toString(36);
+}
+function parseVtt(text) {
+	const body = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+	if (!body.startsWith("WEBVTT")) return {
+		cues: [],
+		skipped: 0
+	};
+	const cues = [];
+	let skipped = 0;
+	const blocks = body.split(/\r?\n\r?\n/).slice(1);
+	for (const block of blocks) {
+		var _settingsMatch$;
+		const lines = block.split(/\r?\n/).filter((line) => line !== "");
+		if (lines.length === 0) continue;
+		const first = lines[0];
+		if (first.startsWith("NOTE") || first.startsWith("STYLE") || first.startsWith("REGION")) continue;
+		const timingIndex = lines.findIndex((line) => line.includes("-->"));
+		if (timingIndex === -1 || timingIndex > 1) {
+			skipped += 1;
+			continue;
+		}
+		const id = timingIndex === 1 ? first : void 0;
+		const [startText, rest] = lines[timingIndex].split("-->");
+		const settingsMatch = (rest !== null && rest !== void 0 ? rest : "").trim().split(/\s+/);
+		const start = parseTimestamp(startText !== null && startText !== void 0 ? startText : "");
+		const end = parseTimestamp((_settingsMatch$ = settingsMatch[0]) !== null && _settingsMatch$ !== void 0 ? _settingsMatch$ : "");
+		if (start === null || end === null || end <= start) {
+			skipped += 1;
+			continue;
+		}
+		const settings = settingsMatch.slice(1).join(" ");
+		const cueText = lines.slice(timingIndex + 1).join("\n");
+		cues.push(_objectSpread2({
+			id: id !== null && id !== void 0 ? id : `${Math.round(start * 1e3)}-${Math.round(end * 1e3)}-${hash(cueText)}`,
+			start,
+			end,
+			text: cueText
+		}, settings !== "" ? { settings } : {}));
+	}
+	return {
+		cues,
+		skipped
+	};
+}
+//#endregion
+export { parseTimestamp, parseVtt };