@banou/media-player 0.10.1 → 0.10.2

package/dist/engine/index.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, d as n, f as r, i, l as a, n as o, o as s, r as c, s as l, t as u, u as d } from "../engine-b5_5HscR.js";
+import { a as e, c as t, d as n, f as r, i, l as a, n as o, o as s, r as c, s as l, t as u, u as d } from "../engine-DqyZgmTv.js";
 export { i as DEFAULT_BUFFER_SIZE, e as MediaElementError, a as SUBTITLES_OFF, u as createPictureInPicture, d as createSubtitleRenderer, c as createThumbnailGenerator, n as getTimeRanges, s as isMediaElementError, o as pictureInPictureMode, l as startPlayback, t as terminateRemuxer, r as updateSourceBuffer };

package/dist/{engine-b5_5HscR.js → engine-DqyZgmTv.js}

@@ -180,7 +180,7 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 		clearTimeout(n), t.terminate();
 	});
 }, te = async (t) => {
-	let { videoElement: n, subtitleContainer: r, read: a, length: s, publicPath: c, libavWorkerUrl: l, jassubWorkerUrl: u, jassubWasmUrl: d, jassubLegacyWasmUrl: f, defaultFontUrl: p, bufferSize: m = k, audioStreamIndex: _, onReady: te, onError: ne, onRecovered: re, onSeek: j, onSubtitleStreams: ie, onAudioStreams: ae } = t, M = await e({
+	let { videoElement: n, subtitleContainer: r, read: a, length: s, publicPath: c, libavWorkerUrl: l, jassubWorkerUrl: u, jassubWasmUrl: d, jassubLegacyWasmUrl: f, defaultFontUrl: p, bufferSize: m = k, audioStreamIndex: _, onReady: te, onError: ne, onRecovered: re, onSeek: ie, onSubtitleStreams: ae, onAudioStreams: oe } = t, j = await e({
 		publicPath: c,
 		workerUrl: l,
 		workerOptions: { type: "module" },
@@ -188,18 +188,18 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 		length: s,
 		audioStreamIndex: _,
 		read: a
-	}), N = [], P = !1, F = () => {
-		if (!P) {
-			P = !0;
-			for (let e of [...N].reverse()) try {
+	}), M = [], N = !1, P = () => {
+		if (!N) {
+			N = !0;
+			for (let e of [...M].reverse()) try {
 				e();
 			} catch {}
 		}
 	};
-	N.push(() => A(M));
+	M.push(() => A(j));
 	try {
-		let e = await M.init(), t = e.audioStreams ?? [], a = t.some((e) => e.streamIndex === _) ? _ : t[0]?.streamIndex ?? -1;
-		ae?.(t, a);
+		let e = await j.init(), t = e.audioStreams ?? [], a = t.some((e) => e.streamIndex === _) ? _ : t[0]?.streamIndex ?? -1;
+		oe?.(t, a);
 		let s = h({
 			video: n,
 			container: r,
@@ -207,13 +207,13 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 			wasmUrl: d,
 			legacyWasmUrl: f,
 			defaultFontUrl: p,
-			onStreams: ie
+			onStreams: ae
 		});
-		if (N.push(() => s.destroy()), e.attachments?.length && s.pushAttachments(e.attachments), !e.info.output.videoMimeType) throw Error("The video codec in this file could not be identified");
+		if (M.push(() => s.destroy()), e.attachments?.length && s.pushAttachments(e.attachments), !e.info.output.videoMimeType) throw Error("The video codec in this file could not be identified");
 		let c = [e.info.output.videoMimeType, e.info.output.audioMimeType].filter(Boolean).join(","), l = `video/mp4; codecs="${c}"`;
 		if (!MediaSource.isTypeSupported(l)) throw Error(`This browser cannot play the codecs in this file: ${c}`);
 		let m = new MediaSource(), k = URL.createObjectURL(m);
-		N.push(() => URL.revokeObjectURL(k)), n.src = k, N.push(() => {
+		M.push(() => URL.revokeObjectURL(k)), n.src = k, M.push(() => {
 			try {
 				n.pause();
 			} catch {}
@@ -237,140 +237,140 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 				i(), n(/* @__PURE__ */ Error("The MediaSource closed before a SourceBuffer could be created"));
 			};
 			m.addEventListener("sourceopen", a, { once: !0 }), m.addEventListener("sourceclose", o, { once: !0 }), m.addEventListener("error", o, { once: !0 });
-		}), { appendBuffer: I, unbufferRange: L, updateTimestampOffset: oe, endOfStream: se } = o(A, m);
-		await I(e.data), e.subtitles?.length && s.pushFragments(e.subtitles), te?.();
-		let R = !1, z = !1, B = 0, V, ce = () => V ?? n.currentTime, H = !1, U = 0, W = 0, G = null, K = 0, le = 0, q = !1, ue = 0, J = (e, t, n = !1) => {
+		}), { appendBuffer: F, unbufferRange: I, updateTimestampOffset: se, endOfStream: L } = o(A, m);
+		await F(e.data), e.subtitles?.length && s.pushFragments(e.subtitles), te?.();
+		let R = !1, z = !1, B = 0, V, ce = () => V ?? n.currentTime, H = !1, le = 0, U = 0, W = null, G = 0, ue = 0, K = !1, de = 0, q = (e, t, n = !1) => {
 			let r = e?.message === "Cancelled";
-			t && r || (console.error(e), !(q && !n) && (q = !0, ne?.(r ? Error("Reading the video file failed", { cause: e }) : e)));
-		}, de = async (e = !1) => {
+			t && r || (console.error(e), !(K && !n) && (K = !0, ne?.(r ? Error("Reading the video file failed", { cause: e }) : e)));
+		}, fe = async (e = !1) => {
 			if (B > 0 && !e) return;
 			let t = n.currentTime, r = e ? x : v, a = e ? S : y;
-			for (let { start: e, end: n } of i(A)) e < t + r && await L(e, t + r), n > t + a && await L(t + a, n);
-		}, fe = () => {
+			for (let { start: e, end: n } of i(A)) e < t + r && await I(e, t + r), n > t + a && await I(t + a, n);
+		}, pe = () => {
 			let e = i(A);
 			if (!e.length) return !0;
 			let t = ce(), n = e.find((e) => e.start <= t + T && t < e.end);
 			return n && n.end >= t + y ? !1 : !n || n.end < t + b;
-		}, pe = () => {
+		}, me = () => {
 			let e = n.currentTime;
 			return i(A).find((t) => t.start <= e + T && e < t.end);
-		}, me = () => {
-			let e = pe();
-			return !!e && e.end >= le - .1;
 		}, he = () => {
+			let e = me();
+			return !!e && e.end >= ue - .1;
+		}, ge = () => {
 			let e = i(A).map((e) => e.end);
-			e.length && (le = Math.max(le, ...e));
-		}, Y = async (e) => {
-			z = !0, G = null, K = 0, ue = e;
-			let t = ++W;
+			e.length && (ue = Math.max(ue, ...e));
+		}, J = async (e) => {
+			z = !0, W = null, G = 0, de = e;
+			let t = ++U;
 			try {
-				let { data: n, pts: r, subtitles: i, finished: a } = await M.seek(e);
-				if (P || t !== W || (a && (H = !0), i?.length && s.pushFragments(i), await oe(r), P || t !== W)) return;
-				n.byteLength && (await I(n), he());
+				let { data: n, pts: r, subtitles: i, finished: a } = await j.seek(e);
+				if (N || t !== U || (a && (H = !0), i?.length && s.pushFragments(i), await se(r), N || t !== U)) return;
+				n.byteLength && (await F(n), ge());
 			} catch (e) {
-				J(e, P || t !== W);
+				q(e, N || t !== U);
 			} finally {
-				t === W && (z = !1);
+				t === U && (z = !1);
 			}
-		}, ge = async () => {
-			let e = G;
+		}, _e = async () => {
+			let e = W;
 			if (e) try {
-				await I(e), he(), G === e && (G = null, K = 0);
+				await F(e), ge(), W === e && (W = null, G = 0);
 			} catch (t) {
-				if (G !== e) return;
+				if (W !== e) return;
 				if (t?.name === "QuotaExceededError") {
-					let t = await de(!0).then(() => !0, () => !1);
-					if (G !== e) return;
+					let t = await fe(!0).then(() => !0, () => !1);
+					if (W !== e) return;
 					if (t) {
-						H = !1, await Y(pe()?.end ?? n.currentTime);
+						H = !1, await J(me()?.end ?? n.currentTime);
 						return;
 					}
 				}
-				if (K += 1, K < C) return;
-				throw G = null, t;
+				if (G += 1, G < C) return;
+				throw W = null, t;
 			}
-		}, _e = async () => {
-			if (R || z || $ !== void 0 || P || !G && (H || !fe())) return;
-			let e = ++U, t = W, n = () => P || e !== U || t !== W;
+		}, ve = async () => {
+			if (R || z || Q !== void 0 || N || !W && (H || !pe())) return;
+			let e = ++le, t = U, n = () => N || e !== le || t !== U;
 			R = !0;
 			try {
-				if (!G) {
-					let { data: e, subtitles: t, finished: r } = await M.read();
+				if (!W) {
+					let { data: e, subtitles: t, finished: r } = await j.read();
 					if (n() || (r && (H = !0), t?.length && s.pushFragments(t), !e.byteLength)) return;
-					G = e, K = 0;
+					W = e, G = 0;
 				}
-				await ge(), !n() && q && (q = !1, re?.());
+				await _e(), !n() && K && (K = !1, re?.());
 			} catch (e) {
-				J(e, n());
+				q(e, n());
 			} finally {
-				e === U && (R = !1);
+				e === le && (R = !1);
 			}
-		}, ve = (e) => e >= ue && !!pe(), ye = (e) => i(A).some((t) => t.start <= e + T && e < t.end), X = (e) => {
+		}, ye = (e) => e >= de && !!me(), be = (e) => i(A).some((t) => t.start <= e + T && e < t.end), Y = (e) => {
 			let t = i(A).find((t) => t.start <= e + T && e < t.end);
 			return t ? t.end - e : 0;
-		}, be = async (e) => {
-			if (!P && !(X(e) >= E)) {
+		}, xe = async (e) => {
+			if (!N && !(Y(e) >= E)) {
 				H = !1, B++, V = e;
 				try {
-					ye(e) || await Y(e);
-					let t = W;
-					for (let n = 0; n < ee && !(P || t !== W || H || X(e) >= E); n++) {
-						let t = X(e);
-						if (await _e(), X(e) <= t) break;
+					be(e) || await J(e);
+					let t = U;
+					for (let n = 0; n < ee && !(N || t !== U || H || Y(e) >= E); n++) {
+						let t = Y(e);
+						if (await ve(), Y(e) <= t) break;
 					}
 				} finally {
 					B--, V === e && (V = void 0);
 				}
 			}
-		}, xe = 0, Z = null, Q, Se = (e) => {
-			let t = performance.now(), n = t - xe;
+		}, Se = 0, X = null, Z, Ce = (e) => {
+			let t = performance.now(), n = t - Se;
 			if (n >= D) {
-				xe = t, Z = null, j?.(e);
+				Se = t, X = null, ie?.(e);
 				return;
 			}
-			Z = e, !Q && (Q = setTimeout(() => {
-				Q = void 0;
-				let e = Z;
-				Z = null, !(e === null || P) && (xe = performance.now(), j?.(e));
+			X = e, !Z && (Z = setTimeout(() => {
+				Z = void 0;
+				let e = X;
+				X = null, !(e === null || N) && (Se = performance.now(), ie?.(e));
 			}, D - n));
 		};
-		N.push(() => {
-			Q && clearTimeout(Q);
+		M.push(() => {
+			Z && clearTimeout(Z);
 		});
-		let Ce = 0, $;
-		N.push(() => {
-			$ && clearTimeout($);
+		let we = 0, Q;
+		M.push(() => {
+			Q && clearTimeout(Q);
 		});
-		let we = () => {
+		let Te = () => {
 			let t = n.currentTime, r = e.info.input.duration || n.duration;
-			r > 0 && Se(Math.min(Math.max(t / r, 0), 1));
-			let i = performance.now(), a = i - Ce < O;
-			if (Ce = i, !ve(t) && !(z && Math.abs(t - ue) < .001)) {
-				if (H = !1, $ && clearTimeout($), !a) {
-					$ = void 0, Y(t);
+			r > 0 && Ce(Math.min(Math.max(t / r, 0), 1));
+			let i = performance.now(), a = i - we < O;
+			if (we = i, !ye(t) && !(z && Math.abs(t - de) < .001)) {
+				if (H = !1, Q && clearTimeout(Q), !a) {
+					Q = void 0, J(t);
 					return;
 				}
-				$ = setTimeout(() => {
-					if ($ = void 0, P) return;
+				Q = setTimeout(() => {
+					if (Q = void 0, N) return;
 					let e = n.currentTime;
-					ve(e) || (H = !1, Y(e));
+					ye(e) || (H = !1, J(e));
 				}, O);
 			}
 		};
-		n.addEventListener("seeking", we), N.push(() => n.removeEventListener("seeking", we));
-		let Te = !1, Ee = () => {
-			if (Te) return;
-			Te = !0;
+		n.addEventListener("seeking", Te), M.push(() => n.removeEventListener("seeking", Te));
+		let $ = !1, Ee = () => {
+			if ($) return;
+			$ = !0;
 			let e = n.error;
-			J(new g(`the media element failed: ${e?.message ?? "unknown"}`, { cause: e }), !1, !0);
+			q(new g(`the media element failed: ${e?.message ?? "unknown"}`, { cause: e }), !1, !0);
 		};
-		n.addEventListener("error", Ee), N.push(() => n.removeEventListener("error", Ee));
+		n.addEventListener("error", Ee), M.push(() => n.removeEventListener("error", Ee));
 		let De = setInterval(() => {
-			Te || n.error || (de().catch(() => {}), _e().catch((e) => J(e, !1)), H && !G && me() && m.readyState === "open" && se().catch(() => {}));
+			$ || n.error || (fe().catch(() => {}), ve().catch((e) => q(e, !1)), H && !W && he() && m.readyState === "open" && L().catch(() => {}));
 		}, 100);
-		return N.push(() => clearInterval(De)), {
-			destroy: F,
-			prepareSeek: be,
+		return M.push(() => clearInterval(De)), {
+			destroy: P,
+			prepareSeek: xe,
 			videoElement: n,
 			selectSubtitleStream: (e) => s.selectStream(e),
 			indexes: e.indexes ?? [],
@@ -380,10 +380,10 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 			audioMimeType: e.info.output.audioMimeType
 		};
 	} catch (e) {
-		throw F(), e;
+		throw P(), e;
 	}
-}, ne = 5, re = 500, j = 320, ie = 1e6, ae = 3, M = 1e4, N = async (e) => {
-	let { publicPath: n, workerUrl: r, length: i, read: a, onThumbnails: o, width: s = j } = e, c = await t({
+}, ne = 5, re = 500, ie = 320, ae = 1e6, oe = 3, j = 1e4, M = 1.5, N = 4e6, P = async (e) => {
+	let { publicPath: n, workerUrl: r, length: i, read: a, onThumbnails: o, width: s = ie } = e, c = await t({
 		publicPath: n,
 		workerUrl: r,
 		workerOptions: { type: "module" },
@@ -391,36 +391,39 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 		read: a
 	});
 	try {
-		let t = await c.init(), n = t.duration, r = Math.max(e.interval ?? ne, n / re), a = [];
-		for (let [e, o] of t.indexes.entries()) {
-			let s = a.at(-1);
-			s && o.timestamp - s.timestamp < r || a.push({
-				timestamp: o.timestamp,
-				endTime: n,
-				startByte: o.pos,
-				endByte: Math.min((t.indexes[e + 1]?.pos ?? i) + ie, i),
-				done: !1,
-				attempts: 0
-			});
-		}
-		for (let [e, t] of a.entries()) t.endTime = a[e + 1]?.timestamp ?? n;
-		a.length > 1 && a.at(-1).timestamp > n - r * 2 && a.pop();
-		let l = [], u = !1, d = [], f = !1, p, m = () => {
-			let e = p;
+		let t = await c.init(), n = t.duration, r = Math.max(e.interval ?? ne, n / re), a = [], l = (e) => {
+			let t = [];
+			for (let [a, o] of e.entries()) {
+				let s = t.at(-1);
+				s && o.timestamp - s.timestamp < r || t.push({
+					timestamp: o.timestamp,
+					endTime: n,
+					startByte: o.pos,
+					endByte: Math.min((e[a + 1]?.pos ?? i) + ae, i),
+					done: !1,
+					attempts: 0
+				});
+			}
+			for (let [e, r] of t.entries()) r.endTime = t[e + 1]?.timestamp ?? n;
+			return t.length > 1 && t.at(-1).timestamp > n - r * 2 && t.pop(), t;
+		};
+		a = l(t.indexes);
+		let u = [], d = !1, f = [], p = !1, m, h = -1, g = !1, _ = !1, v, y = () => {
+			let e = m;
 			if (e !== void 0) {
-				let t = d.findIndex(({ timestamp: t, endTime: n }) => t <= e && e < n);
+				let t = f.findIndex(({ timestamp: t, endTime: n }) => t <= e && e < n);
 				if (t >= 0) return t;
 			}
 			return 0;
-		}, h = () => {
+		}, b = () => {
 			let e = [];
-			for (let [t, n] of l.entries()) {
+			for (let [t, n] of u.entries()) {
 				n.startTime - (e.at(-1)?.endTime ?? 0) > .01 && e.push({
 					url: "",
 					startTime: e.at(-1)?.endTime ?? 0,
 					endTime: n.startTime
 				}), e.push(n);
-				let r = l[t + 1];
+				let r = u[t + 1];
 				r && r.startTime - n.endTime > .01 && e.push({
 					url: "",
 					startTime: n.endTime,
@@ -433,48 +436,83 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 				startTime: t,
 				endTime: n
 			}), o(e);
-		}, g = async (e) => {
-			if (u) return;
-			let t = await Promise.race([c.readKeyframe(e.timestamp), new Promise((e, t) => setTimeout(() => t(/* @__PURE__ */ Error("timed out")), M))]), n = await createImageBitmap(new Blob([t], { type: "image/png" })), r = new OffscreenCanvas(s, Math.max(1, Math.round(n.height * (s / n.width))));
+		}, x = async (e) => {
+			if (d) return;
+			let t = await Promise.race([c.readKeyframe(e.timestamp), new Promise((e, t) => setTimeout(() => t(/* @__PURE__ */ Error("timed out")), j))]), n = await createImageBitmap(new Blob([t], { type: "image/png" })), r = new OffscreenCanvas(s, Math.max(1, Math.round(n.height * (s / n.width))));
 			r.getContext("2d").drawImage(n, 0, 0, r.width, r.height), n.close();
 			let i = await r.convertToBlob({
 				type: "image/webp",
 				quality: .7
 			});
-			u || (l = [...l, {
+			d || (u = [...u, {
 				url: URL.createObjectURL(i),
 				startTime: e.timestamp,
 				endTime: e.endTime
-			}].sort((e, t) => e.startTime - t.startTime), h());
-		}, _ = () => {
-			if (f || u || !d.length) return;
-			let e = d.splice(m(), 1)[0];
-			f = !0, g(e).catch(() => {
-				e.attempts += 1, e.done = e.attempts >= ae;
+			}].sort((e, t) => e.startTime - t.startTime), b());
+		}, S = () => {
+			if (p || d || _) return;
+			if (g) {
+				g = !1;
+				let e = v;
+				w(T(e)).then(() => {
+					E(e), S();
+				});
+				return;
+			}
+			if (!f.length) return;
+			let e = f.splice(y(), 1)[0];
+			p = !0, x(e).catch(() => {
+				e.attempts += 1, e.done = e.attempts >= oe;
 			}).finally(() => {
-				f = !1, _();
+				p = !1, S();
 			});
-		}, v = (e) => {
-			e.done = !0, d.push(e), _();
+		}, C = (e) => {
+			e.done = !0, f.push(e), S();
+		}, w = async (e) => {
+			_ = !0;
+			try {
+				let t = await c.init();
+				if (d) return;
+				h = e;
+				let n = l(t.indexes);
+				if (!n.length) return;
+				let r = new Map(u.map((e) => [e.startTime, e]));
+				for (let e of n) r.has(e.timestamp) && (e.done = !0);
+				a = n;
+				let i = new Set(n.map((e) => e.timestamp));
+				for (let e of u) i.has(e.startTime) || URL.revokeObjectURL(e.url);
+				u = n.filter((e) => r.has(e.timestamp)).map((e) => ({
+					url: r.get(e.timestamp).url,
+					startTime: e.timestamp,
+					endTime: e.endTime
+				})), f.length = 0, b();
+			} catch {} finally {
+				_ = !1;
+			}
+		}, T = (e) => e ? e.reduce((e, [, t]) => Math.max(e, t), 0) : i, E = (e) => {
+			for (let t of a) t.done || (!e || e.some(([e, n]) => e <= t.startByte && t.endByte <= n)) && C(t);
 		};
-		return h(), {
+		return b(), {
 			update: (e) => {
-				if (!u) for (let t of a) t.done || (!e || e.some(([e, n]) => e <= t.startByte && t.endByte <= n)) && v(t);
+				if (d) return;
+				v = e;
+				let t = T(e);
+				h < 0 ? h = t : (t >= Math.max(h * M, h + N) || t >= i && h < i) && (g = !0), E(e), S();
 			},
 			prioritize: (e) => {
-				u || (p = e);
+				d || (m = e);
 			},
 			destroy: () => {
-				u = !0, d.length = 0;
-				for (let e of l) URL.revokeObjectURL(e.url);
-				l = [], A(c);
+				d = !0, f.length = 0;
+				for (let e of u) URL.revokeObjectURL(e.url);
+				u = [], A(c);
 			}
 		};
 	} catch (e) {
 		throw A(c), e;
 	}
-}, P = 1280, F = 1920, I = 250, L = 100, oe = () => typeof HTMLCanvasElement < "u" && "captureStream" in HTMLCanvasElement.prototype, se = () => typeof document < "u" && typeof HTMLVideoElement < "u" && typeof HTMLVideoElement.prototype.requestPictureInPicture == "function" && !!document.pictureInPictureEnabled, R = () => typeof HTMLVideoElement < "u" && "mozCaptureStream" in HTMLVideoElement.prototype, z = () => oe() ? se() ? "window" : R() ? "burn-in" : null : null, B = (e) => {
-	let { video: t, subtitles: n } = e, r = e.mode ?? z() ?? "window", i = e.maxWidth ?? (r === "burn-in" ? F : P), a, o, s, c = !1, l = !1, u = !1, d = !1, f, p = () => r === "burn-in" ? !!a : !!a && document.pictureInPictureElement === a.mirror, m = (e, r) => {
+}, F = 1280, I = 1920, se = 250, L = 100, R = () => typeof HTMLCanvasElement < "u" && "captureStream" in HTMLCanvasElement.prototype, z = () => typeof document < "u" && typeof HTMLVideoElement < "u" && typeof HTMLVideoElement.prototype.requestPictureInPicture == "function" && !!document.pictureInPictureEnabled, B = () => typeof HTMLVideoElement < "u" && "mozCaptureStream" in HTMLVideoElement.prototype, V = () => R() ? z() ? "window" : B() ? "burn-in" : null : null, ce = (e) => {
+	let { video: t, subtitles: n } = e, r = e.mode ?? V() ?? "window", i = e.maxWidth ?? (r === "burn-in" ? I : F), a, o, s, c = !1, l = !1, u = !1, d = !1, f, p = () => r === "burn-in" ? !!a : !!a && document.pictureInPictureElement === a.mirror, m = (e, r) => {
 		r.drawImage(t, 0, 0, e.width, e.height);
 		let i = n.querySelector("canvas");
 		i && i.width > 0 && i.height > 0 && r.drawImage(i, 0, 0, e.width, e.height);
@@ -544,7 +582,7 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 		};
 		if (a = f, u.srcObject = f.stream, (e.container ?? t.parentElement ?? document.body).appendChild(u), v(), s = setInterval(() => {
 			t.paused && h();
-		}, I), u.play().catch(() => {}), u.readyState === 0 && await new Promise((e) => {
+		}, se), u.play().catch(() => {}), u.readyState === 0 && await new Promise((e) => {
 			let t = () => {
 				clearTimeout(n), e();
 			}, n = setTimeout(t, 1e3);
@@ -590,4 +628,4 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 	};
 };
 //#endregion
-export { g as a, A as c, i as d, o as f, k as i, s as l, z as n, _ as o, N as r, te as s, B as t, h as u };
+export { g as a, A as c, i as d, o as f, k as i, s as l, V as n, _ as o, P as r, te as s, ce as t, h as u };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { l as e, n as t, o as n, r, s as i, t as a, u as o } from "./engine-b5_5HscR.js";
+import { l as e, n as t, o as n, r, s as i, t as a, u as o } from "./engine-DqyZgmTv.js";
 import { Children as s, Fragment as c, isValidElement as l, useCallback as u, useEffect as d, useMemo as f, useRef as p, useState as m } from "react";
 import { css as h, keyframes as g } from "@emotion/react";
 import { createPlayer as _, useContainerAttach as v, useMediaAttach as y } from "@videojs/react";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@banou/media-player",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "A video player for containers and codecs the browser cannot play natively, remuxed on the fly",
   "type": "module",
   "main": "dist/index.js",

package/src/lib/engine/thumbnails.ts

@@ -25,6 +25,17 @@ const READAHEAD = 1_000_000
 const MAX_ATTEMPTS = 3
 // a keyframe decode can hang without ever settling
 const KEYFRAME_TIMEOUT = 10_000
+/**
+ * How much more of the file has to become readable before the index is walked again.
+ *
+ * An index is only as complete as the bytes behind it, and over a torrent those arrive for minutes
+ * after the player starts. Re-walking on every range change would demux the file over and over; a
+ * multiplier makes the number of walks logarithmic in the file size instead, so a download that
+ * starts at 2% re-indexes around eight times on its way to whole rather than hundreds.
+ */
+const REINDEX_GROWTH = 1.5
+/** And never re-walk for a trickle, however early. */
+const REINDEX_MIN_BYTES = 4_000_000
 
 export type ThumbnailGenerator = {
   /** Report which byte ranges are readable. Called with no argument when the whole file is. */
@@ -60,22 +71,37 @@ export const createThumbnailGenerator = async (options: ThumbnailGeneratorOption
     const interval = Math.max(options.interval ?? INTERVAL, duration / MAX_THUMBNAILS)
 
     type Slot = { timestamp: number, endTime: number, startByte: number, endByte: number, done: boolean, attempts: number }
-    const slots: Slot[] = []
-    for (const [i, index] of metadata.indexes.entries()) {
-      const last = slots.at(-1)
-      if (last && index.timestamp - last.timestamp < interval) continue
-      slots.push({
-        timestamp: index.timestamp,
-        endTime: duration,
-        startByte: index.pos,
-        endByte: Math.min((metadata.indexes[i + 1]?.pos ?? length) + READAHEAD, length),
-        done: false,
-        attempts: 0,
-      })
+    let slots: Slot[] = []
+
+    /**
+     * The slot list for one index, which is only ever as complete as the bytes it was built from.
+     *
+     * libav walks the clusters it can read and stops, WITHOUT failing: on a file whose first tenth is
+     * readable it reports a single keyframe and a correct duration, because the duration comes from
+     * the header. That single entry then becomes a single slot whose endTime falls through to the
+     * duration, which is one preview covering the whole seekbar.
+     */
+    const buildSlots = (indexes: typeof metadata.indexes): Slot[] => {
+      const built: Slot[] = []
+      for (const [i, index] of indexes.entries()) {
+        const last = built.at(-1)
+        if (last && index.timestamp - last.timestamp < interval) continue
+        built.push({
+          timestamp: index.timestamp,
+          endTime: duration,
+          startByte: index.pos,
+          endByte: Math.min((indexes[i + 1]?.pos ?? length) + READAHEAD, length),
+          done: false,
+          attempts: 0,
+        })
+      }
+      for (const [i, slot] of built.entries()) slot.endTime = built[i + 1]?.timestamp ?? duration
+      // reading the last keyframe runs the demuxer into EOF, which crashes the libav build
+      if (built.length > 1 && (built.at(-1)!.timestamp > duration - interval * 2)) built.pop()
+      return built
     }
-    for (const [i, slot] of slots.entries()) slot.endTime = slots[i + 1]?.timestamp ?? duration
-    // reading the last keyframe runs the demuxer into EOF, which crashes the libav build
-    if (slots.length > 1 && (slots.at(-1)!.timestamp > duration - interval * 2)) slots.pop()
+
+    slots = buildSlots(metadata.indexes)
 
     let thumbnails: ThumbnailImage[] = []
     let destroyed = false
@@ -93,6 +119,19 @@ export const createThumbnailGenerator = async (options: ThumbnailGeneratorOption
     /** Where the pointer is on the seekbar, or undefined when it is off it. */
     let priorityTime: number | undefined
 
+    /**
+     * How much of the file was readable when the current index was built.
+     *
+     * Negative until the first update, which establishes it: the boot walk has just happened against
+     * whatever was readable then, so the first report of the ranges is the baseline rather than a
+     * reason to walk again.
+     */
+    let indexedBytes = -1
+    let reindexWanted = false
+    let reindexing = false
+    /** The ranges last reported, so a walk deferred behind a decode can still claim against them. */
+    let lastRanges: [number, number][] | undefined
+
     /*
      * The slot to decode next: the one under the pointer when it is still waiting, else the oldest claim.
      *
@@ -146,7 +185,25 @@ export const createThumbnailGenerator = async (options: ThumbnailGeneratorOption
 
     // one decode at a time, because there is one wasm worker behind them all
     const pump = () => {
-      if (running || destroyed || !pending.length) return
+      if (running || destroyed || reindexing) return
+      /*
+       * A deferred index walk goes first.
+       *
+       * There is one worker behind both, and a walk started while a decode holds it would have them
+       * interleaved on the same demuxer. Taking it here means the walk happens at the one moment
+       * nothing else is using it, and it happens BEFORE the next decode so that decode comes from
+       * the new slot list rather than the stale one.
+       */
+      if (reindexWanted) {
+        reindexWanted = false
+        const ranges = lastRanges
+        void reindex(readableTo(ranges)).then(() => {
+          claimReadable(ranges)
+          pump()
+        })
+        return
+      }
+      if (!pending.length) return
       const slot = pending.splice(nextIndex(), 1)[0]!
       running = true
       void decode(slot)
@@ -167,15 +224,74 @@ export const createThumbnailGenerator = async (options: ThumbnailGeneratorOption
       pump()
     }
 
+    /**
+     * Walk the index again now that more of the file can be read, and keep what is already drawn.
+     *
+     * A preview survives if its slot survives, which is why the previous timestamps are matched
+     * rather than the list being thrown away: the first slot is almost always still the first slot,
+     * and re-decoding it would throw away work and flicker the seekbar for no reason. What DOES
+     * change is its endTime, since a slot that used to run to the end of the file now runs only as
+     * far as the neighbour the new index revealed.
+     */
+    const reindex = async (readable: number) => {
+      reindexing = true
+      try {
+        const next = await remuxer.init()
+        if (destroyed) return
+        indexedBytes = readable
+        const rebuilt = buildSlots(next.indexes)
+        if (!rebuilt.length) return
+
+        const drawn = new Map(thumbnails.map((t) => [t.startTime, t]))
+        for (const slot of rebuilt) {
+          if (drawn.has(slot.timestamp)) slot.done = true
+        }
+        slots = rebuilt
+        // a preview whose slot is gone is no longer addressable, and its blob would leak
+        const kept = new Set(rebuilt.map((slot) => slot.timestamp))
+        for (const t of thumbnails) if (!kept.has(t.startTime)) URL.revokeObjectURL(t.url)
+        thumbnails = rebuilt
+          .filter((slot) => drawn.has(slot.timestamp))
+          .map((slot) => ({ url: drawn.get(slot.timestamp)!.url, startTime: slot.timestamp, endTime: slot.endTime }))
+        // anything claimed against the old list is stale, and the update below re-claims from the new one
+        pending.length = 0
+        emit()
+      } catch {
+        // an index that could not be re-read leaves the old one in place, and the next update retries
+      } finally {
+        reindexing = false
+      }
+    }
+
+    /** The end of what can be read, which is what an index walk can reach. */
+    const readableTo = (ranges?: [number, number][]) =>
+      ranges ? ranges.reduce((most, [, to]) => Math.max(most, to), 0) : length
+
+    const claimReadable = (ranges?: [number, number][]) => {
+      for (const slot of slots) {
+        if (slot.done) continue
+        if (!ranges || ranges.some(([from, to]) => from <= slot.startByte && slot.endByte <= to)) claim(slot)
+      }
+    }
+
     emit()
 
     return {
       update: (ranges) => {
         if (destroyed) return
-        for (const slot of slots) {
-          if (slot.done) continue
-          if (!ranges || ranges.some(([from, to]) => from <= slot.startByte && slot.endByte <= to)) claim(slot)
+        lastRanges = ranges
+        const readable = readableTo(ranges)
+        if (indexedBytes < 0) indexedBytes = readable
+        else {
+          const grown = readable >= Math.max(indexedBytes * REINDEX_GROWTH, indexedBytes + REINDEX_MIN_BYTES)
+          // and one last walk when the file becomes whole, so a finished download is fully indexed
+          const whole = readable >= length && indexedBytes < length
+          if (grown || whole) reindexWanted = true
         }
+        claimReadable(ranges)
+        // claims first, so a walk that has to wait for a decode does not hold up the previews that
+        // the current index can already produce
+        pump()
       },
       prioritize: (time) => {
         if (destroyed) return